-/////////////////////////////////////////////////////////////////////////////\r
-// Name: wx/xtitypes.h\r
-// Purpose: enum, set, basic types support\r
-// Author: Stefan Csomor\r
-// Modified by: Francesco Montorsi\r
-// Created: 27/07/03\r
-// RCS-ID: $Id: xti.h 47299 2007-07-10 15:58:27Z FM $\r
-// Copyright: (c) 1997 Julian Smart\r
-// (c) 2003 Stefan Csomor\r
-// Licence: wxWindows licence\r
-/////////////////////////////////////////////////////////////////////////////\r
-\r
-#ifndef _XTITYPES_H_\r
-#define _XTITYPES_H_\r
-\r
-#include "wx/defs.h"\r
-\r
-#if wxUSE_EXTENDED_RTTI\r
-\r
-#include "wx/string.h"\r
-#include "wx/hashmap.h"\r
-#include "wx/arrstr.h"\r
-#include "wx/flags.h"\r
-#include "wx/intl.h"\r
-#include "wx/log.h"\r
-#include <typeinfo>\r
-\r
-class WXDLLIMPEXP_BASE wxClassInfo;\r
-\r
-// ----------------------------------------------------------------------------\r
-// Enum Support\r
-//\r
-// In the header files XTI requires no change from pure c++ code, however in the\r
-// implementation, an enum needs to be enumerated eg:\r
-//\r
-// wxBEGIN_ENUM( wxFlavor )\r
-// wxENUM_MEMBER( Vanilla )\r
-// wxENUM_MEMBER( Chocolate )\r
-// wxENUM_MEMBER( Strawberry )\r
-// wxEND_ENUM( wxFlavor )\r
-// ----------------------------------------------------------------------------\r
-\r
-struct WXDLLIMPEXP_BASE wxEnumMemberData\r
-{\r
- const wxChar* m_name;\r
- int m_value;\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxEnumData\r
-{\r
-public:\r
- wxEnumData( wxEnumMemberData* data );\r
-\r
- // returns true if the member has been found and sets the int value\r
- // pointed to accordingly (if ptr != null )\r
- // if not found returns false, value left unchanged\r
- bool HasEnumMemberValue( const wxChar *name, int *value = NULL ) const;\r
-\r
- // returns the value of the member, if not found in debug mode an\r
- // assert is issued, in release 0 is returned\r
- int GetEnumMemberValue(const wxChar *name ) const;\r
-\r
- // returns the name of the enum member having the passed in value\r
- // returns an emtpy string if not found\r
- const wxChar *GetEnumMemberName(int value) const;\r
-\r
- // returns the number of members in this enum\r
- int GetEnumCount() const { return m_count; }\r
-\r
- // returns the value of the nth member\r
- int GetEnumMemberValueByIndex( int n ) const;\r
-\r
- // returns the value of the nth member\r
- const wxChar *GetEnumMemberNameByIndex( int n ) const;\r
-\r
-private:\r
- wxEnumMemberData *m_members;\r
- int m_count;\r
-};\r
-\r
-#define wxBEGIN_ENUM( e ) \\r
- wxEnumMemberData s_enumDataMembers##e[] = {\r
-\r
-#define wxENUM_MEMBER( v ) { wxT(#v), v },\r
-\r
-#define wxEND_ENUM( e ) \\r
- { NULL, 0 } }; \\r
- wxEnumData s_enumData##e( s_enumDataMembers##e ); \\r
- wxEnumData *wxGetEnumData(e) { return &s_enumData##e; } \\r
- template<> void wxStringReadValue(const wxString& s, e &data ) \\r
- { data = (e) s_enumData##e.GetEnumMemberValue(s); } \\r
- template<> void wxStringWriteValue(wxString &s, const e &data ) \\r
- { s = s_enumData##e.GetEnumMemberName((int)data); } \\r
- void FromLong##e( long data, wxVariantBase& result ) \\r
- { result = wxVariantBase((e)data); } \\r
- void ToLong##e( const wxVariantBase& data, long &result ) \\r
- { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get, e); } \\r
- \\r
- wxTO_STRING_IMP( e ) \\r
- wxFROM_STRING_IMP( e ) \\r
- wxEnumTypeInfo s_typeInfo##e(wxT_ENUM, &s_enumData##e, \\r
- &wxTO_STRING( e ), &wxFROM_STRING( e ), &ToLong##e, \\r
- &FromLong##e, typeid(e).name() );\r
-\r
-\r
-// ----------------------------------------------------------------------------\r
-// Set Support\r
-//\r
-// in the header :\r
-//\r
-// enum wxFlavor\r
-// {\r
-// Vanilla,\r
-// Chocolate,\r
-// Strawberry,\r
-// };\r
-//\r
-// typedef wxBitset<wxFlavor> wxCoupe;\r
-//\r
-// in the implementation file :\r
-//\r
-// wxBEGIN_ENUM( wxFlavor )\r
-// wxENUM_MEMBER( Vanilla )\r
-// wxENUM_MEMBER( Chocolate )\r
-// wxENUM_MEMBER( Strawberry )\r
-// wxEND_ENUM( wxFlavor )\r
-//\r
-// wxIMPLEMENT_SET_STREAMING( wxCoupe, wxFlavor )\r
-//\r
-// implementation note: no partial specialization for streaming, but a delegation \r
-// to a different class\r
-//\r
-// ----------------------------------------------------------------------------\r
-\r
-// in order to remove dependancy on string tokenizer\r
-void WXDLLIMPEXP_BASE wxSetStringToArray( const wxString &s, wxArrayString &array );\r
-\r
-template<typename e>\r
-void wxSetFromString(const wxString &s, wxBitset<e> &data )\r
-{\r
- wxEnumData* edata = wxGetEnumData((e) 0);\r
- data.reset();\r
-\r
- wxArrayString array;\r
- wxSetStringToArray( s, array );\r
- wxString flag;\r
- for ( int i = 0; i < array.Count(); ++i )\r
- {\r
- flag = array[i];\r
- int ivalue;\r
- if ( edata->HasEnumMemberValue( flag, &ivalue ) )\r
- {\r
- data.set( (e) ivalue );\r
- }\r
- }\r
-}\r
-\r
-template<typename e>\r
-void wxSetToString( wxString &s, const wxBitset<e> &data )\r
-{\r
- wxEnumData* edata = wxGetEnumData((e) 0);\r
- int count = edata->GetEnumCount();\r
- int i;\r
- s.Clear();\r
- for ( i = 0; i < count; i++ )\r
- {\r
- e value = (e) edata->GetEnumMemberValueByIndex(i);\r
- if ( data.test( value ) )\r
- {\r
- // this could also be done by the templated calls\r
- if ( !s.empty() )\r
- s += wxT("|");\r
- s += edata->GetEnumMemberNameByIndex(i);\r
- }\r
- }\r
-}\r
-\r
-#define wxIMPLEMENT_SET_STREAMING(SetName,e) \\r
- template<> void wxStringReadValue(const wxString &s, wxBitset<e> &data ) \\r
- { wxSetFromString( s, data ); } \\r
- template<> void wxStringWriteValue( wxString &s, const wxBitset<e> &data ) \\r
- { wxSetToString( s, data ); } \\r
- void FromLong##SetName( long data, wxVariantBase& result ) \\r
- { result = wxVariantBase(SetName((unsigned long)data)); } \\r
- void ToLong##SetName( const wxVariantBase& data, long &result ) \\r
- { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get, SetName).to_ulong(); } \\r
- wxTO_STRING_IMP( SetName ) \\r
- wxFROM_STRING_IMP( SetName ) \\r
- wxEnumTypeInfo s_typeInfo##SetName(wxT_SET, &s_enumData##e, \\r
- &wxTO_STRING( SetName ), &wxFROM_STRING( SetName ), \\r
- &ToLong##SetName, &FromLong##SetName, typeid(SetName).name() );\r
-\r
-template<typename e>\r
-void wxFlagsFromString(const wxString &s, e &data )\r
-{\r
- wxEnumData* edata = wxGetEnumData((e*) 0);\r
- data.m_data = 0;\r
-\r
- wxArrayString array;\r
- wxSetStringToArray( s, array );\r
- wxString flag;\r
- for ( size_t i = 0; i < array.Count(); ++i )\r
- {\r
- flag = array[i];\r
- int ivalue;\r
- if ( edata->HasEnumMemberValue( flag, &ivalue ) )\r
- {\r
- data.m_data |= ivalue;\r
- }\r
- }\r
-}\r
-\r
-template<typename e>\r
-void wxFlagsToString( wxString &s, const e& data )\r
-{\r
- wxEnumData* edata = wxGetEnumData((e*) 0);\r
- int count = edata->GetEnumCount();\r
- int i;\r
- s.Clear();\r
- long dataValue = data.m_data;\r
- for ( i = 0; i < count; i++ )\r
- {\r
- int value = edata->GetEnumMemberValueByIndex(i);\r
- // make this to allow for multi-bit constants to work\r
- if ( value && ( dataValue & value ) == value )\r
- {\r
- // clear the flags we just set\r
- dataValue &= ~value;\r
- // this could also be done by the templated calls\r
- if ( !s.empty() )\r
- s +=wxT("|");\r
- s += edata->GetEnumMemberNameByIndex(i);\r
- }\r
- }\r
-}\r
-\r
-#define wxBEGIN_FLAGS( e ) \\r
- wxEnumMemberData s_enumDataMembers##e[] = {\r
-\r
-#define wxFLAGS_MEMBER( v ) { wxT(#v), v },\r
-\r
-#define wxEND_FLAGS( e ) \\r
- { NULL, 0 } }; \\r
- wxEnumData s_enumData##e( s_enumDataMembers##e ); \\r
- wxEnumData *wxGetEnumData(e*) { return &s_enumData##e; } \\r
- template<> void wxStringReadValue(const wxString &s, e &data ) \\r
- { wxFlagsFromString<e>( s, data ); } \\r
- template<> void wxStringWriteValue( wxString &s, const e& data ) \\r
- { wxFlagsToString<e>( s, data ); } \\r
- void FromLong##e( long data, wxVariantBase& result ) \\r
- { result = wxVariantBase(e(data)); } \\r
- void ToLong##e( const wxVariantBase& data, long &result ) \\r
- { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get, e).m_data; } \\r
- wxTO_STRING_IMP( e ) \\r
- wxFROM_STRING_IMP( e ) \\r
- wxEnumTypeInfo s_typeInfo##e(wxT_SET, &s_enumData##e, \\r
- &wxTO_STRING( e ), &wxFROM_STRING( e ), &ToLong##e, \\r
- &FromLong##e, typeid(e).name() );\r
-\r
-// ----------------------------------------------------------------------------\r
-// Type Information\r
-// ----------------------------------------------------------------------------\r
-\r
-// All data exposed by the RTTI is characterized using the following classes.\r
-// The first characterization is done by wxTypeKind. All enums up to and including\r
-// wxT_CUSTOM represent so called simple types. These cannot be divided any further.\r
-// They can be converted to and from wxStrings, that's all.\r
-// Other wxTypeKinds can instead be splitted recursively into smaller parts until\r
-// the simple types are reached.\r
-\r
-enum wxTypeKind\r
-{\r
- wxT_VOID = 0, // unknown type\r
- wxT_BOOL,\r
- wxT_CHAR,\r
- wxT_UCHAR,\r
- wxT_INT,\r
- wxT_UINT,\r
- wxT_LONG,\r
- wxT_ULONG,\r
- wxT_FLOAT,\r
- wxT_DOUBLE,\r
- wxT_STRING, // must be wxString\r
- wxT_SET, // must be wxBitset<> template\r
- wxT_ENUM,\r
- wxT_CUSTOM, // user defined type (e.g. wxPoint)\r
-\r
- wxT_LAST_SIMPLE_TYPE_KIND = wxT_CUSTOM,\r
-\r
- wxT_OBJECT_PTR, // object reference\r
- wxT_OBJECT, // embedded object\r
- wxT_COLLECTION, // collection\r
-\r
- wxT_DELEGATE, // for connecting against an event source\r
-\r
- wxT_LAST_TYPE_KIND = wxT_DELEGATE // sentinel for bad data, asserts, debugging\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxVariantBase;\r
-class WXDLLIMPEXP_BASE wxTypeInfo;\r
-\r
-WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxTypeInfo*, wxTypeInfoMap, class WXDLLIMPEXP_BASE );\r
-\r
-class WXDLLIMPEXP_BASE wxTypeInfo\r
-{\r
-public:\r
- typedef void (*wxVariant2StringFnc)( const wxVariantBase& data, wxString &result );\r
- typedef void (*wxString2VariantFnc)( const wxString& data, wxVariantBase &result );\r
-\r
- wxTypeInfo(wxTypeKind kind,\r
- wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL,\r
- const wxString &name = wxEmptyString):\r
- m_toString(to), m_fromString(from), m_kind(kind), m_name(name)\r
- {\r
- Register();\r
- }\r
-#if wxUSE_UNICODE\r
- wxTypeInfo(wxTypeKind kind,\r
- wxVariant2StringFnc to, wxString2VariantFnc from,\r
- const char *name):\r
- m_toString(to), m_fromString(from), m_kind(kind), \r
- m_name(wxString::FromAscii(name))\r
- {\r
- Register();\r
- }\r
-#endif\r
-\r
- virtual ~wxTypeInfo()\r
- {\r
- Unregister();\r
- }\r
-\r
- // return the kind of this type (wxT_... constants)\r
- wxTypeKind GetKind() const { return m_kind; }\r
-\r
- // returns the unique name of this type\r
- const wxString& GetTypeName() const { return m_name; }\r
-\r
- // is this type a delegate type\r
- bool IsDelegateType() const { return m_kind == wxT_DELEGATE; }\r
-\r
- // is this type a custom type\r
- bool IsCustomType() const { return m_kind == wxT_CUSTOM; }\r
-\r
- // is this type an object type\r
- bool IsObjectType() const { return m_kind == wxT_OBJECT || m_kind == wxT_OBJECT_PTR; }\r
-\r
- // can the content of this type be converted to and from strings ?\r
- bool HasStringConverters() const { return m_toString != NULL && m_fromString != NULL; }\r
-\r
- // convert a wxVariantBase holding data of this type into a string\r
- void ConvertToString( const wxVariantBase& data, wxString &result ) const\r
- { \r
- if ( m_toString ) \r
- (*m_toString)( data, result ); \r
- else \r
- wxLogError( wxGetTranslation(_T("String conversions not supported")) ); \r
- }\r
-\r
- // convert a string into a wxVariantBase holding the corresponding data in this type\r
- void ConvertFromString( const wxString& data, wxVariantBase &result ) const\r
- { \r
- if( m_fromString ) \r
- (*m_fromString)( data, result ); \r
- else \r
- wxLogError( wxGetTranslation(_T("String conversions not supported")) ); \r
- }\r
-\r
- // statics:\r
-\r
-#if wxUSE_UNICODE\r
- static wxTypeInfo *FindType(const char *typeName) \r
- { return FindType( wxString::FromAscii(typeName) ); }\r
-#endif\r
- static wxTypeInfo *FindType(const wxChar *typeName);\r
- static wxTypeInfo *FindType(const wxString& typeName)\r
- {\r
-#if wxUSE_UNICODE\r
- return FindType( typeName.wchar_str() );\r
-#else\r
- return FindType( typeName.char_str() );\r
-#endif\r
- }\r
-\r
-private:\r
- void Register();\r
- void Unregister();\r
-\r
- wxVariant2StringFnc m_toString;\r
- wxString2VariantFnc m_fromString;\r
-\r
- wxTypeKind m_kind;\r
- wxString m_name;\r
-\r
- // the static list of all types we know about\r
- static wxTypeInfoMap* ms_typeTable;\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxBuiltInTypeInfo : public wxTypeInfo\r
-{\r
-public:\r
- wxBuiltInTypeInfo( wxTypeKind kind, wxVariant2StringFnc to = NULL, \r
- wxString2VariantFnc from = NULL, \r
- const wxString &name = wxEmptyString ) :\r
- wxTypeInfo( kind, to, from, name )\r
- { wxASSERT_MSG( GetKind() < wxT_SET, wxT("Illegal Kind for Base Type") ); }\r
-\r
-#if wxUSE_UNICODE\r
- wxBuiltInTypeInfo( wxTypeKind kind, wxVariant2StringFnc to, \r
- wxString2VariantFnc from , const char *name ) :\r
- wxTypeInfo( kind, to, from, name )\r
- { wxASSERT_MSG( GetKind() < wxT_SET, wxT("Illegal Kind for Base Type") ); }\r
-#endif\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxCustomTypeInfo : public wxTypeInfo\r
-{\r
-public:\r
- wxCustomTypeInfo( const wxString &name, wxVariant2StringFnc to, \r
- wxString2VariantFnc from ) :\r
- wxTypeInfo( wxT_CUSTOM, to, from, name )\r
- {}\r
-\r
-#if wxUSE_UNICODE\r
- wxCustomTypeInfo( const char *name , wxVariant2StringFnc to, \r
- wxString2VariantFnc from ) :\r
- wxTypeInfo( wxT_CUSTOM, to, from, name )\r
- {}\r
-#endif\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxEnumTypeInfo : public wxTypeInfo\r
-{\r
-public:\r
- typedef void (*converterToLong_t)( const wxVariantBase& data, long &result );\r
- typedef void (*converterFromLong_t)( long data, wxVariantBase &result );\r
-\r
- wxEnumTypeInfo( wxTypeKind kind, wxEnumData* enumInfo, wxVariant2StringFnc to,\r
- wxString2VariantFnc from, converterToLong_t toLong,\r
- converterFromLong_t fromLong, const wxString &name ) :\r
- wxTypeInfo( kind, to, from, name ), m_toLong( toLong ), m_fromLong( fromLong )\r
- { \r
- wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET,\r
- wxT("Illegal Kind for Enum Type")); \r
- m_enumInfo = enumInfo; \r
- }\r
-\r
-#if wxUSE_UNICODE\r
- wxEnumTypeInfo( wxTypeKind kind, wxEnumData* enumInfo, wxVariant2StringFnc to,\r
- wxString2VariantFnc from, converterToLong_t toLong,\r
- converterFromLong_t fromLong, const char * name ) :\r
- wxTypeInfo( kind, to, from, name ), m_toLong( toLong ), m_fromLong( fromLong )\r
- {\r
- wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET, \r
- wxT("Illegal Kind for Enum Type")); \r
- m_enumInfo = enumInfo; \r
- }\r
-#endif\r
- const wxEnumData* GetEnumData() const { return m_enumInfo; }\r
-\r
- // convert a wxVariantBase holding data of this type into a long\r
- void ConvertToLong( const wxVariantBase& data, long &result ) const\r
- { \r
- if( m_toLong ) \r
- (*m_toLong)( data, result ); \r
- else \r
- wxLogError( wxGetTranslation(_T("Long Conversions not supported")) ); \r
- }\r
-\r
- // convert a long into a wxVariantBase holding the corresponding data in this type\r
- void ConvertFromLong( long data, wxVariantBase &result ) const\r
- { \r
- if( m_fromLong ) \r
- (*m_fromLong)( data, result ); \r
- else \r
- wxLogError( wxGetTranslation(_T("Long Conversions not supported")) ); \r
- }\r
-\r
-private:\r
- converterToLong_t m_toLong;\r
- converterFromLong_t m_fromLong;\r
-\r
- wxEnumData *m_enumInfo; // Kind == wxT_ENUM or Kind == wxT_SET\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo\r
-{\r
-public:\r
- wxClassTypeInfo( wxTypeKind kind, wxClassInfo* classInfo, \r
- wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL, \r
- const wxString &name = wxEmptyString);\r
-\r
-#if wxUSE_UNICODE\r
- wxClassTypeInfo( wxTypeKind kind, wxClassInfo* classInfo, wxVariant2StringFnc to,\r
- wxString2VariantFnc from , const char *name );\r
-#endif\r
-\r
- const wxClassInfo *GetClassInfo() const { return m_classInfo; }\r
-\r
-private:\r
- wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxCollectionTypeInfo : public wxTypeInfo\r
-{\r
-public:\r
- wxCollectionTypeInfo( const wxString &elementName, wxVariant2StringFnc to,\r
- wxString2VariantFnc from , const wxString &name) :\r
- wxTypeInfo( wxT_COLLECTION, to, from, name )\r
- { m_elementTypeName = elementName; m_elementType = NULL; }\r
-\r
-#if wxUSE_UNICODE\r
- wxCollectionTypeInfo( const char *elementName, wxVariant2StringFnc to, \r
- wxString2VariantFnc from , const char *name ) :\r
- wxTypeInfo( wxT_COLLECTION, to, from, name )\r
- { m_elementTypeName = wxString::FromAscii( elementName ); m_elementType = NULL; }\r
-#endif\r
-\r
- const wxTypeInfo* GetElementType() const\r
- {\r
- if ( m_elementType == NULL )\r
- m_elementType = wxTypeInfo::FindType( m_elementTypeName );\r
- return m_elementType; \r
- }\r
-\r
-private:\r
- mutable wxTypeInfo * m_elementType;\r
- wxString m_elementTypeName;\r
-};\r
-\r
-class WXDLLIMPEXP_BASE wxEventSourceTypeInfo : public wxTypeInfo\r
-{\r
-public:\r
- wxEventSourceTypeInfo( int eventType, wxClassInfo* eventClass, \r
- wxVariant2StringFnc to = NULL, \r
- wxString2VariantFnc from = NULL );\r
- wxEventSourceTypeInfo( int eventType, int lastEventType, wxClassInfo* eventClass, \r
- wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL );\r
-\r
- int GetEventType() const { return m_eventType; }\r
- int GetLastEventType() const { return m_lastEventType; }\r
- const wxClassInfo* GetEventClass() const { return m_eventClass; }\r
-\r
-private:\r
- const wxClassInfo *m_eventClass; // (extended will merge into classinfo)\r
- int m_eventType;\r
- int m_lastEventType;\r
-};\r
-\r
-template<typename T> const wxTypeInfo* wxGetTypeInfo( T * ) \\r
- { return wxTypeInfo::FindType(typeid(T).name()); }\r
-\r
-// this macro is for usage with custom, non-object derived classes and structs, \r
-// wxPoint is such a custom type\r
-\r
-#if wxUSE_FUNC_TEMPLATE_POINTER\r
- #define wxCUSTOM_TYPE_INFO( e, toString, fromString ) \\r
- wxCustomTypeInfo s_typeInfo##e(typeid(e).name(), &toString, &fromString);\r
-#else\r
- #define wxCUSTOM_TYPE_INFO( e, toString, fromString ) \\r
- void ToString##e( const wxVariantBase& data, wxString &result ) \\r
- { toString(data, result); } \\r
- void FromString##e( const wxString& data, wxVariantBase &result ) \\r
- { fromString(data, result); } \\r
- wxCustomTypeInfo s_typeInfo##e(typeid(e).name(), \\r
- &ToString##e, &FromString##e);\r
-#endif\r
-\r
-#define wxCOLLECTION_TYPE_INFO( element, collection ) \\r
- wxCollectionTypeInfo s_typeInfo##collection( typeid(element).name(), \\r
- NULL, NULL, typeid(collection).name() );\r
-\r
-// sometimes a compiler invents specializations that are nowhere called, \r
-// use this macro to satisfy the refs, currently we don't have to play \r
-// tricks, but if we will have to according to the compiler, we will use \r
-// that macro for that\r
-\r
-#define wxILLEGAL_TYPE_SPECIALIZATION( a )\r
-\r
-#endif // wxUSE_EXTENDED_RTTI\r
-#endif // _XTITYPES_H_\r
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/xtitypes.h
+// Purpose: enum, set, basic types support
+// Author: Stefan Csomor
+// Modified by: Francesco Montorsi
+// Created: 27/07/03
+// RCS-ID: $Id$
+// Copyright: (c) 1997 Julian Smart
+// (c) 2003 Stefan Csomor
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _XTITYPES_H_
+#define _XTITYPES_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_EXTENDED_RTTI
+
+#include "wx/string.h"
+#include "wx/hashmap.h"
+#include "wx/arrstr.h"
+#include "wx/flags.h"
+#include "wx/intl.h"
+#include "wx/log.h"
+#include <typeinfo>
+
+class WXDLLIMPEXP_BASE wxClassInfo;
+
+// ----------------------------------------------------------------------------
+// Enum Support
+//
+// In the header files XTI requires no change from pure c++ code, however in the
+// implementation, an enum needs to be enumerated eg:
+//
+// wxBEGIN_ENUM( wxFlavor )
+// wxENUM_MEMBER( Vanilla )
+// wxENUM_MEMBER( Chocolate )
+// wxENUM_MEMBER( Strawberry )
+// wxEND_ENUM( wxFlavor )
+// ----------------------------------------------------------------------------
+
+struct WXDLLIMPEXP_BASE wxEnumMemberData
+{
+ const wxChar* m_name;
+ int m_value;
+};
+
+class WXDLLIMPEXP_BASE wxEnumData
+{
+public:
+ wxEnumData( wxEnumMemberData* data );
+
+ // returns true if the member has been found and sets the int value
+ // pointed to accordingly (if ptr != null )
+ // if not found returns false, value left unchanged
+ bool HasEnumMemberValue( const wxChar *name, int *value = NULL ) const;
+
+ // returns the value of the member, if not found in debug mode an
+ // assert is issued, in release 0 is returned
+ int GetEnumMemberValue(const wxChar *name ) const;
+
+ // returns the name of the enum member having the passed in value
+ // returns an emtpy string if not found
+ const wxChar *GetEnumMemberName(int value) const;
+
+ // returns the number of members in this enum
+ int GetEnumCount() const { return m_count; }
+
+ // returns the value of the nth member
+ int GetEnumMemberValueByIndex( int n ) const;
+
+ // returns the value of the nth member
+ const wxChar *GetEnumMemberNameByIndex( int n ) const;
+
+private:
+ wxEnumMemberData *m_members;
+ int m_count;
+};
+
+#define wxBEGIN_ENUM( e ) \
+ wxEnumMemberData s_enumDataMembers##e[] = {
+
+#define wxENUM_MEMBER( v ) { wxT(#v), v },
+
+#define wxEND_ENUM( e ) \
+ { NULL, 0 } }; \
+ wxEnumData s_enumData##e( s_enumDataMembers##e ); \
+ wxEnumData *wxGetEnumData(e) { return &s_enumData##e; } \
+ template<> void wxStringReadValue(const wxString& s, e &data ) \
+ { data = (e) s_enumData##e.GetEnumMemberValue(s.c_str()); } \
+ template<> void wxStringWriteValue(wxString &s, const e &data ) \
+ { s = s_enumData##e.GetEnumMemberName((int)data); } \
+ void FromLong##e( long data, wxAny& result ) \
+ { result = wxAny((e)data); } \
+ void ToLong##e( const wxAny& data, long &result ) \
+ { result = (long) (data).As(static_cast<e*>(NULL)); } \
+ \
+ wxTO_STRING_IMP( e ) \
+ wxFROM_STRING_IMP( e ) \
+ wxEnumTypeInfo s_typeInfo##e(wxT_ENUM, &s_enumData##e, \
+ &wxTO_STRING( e ), &wxFROM_STRING( e ), &ToLong##e, \
+ &FromLong##e, typeid(e).name() );
+
+
+// ----------------------------------------------------------------------------
+// Set Support
+//
+// in the header :
+//
+// enum wxFlavor
+// {
+// Vanilla,
+// Chocolate,
+// Strawberry,
+// };
+//
+// typedef wxBitset<wxFlavor> wxCoupe;
+//
+// in the implementation file :
+//
+// wxBEGIN_ENUM( wxFlavor )
+// wxENUM_MEMBER( Vanilla )
+// wxENUM_MEMBER( Chocolate )
+// wxENUM_MEMBER( Strawberry )
+// wxEND_ENUM( wxFlavor )
+//
+// wxIMPLEMENT_SET_STREAMING( wxCoupe, wxFlavor )
+//
+// implementation note: no partial specialization for streaming, but a delegation
+// to a different class
+//
+// ----------------------------------------------------------------------------
+
+void WXDLLIMPEXP_BASE wxSetStringToArray( const wxString &s, wxArrayString &array );
+
+template<typename e>
+void wxSetFromString(const wxString &s, wxBitset<e> &data )
+{
+ wxEnumData* edata = wxGetEnumData((e) 0);
+ data.reset();
+
+ wxArrayString array;
+ wxSetStringToArray( s, array );
+ wxString flag;
+ for ( int i = 0; i < array.Count(); ++i )
+ {
+ flag = array[i];
+ int ivalue;
+ if ( edata->HasEnumMemberValue( flag.c_str(), &ivalue ) )
+ {
+ data.set( (e) ivalue );
+ }
+ }
+}
+
+template<typename e>
+void wxSetToString( wxString &s, const wxBitset<e> &data )
+{
+ wxEnumData* edata = wxGetEnumData((e) 0);
+ int count = edata->GetEnumCount();
+ int i;
+ s.Clear();
+ for ( i = 0; i < count; i++ )
+ {
+ e value = (e) edata->GetEnumMemberValueByIndex(i);
+ if ( data.test( value ) )
+ {
+ // this could also be done by the templated calls
+ if ( !s.empty() )
+ s += wxT("|");
+ s += edata->GetEnumMemberNameByIndex(i);
+ }
+ }
+}
+
+#define wxIMPLEMENT_SET_STREAMING(SetName,e) \
+ template<> void wxStringReadValue(const wxString &s, wxBitset<e> &data ) \
+ { wxSetFromString( s, data ); } \
+ template<> void wxStringWriteValue( wxString &s, const wxBitset<e> &data ) \
+ { wxSetToString( s, data ); } \
+ void FromLong##SetName( long data, wxAny& result ) \
+ { result = wxAny(SetName((unsigned long)data)); } \
+ void ToLong##SetName( const wxAny& data, long &result ) \
+ { result = (long) (data).As(static_cast<SetName*>(NULL)).to_ulong(); } \
+ wxTO_STRING_IMP( SetName ) \
+ wxFROM_STRING_IMP( SetName ) \
+ wxEnumTypeInfo s_typeInfo##SetName(wxT_SET, &s_enumData##e, \
+ &wxTO_STRING( SetName ), &wxFROM_STRING( SetName ), \
+ &ToLong##SetName, &FromLong##SetName, typeid(SetName).name() );
+
+template<typename e>
+void wxFlagsFromString(const wxString &s, e &data )
+{
+ wxEnumData* edata = wxGetEnumData((e*) 0);
+ data.m_data = 0;
+
+ wxArrayString array;
+ wxSetStringToArray( s, array );
+ wxString flag;
+ for ( size_t i = 0; i < array.Count(); ++i )
+ {
+ flag = array[i];
+ int ivalue;
+ if ( edata->HasEnumMemberValue( flag.c_str(), &ivalue ) )
+ {
+ data.m_data |= ivalue;
+ }
+ }
+}
+
+template<typename e>
+void wxFlagsToString( wxString &s, const e& data )
+{
+ wxEnumData* edata = wxGetEnumData((e*) 0);
+ int count = edata->GetEnumCount();
+ int i;
+ s.Clear();
+ long dataValue = data.m_data;
+ for ( i = 0; i < count; i++ )
+ {
+ int value = edata->GetEnumMemberValueByIndex(i);
+ // make this to allow for multi-bit constants to work
+ if ( value && ( dataValue & value ) == value )
+ {
+ // clear the flags we just set
+ dataValue &= ~value;
+ // this could also be done by the templated calls
+ if ( !s.empty() )
+ s +=wxT("|");
+ s += edata->GetEnumMemberNameByIndex(i);
+ }
+ }
+}
+
+#define wxBEGIN_FLAGS( e ) \
+ wxEnumMemberData s_enumDataMembers##e[] = {
+
+#define wxFLAGS_MEMBER( v ) { wxT(#v), static_cast<int>(v) },
+
+#define wxEND_FLAGS( e ) \
+ { NULL, 0 } }; \
+ wxEnumData s_enumData##e( s_enumDataMembers##e ); \
+ wxEnumData *wxGetEnumData(e*) { return &s_enumData##e; } \
+ template<> void wxStringReadValue(const wxString &s, e &data ) \
+ { wxFlagsFromString<e>( s, data ); } \
+ template<> void wxStringWriteValue( wxString &s, const e& data ) \
+ { wxFlagsToString<e>( s, data ); } \
+ void FromLong##e( long data, wxAny& result ) \
+ { result = wxAny(e(data)); } \
+ void ToLong##e( const wxAny& data, long &result ) \
+ { result = (long) (data).As(static_cast<e*>(NULL)).m_data; } \
+ wxTO_STRING_IMP( e ) \
+ wxFROM_STRING_IMP( e ) \
+ wxEnumTypeInfo s_typeInfo##e(wxT_SET, &s_enumData##e, \
+ &wxTO_STRING( e ), &wxFROM_STRING( e ), &ToLong##e, \
+ &FromLong##e, typeid(e).name() );
+
+// ----------------------------------------------------------------------------
+// Type Information
+// ----------------------------------------------------------------------------
+
+// All data exposed by the RTTI is characterized using the following classes.
+// The first characterization is done by wxTypeKind. All enums up to and including
+// wxT_CUSTOM represent so called simple types. These cannot be divided any further.
+// They can be converted to and from wxStrings, that's all.
+// Other wxTypeKinds can instead be splitted recursively into smaller parts until
+// the simple types are reached.
+
+enum wxTypeKind
+{
+ wxT_VOID = 0, // unknown type
+ wxT_BOOL,
+ wxT_CHAR,
+ wxT_UCHAR,
+ wxT_INT,
+ wxT_UINT,
+ wxT_LONG,
+ wxT_ULONG,
+ wxT_LONGLONG,
+ wxT_ULONGLONG,
+ wxT_FLOAT,
+ wxT_DOUBLE,
+ wxT_STRING, // must be wxString
+ wxT_SET, // must be wxBitset<> template
+ wxT_ENUM,
+ wxT_CUSTOM, // user defined type (e.g. wxPoint)
+
+ wxT_LAST_SIMPLE_TYPE_KIND = wxT_CUSTOM,
+
+ wxT_OBJECT_PTR, // object reference
+ wxT_OBJECT, // embedded object
+ wxT_COLLECTION, // collection
+
+ wxT_DELEGATE, // for connecting against an event source
+
+ wxT_LAST_TYPE_KIND = wxT_DELEGATE // sentinel for bad data, asserts, debugging
+};
+
+class WXDLLIMPEXP_BASE wxAny;
+class WXDLLIMPEXP_BASE wxTypeInfo;
+
+WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxTypeInfo*, wxTypeInfoMap, class WXDLLIMPEXP_BASE );
+
+class WXDLLIMPEXP_BASE wxTypeInfo
+{
+public:
+ typedef void (*wxVariant2StringFnc)( const wxAny& data, wxString &result );
+ typedef void (*wxString2VariantFnc)( const wxString& data, wxAny &result );
+
+ wxTypeInfo(wxTypeKind kind,
+ wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL,
+ const wxString &name = wxEmptyString):
+ m_toString(to), m_fromString(from), m_kind(kind), m_name(name)
+ {
+ Register();
+ }
+#if 0 // wxUSE_UNICODE
+ wxTypeInfo(wxTypeKind kind,
+ wxVariant2StringFnc to, wxString2VariantFnc from,
+ const char *name):
+ m_toString(to), m_fromString(from), m_kind(kind),
+ m_name(wxString::FromAscii(name))
+ {
+ Register();
+ }
+#endif
+
+ virtual ~wxTypeInfo()
+ {
+ Unregister();
+ }
+
+ // return the kind of this type (wxT_... constants)
+ wxTypeKind GetKind() const { return m_kind; }
+
+ // returns the unique name of this type
+ const wxString& GetTypeName() const { return m_name; }
+
+ // is this type a delegate type
+ bool IsDelegateType() const { return m_kind == wxT_DELEGATE; }
+
+ // is this type a custom type
+ bool IsCustomType() const { return m_kind == wxT_CUSTOM; }
+
+ // is this type an object type
+ bool IsObjectType() const { return m_kind == wxT_OBJECT || m_kind == wxT_OBJECT_PTR; }
+
+ // can the content of this type be converted to and from strings ?
+ bool HasStringConverters() const { return m_toString != NULL && m_fromString != NULL; }
+
+ // convert a wxAny holding data of this type into a string
+ void ConvertToString( const wxAny& data, wxString &result ) const
+ {
+ if ( m_toString )
+ (*m_toString)( data, result );
+ else
+ wxLogError( wxGetTranslation(wxT("String conversions not supported")) );
+ }
+
+ // convert a string into a wxAny holding the corresponding data in this type
+ void ConvertFromString( const wxString& data, wxAny &result ) const
+ {
+ if( m_fromString )
+ (*m_fromString)( data, result );
+ else
+ wxLogError( wxGetTranslation(wxT("String conversions not supported")) );
+ }
+
+ // statics:
+
+ // looks for the corresponding type, will return NULL if not found
+ static wxTypeInfo *FindType( const wxString& typeName );
+private:
+ void Register();
+ void Unregister();
+
+ wxVariant2StringFnc m_toString;
+ wxString2VariantFnc m_fromString;
+
+ wxTypeKind m_kind;
+ wxString m_name;
+
+ // the static list of all types we know about
+ static wxTypeInfoMap* ms_typeTable;
+};
+
+class WXDLLIMPEXP_BASE wxBuiltInTypeInfo : public wxTypeInfo
+{
+public:
+ wxBuiltInTypeInfo( wxTypeKind kind, wxVariant2StringFnc to = NULL,
+ wxString2VariantFnc from = NULL,
+ const wxString &name = wxEmptyString ) :
+ wxTypeInfo( kind, to, from, name )
+ { wxASSERT_MSG( GetKind() < wxT_SET, wxT("Illegal Kind for Base Type") ); }
+};
+
+class WXDLLIMPEXP_BASE wxCustomTypeInfo : public wxTypeInfo
+{
+public:
+ wxCustomTypeInfo( const wxString &name, wxVariant2StringFnc to,
+ wxString2VariantFnc from ) :
+ wxTypeInfo( wxT_CUSTOM, to, from, name )
+ {}
+};
+
+class WXDLLIMPEXP_BASE wxEnumTypeInfo : public wxTypeInfo
+{
+public:
+ typedef void (*converterToLong_t)( const wxAny& data, long &result );
+ typedef void (*converterFromLong_t)( long data, wxAny &result );
+
+ wxEnumTypeInfo( wxTypeKind kind, wxEnumData* enumInfo, wxVariant2StringFnc to,
+ wxString2VariantFnc from, converterToLong_t toLong,
+ converterFromLong_t fromLong, const wxString &name ) :
+ wxTypeInfo( kind, to, from, name ), m_toLong( toLong ), m_fromLong( fromLong )
+ {
+ wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET,
+ wxT("Illegal Kind for Enum Type"));
+ m_enumInfo = enumInfo;
+ }
+
+ const wxEnumData* GetEnumData() const { return m_enumInfo; }
+
+ // convert a wxAny holding data of this type into a long
+ void ConvertToLong( const wxAny& data, long &result ) const
+ {
+ if( m_toLong )
+ (*m_toLong)( data, result );
+ else
+ wxLogError( wxGetTranslation(wxT("Long Conversions not supported")) );
+ }
+
+ // convert a long into a wxAny holding the corresponding data in this type
+ void ConvertFromLong( long data, wxAny &result ) const
+ {
+ if( m_fromLong )
+ (*m_fromLong)( data, result );
+ else
+ wxLogError( wxGetTranslation(wxT("Long Conversions not supported")) );
+ }
+
+private:
+ converterToLong_t m_toLong;
+ converterFromLong_t m_fromLong;
+
+ wxEnumData *m_enumInfo; // Kind == wxT_ENUM or Kind == wxT_SET
+};
+
+class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo
+{
+public:
+ wxClassTypeInfo( wxTypeKind kind, wxClassInfo* classInfo,
+ wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL,
+ const wxString &name = wxEmptyString);
+
+ const wxClassInfo *GetClassInfo() const { return m_classInfo; }
+
+private:
+ wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL
+};
+
+class WXDLLIMPEXP_BASE wxCollectionTypeInfo : public wxTypeInfo
+{
+public:
+ wxCollectionTypeInfo( const wxString &elementName, wxVariant2StringFnc to,
+ wxString2VariantFnc from , const wxString &name) :
+ wxTypeInfo( wxT_COLLECTION, to, from, name )
+ { m_elementTypeName = elementName; m_elementType = NULL; }
+
+ const wxTypeInfo* GetElementType() const
+ {
+ if ( m_elementType == NULL )
+ m_elementType = wxTypeInfo::FindType( m_elementTypeName );
+ return m_elementType;
+ }
+
+private:
+ mutable wxTypeInfo * m_elementType;
+ wxString m_elementTypeName;
+};
+
+class WXDLLIMPEXP_BASE wxEventSourceTypeInfo : public wxTypeInfo
+{
+public:
+ wxEventSourceTypeInfo( int eventType, wxClassInfo* eventClass,
+ wxVariant2StringFnc to = NULL,
+ wxString2VariantFnc from = NULL );
+ wxEventSourceTypeInfo( int eventType, int lastEventType, wxClassInfo* eventClass,
+ wxVariant2StringFnc to = NULL, wxString2VariantFnc from = NULL );
+
+ int GetEventType() const { return m_eventType; }
+ int GetLastEventType() const { return m_lastEventType; }
+ const wxClassInfo* GetEventClass() const { return m_eventClass; }
+
+private:
+ const wxClassInfo *m_eventClass; // (extended will merge into classinfo)
+ int m_eventType;
+ int m_lastEventType;
+};
+
+template<typename T> const wxTypeInfo* wxGetTypeInfo( T * )
+ { return wxTypeInfo::FindType(typeid(T).name()); }
+
+// this macro is for usage with custom, non-object derived classes and structs,
+// wxPoint is such a custom type
+
+#if wxUSE_FUNC_TEMPLATE_POINTER
+ #define wxCUSTOM_TYPE_INFO( e, toString, fromString ) \
+ wxCustomTypeInfo s_typeInfo##e(typeid(e).name(), &toString, &fromString);
+#else
+ #define wxCUSTOM_TYPE_INFO( e, toString, fromString ) \
+ void ToString##e( const wxAny& data, wxString &result ) \
+ { toString(data, result); } \
+ void FromString##e( const wxString& data, wxAny &result ) \
+ { fromString(data, result); } \
+ wxCustomTypeInfo s_typeInfo##e(typeid(e).name(), \
+ &ToString##e, &FromString##e);
+#endif
+
+#define wxCOLLECTION_TYPE_INFO( element, collection ) \
+ wxCollectionTypeInfo s_typeInfo##collection( typeid(element).name(), \
+ NULL, NULL, typeid(collection).name() );
+
+// sometimes a compiler invents specializations that are nowhere called,
+// use this macro to satisfy the refs, currently we don't have to play
+// tricks, but if we will have to according to the compiler, we will use
+// that macro for that
+
+#define wxILLEGAL_TYPE_SPECIALIZATION( a )
+
+#endif // wxUSE_EXTENDED_RTTI
+#endif // _XTITYPES_H_
projects / wxWidgets.git / blobdiff