[wxWidgets.git] / src / common / any.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/any.cpp
// Purpose:     wxAny class, container for any type
// Author:      Jaakko Salli
// Modified by:
// Created:     07/05/2009
// Copyright:   (c) wxWidgets team
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/any.h"

#if wxUSE_ANY

#ifndef WX_PRECOMP
    #include "wx/math.h"
    #include "wx/crt.h"
#endif

#include "wx/vector.h"
#include "wx/module.h"
#include "wx/hashmap.h"
#include "wx/hashset.h"

using namespace wxPrivate;

#if wxUSE_VARIANT

//-------------------------------------------------------------------------
// wxAnyValueTypeGlobals
//-------------------------------------------------------------------------

WX_DECLARE_HASH_MAP(wxAnyValueType*,
                    wxVariantDataFactory,
                    wxPointerHash,
                    wxPointerEqual,
                    wxAnyTypeToVariantDataFactoryMap);

//
// Helper class to manage global variables related to type conversion
// between wxAny and wxVariant.
//
class wxAnyValueTypeGlobals
{
public:
    wxAnyValueTypeGlobals()
    {
    }
    ~wxAnyValueTypeGlobals()
    {
        m_anyToVariant.clear();
    }

    void PreRegisterAnyToVariant(wxAnyToVariantRegistration* reg)
    {
        m_anyToVariantRegs.push_back(reg);
    }

    // Find wxVariantData factory function for given value type,
    // (or compatible, if possible)
    wxVariantDataFactory FindVariantDataFactory(const wxAnyValueType* type_)
    {
        // Ideally we'd have the hash map of type 'const wxAnyValueType*',
        // but WX_DECLARE_HASH_MAP() has some trouble with it.
        wxAnyValueType* type = const_cast<wxAnyValueType*>(type_);

        wxAnyTypeToVariantDataFactoryMap& anyToVariant = m_anyToVariant;
        wxAnyTypeToVariantDataFactoryMap::const_iterator it;
        it = anyToVariant.find(type);
        if ( it != anyToVariant.end() )
            return it->second;

        // Not found, handle pre-registrations
        size_t i = m_anyToVariantRegs.size();
        while ( i > 0 )
        {
            i--;
            wxAnyToVariantRegistration* reg = m_anyToVariantRegs[i];
            wxAnyValueType* assocType = reg->GetAssociatedType();
            if ( assocType )
            {
                // Both variant data and wxAnyValueType have been
                // now been properly initialized, so remove the
                // pre-registration entry and move data to anyToVarian
                // map.
                anyToVariant[assocType] = reg->GetFactory();
                m_anyToVariantRegs.erase( m_anyToVariantRegs.begin() + i );
            }
        }

        // Then try again
        it = anyToVariant.find(type);
        if ( it != anyToVariant.end() )
            return it->second;

        // Finally, attempt to find a compatible type
        for ( it = anyToVariant.begin(); it != anyToVariant.end(); it++ )
        {
            if ( type->IsSameType(it->first) )
            {
                wxVariantDataFactory f = it->second;
                anyToVariant[type] = f;
                return f;
            }
        }

        // Nothing found
        return NULL;
    }

private:
    wxAnyTypeToVariantDataFactoryMap        m_anyToVariant;
    wxVector<wxAnyToVariantRegistration*>   m_anyToVariantRegs;
};

static wxAnyValueTypeGlobals* g_wxAnyValueTypeGlobals = NULL;


WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplVariantData)

void wxPreRegisterAnyToVariant(wxAnyToVariantRegistration* reg)
{
    if ( !g_wxAnyValueTypeGlobals )
        g_wxAnyValueTypeGlobals = new wxAnyValueTypeGlobals();
    g_wxAnyValueTypeGlobals->PreRegisterAnyToVariant(reg);
}

