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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/* Copyright (c) 2015, 2025, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is designed to work with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have either included with
the program or referenced in the documentation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License, version 2.0, for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifndef DD_CACHE__MULTI_MAP_BASE_INCLUDED
#define DD_CACHE__MULTI_MAP_BASE_INCLUDED
#include <stdio.h>
#include "element_map.h" // Element_map
#include "sql/dd/types/abstract_table.h"
#include "sql/dd/types/charset.h"
#include "sql/dd/types/collation.h"
#include "sql/dd/types/column_statistics.h"
#include "sql/dd/types/event.h"
#include "sql/dd/types/resource_group.h"
#include "sql/dd/types/routine.h"
#include "sql/dd/types/schema.h"
#include "sql/dd/types/spatial_reference_system.h"
#include "sql/dd/types/tablespace.h"
namespace dd {
namespace cache {
template <typename T>
class Cache_element;
/**
Implementation of a set of maps for a given object type.
The class declares a set of maps, each of which maps from a key type
to an element type. The element type wraps the template object type
parameter into a wrapper instance.
The implementation is intended to be used as a base to be extended for
usage in a specific context. There is support for adding and removing
elements in all maps with one operation (but not necessarily atomically),
and for retrieving a single map. There is no support for tracking object
usage, free list management, thread synchronization, etc.
@tparam T Dictionary object type.
*/
template <typename T>
class Multi_map_base {
private:
Element_map<const T *, Cache_element<T>> m_rev_map; // Reverse element map.
Element_map<typename T::Id_key, Cache_element<T>>
m_id_map; // Id map instance.
Element_map<typename T::Name_key, Cache_element<T>>
m_name_map; // Name map instance.
Element_map<typename T::Aux_key, Cache_element<T>>
m_aux_map; // Aux map instance.
template <typename K>
struct Type_selector {}; // Dummy type to use for
// selecting map instance.
/**
Overloaded functions to use for selecting an element list instance
based on a key type. Const and non-const variants.
*/
Element_map<const T *, Cache_element<T>> *m_map(Type_selector<const T *>) {
return &m_rev_map;
}
const Element_map<const T *, Cache_element<T>> *m_map(
Type_selector<const T *>) const {
return &m_rev_map;
}
Element_map<typename T::Id_key, Cache_element<T>> *m_map(
Type_selector<typename T::Id_key>) {
return &m_id_map;
}
const Element_map<typename T::Id_key, Cache_element<T>> *m_map(
Type_selector<typename T::Id_key>) const {
return &m_id_map;
}
Element_map<typename T::Name_key, Cache_element<T>> *m_map(
Type_selector<typename T::Name_key>) {
return &m_name_map;
}
const Element_map<typename T::Name_key, Cache_element<T>> *m_map(
Type_selector<typename T::Name_key>) const {
return &m_name_map;
}
Element_map<typename T::Aux_key, Cache_element<T>> *m_map(
Type_selector<typename T::Aux_key>) {
return &m_aux_map;
}
const Element_map<typename T::Aux_key, Cache_element<T>> *m_map(
Type_selector<typename T::Aux_key>) const {
return &m_aux_map;
}
public:
// Iterate based on the reverse map where all elements must be present.
typedef typename Element_map<const T *, Cache_element<T>>::Const_iterator
Const_iterator;
typedef typename Element_map<const T *, Cache_element<T>>::Iterator Iterator;
protected:
/**
Template function to get an element map.
To support generic code, the element map instances are available
through template function instances. This allows looking up the
appropriate instance based on the key type. We must use overloading
to accomplish this (see above). Const and non-const variants.
@tparam K Key type.
@return The element map handling keys of type K.
*/
template <typename K>
Element_map<K, Cache_element<T>> *m_map() {
return m_map(Type_selector<K>());
}
template <typename K>
const Element_map<K, Cache_element<T>> *m_map() const {
return m_map(Type_selector<K>());
}
/**
Helper function to remove the mapping of a single element, without
deleting the element itself. This function assumes that checking for
key and element presence has already been done.
@param element Element to be removed and deleted.
*/
void remove_single_element(Cache_element<T> *element);
/**
Helper function to add a single element.
This function assumes that checking for key and element presence
has already been done, that the object has been assigned, and that the
keys have been generated.
@param element Element to be added.
*/
void add_single_element(Cache_element<T> *element);
/**
Debug dump of the multi map base to stderr.
*/
/* purecov: begin inspected */
void dump() const {
#ifndef NDEBUG
fprintf(stderr, " Reverse element map:\n");
m_map<const T *>()->dump();
fprintf(stderr, " Id map:\n");
m_map<typename T::Id_key>()->dump();
fprintf(stderr, " Name map:\n");
m_map<typename T::Name_key>()->dump();
fprintf(stderr, " Aux map:\n");
m_map<typename T::Aux_key>()->dump();
#endif
}
/* purecov: end */
};
} // namespace cache
} // namespace dd
#endif // DD_CACHE__MULTI_MAP_BASE_INCLUDED
|
