trunk/src/typeinfo.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2017 Christian Schoenebeck                              *
 *                      <cuse@users.sourceforge.net>                       *
 *                                                                         *
 *   This library is part of libgig.                                       *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This library 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 for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this library; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include <typeinfo>
#include <map>
#include <string>
#include <stdlib.h>
#include <stdint.h>
#include <string.h> // for strdup()

#if defined _MSC_VER // Microsoft compiler ...
# define RAW_CPP_TYPENAME(t) t.raw_name()
#else // i.e. especially GCC and clang ...
# define RAW_CPP_TYPENAME(t) t.name()
#endif

#define RAW_CPP_TYPENAME_OF(type) RAW_CPP_TYPENAME(typeid(type))

#define GIG_DECLARE_ENUM(type, ...) \
    enum type { __VA_ARGS__ }; \
    \
    struct type##InfoRegistrator { \
        type##InfoRegistrator() { \
            const char* typeName = RAW_CPP_TYPENAME_OF(type); \
            g_enumsByRawTypeName[typeName] = _parseEnumBody( #__VA_ARGS__ ); \
        } \
    }; \
    \
    static type##InfoRegistrator g_##type##InfoRegistrator

struct EnumDeclaration {
    std::map<size_t, std::string> nameByValue;
    std::map<std::string, size_t> valueByName;
    char** allKeys;

    EnumDeclaration() : allKeys(NULL) {}

    const size_t countKeys() const { return valueByName.size(); }

    void loadAllKeys() {
        const size_t n = valueByName.size();
        allKeys = new char*[n + 1];
        size_t i = 0;
        for (std::map<std::string, size_t>::const_iterator it = valueByName.begin();
             it != valueByName.end(); ++it, ++i)
        {
            allKeys[i] = strdup(it->first.c_str());
        }
        allKeys[n] = NULL;
    }
};

struct EnumKeyVal {
    std::string name;
    size_t value;
    bool isValid() const { return !name.empty(); }
};

static std::map<std::string, EnumDeclaration> g_enumsByRawTypeName;
static std::map<std::string, size_t> g_allEnumValuesByKey;


// *************** Internal functions **************
// *

static inline bool isWhiteSpace(const char& c) {
    return c == ' ' || c == '\t' || c == '\n' || c == '\r';
}

static size_t decodeEnumValue(const std::string& encodedValue) {
    return strtoll(encodedValue.c_str(), NULL, 0 /* auto detect base */);
}

static EnumKeyVal _parseEnumKeyVal(const char* start, const char* end, size_t value) {
    EnumKeyVal keyval;

    if (start >= end)
        return keyval; // invalid
    // ignore white space
    for (; isWhiteSpace(*start); ++start)
        if (start >= end)
            return keyval; // invalid
    if (start >= end)
        return keyval; // invalid

    // parse key
    for (const char* p = start; true; ++p) {
        if (p >= end || isWhiteSpace(*p) || *p == '=') {
            const size_t sz = p - start;
            keyval.name.resize(sz);
            memcpy(&keyval.name[0], start, sz);
            keyval.value = value;
            start = p + 1;
            break;
        }
    }

    if (start >= end)
        return keyval; // valid, no explicit value provided
    // seek forward to start of value
    for (; isWhiteSpace(*start) || *start == '='; ++start)
        if (start >= end)
            return keyval; // valid, no explicit value provided
    if (start >= end)
        return keyval; // valid, no explicit value provided

    std::string encodedValue;
    // parse value portion
    for (const char* p = start; true; ++p) {
        if (p >= end || isWhiteSpace(*p)) {
            const size_t sz = p - start;
            encodedValue.resize(sz);
            memcpy(&encodedValue[0], start, sz);
            break;
        }
    }

    if (encodedValue.empty())
        return keyval; // valid, no explicit value provided

    keyval.value = decodeEnumValue(encodedValue);

    return keyval;
}

