]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/variantbase.h
Test using wxString::ToCDouble() in wxAny.
[wxWidgets.git] / include / wx / variantbase.h
index 5745c92af5b2a3d4bc9a9f35f71a31e1b6c8f294..4d994f37a9048af3d8165fbdb51c58799754f3d7 100644 (file)
-/////////////////////////////////////////////////////////////////////////////\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
+// RCS-ID:      $Id$
+// 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_