bool wxConvertAnyToVariant(const wxAny& any, wxVariant* variant)
{
    if ( any.IsNull() )
    {
        variant->MakeNull();
        return true;
    }

    // (signed) integer is a special case, because there is only one type
    // in wxAny, and two ("long" and "longlong") in wxVariant. For better
    // backwards compatibility, convert all values that fit in "long",
    // and others to "longlong".
    if ( wxANY_CHECK_TYPE(any, signed int) )
    {
#ifdef wxLongLong_t
        wxLongLong_t ll = 0;
        if ( any.GetAs(&ll) )
        {
            // NB: Do not use LONG_MAX here. Explicitly using 32-bit
            //     integer constraint yields more consistent behaviour across
            //     builds.
            if ( ll > wxINT32_MAX || ll < wxINT32_MIN )
                *variant = wxLongLong(ll);
            else
                *variant = (long) wxLongLong(ll).GetLo();
        }
        else
        {
            return false;
        }
#else
        long l;
        if ( any.GetAs(&l) )
            *variant = l;
        else
            return false;
#endif
        return true;
    }

    // Find matching factory function
    wxVariantDataFactory f =
        g_wxAnyValueTypeGlobals->FindVariantDataFactory(any.GetType());

    wxVariantData* data = NULL;

    if ( f )
    {
        data = f(any);
    }
    else
    {
        // Check if wxAny wrapped wxVariantData*
        if ( !any.GetAs(&data) )
        {
            // Ok, one last chance: while unlikely, it is possible that the
            // wxAny actually contains wxVariant.
            if ( wxANY_CHECK_TYPE(any, wxVariant) )
                *variant = wxANY_AS(any, wxVariant);
            return false;
        }

        // Wrapper's GetValue() does not increase reference
        // count, se have to do it before the data gets passed
        // to a new variant.
        data->IncRef();
    }

    variant->SetData(data);
    return true;
}

//
// This class is to make sure that wxAnyValueType instances
// etc. get freed correctly. We must use a separate wxAnyValueTypeGlobals
// because wxModule itself is instantiated too late.
//
class wxAnyValueTypeGlobalsManager : public wxModule
{
    DECLARE_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager)
public:
    wxAnyValueTypeGlobalsManager() : wxModule() { }
    virtual ~wxAnyValueTypeGlobalsManager() { }

    virtual bool OnInit()
    {
        return true;
    }
    virtual void OnExit()
    {
        wxDELETE(g_wxAnyValueTypeGlobals);
    }
private:
};

IMPLEMENT_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager, wxModule)

#endif // wxUSE_VARIANT


//-------------------------------------------------------------------------
// Dynamic conversion member functions
//-------------------------------------------------------------------------

//
// Define integer minimum and maximum as helpers
#ifdef wxLongLong_t
    #define UseIntMin  (wxINT64_MIN)
    #define UseIntMax  (wxINT64_MAX)
    #define UseUintMax (wxUINT64_MAX)
#else
    #define UseIntMin  (LONG_MIN)
    #define UseIntMax  (LONG_MAX)
    #define UseUintMax (ULONG_MAX)
#endif

namespace
{

const double UseIntMinF = static_cast<double>(UseIntMin);
const double UseIntMaxF = static_cast<double>(UseIntMax);
const double UseUintMaxF = static_cast<double>(UseUintMax);

} // anonymous namespace