static EnumDeclaration _parseEnumBody(const char* body) {
    EnumDeclaration decl;
    size_t value = 0;
    for (const char* a = body, *b = body; true; ++b) {
        if (*b == 0 || *b == ',') {
            const EnumKeyVal keyval = _parseEnumKeyVal(a, b, value);
            if (!keyval.isValid()) break;
            decl.nameByValue[keyval.value] = keyval.name;
            decl.valueByName[keyval.name] = keyval.value;
            g_allEnumValuesByKey[keyval.name] = keyval.value;
            value = keyval.value + 1;
            if (*b == 0) break;
            a = b + 1;
        }
    }
    return decl;
}

#include "gig.h"

// *************** gig API functions **************
// *

namespace gig {

    // this has to be defined manually, since leverarge_ctrl_t::type_t is a
    // class internal member type
    static leverage_ctrl_t::type_tInfoRegistrator g_leverageCtrlTTypeT;


    /** @brief Amount of elements in given enum type.
     *
     * Returns the amount of elements of the enum type with raw C++ type name
     * @a typeName. If the requested enum type is unknown, then this function
     * returns @c 0 instead.
     *
     * Note: you @b MUST pass the raw C++ type name, not a demangled human
     * readable C++ type name. On doubt use the overloaded function which takes
     * a @c std::type_info as argument instead.
     *
     * @param typeName - raw C++ type name of enum
     * @returns enum's amount of elements
     */
    size_t enumCount(String typeName) {
        if (!g_enumsByRawTypeName.count(typeName))
            return 0;
        return g_enumsByRawTypeName[typeName].countKeys();
    }

    /** @brief Amount of elements in given enum type.
     *
     * Returns the amount of elements of the enum type given by @a type. If the
     * requested enum type is unknown, then this function returns @c 0 instead.
     *
     * Use the @c typeid() keyword of C++ to get a @c std::type_info object.
     *
     * @param type - enum type of interest
     * @returns enum's amount of elements
     */
    size_t enumCount(const std::type_info& type) {
        return enumCount(RAW_CPP_TYPENAME(type));
    }

    /** @brief Numeric value of enum constant.
     *
     * Returns the numeric value (assigned at library compile time) to the enum
     * constant with given @a name. If the requested enum constant is unknown,
     * then this function returns @c 0 instead.
     *
     * @param key - enum constant name
     * @returns enum constant's numeric value
     */
    size_t enumValue(String key) {
        if (!g_allEnumValuesByKey.count(key))
            return 0;
        return g_allEnumValuesByKey[key];
    }

    /** @brief Check if enum element exists.
     *
     * Checks whether the enum constant with name @a key of enum type with raw
     * C++ enum type name @a typeName exists. If either the requested enum type
     * or enum constant is unknown, then this function returns @c false instead.
     *
     * Note: you @b MUST pass the raw C++ type name, not a demangled human
     * readable C++ type name. On doubt use the overloaded function which takes
     * a @c std::type_info as argument instead.
     *
     * @param typeName - raw C++ type name of enum
     * @param key - name of enum constant
     * @returns @c true if requested enum element exists
     */
    bool enumKey(String typeName, String key) {
        if (!g_enumsByRawTypeName.count(typeName))
            return false;
        return g_enumsByRawTypeName[typeName].valueByName.count(key);
    }

    /** @brief Check if enum element exists.
     *
     * Checks whether the enum constant with name @a key of requested enum
     * @a type exists. If either the requested enum type or enum constant is
     * unknown, then this function returns @c false instead.
     *
     * Use the @c typeid() keyword of C++ to get a @c std::type_info object.
     *
     * @param type - enum type of interest
     * @param key - name of enum constant
     * @returns @c true if requested enum element exists
     */
    bool enumKey(const std::type_info& type, String key) {
        return enumKey(RAW_CPP_TYPENAME(type), key);
    }

