1 | #ifndef Py_DICTOBJECT_H |
2 | #define Py_DICTOBJECT_H |
3 | #ifdef __cplusplus |
4 | extern "C" { |
5 | #endif |
6 | |
7 | |
8 | /* Dictionary object type -- mapping from hashable object to object */ |
9 | |
10 | /* The distribution includes a separate file, Objects/dictnotes.txt, |
11 | describing explorations into dictionary design and optimization. |
12 | It covers typical dictionary use patterns, the parameters for |
13 | tuning dictionaries, and several ideas for possible optimizations. |
14 | */ |
15 | |
16 | /* |
17 | There are three kinds of slots in the table: |
18 | |
19 | 1. Unused. me_key == me_value == NULL |
20 | Does not hold an active (key, value) pair now and never did. Unused can |
21 | transition to Active upon key insertion. This is the only case in which |
22 | me_key is NULL, and is each slot's initial state. |
23 | |
24 | 2. Active. me_key != NULL and me_key != dummy and me_value != NULL |
25 | Holds an active (key, value) pair. Active can transition to Dummy upon |
26 | key deletion. This is the only case in which me_value != NULL. |
27 | |
28 | 3. Dummy. me_key == dummy and me_value == NULL |
29 | Previously held an active (key, value) pair, but that was deleted and an |
30 | active pair has not yet overwritten the slot. Dummy can transition to |
31 | Active upon key insertion. Dummy slots cannot be made Unused again |
32 | (cannot have me_key set to NULL), else the probe sequence in case of |
33 | collision would have no way to know they were once active. |
34 | |
35 | Note: .popitem() abuses the me_hash field of an Unused or Dummy slot to |
36 | hold a search finger. The me_hash field of Unused or Dummy slots has no |
37 | meaning otherwise. |
38 | */ |
39 | |
40 | /* PyDict_MINSIZE is the minimum size of a dictionary. This many slots are |
41 | * allocated directly in the dict object (in the ma_smalltable member). |
42 | * It must be a power of 2, and at least 4. 8 allows dicts with no more |
43 | * than 5 active entries to live in ma_smalltable (and so avoid an |
44 | * additional malloc); instrumentation suggested this suffices for the |
45 | * majority of dicts (consisting mostly of usually-small instance dicts and |
46 | * usually-small dicts created to pass keyword arguments). |
47 | */ |
48 | #define PyDict_MINSIZE 8 |
49 | |
50 | typedef struct { |
51 | /* Cached hash code of me_key. Note that hash codes are C longs. |
52 | * We have to use Py_ssize_t instead because dict_popitem() abuses |
53 | * me_hash to hold a search finger. |
54 | */ |
55 | Py_ssize_t me_hash; |
56 | PyObject *me_key; |
57 | PyObject *me_value; |
58 | } PyDictEntry; |
59 | |
60 | /* |
61 | To ensure the lookup algorithm terminates, there must be at least one Unused |
62 | slot (NULL key) in the table. |
63 | The value ma_fill is the number of non-NULL keys (sum of Active and Dummy); |
64 | ma_used is the number of non-NULL, non-dummy keys (== the number of non-NULL |
65 | values == the number of Active items). |
66 | To avoid slowing down lookups on a near-full table, we resize the table when |
67 | it's two-thirds full. |
68 | */ |
69 | typedef struct _dictobject PyDictObject; |
70 | struct _dictobject { |
71 | PyObject_HEAD |
72 | Py_ssize_t ma_fill; /* # Active + # Dummy */ |
73 | Py_ssize_t ma_used; /* # Active */ |
74 | |
75 | /* The table contains ma_mask + 1 slots, and that's a power of 2. |
76 | * We store the mask instead of the size because the mask is more |
77 | * frequently needed. |
78 | */ |
79 | Py_ssize_t ma_mask; |
80 | |
81 | /* ma_table points to ma_smalltable for small tables, else to |
82 | * additional malloc'ed memory. ma_table is never NULL! This rule |
83 | * saves repeated runtime null-tests in the workhorse getitem and |
84 | * setitem calls. |
85 | */ |
86 | PyDictEntry *ma_table; |
87 | PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash); |
88 | PyDictEntry ma_smalltable[PyDict_MINSIZE]; |
89 | }; |
90 | |
91 | PyAPI_DATA(PyTypeObject) PyDict_Type; |
92 | PyAPI_DATA(PyTypeObject) PyDictIterKey_Type; |
93 | PyAPI_DATA(PyTypeObject) PyDictIterValue_Type; |
94 | PyAPI_DATA(PyTypeObject) PyDictIterItem_Type; |
95 | PyAPI_DATA(PyTypeObject) PyDictKeys_Type; |
96 | PyAPI_DATA(PyTypeObject) PyDictItems_Type; |
97 | PyAPI_DATA(PyTypeObject) PyDictValues_Type; |
98 | |
99 | #define PyDict_Check(op) \ |
100 | PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS) |
101 | #define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type) |
102 | #define PyDictKeys_Check(op) (Py_TYPE(op) == &PyDictKeys_Type) |
103 | #define PyDictItems_Check(op) (Py_TYPE(op) == &PyDictItems_Type) |
104 | #define PyDictValues_Check(op) (Py_TYPE(op) == &PyDictValues_Type) |
105 | /* This excludes Values, since they are not sets. */ |
106 | # define PyDictViewSet_Check(op) \ |
107 | (PyDictKeys_Check(op) || PyDictItems_Check(op)) |
108 | |
109 | PyAPI_FUNC(PyObject *) PyDict_New(void); |
110 | PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key); |
111 | PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item); |
112 | PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key); |
113 | PyAPI_FUNC(void) PyDict_Clear(PyObject *mp); |
114 | PyAPI_FUNC(int) PyDict_Next( |
115 | PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value); |
116 | PyAPI_FUNC(int) _PyDict_Next( |
117 | PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash); |
118 | PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp); |
119 | PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp); |
120 | PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp); |
121 | PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp); |
122 | PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp); |
123 | PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key); |
124 | PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, long hash); |
125 | PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused); |
126 | PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp); |
127 | |
128 | /* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */ |
129 | PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other); |
130 | |
131 | /* PyDict_Merge updates/merges from a mapping object (an object that |
132 | supports PyMapping_Keys() and PyObject_GetItem()). If override is true, |
133 | the last occurrence of a key wins, else the first. The Python |
134 | dict.update(other) is equivalent to PyDict_Merge(dict, other, 1). |
135 | */ |
136 | PyAPI_FUNC(int) PyDict_Merge(PyObject *mp, |
137 | PyObject *other, |
138 | int override); |
139 | |
140 | /* PyDict_MergeFromSeq2 updates/merges from an iterable object producing |
141 | iterable objects of length 2. If override is true, the last occurrence |
142 | of a key wins, else the first. The Python dict constructor dict(seq2) |
143 | is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1). |
144 | */ |
145 | PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d, |
146 | PyObject *seq2, |
147 | int override); |
148 | |
149 | PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key); |
150 | PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item); |
151 | PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key); |
152 | |
153 | #ifdef __cplusplus |
154 | } |
155 | #endif |
156 | #endif /* !Py_DICTOBJECT_H */ |
157 | |