bool wxAnyValueTypeImplInt::ConvertValue(const wxAnyValueBuffer& src,
                                         wxAnyValueType* dstType,
                                         wxAnyValueBuffer& dst) const
{
    wxAnyBaseIntType value = GetValue(src);
    if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
    {
#ifdef wxLongLong_t
        wxLongLong ll(value);
        wxString s = ll.ToString();
#else
        wxString s = wxString::Format(wxS("%ld"), (long)value);
#endif
        wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
    {
        if ( value < 0 )
            return false;
        wxAnyBaseUintType ul = (wxAnyBaseUintType) value;
        wxAnyValueTypeImplUint::SetValue(ul, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
    {
        double value2 = static_cast<double>(value);
        wxAnyValueTypeImplDouble::SetValue(value2, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
    {
        bool value2 = value ? true : false;
        wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
    }
    else
        return false;

    return true;
}

bool wxAnyValueTypeImplUint::ConvertValue(const wxAnyValueBuffer& src,
                                          wxAnyValueType* dstType,
                                          wxAnyValueBuffer& dst) const
{
    wxAnyBaseUintType value = GetValue(src);
    if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
    {
#ifdef wxLongLong_t
        wxULongLong ull(value);
        wxString s = ull.ToString();
#else
        wxString s = wxString::Format(wxS("%lu"), (long)value);
#endif
        wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
    {
        if ( value > UseIntMax )
            return false;
        wxAnyBaseIntType l = (wxAnyBaseIntType) value;
        wxAnyValueTypeImplInt::SetValue(l, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
    {
#ifndef __VISUALC6__
        double value2 = static_cast<double>(value);
#else
        // VC6 doesn't implement conversion from unsigned __int64 to double
        wxAnyBaseIntType value0 = static_cast<wxAnyBaseIntType>(value);
        double value2 = static_cast<double>(value0);
#endif
        wxAnyValueTypeImplDouble::SetValue(value2, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
    {
        bool value2 = value ? true : false;
        wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
    }
    else
        return false;

    return true;
}

// Convert wxString to destination wxAny value type
bool wxAnyConvertString(const wxString& value,
                        wxAnyValueType* dstType,
                        wxAnyValueBuffer& dst)
{
    if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
    {
        wxAnyValueTypeImpl<wxString>::SetValue(value, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
    {
        wxAnyBaseIntType value2;
#ifdef wxLongLong_t
        if ( !value.ToLongLong(&value2) )
#else
        if ( !value.ToLong(&value2) )
#endif
            return false;
        wxAnyValueTypeImplInt::SetValue(value2, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
    {
        wxAnyBaseUintType value2;
#ifdef wxLongLong_t
        if ( !value.ToULongLong(&value2) )
#else
        if ( !value.ToULong(&value2) )
#endif
            return false;
        wxAnyValueTypeImplUint::SetValue(value2, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
    {
        double value2;
        if ( !value.ToCDouble(&value2) )
            return false;
        wxAnyValueTypeImplDouble::SetValue(value2, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
    {
        bool value2;
        wxString s(value);
        s.MakeLower();
        if ( s == wxS("true") ||
             s == wxS("yes") ||
             s == wxS('1') )
            value2 = true;
        else if ( s == wxS("false") ||
                  s == wxS("no") ||
                  s == wxS('0') )
            value2 = false;
        else
            return false;

        wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
    }
    else
        return false;

    return true;
}

bool wxAnyValueTypeImpl<bool>::ConvertValue(const wxAnyValueBuffer& src,
                                            wxAnyValueType* dstType,
                                            wxAnyValueBuffer& dst) const
{
    bool value = GetValue(src);
    if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
    {
        wxAnyBaseIntType value2 = static_cast<wxAnyBaseIntType>(value);
        wxAnyValueTypeImplInt::SetValue(value2, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
    {
        wxAnyBaseIntType value2 = static_cast<wxAnyBaseUintType>(value);
        wxAnyValueTypeImplUint::SetValue(value2, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
    {
        wxString s;
        if ( value )
            s = wxS("true");
        else
            s = wxS("false");
        wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
    }
    else
        return false;

    return true;
}

bool wxAnyValueTypeImplDouble::ConvertValue(const wxAnyValueBuffer& src,
                                            wxAnyValueType* dstType,
                                            wxAnyValueBuffer& dst) const
{
    double value = GetValue(src);
    if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
    {
        if ( value < UseIntMinF || value > UseIntMaxF )
            return false;
        wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);
        wxAnyValueTypeImplUint::SetValue(ul, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
    {
        if ( value < 0.0 || value > UseUintMaxF )
            return false;
        wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);
        wxAnyValueTypeImplUint::SetValue(ul, dst);
    }
    else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
    {
        wxString s = wxString::FromCDouble(value, 14);
        wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
    }
    else
        return false;

    return true;
}

WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplInt)
WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplUint)
WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<bool>)
WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplDouble)

WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplwxString)
WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplConstCharPtr)
WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplConstWchar_tPtr)

#if wxUSE_DATETIME
WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxDateTime>)
#endif // wxUSE_DATETIME

//WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxObject*>)
//WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxArrayString>)

//-------------------------------------------------------------------------
// wxAnyNullValueType implementation
//-------------------------------------------------------------------------

class wxAnyNullValue
{
protected:
    // this field is unused, but can't be private to avoid Clang's
    // "Private field 'm_dummy' is not used" warning
    void*   m_dummy;
};

template <>
class wxAnyValueTypeImpl<wxAnyNullValue> : public wxAnyValueType
{
    WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)
public:
    // Dummy implementations
    virtual void DeleteValue(wxAnyValueBuffer& buf) const
    {
        wxUnusedVar(buf);
    }

    virtual void CopyBuffer(const wxAnyValueBuffer& src,
                            wxAnyValueBuffer& dst) const
    {
        wxUnusedVar(src);
        wxUnusedVar(dst);
    }

    virtual bool ConvertValue(const wxAnyValueBuffer& src,
                              wxAnyValueType* dstType,
                              wxAnyValueBuffer& dst) const
    {
        wxUnusedVar(src);
        wxUnusedVar(dstType);
        wxUnusedVar(dst);
        return false;
    }

#if wxUSE_EXTENDED_RTTI
    virtual const wxTypeInfo* GetTypeInfo() const
    {
        wxFAIL_MSG("Null Type Info not available");
        return NULL;
    }
#endif

private:
};

WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)

wxAnyValueType* wxAnyNullValueType =
    wxAnyValueTypeImpl<wxAnyNullValue>::GetInstance();

#include "wx/listimpl.cpp"
WX_DEFINE_LIST(wxAnyList)

#endif // wxUSE_ANY
Commit	Line	Data
39601a7f VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/any.cpp
	3	// Purpose: wxAny class, container for any type
	4	// Author: Jaakko Salli
	5	// Modified by:
	6	// Created: 07/05/2009
39601a7f VZ	7	// Copyright: (c) wxWidgets team
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx/wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#include "wx/any.h"
	19
	20	#if wxUSE_ANY
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/math.h"
	24	#include "wx/crt.h"
	25	#endif
	26
	27	#include "wx/vector.h"
	28	#include "wx/module.h"
0bf14ab8	29	#include "wx/hashmap.h"
ee7bcb84	30	#include "wx/hashset.h"
39601a7f VZ	31
	32	using namespace wxPrivate;
	33
0cc226ad JS	34	#if wxUSE_VARIANT
0cc226ad JS	35
39601a7f VZ	36	//-------------------------------------------------------------------------
	37	// wxAnyValueTypeGlobals
	38	//-------------------------------------------------------------------------
	39
0bf14ab8 JS	40	WX_DECLARE_HASH_MAP(wxAnyValueType*,
	41	wxVariantDataFactory,
	42	wxPointerHash,
	43	wxPointerEqual,
	44	wxAnyTypeToVariantDataFactoryMap);
	45
39601a7f	46	//
0cc226ad JS	47	// Helper class to manage global variables related to type conversion
0cc226ad JS	48	// between wxAny and wxVariant.
39601a7f VZ	49	//
	50	class wxAnyValueTypeGlobals
	51	{
	52	public:
	53	wxAnyValueTypeGlobals()
	54	{
	55	}
	56	~wxAnyValueTypeGlobals()
	57	{
0bf14ab8	58	m_anyToVariant.clear();
39601a7f VZ	59	}
39601a7f VZ	60
0bf14ab8 JS	61	void PreRegisterAnyToVariant(wxAnyToVariantRegistration* reg)
	62	{
	63	m_anyToVariantRegs.push_back(reg);
	64	}
	65
	66	// Find wxVariantData factory function for given value type,
	67	// (or compatible, if possible)
549d99f0	68	wxVariantDataFactory FindVariantDataFactory(const wxAnyValueType* type_)
0bf14ab8	69	{
549d99f0	70	// Ideally we'd have the hash map of type 'const wxAnyValueType*',
dabf03b4 JS	71	// but WX_DECLARE_HASH_MAP() has some trouble with it.
dabf03b4 JS	72	wxAnyValueType* type = const_cast<wxAnyValueType*>(type_);
549d99f0	73
0bf14ab8 JS	74	wxAnyTypeToVariantDataFactoryMap& anyToVariant = m_anyToVariant;
	75	wxAnyTypeToVariantDataFactoryMap::const_iterator it;
	76	it = anyToVariant.find(type);
	77	if ( it != anyToVariant.end() )
	78	return it->second;
	79
	80	// Not found, handle pre-registrations
	81	size_t i = m_anyToVariantRegs.size();
	82	while ( i > 0 )
	83	{
	84	i--;
	85	wxAnyToVariantRegistration* reg = m_anyToVariantRegs[i];
	86	wxAnyValueType* assocType = reg->GetAssociatedType();
	87	if ( assocType )
	88	{
	89	// Both variant data and wxAnyValueType have been
	90	// now been properly initialized, so remove the
	91	// pre-registration entry and move data to anyToVarian
	92	// map.
	93	anyToVariant[assocType] = reg->GetFactory();
	94	m_anyToVariantRegs.erase( m_anyToVariantRegs.begin() + i );
	95	}
	96	}
	97
	98	// Then try again
	99	it = anyToVariant.find(type);
	100	if ( it != anyToVariant.end() )
	101	return it->second;
	102
	103	// Finally, attempt to find a compatible type
	104	for ( it = anyToVariant.begin(); it != anyToVariant.end(); it++ )
	105	{
	106	if ( type->IsSameType(it->first) )
	107	{
	108	wxVariantDataFactory f = it->second;
	109	anyToVariant[type] = f;
	110	return f;
	111	}
	112	}
	113
	114	// Nothing found
	115	return NULL;
	116	}
0bf14ab8	117
39601a7f	118	private:
0bf14ab8 JS	119	wxAnyTypeToVariantDataFactoryMap m_anyToVariant;
0bf14ab8 JS	120	wxVector<wxAnyToVariantRegistration*> m_anyToVariantRegs;
39601a7f VZ	121	};
	122
	123	static wxAnyValueTypeGlobals* g_wxAnyValueTypeGlobals = NULL;
	124
0bf14ab8 JS	125
	126	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplVariantData)
	127
	128	void wxPreRegisterAnyToVariant(wxAnyToVariantRegistration* reg)
	129	{
	130	if ( !g_wxAnyValueTypeGlobals )
	131	g_wxAnyValueTypeGlobals = new wxAnyValueTypeGlobals();
	132	g_wxAnyValueTypeGlobals->PreRegisterAnyToVariant(reg);
	133	}
	134
	135	bool wxConvertAnyToVariant(const wxAny& any, wxVariant* variant)
	136	{
	137	if ( any.IsNull() )
	138	{
	139	variant->MakeNull();
	140	return true;
	141	}
	142
	143	// (signed) integer is a special case, because there is only one type
	144	// in wxAny, and two ("long" and "longlong") in wxVariant. For better
	145	// backwards compatibility, convert all values that fit in "long",
	146	// and others to "longlong".
	147	if ( wxANY_CHECK_TYPE(any, signed int) )
	148	{
	149	#ifdef wxLongLong_t
5afecf60	150	wxLongLong_t ll = 0;
0bf14ab8 JS	151	if ( any.GetAs(&ll) )
0bf14ab8 JS	152	{
4403de76	153	// NB: Do not use LONG_MAX here. Explicitly using 32-bit
4c51a665	154	// integer constraint yields more consistent behaviour across
4403de76	155	// builds.
2dcd173e	156	if ( ll > wxINT32_MAX \|\| ll < wxINT32_MIN )
0bf14ab8 JS	157	*variant = wxLongLong(ll);
	158	else
	159	*variant = (long) wxLongLong(ll).GetLo();
	160	}
	161	else
	162	{
	163	return false;
	164	}
	165	#else
	166	long l;
	167	if ( any.GetAs(&l) )
	168	*variant = l;
	169	else
	170	return false;
	171	#endif
	172	return true;
	173	}
	174
	175	// Find matching factory function
	176	wxVariantDataFactory f =
	177	g_wxAnyValueTypeGlobals->FindVariantDataFactory(any.GetType());
	178
5afecf60 JS	179	wxVariantData* data = NULL;
5afecf60 JS	180
0bf14ab8 JS	181	if ( f )
	182	{
	183	data = f(any);
	184	}
	185	else
	186	{
	187	// Check if wxAny wrapped wxVariantData*
	188	if ( !any.GetAs(&data) )
0aaed451 JS	189	{
	190	// Ok, one last chance: while unlikely, it is possible that the
	191	// wxAny actually contains wxVariant.
	192	if ( wxANY_CHECK_TYPE(any, wxVariant) )
	193	*variant = wxANY_AS(any, wxVariant);
0bf14ab8	194	return false;
0aaed451	195	}
0bf14ab8 JS	196
	197	// Wrapper's GetValue() does not increase reference
	198	// count, se have to do it before the data gets passed
	199	// to a new variant.
	200	data->IncRef();
	201	}
	202
	203	variant->SetData(data);
	204	return true;
	205	}
	206
39601a7f VZ	207	//
	208	// This class is to make sure that wxAnyValueType instances
	209	// etc. get freed correctly. We must use a separate wxAnyValueTypeGlobals
	210	// because wxModule itself is instantiated too late.
	211	//
	212	class wxAnyValueTypeGlobalsManager : public wxModule
	213	{
	214	DECLARE_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager)
	215	public:
	216	wxAnyValueTypeGlobalsManager() : wxModule() { }
	217	virtual ~wxAnyValueTypeGlobalsManager() { }
	218
	219	virtual bool OnInit()
	220	{
	221	return true;
	222	}
	223	virtual void OnExit()
	224	{
5276b0a5	225	wxDELETE(g_wxAnyValueTypeGlobals);
39601a7f VZ	226	}
	227	private:
	228	};
	229
	230	IMPLEMENT_DYNAMIC_CLASS(wxAnyValueTypeGlobalsManager, wxModule)
	231
0cc226ad	232	#endif // wxUSE_VARIANT
39601a7f	233
39601a7f	234
39601a7f VZ	235	//-------------------------------------------------------------------------
	236	// Dynamic conversion member functions
	237	//-------------------------------------------------------------------------
	238
	239	//
	240	// Define integer minimum and maximum as helpers
	241	#ifdef wxLongLong_t
982d7f93 VZ	242	#define UseIntMin (wxINT64_MIN)
	243	#define UseIntMax (wxINT64_MAX)
	244	#define UseUintMax (wxUINT64_MAX)
39601a7f	245	#else
982d7f93 VZ	246	#define UseIntMin (LONG_MIN)
	247	#define UseIntMax (LONG_MAX)
	248	#define UseUintMax (ULONG_MAX)
39601a7f VZ	249	#endif
39601a7f VZ	250
982d7f93 VZ	251	namespace
	252	{
	253
39601a7f	254	const double UseIntMinF = static_cast<double>(UseIntMin);
39601a7f VZ	255	const double UseIntMaxF = static_cast<double>(UseIntMax);
39601a7f VZ	256	const double UseUintMaxF = static_cast<double>(UseUintMax);
39601a7f	257
982d7f93	258	} // anonymous namespace
39601a7f VZ	259
	260	bool wxAnyValueTypeImplInt::ConvertValue(const wxAnyValueBuffer& src,
	261	wxAnyValueType* dstType,
	262	wxAnyValueBuffer& dst) const
	263	{
	264	wxAnyBaseIntType value = GetValue(src);
	265	if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
	266	{
	267	#ifdef wxLongLong_t
	268	wxLongLong ll(value);
	269	wxString s = ll.ToString();
	270	#else
	271	wxString s = wxString::Format(wxS("%ld"), (long)value);
	272	#endif
	273	wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
	274	}
	275	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
	276	{
	277	if ( value < 0 )
	278	return false;
	279	wxAnyBaseUintType ul = (wxAnyBaseUintType) value;
	280	wxAnyValueTypeImplUint::SetValue(ul, dst);
	281	}
	282	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
	283	{
	284	double value2 = static_cast<double>(value);
	285	wxAnyValueTypeImplDouble::SetValue(value2, dst);
	286	}
	287	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
	288	{
	289	bool value2 = value ? true : false;
	290	wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
	291	}
	292	else
	293	return false;
	294
	295	return true;
	296	}
	297
	298	bool wxAnyValueTypeImplUint::ConvertValue(const wxAnyValueBuffer& src,
	299	wxAnyValueType* dstType,
	300	wxAnyValueBuffer& dst) const
	301	{
	302	wxAnyBaseUintType value = GetValue(src);
	303	if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
	304	{
	305	#ifdef wxLongLong_t
	306	wxULongLong ull(value);
	307	wxString s = ull.ToString();
	308	#else
	309	wxString s = wxString::Format(wxS("%lu"), (long)value);
	310	#endif
	311	wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
	312	}
	313	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
	314	{
	315	if ( value > UseIntMax )
	316	return false;
	317	wxAnyBaseIntType l = (wxAnyBaseIntType) value;
	318	wxAnyValueTypeImplInt::SetValue(l, dst);
	319	}
	320	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
	321	{
	322	#ifndef __VISUALC6__
323	double value2 = static_cast<double>(value);
324	#else
325	// VC6 doesn't implement conversion from unsigned __int64 to double
326	wxAnyBaseIntType value0 = static_cast<wxAnyBaseIntType>(value);
327	double value2 = static_cast<double>(value0);
328	#endif
329	wxAnyValueTypeImplDouble::SetValue(value2, dst);
330	}
331	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
332	{
333	bool value2 = value ? true : false;
334	wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
335	}
336	else
337	return false;
338
339	return true;
340	}
341
153107b4 JS	342	// Convert wxString to destination wxAny value type
	343	bool wxAnyConvertString(const wxString& value,
	344	wxAnyValueType* dstType,
	345	wxAnyValueBuffer& dst)
39601a7f	346	{
153107b4 JS	347	if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
	348	{
	349	wxAnyValueTypeImpl<wxString>::SetValue(value, dst);
	350	}
	351	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
39601a7f VZ	352	{
	353	wxAnyBaseIntType value2;
	354	#ifdef wxLongLong_t
	355	if ( !value.ToLongLong(&value2) )
	356	#else
	357	if ( !value.ToLong(&value2) )
	358	#endif
	359	return false;
	360	wxAnyValueTypeImplInt::SetValue(value2, dst);
	361	}
	362	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
	363	{
	364	wxAnyBaseUintType value2;
	365	#ifdef wxLongLong_t
	366	if ( !value.ToULongLong(&value2) )
	367	#else
	368	if ( !value.ToULong(&value2) )
	369	#endif
	370	return false;
	371	wxAnyValueTypeImplUint::SetValue(value2, dst);
	372	}
	373	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, double) )
	374	{
	375	double value2;
43c42c18	376	if ( !value.ToCDouble(&value2) )
39601a7f VZ	377	return false;
	378	wxAnyValueTypeImplDouble::SetValue(value2, dst);
	379	}
	380	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, bool) )
	381	{
	382	bool value2;
153107b4 JS	383	wxString s(value);
	384	s.MakeLower();
	385	if ( s == wxS("true") \|\|
	386	s == wxS("yes") \|\|
	387	s == wxS('1') )
39601a7f	388	value2 = true;
153107b4 JS	389	else if ( s == wxS("false") \|\|
	390	s == wxS("no") \|\|
	391	s == wxS('0') )
39601a7f VZ	392	value2 = false;
	393	else
	394	return false;
	395
	396	wxAnyValueTypeImpl<bool>::SetValue(value2, dst);
	397	}
	398	else
	399	return false;
	400
	401	return true;
	402	}
	403
	404	bool wxAnyValueTypeImpl<bool>::ConvertValue(const wxAnyValueBuffer& src,
	405	wxAnyValueType* dstType,
	406	wxAnyValueBuffer& dst) const
	407	{
	408	bool value = GetValue(src);
	409	if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
	410	{
	411	wxAnyBaseIntType value2 = static_cast<wxAnyBaseIntType>(value);
	412	wxAnyValueTypeImplInt::SetValue(value2, dst);
	413	}
	414	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
	415	{
	416	wxAnyBaseIntType value2 = static_cast<wxAnyBaseUintType>(value);
	417	wxAnyValueTypeImplUint::SetValue(value2, dst);
	418	}
	419	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
	420	{
	421	wxString s;
	422	if ( value )
	423	s = wxS("true");
	424	else
	425	s = wxS("false");
	426	wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
	427	}
	428	else
	429	return false;
	430
	431	return true;
	432	}
	433
	434	bool wxAnyValueTypeImplDouble::ConvertValue(const wxAnyValueBuffer& src,
	435	wxAnyValueType* dstType,
	436	wxAnyValueBuffer& dst) const
	437	{
	438	double value = GetValue(src);
	439	if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseIntType) )
	440	{
	441	if ( value < UseIntMinF \|\| value > UseIntMaxF )
	442	return false;
	443	wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);
	444	wxAnyValueTypeImplUint::SetValue(ul, dst);
	445	}
	446	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxAnyBaseUintType) )
	447	{
	448	if ( value < 0.0 \|\| value > UseUintMaxF )
	449	return false;
	450	wxAnyBaseUintType ul = static_cast<wxAnyBaseUintType>(value);
	451	wxAnyValueTypeImplUint::SetValue(ul, dst);
	452	}
	453	else if ( wxANY_VALUE_TYPE_CHECK_TYPE(dstType, wxString) )
	454	{
850a256b	455	wxString s = wxString::FromCDouble(value, 14);
39601a7f VZ	456	wxAnyValueTypeImpl<wxString>::SetValue(s, dst);
	457	}
	458	else
	459	return false;
	460
	461	return true;
	462	}
	463
	464	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplInt)
	465	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplUint)