    /** @brief Enum constant name of numeric value.
     *
     * Returns the enum constant name (a.k.a. enum element name) for the given
     * numeric @a value and the enum type with raw C++ enum type name
     * @a typeName. If either the requested enum type or enum constant numeric
     * value is unknown, then this function returns @c NULL instead.
     *
     * If the requested enum type contains several enum elements with the
     * requested numeric enum value, then this function will simply return one
     * of them, it is undefined which one it would return exactly in this case.
     *
     * Note: you @b MUST pass the raw C++ type name, not a demangled human
     * readable C++ type name. On doubt use the overloaded function which takes
     * a @c std::type_info as argument instead.
     *
     * @param typeName - raw C++ type name of enum
     * @param value - numeric value of sought enum constant
     * @returns @c true if requested enum element exists
     */
    const char* enumKey(String typeName, size_t value) {
        if (!g_enumsByRawTypeName.count(typeName))
            return NULL;
        if (!g_enumsByRawTypeName[typeName].nameByValue.count(value))
            return NULL;
        return g_enumsByRawTypeName[typeName].nameByValue[value].c_str();
    }

    /** @brief Enum constant name of numeric value.
     *
     * Returns the enum constant name (a.k.a. enum element name) for the given
     * numeric @a value and the given enum @a type. If either the requested
     * enum type or enum constant numeric value is unknown, then this function
     * returns @c NULL instead.
     *
     * If the requested enum type contains several enum elements with the
     * requested numeric enum value, then this function will simply return one
     * of them, it is undefined which one it would return exactly in this case.
     *
     * Use the @c typeid() keyword of C++ to get a @c std::type_info object.
     *
     * @param type - enum type of interest
     * @param value - numeric value of sought enum constant
     * @returns @c true if requested enum element exists
     */
    const char* enumKey(const std::type_info& type, size_t value) {
        return enumKey(RAW_CPP_TYPENAME(type), value);
    }

    /** @brief All element names of enum type.
     *
     * Returns a NULL terminated array of C strings of all enum constant names
     * of the given enum type with raw C++ enum type name @a typeName. If the
     * requested enum type is unknown, then this function returns @c NULL
     * instead.
     *
     * Note: you @b MUST pass the raw C++ type name, not a demangled human
     * readable C++ type name. On doubt use the overloaded function which takes
     * a @c std::type_info as argument instead.
     *
     * @param typeName - raw C++ type name of enum
     * @returns list of all enum element names
     */
    const char** enumKeys(String typeName) {
        if (!g_enumsByRawTypeName.count(typeName))
            return NULL;
        if (!g_enumsByRawTypeName[typeName].allKeys)
            g_enumsByRawTypeName[typeName].loadAllKeys();
        return (const char**) g_enumsByRawTypeName[typeName].allKeys;
    }

