#if wxUSE_ANY
+#include <new> // for placement new
#include "wx/string.h"
-#include "wx/meta/movable.h"
#include "wx/meta/if.h"
#include "wx/typeinfo.h"
-
+#include "wx/list.h"
// Size of the wxAny value buffer.
enum
/**
Default constructor.
*/
- wxAnyValueType();
+ wxAnyValueType()
+ {
+ }
/**
Destructor.
a specific C++ data type.
@remarks This template function does not work on some older compilers
- (such as Visual C++ 6.0). For full compiler ccompatibility
+ (such as Visual C++ 6.0). For full compiler compatibility
please use wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) macro
instead.
*/
// FIXME-VC6: remove this hack when VC6 is no longer supported
template <typename T>
- bool CheckType(T* reserved = NULL);
+ bool CheckType(T* reserved = NULL) const;
+
+#if wxUSE_EXTENDED_RTTI
+ virtual const wxTypeInfo* GetTypeInfo() const = 0;
+#endif
private:
};
+
+//
+// We need to allocate wxAnyValueType instances in heap, and need to use
+// scoped ptr to properly deallocate them in dynamic library use cases.
+// Here we have a minimal specialized scoped ptr implementation to deal
+// with various compiler-specific problems with template class' static
+// member variable of template type with explicit constructor which
+// is initialized in global scope.
+//
+class wxAnyValueTypeScopedPtr
+{
+public:
+ wxAnyValueTypeScopedPtr(wxAnyValueType* ptr) : m_ptr(ptr) { }
+ ~wxAnyValueTypeScopedPtr() { delete m_ptr; }
+ wxAnyValueType* get() const { return m_ptr; }
+private:
+ wxAnyValueType* m_ptr;
+};
+
+
//
// This method of checking the type is compatible with VC6
#define wxANY_VALUE_TYPE_CHECK_TYPE(valueTypePtr, T) \
facilitate sub-type system which allows, for instance, wxAny with
signed short '15' to be treated equal to wxAny with signed long long '15'.
Having sm_instance is important here.
+
+ NB: We really need to have wxAnyValueType instances allocated
+ in heap. They are stored as static template member variables,
+ and with them we just can't be too careful (eg. not allocating
+ them in heap broke the type identification in GCC).
*/
#define WX_DECLARE_ANY_VALUE_TYPE(CLS) \
friend class wxAny; \
public: \
static bool IsSameClass(const wxAnyValueType* otherType) \
{ \
- return wxTypeId(*sm_instance) == wxTypeId(*otherType); \
+ return wxTypeId(*sm_instance.get()) == wxTypeId(*otherType); \
} \
virtual bool IsSameType(const wxAnyValueType* otherType) const \
{ \
return IsSameClass(otherType); \
} \
private: \
- static CLS* sm_instance; \
+ static wxAnyValueTypeScopedPtr sm_instance; \
public: \
static wxAnyValueType* GetInstance() \
{ \
- return sm_instance; \
+ return sm_instance.get(); \
}
#define WX_IMPLEMENT_ANY_VALUE_TYPE(CLS) \
- CLS* CLS::sm_instance = new CLS();
+wxAnyValueTypeScopedPtr CLS::sm_instance(new CLS());
#ifdef __VISUALC6__
{
template<typename T>
-class wxAnyValueTypeOpsMovable
+class wxAnyValueTypeOpsInplace
{
public:
static void DeleteValue(wxAnyValueBuffer& buf)
{
- wxUnusedVar(buf);
+ T* value = reinterpret_cast<T*>(&buf.m_buffer[0]);
+ value->~T();
+
+ // Some compiler may given 'unused variable' warnings without this
+ wxUnusedVar(value);
}
static void SetValue(const T& value,
wxAnyValueBuffer& buf)
{
- memcpy(buf.m_buffer, &value, sizeof(T));
+ // Use placement new
+ void* const place = buf.m_buffer;
+ ::new(place) T(value);
}
static const T& GetValue(const wxAnyValueBuffer& buf)
{
- // Breaking this code into two lines should supress
+ // Breaking this code into two lines should suppress
// GCC's 'type-punned pointer will break strict-aliasing rules'
// warning.
const T* value = reinterpret_cast<const T*>(&buf.m_buffer[0]);
template<typename T>
class wxAnyValueTypeImplBase : public wxAnyValueType
{
- typedef typename wxIf< wxIsMovable<T>::value &&
- sizeof(T) <= WX_ANY_VALUE_BUFFER_SIZE,
- wxPrivate::wxAnyValueTypeOpsMovable<T>,
+ typedef typename wxIf< sizeof(T) <= WX_ANY_VALUE_BUFFER_SIZE,
+ wxPrivate::wxAnyValueTypeOpsInplace<T>,
wxPrivate::wxAnyValueTypeOpsGeneric<T> >::value
Ops;
{
return Ops::GetValue(buf);
}
+#if wxUSE_EXTENDED_RTTI
+ virtual const wxTypeInfo* GetTypeInfo() const
+ {
+ return wxGetTypeInfo((T*)NULL);
+ }
+#endif
};
};
template<typename T>
-wxAnyValueTypeImpl<T>* wxAnyValueTypeImpl<T>::sm_instance =
- new wxAnyValueTypeImpl<T>();
+wxAnyValueTypeScopedPtr wxAnyValueTypeImpl<T>::sm_instance = new wxAnyValueTypeImpl<T>();
//
// Helper macro for using same base value type implementation for multiple
// actual C++ data types.
//
-#define WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE) \
+#define _WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE) \
template<> \
class wxAnyValueTypeImpl<T> : public wxAnyValueTypeImpl##CLSTYPE \
{ \
const UseDataType* sptr = \
reinterpret_cast<const UseDataType*>(voidPtr); \
return static_cast<T>(*sptr); \
+ }
+
+#if wxUSE_EXTENDED_RTTI
+#define WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE) \
+_WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE)\
+ virtual const wxTypeInfo* GetTypeInfo() const \
+ { \
+ return wxGetTypeInfo((T*)NULL); \
} \
};
-
+#else
+#define WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE) \
+_WX_ANY_DEFINE_SUB_TYPE(T, CLSTYPE)\
+};
+#endif
//
// Integer value types
//
-// String value type
+// This macro is used in header, but then in source file we must have:
+// WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl##TYPENAME)
//
-class WXDLLIMPEXP_BASE wxAnyValueTypeImplString :
- public wxAnyValueTypeImplBase<wxString>
-{
- WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImplString)
-public:
- wxAnyValueTypeImplString() :
- wxAnyValueTypeImplBase<wxString>() { }
- virtual ~wxAnyValueTypeImplString() { }
+#define _WX_ANY_DEFINE_CONVERTIBLE_TYPE(T, TYPENAME, CONVFUNC, GV) \
+class WXDLLIMPEXP_BASE wxAnyValueTypeImpl##TYPENAME : \
+ public wxAnyValueTypeImplBase<T> \
+{ \
+ WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl##TYPENAME) \
+public: \
+ wxAnyValueTypeImpl##TYPENAME() : \
+ wxAnyValueTypeImplBase<T>() { } \
+ virtual ~wxAnyValueTypeImpl##TYPENAME() { } \
+ virtual bool ConvertValue(const wxAnyValueBuffer& src, \
+ wxAnyValueType* dstType, \
+ wxAnyValueBuffer& dst) const \
+ { \
+ GV value = GetValue(src); \
+ return CONVFUNC(value, dstType, dst); \
+ } \
+}; \
+template<> \
+class wxAnyValueTypeImpl<T> : public wxAnyValueTypeImpl##TYPENAME \
+{ \
+public: \
+ wxAnyValueTypeImpl() : wxAnyValueTypeImpl##TYPENAME() { } \
+ virtual ~wxAnyValueTypeImpl() { } \
+};
- /**
- Convert value into buffer of different type. Return false if
- not possible.
- */
- virtual bool ConvertValue(const wxAnyValueBuffer& src,
- wxAnyValueType* dstType,
- wxAnyValueBuffer& dst) const;
+#define WX_ANY_DEFINE_CONVERTIBLE_TYPE(T, TYPENAME, CONVFUNC, BT) \
+_WX_ANY_DEFINE_CONVERTIBLE_TYPE(T, TYPENAME, CONVFUNC, BT) \
-};
+#define WX_ANY_DEFINE_CONVERTIBLE_TYPE_BASE(T, TYPENAME, CONVFUNC) \
+_WX_ANY_DEFINE_CONVERTIBLE_TYPE(T, TYPENAME, \
+ CONVFUNC, const T&) \
-template<>
-class wxAnyValueTypeImpl<wxString> : public wxAnyValueTypeImplString
-{
-public:
- wxAnyValueTypeImpl() : wxAnyValueTypeImplString() { }
- virtual ~wxAnyValueTypeImpl() { }
-};
+//
+// String value type
+//
+// Convert wxString to destination wxAny value type
+extern WXDLLIMPEXP_BASE bool wxAnyConvertString(const wxString& value,
+ wxAnyValueType* dstType,
+ wxAnyValueBuffer& dst);
+
+WX_ANY_DEFINE_CONVERTIBLE_TYPE_BASE(wxString, wxString, wxAnyConvertString)
+WX_ANY_DEFINE_CONVERTIBLE_TYPE(const char*, ConstCharPtr,
+ wxAnyConvertString, wxString)
+WX_ANY_DEFINE_CONVERTIBLE_TYPE(const wchar_t*, ConstWchar_tPtr,
+ wxAnyConvertString, wxString)
//
// Bool value type
// (this is needed only for types that are referred to from wxBase.
// currently we may not use any of these types from there, but let's
// use the macro on at least one to make sure it compiles since we can't
-// really test it properly in unittests since a separate DLL would
+// really test it properly in unit tests since a separate DLL would
// be needed).
#if wxUSE_DATETIME
#include "wx/datetime.h"
template<typename T>
wxAny(const T& value)
{
- m_type = wxAnyValueTypeImpl<T>::sm_instance;
+ m_type = wxAnyValueTypeImpl<T>::sm_instance.get();
wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);
}
+ // These two constructors are needed to deal with string literals
wxAny(const char* value)
{
- m_type = wxAnyNullValueType;
- Assign(wxString(value));
+ m_type = wxAnyValueTypeImpl<const char*>::sm_instance.get();
+ wxAnyValueTypeImpl<const char*>::SetValue(value, m_buffer);
}
-
wxAny(const wchar_t* value)
{
- m_type = wxAnyNullValueType;
- Assign(wxString(value));
+ m_type = wxAnyValueTypeImpl<const wchar_t*>::sm_instance.get();
+ wxAnyValueTypeImpl<const wchar_t*>::SetValue(value, m_buffer);
}
wxAny(const wxAny& any)
*/
// FIXME-VC6: remove this hack when VC6 is no longer supported
template <typename T>
- bool CheckType(T* = NULL)
+ bool CheckType(T* = NULL) const
{
return m_type->CheckType<T>();
}
@remarks You cannot reliably test whether two wxAnys are of
same value type by simply comparing return values
- of wxAny::GetType(). Instead use
- wxAnyValueType::CheckType<T>() template function.
+ of wxAny::GetType(). Instead, use wxAny::HasSameType().
+
+ @see HasSameType()
*/
const wxAnyValueType* GetType() const
{
}
/**
- Tests if wxAny is null (that is, whether there is data).
+ Returns @true if this and another wxAny have the same
+ value type.
+ */
+ bool HasSameType(const wxAny& other) const
+ {
+ return GetType()->IsSameType(other.GetType());
+ }
+
+ /**
+ Tests if wxAny is null (that is, whether there is no data).
*/
bool IsNull() const
{
/**
Assignment operators.
*/
+ template<typename T>
+ wxAny& operator=(const T &value)
+ {
+ m_type->DeleteValue(m_buffer);
+ m_type = wxAnyValueTypeImpl<T>::sm_instance.get();
+ wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);
+ return *this;
+ }
+
wxAny& operator=(const wxAny &any)
{
if (this != &any)
return *this;
}
-#if wxUSE_VARIANT && (!defined(__VISUALC__) || __VISUALC__ >= 1300)
- //
- // Adding this operator for VC6 breaks wxAny, and also
- // some cases of implicit conversion from wxVariant to wxAny.
- //
- // e.g. wxAny any = variant; // should work
- //
- // wxAny any;
- // any = 16;
- // any = variant; // probably doesn't work - uses template
- // // assignment, most likely
- //
+#if wxUSE_VARIANT
wxAny& operator=(const wxVariant &variant)
{
AssignVariant(variant);
}
#endif
- template<typename T>
- wxAny& operator=(const T &value)
+ // These two operators are needed to deal with string literals
+ wxAny& operator=(const char* value)
{
- m_type->DeleteValue(m_buffer);
- m_type = wxAnyValueTypeImpl<T>::sm_instance;
- wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);
+ Assign(value);
return *this;
}
-
- wxAny& operator=(const char* value)
- { Assign(wxString(value)); return *this; }
wxAny& operator=(const wchar_t* value)
- { Assign(wxString(value)); return *this; }
- //@}
+ {
+ Assign(value);
+ return *this;
+ }
//@{
/**
*/
bool operator==(const wxString& value) const
{
- if ( !wxAnyValueTypeImpl<wxString>::IsSameClass(m_type) )
+ wxString value2;
+ if ( !GetAs(&value2) )
return false;
-
- return value ==
- static_cast<wxString>
- (wxAnyValueTypeImpl<wxString>::GetValue(m_buffer));
+ return value == value2;
}
bool operator==(const char* value) const
WXANY_IMPLEMENT_INT_EQ_OP(wxLongLong_t, wxULongLong_t)
#endif
+ wxGCC_WARNING_SUPPRESS(float-equal)
+
bool operator==(float value) const
{
if ( !wxAnyValueTypeImpl<float>::IsSameClass(m_type) )
(wxAnyValueTypeImpl<double>::GetValue(m_buffer));
}
+ wxGCC_WARNING_RESTORE(float-equal)
+
bool operator==(bool value) const
{
if ( !wxAnyValueTypeImpl<bool>::IsSameClass(m_type) )
//@}
/**
- This template function converts wxAny into given type. No dynamic
- conversion is performed, so if the type is incorrect an assertion
- failure will occur in debug builds, and a bogus value is returned
- in release ones.
+ This template function converts wxAny into given type. In most cases
+ no type conversion is performed, so if the type is incorrect an
+ assertion failure will occur.
- @remarks This template function does not work on some older compilers
- (such as Visual C++ 6.0). For full compiler compatibility
- please use wxANY_AS(any, T) macro instead.
+ @remarks For convenience, conversion is done when T is wxString. This
+ is useful when a string literal (which are treated as
+ const char* and const wchar_t*) has been assigned to wxAny.
+
+ This template function may not work properly with Visual C++
+ 6. For full compiler compatibility, please use
+ wxANY_AS(any, T) macro instead.
*/
// FIXME-VC6: remove this hack when VC6 is no longer supported
template<typename T>
return static_cast<T>(wxAnyValueTypeImpl<T>::GetValue(m_buffer));
}
+ // Allow easy conversion from 'const char *' etc. to wxString
+ // FIXME-VC6: remove this hack when VC6 is no longer supported
+ //template<>
+ wxString As(wxString*) const
+ {
+ wxString value;
+ if ( !GetAs(&value) )
+ {
+ wxFAIL_MSG("Incorrect or non-convertible data type");
+ }
+ return value;
+ }
+
+#if wxUSE_EXTENDED_RTTI
+ const wxTypeInfo* GetTypeInfo() const
+ {
+ return m_type->GetTypeInfo();
+ }
+#endif
/**
- Template function that etrieves and converts the value of this
+ Template function that retrieves and converts the value of this
variant to the type that T* value is.
- @return Returns @true if conversion was succesfull.
+ @return Returns @true if conversion was successful.
*/
template<typename T>
bool GetAs(T* value) const
if ( !wxAnyValueTypeImpl<T>::IsSameClass(m_type) )
{
wxAnyValueType* otherType =
- wxAnyValueTypeImpl<T>::sm_instance;
+ wxAnyValueTypeImpl<T>::sm_instance.get();
wxAnyValueBuffer temp_buf;
if ( !m_type->ConvertValue(m_buffer, otherType, temp_buf) )
else
{
// If everything else fails, wrap the whole wxVariantData
- m_type = wxAnyValueTypeImpl<wxVariantData*>::sm_instance;
+ m_type = wxAnyValueTypeImpl<wxVariantData*>::sm_instance.get();
wxAnyValueTypeImpl<wxVariantData*>::SetValue(data, m_buffer);
}
}
void Assign(const T &value)
{
m_type->DeleteValue(m_buffer);
- m_type = wxAnyValueTypeImpl<T>::sm_instance;
+ m_type = wxAnyValueTypeImpl<T>::sm_instance.get();
wxAnyValueTypeImpl<T>::SetValue(value, m_buffer);
}
//
// This method of checking the type is compatible with VC6
#define wxANY_CHECK_TYPE(any, T) \
- wxANY_VALUE_TYPE_CHECK_TYPE(any.GetType(), T)
+ wxANY_VALUE_TYPE_CHECK_TYPE((any).GetType(), T)
//
// This method of getting the value is compatible with VC6
#define wxANY_AS(any, T) \
- any.As(static_cast<T*>(NULL))
+ (any).As(static_cast<T*>(NULL))
template<typename T>
-inline bool wxAnyValueType::CheckType(T* reserved)
+inline bool wxAnyValueType::CheckType(T* reserved) const
{
wxUnusedVar(reserved);
return wxAnyValueTypeImpl<T>::IsSameClass(this);
}
-
+WX_DECLARE_LIST_WITH_DECL(wxAny, wxAnyList, class WXDLLIMPEXP_BASE);
#endif // wxUSE_ANY
projects / wxWidgets.git / blobdiff