39601a7f VZ	466	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<bool>)
	467	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplDouble)
	468
153107b4 JS	469	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplwxString)
	470	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplConstCharPtr)
	471	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImplConstWchar_tPtr)
	472
103bfa6f	473	#if wxUSE_DATETIME
c5fe6a5b	474	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxDateTime>)
103bfa6f JS	475	#endif // wxUSE_DATETIME
103bfa6f JS	476
c5fe6a5b JS	477	//WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxObject*>)
	478	//WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxArrayString>)
	479
39601a7f VZ	480	//-------------------------------------------------------------------------
	481	// wxAnyNullValueType implementation
	482	//-------------------------------------------------------------------------
	483
	484	class wxAnyNullValue
	485	{
17473a77 VS	486	protected:
	487	// this field is unused, but can't be private to avoid Clang's
	488	// "Private field 'm_dummy' is not used" warning
39601a7f VZ	489	void* m_dummy;
	490	};
	491
	492	template <>
	493	class wxAnyValueTypeImpl<wxAnyNullValue> : public wxAnyValueType
	494	{
	495	WX_DECLARE_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)
	496	public:
24985a9b	497	// Dummy implementations
39601a7f VZ	498	virtual void DeleteValue(wxAnyValueBuffer& buf) const
39601a7f VZ	499	{
24985a9b	500	wxUnusedVar(buf);
39601a7f VZ	501	}
39601a7f VZ	502
39601a7f VZ	503	virtual void CopyBuffer(const wxAnyValueBuffer& src,
	504	wxAnyValueBuffer& dst) const
	505	{
	506	wxUnusedVar(src);
	507	wxUnusedVar(dst);
	508	}
	509
	510	virtual bool ConvertValue(const wxAnyValueBuffer& src,
	511	wxAnyValueType* dstType,
	512	wxAnyValueBuffer& dst) const
	513	{
	514	wxUnusedVar(src);
	515	wxUnusedVar(dstType);
	516	wxUnusedVar(dst);
	517	return false;
	518	}
	519
e765d7ee SC	520	#if wxUSE_EXTENDED_RTTI
	521	virtual const wxTypeInfo* GetTypeInfo() const
	522	{
	523	wxFAIL_MSG("Null Type Info not available");
	524	return NULL;
	525	}
	526	#endif
	527
39601a7f VZ	528	private:
	529	};
	530
	531	WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxAnyNullValue>)
	532
	533	wxAnyValueType* wxAnyNullValueType =
	534	wxAnyValueTypeImpl<wxAnyNullValue>::GetInstance();
	535
f41d5991 SC	536	#include "wx/listimpl.cpp"
	537	WX_DEFINE_LIST(wxAnyList)
	538
39601a7f	539	#endif // wxUSE_ANY