    /** @brief All element names of enum type.
     *
     * Returns a NULL terminated array of C strings of all enum constant names
     * of the given enum @a type. If the requested enum type is unknown, then
     * this function returns @c NULL instead.
     *
     * Use the @c typeid() keyword of C++ to get a @c std::type_info object.
     *
     * @param type - enum type of interest
     * @returns list of all enum element names
     */
    const char** enumKeys(const std::type_info& type) {
        return enumKeys(RAW_CPP_TYPENAME(type));
    }

} // namespace gig
1	/***************************************************************************
2	* *
3	* Copyright (C) 2017 Christian Schoenebeck *
4	* <cuse@users.sourceforge.net> *
5	* *
6	* This library is part of libgig. *
7	* *
8	* This library is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *
12	* *
13	* This library is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *
17	* *
18	* You should have received a copy of the GNU General Public License *
19	* along with this library; if not, write to the Free Software *
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21	* MA 02111-1307 USA *
22	***************************************************************************/
23
24	#include <typeinfo>
25	#include <map>
26	#include <string>
27	#include <stdlib.h>
28	#include <stdint.h>
29	#include <string.h> // for strdup()
30
31	#if defined _MSC_VER // Microsoft compiler ...
32	# define RAW_CPP_TYPENAME(t) t.raw_name()
33	#else // i.e. especially GCC and clang ...
34	# define RAW_CPP_TYPENAME(t) t.name()
35	#endif
36
37	#define RAW_CPP_TYPENAME_OF(type) RAW_CPP_TYPENAME(typeid(type))
38
39	#define GIG_DECLARE_ENUM(type, ...) \
40	enum type { __VA_ARGS__ }; \
41	\
42	struct type##InfoRegistrator { \
43	type##InfoRegistrator() { \
44	const char* typeName = RAW_CPP_TYPENAME_OF(type); \
45	g_enumsByRawTypeName[typeName] = _parseEnumBody( #__VA_ARGS__ ); \
46	} \
47	}; \
48	\
49	static type##InfoRegistrator g_##type##InfoRegistrator
50
51	struct EnumDeclaration {
52	std::map<size_t, std::string> nameByValue;
53	std::map<std::string, size_t> valueByName;
54	char** allKeys;
55
56	EnumDeclaration() : allKeys(NULL) {}
57
58	const size_t countKeys() const { return valueByName.size(); }
59
60	void loadAllKeys() {
61	const size_t n = valueByName.size();
62	allKeys = new char*[n + 1];
63	size_t i = 0;
64	for (std::map<std::string, size_t>::const_iterator it = valueByName.begin();
65	it != valueByName.end(); ++it, ++i)
66	{
67	allKeys[i] = strdup(it->first.c_str());
68	}
69	allKeys[n] = NULL;
70	}
71	};
72
73	struct EnumKeyVal {
74	std::string name;
75	size_t value;
76	bool isValid() const { return !name.empty(); }
77	};
78
79	static std::map<std::string, EnumDeclaration> g_enumsByRawTypeName;
80	static std::map<std::string, size_t> g_allEnumValuesByKey;
81
82
83
84	// ************* Internal functions ************
85	// *
86
87	static inline bool isWhiteSpace(const char& c) {
88	return c == ' ' \|\| c == '\t' \|\| c == '\n' \|\| c == '\r';
89	}
90
91	static size_t decodeEnumValue(const std::string& encodedValue) {
92	return strtoll(encodedValue.c_str(), NULL, 0 /* auto detect base */);
93	}
94
95	static EnumKeyVal _parseEnumKeyVal(const char* start, const char* end, size_t value) {
96	EnumKeyVal keyval;
97
98	if (start >= end)
99	return keyval; // invalid
100	// ignore white space
101	for (; isWhiteSpace(*start); ++start)
102	if (start >= end)
103	return keyval; // invalid
104	if (start >= end)
105	return keyval; // invalid
106
107	// parse key
108	for (const char* p = start; true; ++p) {
109	if (p >= end \|\| isWhiteSpace(p) \|\| p == '=') {
110	const size_t sz = p - start;
111	keyval.name.resize(sz);
112	memcpy(&keyval.name[0], start, sz);
113	keyval.value = value;
114	start = p + 1;
115	break;
116	}
117	}
118
119	if (start >= end)
120	return keyval; // valid, no explicit value provided
121	// seek forward to start of value
122	for (; isWhiteSpace(start) \|\| start == '='; ++start)
123	if (start >= end)
124	return keyval; // valid, no explicit value provided
125	if (start >= end)
126	return keyval; // valid, no explicit value provided
127
128	std::string encodedValue;
129	// parse value portion
130	for (const char* p = start; true; ++p) {
131	if (p >= end \|\| isWhiteSpace(*p)) {
132	const size_t sz = p - start;
133	encodedValue.resize(sz);
134	memcpy(&encodedValue[0], start, sz);
135	break;
136	}
137	}
138
139	if (encodedValue.empty())
140	return keyval; // valid, no explicit value provided
141
142	keyval.value = decodeEnumValue(encodedValue);
143
144	return keyval;
145	}
146
147	static EnumDeclaration _parseEnumBody(const char* body) {
148	EnumDeclaration decl;
149	size_t value = 0;
150	for (const char* a = body, *b = body; true; ++b) {
151	if (b == 0 \|\| b == ',') {
152	const EnumKeyVal keyval = _parseEnumKeyVal(a, b, value);
153	if (!keyval.isValid()) break;
154	decl.nameByValue[keyval.value] = keyval.name;
155	decl.valueByName[keyval.name] = keyval.value;
156	g_allEnumValuesByKey[keyval.name] = keyval.value;
157	value = keyval.value + 1;
158	if (*b == 0) break;
159	a = b + 1;
160	}
161	}
162	return decl;
163	}
164
165	#include "gig.h"
166
167	// ************* gig API functions ************
168	// *
169
170	namespace gig {
171
172	// this has to be defined manually, since leverarge_ctrl_t::type_t is a
173	// class internal member type
174	static leverage_ctrl_t::type_tInfoRegistrator g_leverageCtrlTTypeT;
175
176
177	/** @brief Amount of elements in given enum type.
178	*
179	* Returns the amount of elements of the enum type with raw C++ type name
180	* @a typeName. If the requested enum type is unknown, then this function
181	* returns @c 0 instead.
182	*
183	* Note: you @b MUST pass the raw C++ type name, not a demangled human
184	* readable C++ type name. On doubt use the overloaded function which takes
185	* a @c std::type_info as argument instead.
186	*
187	* @param typeName - raw C++ type name of enum
188	* @returns enum's amount of elements
189	*/
190	size_t enumCount(String typeName) {
191	if (!g_enumsByRawTypeName.count(typeName))
192	return 0;
193	return g_enumsByRawTypeName[typeName].countKeys();
194	}
195
196	/** @brief Amount of elements in given enum type.
197	*
198	* Returns the amount of elements of the enum type given by @a type. If the
199	* requested enum type is unknown, then this function returns @c 0 instead.
200	*
201	* Use the @c typeid() keyword of C++ to get a @c std::type_info object.
202	*
203	* @param type - enum type of interest
204	* @returns enum's amount of elements
205	*/
206	size_t enumCount(const std::type_info& type) {
207	return enumCount(RAW_CPP_TYPENAME(type));
208	}
209
210	/** @brief Numeric value of enum constant.
211	*
212	* Returns the numeric value (assigned at library compile time) to the enum
213	* constant with given @a name. If the requested enum constant is unknown,
214	* then this function returns @c 0 instead.
215	*
216	* @param key - enum constant name
217	* @returns enum constant's numeric value
218	*/
219	size_t enumValue(String key) {
220	if (!g_allEnumValuesByKey.count(key))
221	return 0;
222	return g_allEnumValuesByKey[key];
223	}
224
225	/** @brief Check if enum element exists.
226	*
227	* Checks whether the enum constant with name @a key of enum type with raw
228	* C++ enum type name @a typeName exists. If either the requested enum type
229	* or enum constant is unknown, then this function returns @c false instead.
230	*
231	* Note: you @b MUST pass the raw C++ type name, not a demangled human
232	* readable C++ type name. On doubt use the overloaded function which takes
233	* a @c std::type_info as argument instead.
234	*
235	* @param typeName - raw C++ type name of enum
236	* @param key - name of enum constant
237	* @returns @c true if requested enum element exists
238	*/
239	bool enumKey(String typeName, String key) {
240	if (!g_enumsByRawTypeName.count(typeName))
241	return false;
242	return g_enumsByRawTypeName[typeName].valueByName.count(key);
243	}
244
245	/** @brief Check if enum element exists.
246	*
247	* Checks whether the enum constant with name @a key of requested enum
248	* @a type exists. If either the requested enum type or enum constant is
249	* unknown, then this function returns @c false instead.
250	*
251	* Use the @c typeid() keyword of C++ to get a @c std::type_info object.
252	*
253	* @param type - enum type of interest
254	* @param key - name of enum constant
255	* @returns @c true if requested enum element exists
256	*/
257	bool enumKey(const std::type_info& type, String key) {
258	return enumKey(RAW_CPP_TYPENAME(type), key);
259	}
260
261	/** @brief Enum constant name of numeric value.
262	*
263	* Returns the enum constant name (a.k.a. enum element name) for the given
264	* numeric @a value and the enum type with raw C++ enum type name
265	* @a typeName. If either the requested enum type or enum constant numeric
266	* value is unknown, then this function returns @c NULL instead.
267	*
268	* If the requested enum type contains several enum elements with the
269	* requested numeric enum value, then this function will simply return one
270	* of them, it is undefined which one it would return exactly in this case.
271	*
272	* Note: you @b MUST pass the raw C++ type name, not a demangled human
273	* readable C++ type name. On doubt use the overloaded function which takes
274	* a @c std::type_info as argument instead.
275	*
276	* @param typeName - raw C++ type name of enum
277	* @param value - numeric value of sought enum constant
278	* @returns @c true if requested enum element exists
279	*/
280	const char* enumKey(String typeName, size_t value) {
281	if (!g_enumsByRawTypeName.count(typeName))
282	return NULL;
283	if (!g_enumsByRawTypeName[typeName].nameByValue.count(value))
284	return NULL;
285	return g_enumsByRawTypeName[typeName].nameByValue[value].c_str();
286	}
287
288	/** @brief Enum constant name of numeric value.
289	*
290	* Returns the enum constant name (a.k.a. enum element name) for the given
291	* numeric @a value and the given enum @a type. If either the requested
292	* enum type or enum constant numeric value is unknown, then this function
293	* returns @c NULL instead.
294	*
295	* If the requested enum type contains several enum elements with the
296	* requested numeric enum value, then this function will simply return one
297	* of them, it is undefined which one it would return exactly in this case.
298	*
299	* Use the @c typeid() keyword of C++ to get a @c std::type_info object.
300	*
301	* @param type - enum type of interest
302	* @param value - numeric value of sought enum constant
303	* @returns @c true if requested enum element exists
304	*/
305	const char* enumKey(const std::type_info& type, size_t value) {
306	return enumKey(RAW_CPP_TYPENAME(type), value);
307	}
308
309	/** @brief All element names of enum type.
310	*
311	* Returns a NULL terminated array of C strings of all enum constant names
312	* of the given enum type with raw C++ enum type name @a typeName. If the
313	* requested enum type is unknown, then this function returns @c NULL
314	* instead.
315	*
316	* Note: you @b MUST pass the raw C++ type name, not a demangled human
317	* readable C++ type name. On doubt use the overloaded function which takes
318	* a @c std::type_info as argument instead.
319	*
320	* @param typeName - raw C++ type name of enum
321	* @returns list of all enum element names
322	*/
323	const char** enumKeys(String typeName) {
324	if (!g_enumsByRawTypeName.count(typeName))
325	return NULL;
326	if (!g_enumsByRawTypeName[typeName].allKeys)
327	g_enumsByRawTypeName[typeName].loadAllKeys();
328	return (const char**) g_enumsByRawTypeName[typeName].allKeys;
329	}
330
331	/** @brief All element names of enum type.
332	*
333	* Returns a NULL terminated array of C strings of all enum constant names
334	* of the given enum @a type. If the requested enum type is unknown, then
335	* this function returns @c NULL instead.
336	*
337	* Use the @c typeid() keyword of C++ to get a @c std::type_info object.
338	*
339	* @param type - enum type of interest
340	* @returns list of all enum element names
341	*/
342	const char** enumKeys(const std::type_info& type) {
343	return enumKeys(RAW_CPP_TYPENAME(type));
344	}
345
346	} // namespace gig