]> git.saurik.com Git - wxWidgets.git/blame - include/wx/xtitypes.h
reverting AssignAny fix, not needed if wxAny is not instantiated during static global...
[wxWidgets.git] / include / wx / xtitypes.h
CommitLineData
e1d3601a
PC
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/xtitypes.h
3// Purpose: enum, set, basic types support
4// Author: Stefan Csomor
5// Modified by: Francesco Montorsi
6// Created: 27/07/03
7// RCS-ID: $Id$
8// Copyright: (c) 1997 Julian Smart
9// (c) 2003 Stefan Csomor
10// Licence: wxWindows licence
11/////////////////////////////////////////////////////////////////////////////
12
13#ifndef _XTITYPES_H_
14#define _XTITYPES_H_
15
16#include "wx/defs.h"
17
18#if wxUSE_EXTENDED_RTTI
19
20#include "wx/string.h"
21#include "wx/hashmap.h"
22#include "wx/arrstr.h"
23#include "wx/flags.h"
24#include "wx/intl.h"
25#include "wx/log.h"
26#include <typeinfo>
27
28class WXDLLIMPEXP_BASE wxClassInfo;
29
30// ----------------------------------------------------------------------------
31// Enum Support
32//
33// In the header files XTI requires no change from pure c++ code, however in the
34// implementation, an enum needs to be enumerated eg:
35//
36// wxBEGIN_ENUM( wxFlavor )
37// wxENUM_MEMBER( Vanilla )
38// wxENUM_MEMBER( Chocolate )
39// wxENUM_MEMBER( Strawberry )
40// wxEND_ENUM( wxFlavor )
41// ----------------------------------------------------------------------------
42
43struct WXDLLIMPEXP_BASE wxEnumMemberData
44{
45 const wxChar* m_name;
46 int m_value;
47};
48
49class WXDLLIMPEXP_BASE wxEnumData
50{
51public:
52 wxEnumData( wxEnumMemberData* data );
53
54 // returns true if the member has been found and sets the int value
55 // pointed to accordingly (if ptr != null )
56 // if not found returns false, value left unchanged
57 bool HasEnumMemberValue( const wxChar *name, int *value = NULL ) const;
58
59 // returns the value of the member, if not found in debug mode an
60 // assert is issued, in release 0 is returned
61 int GetEnumMemberValue(const wxChar *name ) const;
62
63 // returns the name of the enum member having the passed in value
64 // returns an emtpy string if not found
65 const wxChar *GetEnumMemberName(int value) const;
66
67 // returns the number of members in this enum
68 int GetEnumCount() const { return m_count; }
69
70 // returns the value of the nth member
71 int GetEnumMemberValueByIndex( int n ) const;
72
73 // returns the value of the nth member
74 const wxChar *GetEnumMemberNameByIndex( int n ) const;
75
76private:
77 wxEnumMemberData *m_members;
78 int m_count;
79};
80
81#define wxBEGIN_ENUM( e ) \
82 wxEnumMemberData s_enumDataMembers##e[] = {
83
84#define wxENUM_MEMBER( v ) { wxT(#v), v },
85
86#define wxEND_ENUM( e ) \
87 { NULL, 0 } }; \
88 wxEnumData s_enumData##e( s_enumDataMembers##e ); \
89 wxEnumData *wxGetEnumData(e) { return &s_enumData##e; } \
90 template<> void wxStringReadValue(const wxString& s, e &data ) \
91 { data = (e) s_enumData##e.GetEnumMemberValue(s); } \
92 template<> void wxStringWriteValue(wxString &s, const e &data ) \
93 { s = s_enumData##e.GetEnumMemberName((int)data); } \
94 void FromLong##e( long data, wxVariantBase& result ) \
95 { result = wxVariantBase((e)data); } \
96 void ToLong##e( const wxVariantBase& data, long &result ) \
97 { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get, e); } \
98 \
99 wxTO_STRING_IMP( e ) \
100 wxFROM_STRING_IMP( e ) \
101 wxEnumTypeInfo s_typeInfo##e(wxT_ENUM, &s_enumData##e, \
102 &wxTO_STRING( e ), &wxFROM_STRING( e ), &ToLong##e, \
103 &FromLong##e, typeid(e).name() );
104
105
106// ----------------------------------------------------------------------------
107// Set Support
108//
109// in the header :
110//
111// enum wxFlavor
112// {
113// Vanilla,
114// Chocolate,
115// Strawberry,
116// };
117//
118// typedef wxBitset<wxFlavor> wxCoupe;
119//
120// in the implementation file :
121//
122// wxBEGIN_ENUM( wxFlavor )
123// wxENUM_MEMBER( Vanilla )
124// wxENUM_MEMBER( Chocolate )
125// wxENUM_MEMBER( Strawberry )
126// wxEND_ENUM( wxFlavor )
127//
128// wxIMPLEMENT_SET_STREAMING( wxCoupe, wxFlavor )
129//
130// implementation note: no partial specialization for streaming, but a delegation
131// to a different class
132//
133// ----------------------------------------------------------------------------
134
135// in order to remove dependancy on string tokenizer
136void WXDLLIMPEXP_BASE wxSetStringToArray( const wxString &s, wxArrayString &array );
137
138template<typename e>
139void wxSetFromString(const wxString &s, wxBitset<e> &data )
140{
141 wxEnumData* edata = wxGetEnumData((e) 0);
142 data.reset();
143
144 wxArrayString array;
145 wxSetStringToArray( s, array );
146 wxString flag;
147 for ( int i = 0; i < array.Count(); ++i )
148 {
149 flag = array[i];
150 int ivalue;
151 if ( edata->HasEnumMemberValue( flag, &ivalue ) )
152 {
153 data.set( (e) ivalue );
154 }
155 }
156}
157
158template<typename e>
159void wxSetToString( wxString &s, const wxBitset<e> &data )
160{
161 wxEnumData* edata = wxGetEnumData((e) 0);
162 int count = edata->GetEnumCount();
163 int i;
164 s.Clear();
165 for ( i = 0; i < count; i++ )
166 {
167 e value = (e) edata->GetEnumMemberValueByIndex(i);
168 if ( data.test( value ) )
169 {
170 // this could also be done by the templated calls
171 if ( !s.empty() )
172 s += wxT("|");
173 s += edata->GetEnumMemberNameByIndex(i);
174 }
175 }
176}
177
178#define wxIMPLEMENT_SET_STREAMING(SetName,e) \
179 template<> void wxStringReadValue(const wxString &s, wxBitset<e> &data ) \
180 { wxSetFromString( s, data ); } \
181 template<> void wxStringWriteValue( wxString &s, const wxBitset<e> &data ) \
182 { wxSetToString( s, data ); } \
183 void FromLong##SetName( long data, wxVariantBase& result ) \
184 { result = wxVariantBase(SetName((unsigned long)data)); } \
185 void ToLong##SetName( const wxVariantBase& data, long &result ) \
186 { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get, SetName).to_ulong(); } \
187 wxTO_STRING_IMP( SetName ) \
188 wxFROM_STRING_IMP( SetName ) \
189 wxEnumTypeInfo s_typeInfo##SetName(wxT_SET, &s_enumData##e, \
190 &wxTO_STRING( SetName ), &wxFROM_STRING( SetName ), \
191 &ToLong##SetName, &FromLong##SetName, typeid(SetName).name() );
192
193template<typename e>
194void wxFlagsFromString(const wxString &s, e &data )
195{
196 wxEnumData* edata = wxGetEnumData((e*) 0);
197 data.m_data = 0;
198
199 wxArrayString array;
200 wxSetStringToArray( s, array );
201 wxString flag;
202 for ( size_t i = 0; i < array.Count(); ++i )
203 {
204 flag = array[i];
205 int ivalue;
206 if ( edata->HasEnumMemberValue( flag, &ivalue ) )
207 {
208 data.m_data |= ivalue;
209 }
210 }
211}
212
213template<typename e>
214void wxFlagsToString( wxString &s, const e& data )
215{
216 wxEnumData* edata = wxGetEnumData((e*) 0);
217 int count = edata->GetEnumCount();
218 int i;
219 s.Clear();
220 long dataValue = data.m_data;
221 for ( i = 0; i < count; i++ )
222 {
223 int value = edata->GetEnumMemberValueByIndex(i);
224 // make this to allow for multi-bit constants to work
225 if ( value && ( dataValue & value ) == value )
226 {
227 // clear the flags we just set
228 dataValue &= ~value;
229 // this could also be done by the templated calls
230 if ( !s.empty() )
231 s +=wxT("|");
232 s += edata->GetEnumMemberNameByIndex(i);
233 }
234 }
235}
236
237#define wxBEGIN_FLAGS( e ) \
238 wxEnumMemberData s_enumDataMembers##e[] = {
239
240#define wxFLAGS_MEMBER( v ) { wxT(#v), v },
241
242#define wxEND_FLAGS( e ) \
243 { NULL, 0 } }; \
244 wxEnumData s_enumData##e( s_enumDataMembers##e ); \
245 wxEnumData *wxGetEnumData(e*) { return &s_enumData##e; } \
246 template<> void wxStringReadValue(const wxString &s, e &data ) \
247 { wxFlagsFromString<e>( s, data ); } \
248 template<> void wxStringWriteValue( wxString &s, const e& data ) \
249 { wxFlagsToString<e>( s, data ); } \
250 void FromLong##e( long data, wxVariantBase& result ) \
251 { result = wxVariantBase(e(data)); } \
252 void ToLong##e( const wxVariantBase& data, long &result ) \
253 { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get, e).m_data; } \
254 wxTO_STRING_IMP( e ) \
255 wxFROM_STRING_IMP( e ) \
256 wxEnumTypeInfo s_typeInfo##e(wxT_SET, &s_enumData##e, \
257 &wxTO_STRING( e ), &wxFROM_STRING( e ), &ToLong##e, \
258 &FromLong##e, typeid(e).name() );
259
260// ----------------------------------------------------------------------------
261// Type Information
262// ----------------------------------------------------------------------------
263
264// All data exposed by the RTTI is characterized using the following classes.
265// The first characterization is done by wxTypeKind. All enums up to and including
266// wxT_CUSTOM represent so called simple types. These cannot be divided any further.
267// They can be converted to and from wxStrings, that's all.
268// Other wxTypeKinds can instead be splitted recursively into smaller parts until
269// the simple types are reached.
270
271enum wxTypeKind
272{
273 wxT_VOID = 0, // unknown type
274 wxT_BOOL,
275 wxT_CHAR,
276 wxT_UCHAR,
277 wxT_INT,
278 wxT_UINT,
279 wxT_LONG,
280 wxT_ULONG,
281 wxT_FLOAT,
282 wxT_DOUBLE,
283 wxT_STRING, // must be wxString
284 wxT_SET, // must be wxBitset<> template
285 wxT_ENUM,
286 wxT_CUSTOM, // user defined type (e.g. wxPoint)
287
288 wxT_LAST_SIMPLE_TYPE_KIND = wxT_CUSTOM,
289
290 wxT_OBJECT_PTR, // object reference
291 wxT_OBJECT, // embedded object
292 wxT_COLLECTION, // collection
293
294 wxT_DELEGATE, // for connecting against an event source
295
296 wxT_LAST_TYPE_KIND = wxT_DELEGATE // sentinel for bad data, asserts, debugging
297};
298
299class WXDLLIMPEXP_BASE wxVariantBase;
300class WXDLLIMPEXP_BASE wxTypeInfo;
301
302WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxTypeInfo*, wxTypeInfoMap, class WXDLLIMPEXP_BASE );
303
304class WXDLLIMPEXP_BASE wxTypeInfo
305{
306public:
307 typedef void (*wxVariant2StringFnc)( const wxVariantBase& data, wxString &result );
308 typedef void (*wxString2VariantFnc)( const wxString& data, wxVariantBase &result );
309
310 wxTypeInfo(wxTypeKind kind,
311 wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL,
312 const wxString &name = wxEmptyString):
313 m_toString(to), m_fromString(from), m_kind(kind), m_name(name)
314 {
315 Register();
316 }
317#if wxUSE_UNICODE
318 wxTypeInfo(wxTypeKind kind,
319 wxVariant2StringFnc to, wxString2VariantFnc from,
320 const char *name):
321 m_toString(to), m_fromString(from), m_kind(kind),
322 m_name(wxString::FromAscii(name))
323 {
324 Register();
325 }
326#endif
327
328 virtual ~wxTypeInfo()
329 {
330 Unregister();
331 }
332
333 // return the kind of this type (wxT_... constants)
334 wxTypeKind GetKind() const { return m_kind; }
335
336 // returns the unique name of this type
337 const wxString& GetTypeName() const { return m_name; }
338
339 // is this type a delegate type
340 bool IsDelegateType() const { return m_kind == wxT_DELEGATE; }
341
342 // is this type a custom type
343 bool IsCustomType() const { return m_kind == wxT_CUSTOM; }
344
345 // is this type an object type
346 bool IsObjectType() const { return m_kind == wxT_OBJECT || m_kind == wxT_OBJECT_PTR; }
347
348 // can the content of this type be converted to and from strings ?
349 bool HasStringConverters() const { return m_toString != NULL && m_fromString != NULL; }
350
351 // convert a wxVariantBase holding data of this type into a string
352 void ConvertToString( const wxVariantBase& data, wxString &result ) const
353 {
354 if ( m_toString )
355 (*m_toString)( data, result );
356 else
357 wxLogError( wxGetTranslation(_T("String conversions not supported")) );
358 }
359
360 // convert a string into a wxVariantBase holding the corresponding data in this type
361 void ConvertFromString( const wxString& data, wxVariantBase &result ) const
362 {
363 if( m_fromString )
364 (*m_fromString)( data, result );
365 else
366 wxLogError( wxGetTranslation(_T("String conversions not supported")) );
367 }
368
369 // statics:
370
371#if wxUSE_UNICODE
372 static wxTypeInfo *FindType(const char *typeName)
373 { return FindType( wxString::FromAscii(typeName) ); }
374#endif
375 static wxTypeInfo *FindType(const wxChar *typeName);
376 static wxTypeInfo *FindType(const wxString& typeName)
377 {
378#if wxUSE_UNICODE
379 return FindType( typeName.wchar_str() );
380#else
381 return FindType( typeName.char_str() );
382#endif
383 }
384
385private:
386 void Register();
387 void Unregister();
388
389 wxVariant2StringFnc m_toString;
390 wxString2VariantFnc m_fromString;
391
392 wxTypeKind m_kind;
393 wxString m_name;
394
395 // the static list of all types we know about
396 static wxTypeInfoMap* ms_typeTable;
397};
398
399class WXDLLIMPEXP_BASE wxBuiltInTypeInfo : public wxTypeInfo
400{
401public:
402 wxBuiltInTypeInfo( wxTypeKind kind, wxVariant2StringFnc to = NULL,
403 wxString2VariantFnc from = NULL,
404 const wxString &name = wxEmptyString ) :
405 wxTypeInfo( kind, to, from, name )
406 { wxASSERT_MSG( GetKind() < wxT_SET, wxT("Illegal Kind for Base Type") ); }
407
408#if wxUSE_UNICODE
409 wxBuiltInTypeInfo( wxTypeKind kind, wxVariant2StringFnc to,
410 wxString2VariantFnc from , const char *name ) :
411 wxTypeInfo( kind, to, from, name )
412 { wxASSERT_MSG( GetKind() < wxT_SET, wxT("Illegal Kind for Base Type") ); }
413#endif
414};
415
416class WXDLLIMPEXP_BASE wxCustomTypeInfo : public wxTypeInfo
417{
418public:
419 wxCustomTypeInfo( const wxString &name, wxVariant2StringFnc to,
420 wxString2VariantFnc from ) :
421 wxTypeInfo( wxT_CUSTOM, to, from, name )
422 {}
423
424#if wxUSE_UNICODE
425 wxCustomTypeInfo( const char *name , wxVariant2StringFnc to,
426 wxString2VariantFnc from ) :
427 wxTypeInfo( wxT_CUSTOM, to, from, name )
428 {}
429#endif
430};
431
432class WXDLLIMPEXP_BASE wxEnumTypeInfo : public wxTypeInfo
433{
434public:
435 typedef void (*converterToLong_t)( const wxVariantBase& data, long &result );
436 typedef void (*converterFromLong_t)( long data, wxVariantBase &result );
437
438 wxEnumTypeInfo( wxTypeKind kind, wxEnumData* enumInfo, wxVariant2StringFnc to,
439 wxString2VariantFnc from, converterToLong_t toLong,
440 converterFromLong_t fromLong, const wxString &name ) :
441 wxTypeInfo( kind, to, from, name ), m_toLong( toLong ), m_fromLong( fromLong )
442 {
443 wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET,
444 wxT("Illegal Kind for Enum Type"));
445 m_enumInfo = enumInfo;
446 }
447
448#if wxUSE_UNICODE
449 wxEnumTypeInfo( wxTypeKind kind, wxEnumData* enumInfo, wxVariant2StringFnc to,
450 wxString2VariantFnc from, converterToLong_t toLong,
451 converterFromLong_t fromLong, const char * name ) :
452 wxTypeInfo( kind, to, from, name ), m_toLong( toLong ), m_fromLong( fromLong )
453 {
454 wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET,
455 wxT("Illegal Kind for Enum Type"));
456 m_enumInfo = enumInfo;
457 }
458#endif
459 const wxEnumData* GetEnumData() const { return m_enumInfo; }
460
461 // convert a wxVariantBase holding data of this type into a long
462 void ConvertToLong( const wxVariantBase& data, long &result ) const
463 {
464 if( m_toLong )
465 (*m_toLong)( data, result );
466 else
467 wxLogError( wxGetTranslation(_T("Long Conversions not supported")) );
468 }
469
470 // convert a long into a wxVariantBase holding the corresponding data in this type
471 void ConvertFromLong( long data, wxVariantBase &result ) const
472 {
473 if( m_fromLong )
474 (*m_fromLong)( data, result );
475 else
476 wxLogError( wxGetTranslation(_T("Long Conversions not supported")) );
477 }
478
479private:
480 converterToLong_t m_toLong;
481 converterFromLong_t m_fromLong;
482
483 wxEnumData *m_enumInfo; // Kind == wxT_ENUM or Kind == wxT_SET
484};
485
486class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo
487{
488public:
489 wxClassTypeInfo( wxTypeKind kind, wxClassInfo* classInfo,
490 wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL,
491 const wxString &name = wxEmptyString);
492
493#if wxUSE_UNICODE
494 wxClassTypeInfo( wxTypeKind kind, wxClassInfo* classInfo, wxVariant2StringFnc to,
495 wxString2VariantFnc from , const char *name );
496#endif
497
498 const wxClassInfo *GetClassInfo() const { return m_classInfo; }
499
500private:
501 wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL
502};
503
504class WXDLLIMPEXP_BASE wxCollectionTypeInfo : public wxTypeInfo
505{
506public:
507 wxCollectionTypeInfo( const wxString &elementName, wxVariant2StringFnc to,
508 wxString2VariantFnc from , const wxString &name) :
509 wxTypeInfo( wxT_COLLECTION, to, from, name )
510 { m_elementTypeName = elementName; m_elementType = NULL; }
511
512#if wxUSE_UNICODE
513 wxCollectionTypeInfo( const char *elementName, wxVariant2StringFnc to,
514 wxString2VariantFnc from , const char *name ) :
515 wxTypeInfo( wxT_COLLECTION, to, from, name )
516 { m_elementTypeName = wxString::FromAscii( elementName ); m_elementType = NULL; }
517#endif
518
519 const wxTypeInfo* GetElementType() const
520 {
521 if ( m_elementType == NULL )
522 m_elementType = wxTypeInfo::FindType( m_elementTypeName );
523 return m_elementType;
524 }
525
526private:
527 mutable wxTypeInfo * m_elementType;
528 wxString m_elementTypeName;
529};
530
531class WXDLLIMPEXP_BASE wxEventSourceTypeInfo : public wxTypeInfo
532{
533public:
534 wxEventSourceTypeInfo( int eventType, wxClassInfo* eventClass,
535 wxVariant2StringFnc to = NULL,
536 wxString2VariantFnc from = NULL );
537 wxEventSourceTypeInfo( int eventType, int lastEventType, wxClassInfo* eventClass,
538 wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL );
539
540 int GetEventType() const { return m_eventType; }
541 int GetLastEventType() const { return m_lastEventType; }
542 const wxClassInfo* GetEventClass() const { return m_eventClass; }
543
544private:
545 const wxClassInfo *m_eventClass; // (extended will merge into classinfo)
546 int m_eventType;
547 int m_lastEventType;
548};
549
550template<typename T> const wxTypeInfo* wxGetTypeInfo( T * ) \
551 { return wxTypeInfo::FindType(typeid(T).name()); }
552
553// this macro is for usage with custom, non-object derived classes and structs,
554// wxPoint is such a custom type
555
556#if wxUSE_FUNC_TEMPLATE_POINTER
557 #define wxCUSTOM_TYPE_INFO( e, toString, fromString ) \
558 wxCustomTypeInfo s_typeInfo##e(typeid(e).name(), &toString, &fromString);
559#else
560 #define wxCUSTOM_TYPE_INFO( e, toString, fromString ) \
561 void ToString##e( const wxVariantBase& data, wxString &result ) \
562 { toString(data, result); } \
563 void FromString##e( const wxString& data, wxVariantBase &result ) \
564 { fromString(data, result); } \
565 wxCustomTypeInfo s_typeInfo##e(typeid(e).name(), \
566 &ToString##e, &FromString##e);
567#endif
568
569#define wxCOLLECTION_TYPE_INFO( element, collection ) \
570 wxCollectionTypeInfo s_typeInfo##collection( typeid(element).name(), \
571 NULL, NULL, typeid(collection).name() );
572
573// sometimes a compiler invents specializations that are nowhere called,
574// use this macro to satisfy the refs, currently we don't have to play
575// tricks, but if we will have to according to the compiler, we will use
576// that macro for that
577
578#define wxILLEGAL_TYPE_SPECIALIZATION( a )
579
580#endif // wxUSE_EXTENDED_RTTI
581#endif // _XTITYPES_H_