-/////////////////////////////////////////////////////////////////////////////\r
-// Name: wx/variantbase.h\r
-// Purpose: wxVariantBase class, a minimal version of wxVariant used by XTI\r
-// Author: Julian Smart\r
-// Modified by: Francesco Montorsi\r
-// Created: 10/09/98\r
-// RCS-ID: $Id: variant.h 44625 2007-03-07 11:35:04Z VZ $\r
-// Copyright: (c) Julian Smart\r
-// Licence: wxWindows licence\r
-/////////////////////////////////////////////////////////////////////////////\r
-\r
-#ifndef _WX_VARIANTBASE_H_\r
-#define _WX_VARIANTBASE_H_\r
-\r
-#include "wx/defs.h"\r
-\r
-#if wxUSE_VARIANT\r
-\r
-#include "wx/string.h"\r
-#include "wx/arrstr.h"\r
-#include "wx/cpp.h"\r
-#include <typeinfo>\r
-\r
-#if wxUSE_DATETIME\r
- #include "wx/datetime.h"\r
-#endif // wxUSE_DATETIME\r
-\r
-#include "wx/iosfwrap.h"\r
-\r
-class wxTypeInfo;\r
-class wxObject;\r
-class wxClassInfo;\r
-\r
-/*\r
- * wxVariantData stores the actual data in a wxVariant object,\r
- * to allow it to store any type of data.\r
- * Derive from this to provide custom data handling.\r
- *\r
- * NB: To prevent addition of extra vtbl pointer to wxVariantData,\r
- * we don't multiple-inherit from wxObjectRefData. Instead,\r
- * we simply replicate the wxObject ref-counting scheme.\r
- *\r
- * NB: When you construct a wxVariantData, it will have refcount\r
- * of one. Refcount will not be further increased when\r
- * it is passed to wxVariant. This simulates old common\r
- * scenario where wxVariant took ownership of wxVariantData\r
- * passed to it.\r
- * If you create wxVariantData for other reasons than passing\r
- * it to wxVariant, technically you are not required to call\r
- * DecRef() before deleting it.\r
- *\r
- * TODO: in order to replace wxPropertyValue, we would need\r
- * to consider adding constructors that take pointers to C++ variables,\r
- * or removing that functionality from the wxProperty library.\r
- * Essentially wxPropertyValue takes on some of the wxValidator functionality\r
- * by storing pointers and not just actual values, allowing update of C++ data\r
- * to be handled automatically. Perhaps there's another way of doing this without\r
- * overloading wxVariant with unnecessary functionality.\r
- */\r
-\r
-class WXDLLIMPEXP_BASE wxVariantData\r
-{\r
- friend class wxVariantBase;\r
-\r
-public:\r
- wxVariantData()\r
- : m_count(1)\r
- { }\r
-\r
-#if wxUSE_STD_IOSTREAM\r
- virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; }\r
- virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }\r
-#endif\r
- virtual bool Write(wxString& WXUNUSED(str)) const { return false; }\r
- virtual bool Read(wxString& WXUNUSED(str)) { return false; }\r
-\r
- // Override these to provide common functionality\r
- virtual bool Eq(wxVariantData& data) const = 0;\r
-\r
- // What type is it? Return a string name.\r
- virtual wxString GetType() const = 0;\r
-\r
- // returns the type info of the content\r
- virtual const wxTypeInfo* GetTypeInfo() const = 0;\r
-\r
- // If it based on wxObject return the ClassInfo.\r
- virtual wxClassInfo* GetValueClassInfo() { return NULL; }\r
-\r
- int GetRefCount() const \r
- { return m_count; }\r
- void IncRef() \r
- { m_count++; }\r
- void DecRef()\r
- {\r
- if ( --m_count == 0 )\r
- delete this;\r
- }\r
-\r
-protected:\r
- // Protected dtor should make some incompatible code\r
- // break more louder. That is, they should do data->DecRef()\r
- // instead of delete data.\r
- virtual ~wxVariantData() {}\r
-\r
-private:\r
- int m_count;\r
-};\r
-\r
-template<typename T> class wxVariantDataT : public wxVariantData\r
-{\r
-public:\r
- wxVariantDataT(const T& d) : m_data(d) {}\r
- virtual ~wxVariantDataT() {}\r
-\r
- // get a ref to the stored data\r
- T & Get() { return m_data; }\r
-\r
- // get a const ref to the stored data\r
- const T & Get() const { return m_data; }\r
-\r
- // set the data\r
- void Set(const T& d) { m_data = d; }\r
-\r
- // Override these to provide common functionality\r
- virtual bool Eq(wxVariantData& WXUNUSED(data)) const\r
- { return false; /* FIXME!! */ }\r
-\r
- // What type is it? Return a string name.\r
- virtual wxString GetType() const\r
- { return GetTypeInfo()->GetTypeName(); }\r
-\r
- // return a heap allocated duplicate\r
- //virtual wxVariantData* Clone() const { return new wxVariantDataT<T>( Get() ); }\r
-\r
- // returns the type info of the contentc\r
- virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ); }\r
-\r
-private:\r
- T m_data;\r
-};\r
-\r
-\r
-/*\r
- * wxVariantBase can store any kind of data, but has some basic types\r
- * built in.\r
- */\r
-\r
-class WXDLLIMPEXP_BASE wxVariantBase\r
-{\r
-public:\r
- wxVariantBase();\r
- wxVariantBase(const wxVariantBase& variant);\r
- wxVariantBase(wxVariantData* data, const wxString& name = wxEmptyString);\r
-\r
- template<typename T> \r
- wxVariantBase(const T& data, const wxString& name = wxEmptyString) :\r
- m_data(new wxVariantDataT<T>(data)), m_name(name) {}\r
-\r
- virtual ~wxVariantBase();\r
-\r
- // generic assignment\r
- void operator= (const wxVariantBase& variant);\r
-\r
- // Assignment using data, e.g.\r
- // myVariant = new wxStringVariantData("hello");\r
- void operator= (wxVariantData* variantData);\r
-\r
- bool operator== (const wxVariantBase& variant) const;\r
- bool operator!= (const wxVariantBase& variant) const;\r
-\r
- // Sets/gets name\r
- inline void SetName(const wxString& name) { m_name = name; }\r
- inline const wxString& GetName() const { return m_name; }\r
-\r
- // Tests whether there is data\r
- bool IsNull() const;\r
-\r
- // FIXME: used by wxVariantBase code but is nice wording...\r
- bool IsEmpty() const { return IsNull(); }\r
-\r
- // For compatibility with wxWidgets <= 2.6, this doesn't increase\r
- // reference count.\r
- wxVariantData* GetData() const { return m_data; }\r
- void SetData(wxVariantData* data) ;\r
-\r
- // make a 'clone' of the object\r
- void Ref(const wxVariantBase& clone);\r
-\r
- // destroy a reference\r
- void UnRef();\r
-\r
- // Make NULL (i.e. delete the data)\r
- void MakeNull();\r
-\r
- // write contents to a string (e.g. for debugging)\r
- wxString MakeString() const;\r
-\r
- // Delete data and name\r
- void Clear();\r
-\r
- // Returns a string representing the type of the variant,\r
- // e.g. "string", "bool", "stringlist", "list", "double", "long"\r
- wxString GetType() const;\r
-\r
- bool IsType(const wxString& type) const;\r
- bool IsValueKindOf(const wxClassInfo* type) const;\r
-\r
- // FIXME wxXTI methods:\r
-\r
- // get the typeinfo of the stored object\r
- const wxTypeInfo* GetTypeInfo() const \r
- { \r
- if (!m_data)\r
- return NULL;\r
- return m_data->GetTypeInfo(); \r
- }\r
-\r
- // get a ref to the stored data\r
- template<typename T> T& Get(wxTEMPLATED_MEMBER_FIX(T))\r
- {\r
- wxVariantDataT<T> *dataptr = \r
- wx_dynamic_cast(wxVariantDataT<T>*, m_data);\r
- wxASSERT_MSG( dataptr, \r
- wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );\r
- return dataptr->Get();\r
- }\r
-\r
- // get a const ref to the stored data\r
- template<typename T> const T& Get(wxTEMPLATED_MEMBER_FIX(T)) const\r
- {\r
- const wxVariantDataT<T> *dataptr = \r
- wx_dynamic_cast(const wxVariantDataT<T>*, m_data);\r
- wxASSERT_MSG( dataptr, \r
- wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );\r
- return dataptr->Get();\r
- }\r
-\r
- template<typename T> bool HasData(wxTEMPLATED_MEMBER_FIX(T)) const\r
- {\r
- const wxVariantDataT<T> *dataptr = \r
- wx_dynamic_cast(const wxVariantDataT<T>*, m_data);\r
- return dataptr != NULL;\r
- }\r
-\r
- // returns this value as string\r
- wxString GetAsString() const;\r
-\r
- // gets the stored data casted to a wxObject*, \r
- // returning NULL if cast is not possible\r
- wxObject* GetAsObject();\r
-\r
-protected:\r
- wxVariantData* m_data;\r
- wxString m_name;\r
-};\r
-\r
-#include "wx/dynarray.h"\r
-WX_DECLARE_OBJARRAY_WITH_DECL(wxVariantBase, wxVariantBaseArray, class WXDLLIMPEXP_BASE);\r
-\r
-\r
-// templated streaming, every type must have their specialization for these methods\r
-\r
-template<typename T>\r
-void wxStringReadValue( const wxString &s, T &data );\r
-\r
-template<typename T>\r
-void wxStringWriteValue( wxString &s, const T &data);\r
-\r
-template<typename T>\r
-void wxToStringConverter( const wxVariantBase &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) \\r
- { wxStringWriteValue( s, v.wxTEMPLATED_MEMBER_CALL(Get, T) ); }\r
-\r
-template<typename T>\r
-void wxFromStringConverter( const wxString &s, wxVariantBase &v wxTEMPLATED_FUNCTION_FIX(T)) \\r
- { T d; wxStringReadValue( s, d ); v = wxVariantBase(d); }\r
-\r
-\r
-#endif // wxUSE_VARIANT\r
-#endif // _WX_VARIANTBASE_H_\r
+/////////////////////////////////////////////////////////////////////////////
+// Name: wx/variantbase.h
+// Purpose: wxVariantBase class, a minimal version of wxVariant used by XTI
+// Author: Julian Smart
+// Modified by: Francesco Montorsi
+// Created: 10/09/98
+// Copyright: (c) Julian Smart
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_VARIANTBASE_H_
+#define _WX_VARIANTBASE_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_VARIANT
+
+#include "wx/string.h"
+#include "wx/arrstr.h"
+#include "wx/cpp.h"
+#include <typeinfo>
+
+#if wxUSE_DATETIME
+ #include "wx/datetime.h"
+#endif // wxUSE_DATETIME
+
+#include "wx/iosfwrap.h"
+
+class wxTypeInfo;
+class wxObject;
+class wxClassInfo;
+
+/*
+ * wxVariantData stores the actual data in a wxVariant object,
+ * to allow it to store any type of data.
+ * Derive from this to provide custom data handling.
+ *
+ * NB: To prevent addition of extra vtbl pointer to wxVariantData,
+ * we don't multiple-inherit from wxObjectRefData. Instead,
+ * we simply replicate the wxObject ref-counting scheme.
+ *
+ * NB: When you construct a wxVariantData, it will have refcount
+ * of one. Refcount will not be further increased when
+ * it is passed to wxVariant. This simulates old common
+ * scenario where wxVariant took ownership of wxVariantData
+ * passed to it.
+ * If you create wxVariantData for other reasons than passing
+ * it to wxVariant, technically you are not required to call
+ * DecRef() before deleting it.
+ *
+ * TODO: in order to replace wxPropertyValue, we would need
+ * to consider adding constructors that take pointers to C++ variables,
+ * or removing that functionality from the wxProperty library.
+ * Essentially wxPropertyValue takes on some of the wxValidator functionality
+ * by storing pointers and not just actual values, allowing update of C++ data
+ * to be handled automatically. Perhaps there's another way of doing this without
+ * overloading wxVariant with unnecessary functionality.
+ */
+
+class WXDLLIMPEXP_BASE wxVariantData
+{
+ friend class wxVariantBase;
+
+public:
+ wxVariantData()
+ : m_count(1)
+ { }
+
+#if wxUSE_STD_IOSTREAM
+ virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; }
+ virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }
+#endif
+ virtual bool Write(wxString& WXUNUSED(str)) const { return false; }
+ virtual bool Read(wxString& WXUNUSED(str)) { return false; }
+
+ // Override these to provide common functionality
+ virtual bool Eq(wxVariantData& data) const = 0;
+
+ // What type is it? Return a string name.
+ virtual wxString GetType() const = 0;
+
+ // returns the type info of the content
+ virtual const wxTypeInfo* GetTypeInfo() const = 0;
+
+ // If it based on wxObject return the ClassInfo.
+ virtual wxClassInfo* GetValueClassInfo() { return NULL; }
+
+ int GetRefCount() const
+ { return m_count; }
+ void IncRef()
+ { m_count++; }
+ void DecRef()
+ {
+ if ( --m_count == 0 )
+ delete this;
+ }
+
+protected:
+ // Protected dtor should make some incompatible code
+ // break more louder. That is, they should do data->DecRef()
+ // instead of delete data.
+ virtual ~wxVariantData() {}
+
+private:
+ int m_count;
+};
+
+template<typename T> class wxVariantDataT : public wxVariantData
+{
+public:
+ wxVariantDataT(const T& d) : m_data(d) {}
+ virtual ~wxVariantDataT() {}
+
+ // get a ref to the stored data
+ T & Get() { return m_data; }
+
+ // get a const ref to the stored data
+ const T & Get() const { return m_data; }
+
+ // set the data
+ void Set(const T& d) { m_data = d; }
+
+ // Override these to provide common functionality
+ virtual bool Eq(wxVariantData& WXUNUSED(data)) const
+ { return false; /* FIXME!! */ }
+
+ // What type is it? Return a string name.
+ virtual wxString GetType() const
+ { return GetTypeInfo()->GetTypeName(); }
+
+ // return a heap allocated duplicate
+ //virtual wxVariantData* Clone() const { return new wxVariantDataT<T>( Get() ); }
+
+ // returns the type info of the contentc
+ virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ); }
+
+private:
+ T m_data;
+};
+
+
+/*
+ * wxVariantBase can store any kind of data, but has some basic types
+ * built in.
+ */
+
+class WXDLLIMPEXP_BASE wxVariantBase
+{
+public:
+ wxVariantBase();
+ wxVariantBase(const wxVariantBase& variant);
+ wxVariantBase(wxVariantData* data, const wxString& name = wxEmptyString);
+
+ template<typename T>
+ wxVariantBase(const T& data, const wxString& name = wxEmptyString) :
+ m_data(new wxVariantDataT<T>(data)), m_name(name) {}
+
+ virtual ~wxVariantBase();
+
+ // generic assignment
+ void operator= (const wxVariantBase& variant);
+
+ // Assignment using data, e.g.
+ // myVariant = new wxStringVariantData("hello");
+ void operator= (wxVariantData* variantData);
+
+ bool operator== (const wxVariantBase& variant) const;
+ bool operator!= (const wxVariantBase& variant) const;
+
+ // Sets/gets name
+ inline void SetName(const wxString& name) { m_name = name; }
+ inline const wxString& GetName() const { return m_name; }
+
+ // Tests whether there is data
+ bool IsNull() const;
+
+ // FIXME: used by wxVariantBase code but is nice wording...
+ bool IsEmpty() const { return IsNull(); }
+
+ // For compatibility with wxWidgets <= 2.6, this doesn't increase
+ // reference count.
+ wxVariantData* GetData() const { return m_data; }
+ void SetData(wxVariantData* data) ;
+
+ // make a 'clone' of the object
+ void Ref(const wxVariantBase& clone);
+
+ // destroy a reference
+ void UnRef();
+
+ // Make NULL (i.e. delete the data)
+ void MakeNull();
+
+ // write contents to a string (e.g. for debugging)
+ wxString MakeString() const;
+
+ // Delete data and name
+ void Clear();
+
+ // Returns a string representing the type of the variant,
+ // e.g. "string", "bool", "stringlist", "list", "double", "long"
+ wxString GetType() const;
+
+ bool IsType(const wxString& type) const;
+ bool IsValueKindOf(const wxClassInfo* type) const;
+
+ // FIXME wxXTI methods:
+
+ // get the typeinfo of the stored object
+ const wxTypeInfo* GetTypeInfo() const
+ {
+ if (!m_data)
+ return NULL;
+ return m_data->GetTypeInfo();
+ }
+
+ // get a ref to the stored data
+ template<typename T> T& Get(wxTEMPLATED_MEMBER_FIX(T))
+ {
+ wxVariantDataT<T> *dataptr =
+ wx_dynamic_cast(wxVariantDataT<T>*, m_data);
+ wxASSERT_MSG( dataptr,
+ wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );
+ return dataptr->Get();
+ }
+
+ // get a const ref to the stored data
+ template<typename T> const T& Get(wxTEMPLATED_MEMBER_FIX(T)) const
+ {
+ const wxVariantDataT<T> *dataptr =
+ wx_dynamic_cast(const wxVariantDataT<T>*, m_data);
+ wxASSERT_MSG( dataptr,
+ wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );
+ return dataptr->Get();
+ }
+
+ template<typename T> bool HasData(wxTEMPLATED_MEMBER_FIX(T)) const
+ {
+ const wxVariantDataT<T> *dataptr =
+ wx_dynamic_cast(const wxVariantDataT<T>*, m_data);
+ return dataptr != NULL;
+ }
+
+ // returns this value as string
+ wxString GetAsString() const;
+
+ // gets the stored data casted to a wxObject*,
+ // returning NULL if cast is not possible
+ wxObject* GetAsObject();
+
+protected:
+ wxVariantData* m_data;
+ wxString m_name;
+};
+
+#include "wx/dynarray.h"
+WX_DECLARE_OBJARRAY_WITH_DECL(wxVariantBase, wxVariantBaseArray, class WXDLLIMPEXP_BASE);
+
+
+// templated streaming, every type must have their specialization for these methods
+
+template<typename T>
+void wxStringReadValue( const wxString &s, T &data );
+
+template<typename T>
+void wxStringWriteValue( wxString &s, const T &data);
+
+template<typename T>
+void wxToStringConverter( const wxVariantBase &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) \
+ { wxStringWriteValue( s, v.wxTEMPLATED_MEMBER_CALL(Get, T) ); }
+
+template<typename T>
+void wxFromStringConverter( const wxString &s, wxVariantBase &v wxTEMPLATED_FUNCTION_FIX(T)) \
+ { T d; wxStringReadValue( s, d ); v = wxVariantBase(d); }
+
+
+#endif // wxUSE_VARIANT
+#endif // _WX_VARIANTBASE_H_
projects / wxWidgets.git / blobdiff