1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*
* This source file is part of libRocket, the HTML/CSS Interface Middleware
*
* For the latest information, see http://www.librocket.com
*
* Copyright (c) 2008-2010 CodePoint Ltd, Shift Technology Ltd
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
#ifndef ROCKETCOREDICTIONARY_H
#define ROCKETCOREDICTIONARY_H
#include "Header.h"
#include "Variant.h"
namespace Rocket {
namespace Core {
/**
A dictionay is a container of variants.
It uses a hash table to maintain a string key to variant mapping.
@author Lloyd Weehuizen
*/
class ROCKETCORE_API Dictionary
{
public:
Dictionary();
Dictionary(const Dictionary &dict);
~Dictionary();
/// Store an item in the dictionary
void Set(const String& key, const Variant &value);
/// Templated set eases setting of values
template <typename T>
inline void Set(const String& key, const T& value);
/// Get an item from the dictionary
Variant* Get(const String& key) const;
Variant* operator[](const String& key) const;
/// Get a value from the dictionary, if it doesn't exist
/// use the supplied default value
template <typename T>
inline T Get(const String& key, const T& default_val) const;
/// Get a value from the dictionary, returns if the
/// value was found or not.
template <typename T>
inline bool GetInto(const String& key, T& value) const;
/// Remove an item from the dictionary
bool Remove(const String& key);
/// Iterate through a dictionary
bool Iterate(int &pos, String& key, Variant* &value) const;
template <typename T>
bool Iterate(int &pos, String& key, T& value) const;
/// Reserve the specified number of entries in the dictionary
bool Reserve(int size);
/// Empty the dictionary
void Clear();
/// Is the dictionary empty?
bool IsEmpty() const;
/// Items in the dict
int Size() const;
/// Merges another dictionary into this one. Any existing values stored against similar keys will be updated.
void Merge(const Dictionary& dict);
// Copy
void operator=(const Dictionary &dict);
private:
unsigned int num_full; // Active + # Dummy
unsigned int num_used; // Active
/* DICTIONARY_MINSIZE is the minimum size of a dictionary. This many slots are
* allocated directly in the dict object (in the small_table member).
* It must be a power of 2, and at least 4. 8 allows dicts with no more
* than 5 active entries to live in small_table (and so avoid an
* additional malloc); instrumentation suggested this suffices for the
* majority of dicts (consisting mostly of usually-small instance dicts and
* usually-small dicts created to pass keyword arguments).
*/
static const int DICTIONARY_MINSIZE = 8;
// Individual entry in a dictionary
struct DictionaryEntry
{
DictionaryEntry() : hash(0) {}
Hash hash; // Cached hash of key
String key; // key in plain text
Variant value; // Value for this entry
};
/* The table contains mask + 1 slots, and that's a power of 2.
* We store the mask instead of the size because the mask is more
* frequently needed.
*/
unsigned int mask;
// Small dictionaries just use this, saves mallocs for small tables
DictionaryEntry small_table[DICTIONARY_MINSIZE];
/// Pointer to table in use, may be malloc'd or may point to smallTable
DictionaryEntry* table;
/// Insert an item
void Insert(const String& key, Hash hash, const Variant& value);
/// Retrieve an item
DictionaryEntry* Retrieve(const String& key, Hash hash) const;
/// Reset to small dictionary
void ResetToMinimumSize();
// Copy another dict
void Copy(const Dictionary &dict);
};
#include "Dictionary.inl"
}
}
#endif
|
