XMLSerialisation.h

/*
www.sourceforge.net/projects/tinybind
Original code copyright (c) 2004 IMVU, Inc (author: eric@imvu.com)

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.

Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source
distribution.
*/

//Memory leaks fixed and drastically hacked for thread safety by Lorien Dunn during integration with LDK


#ifdef _WINDOWS
#define strcasecmp _stricmp
#endif

#ifndef __LDK_XMLBIND_HH__
#define __LDK_XMLBIND_HH__

#include "LDK/XML.h"
#include "LDK/SStream.h"
#include "LDK/Threading.h"
#include <vector>
#include <list>
#include <string.h>

namespace LDK
{

class LDK_API IdentityBase
{
};

template<class T>
class Identity : public IdentityBase
{
public:
    typedef T type;

};

enum MemberSerializeFlags
{
    MemberSerializeFlagsNone = 0,
    MemberOptional = 1,
};

class LDK_API Tag
{
public:
    // support up to 3 tags
    char const * tag_[3];

    Tag(char const * tagOne = NULL)
    {
        tag_[0] = tagOne;
        tag_[1] = NULL;
        tag_[2] = NULL;
    }

    Tag(char const * tagOne, char const * tagTwo)
    {
        tag_[0] = tagOne;
        tag_[1] = tagTwo;
        tag_[2] = NULL;
    }

    Tag(char const * tagOne, char const * tagTwo, char const * tagThree)
    {
        tag_[0] = tagOne;
        tag_[1] = tagTwo;
        tag_[2] = tagThree;
    }
};

struct LDK_API SerializeParams
{
    Tag tag_;
};



template<class T>
class XmlBinding
{
public:
    virtual ~XmlBinding() {}
    virtual bool fromXml(XmlElement const & elem, T * data, SerializeParams const &) const = 0;
    virtual bool intoXml(XmlElement * elem, T const & data, SerializeParams const &) const = 0;
};

template<class T>
bool BindToXml(XmlElement * elemOut, T const & dataIn)
{
    SmartPointer<XmlBinding<T> > binding = GetXmlBinding( dataIn, Identity<T>() );
    SerializeParams params;
    return binding->intoXml( elemOut, dataIn, params );
}

template<class T>
bool BindFromXml( XmlElement const & elemIn, T * dataOut )
{
    SmartPointer<XmlBinding<T> > binding = GetXmlBinding( *dataOut, Identity<T>() );
    SerializeParams params;
    return binding->fromXml( elemIn, dataOut, params );
}


template<class T>
class IMemberHolder
{
public:
    MemberSerializeFlags flags_;
    Tag tag_;
    SerializeParams params_;

    void setFlags( MemberSerializeFlags f )
    {
        flags_ = f;
    }

    SerializeParams const & params()
    {
        params_.tag_ = tag_;
        return params_;
    }

    virtual char const * tag( int which = 0) { return tag_.tag_[which]; }

    virtual bool fromXml( XmlElement const &, T * ) = 0;
    virtual bool intoXml( XmlElement *, T const * ) = 0;
    virtual bool isAttributeMember() = 0;
};

template<class T, class MT>
class IMemberValuePolicy
{
public:
    virtual MT getMemberValue( T const * thisPtr ) = 0;
    virtual void setMemberValue( T * thisPtr, MT const & mv ) = 0;
};


template<class T, class MT>
class MemberFuncHolder : public IMemberValuePolicy<T, MT>
{
public:
    MT (T::*getter_)();
    void (T::*setter_)(MT);

    virtual MT getMemberValue( T const * thisPtr )
    {
        return (const_cast<T*>(thisPtr)->*getter_)();
    }

    virtual void setMemberValue( T * thisPtr, MT const & mv )
    {
        (thisPtr->*setter_)(mv);
    }
};

template<class T, class MT>
class MemberFuncHolderConstRef  : public IMemberValuePolicy<T, MT>
{
public:
  MT const & (T::*getter_)();
  void (T::*setter_)(MT const &);

    virtual MT getMemberValue( T const * thisPtr )
    {
        return (thisPtr->*getter_)();
    }

    virtual void setMemberValue( T * thisPtr, MT const & mv )
    {
        (thisPtr->*setter_)(mv);
    }
};

template<class T, class MT>
class MemberPtrHolder : public IMemberValuePolicy<T, MT>
{
public:
    MT T::*memberPtr_;
    virtual MT getMemberValue( T const * thisPtr ) { return thisPtr->*memberPtr_; }
    virtual void setMemberValue( T * thisPtr, MT const & mv )
    {
        // by casting away const here, we can support member pointers to arrays
        thisPtr->*memberPtr_ = const_cast<MT &>(mv);
    }
};


template<class T, class MT>
class MemberRefFuncHolder : public IMemberValuePolicy<T, MT>
{
public:
    MT & (T::*memberRefFunc_)();
    virtual MT getMemberValue( T const * thisPtr ) { return (const_cast<T*>(thisPtr)->*memberRefFunc_)(); }
    virtual void setMemberValue( T * thisPtr, MT const & mv ) { (thisPtr->*memberRefFunc_)() = mv; }
};


template<class T, class MT>
class FromXmlElement : public IMemberHolder<T>
{
public:

    IMemberValuePolicy<T, MT> * mvPolicy_;
    FromXmlElement( IMemberValuePolicy<T, MT> * mvPolicy )
    {
        mvPolicy_ = mvPolicy;
    }

    virtual bool fromXml( XmlElement const & elem, T * thisPtr)
    {
        MT  mv = mvPolicy_->getMemberValue(thisPtr);
        SmartPointer<XmlBinding<MT> > binding = GetXmlBinding( mv,  Identity<MT>()  );
        if( binding->fromXml(elem, &mv, IMemberHolder<T>::params()) )
        {
            mvPolicy_->setMemberValue(thisPtr, mv);
            return true;
        }
        return false;
    }

    virtual bool intoXml( XmlElement * elem, T const * thisPtr)
    {
        MT const & mv = mvPolicy_->getMemberValue(thisPtr);
        SmartPointer<XmlBinding<MT> > binding = GetXmlBinding( mv,  Identity<MT>() );
        String oldValue = elem->Value();
        elem->SetValue( IMemberHolder<T>::tag() );
        bool ret = binding->intoXml( elem, mv, IMemberHolder<T>::params() );
        elem->SetValue( oldValue );
        return ret;
    }

    virtual bool isAttributeMember() { return true; }
};


template<class T, class MT, class FromXmlPolicy, class MemberValuePolicy>
class MemberHolder
{
public:
    FromXmlPolicy xmlPolicy_;
    MemberValuePolicy mvPolicy_;

    MemberHolder()
    : xmlPolicy_((IMemberValuePolicy<T, MT> *)&mvPolicy_)
    {
    }
};


template<class T, class MT>
class FromXmlChildElement : public IMemberHolder<T>
{
public:
    IMemberValuePolicy<T, MT> * mvPolicy_;
    FromXmlChildElement( IMemberValuePolicy<T, MT> * mvPolicy )
    {
        mvPolicy_ = mvPolicy;
    }

    virtual bool fromXml( XmlElement const & elem, T * thisPtr)
    {//stricmp
        if( !strcasecmp(elem.Value(), IMemberHolder<T>::tag()) )
        {
            MT mv;
            SmartPointer<XmlBinding<MT> > binding = GetXmlBinding( mv,  Identity<MT>()  );
            if( binding->fromXml(elem, &mv, IMemberHolder<T>::params()) )
            {
                mvPolicy_->setMemberValue(thisPtr, mv);
                return true;
            }
            return false;
        }
        return false;
    }

    virtual bool intoXml( XmlElement * elem, T const * thisPtr)
    {
        MT const & mv = mvPolicy_->getMemberValue(thisPtr);
        XmlElement child(IMemberHolder<T>::tag());
        SmartPointer<XmlBinding<MT> > binding = GetXmlBinding( mv, Identity<MT>()  );
        if( binding->intoXml( &child, mv, IMemberHolder<T>::params() ) )
        {
            elem->InsertEndChild(child);
            return true;
        }
        return false;
    }

    virtual bool isAttributeMember() { return false; }
};

template<class T, class MT>
class FromXmlAttribute  : public IMemberHolder<T>
{
public:
    IMemberValuePolicy<T, MT> * mvPolicy_;
    FromXmlAttribute( IMemberValuePolicy<T, MT> * mvPolicy )
    {
        mvPolicy_ = mvPolicy;
    }

    virtual bool fromXml( XmlElement const & elem, T * thisPtr)
    {
        MT mv;
        const char * attributeValue = elem.Attribute( IMemberHolder<T>::tag() );
        if( attributeValue && *attributeValue )
        {
            StringStream strm;
            strm << attributeValue;
            strm >> mv;
            mvPolicy_->setMemberValue(thisPtr, mv);
            return true;
        }
        return false;
    }

    virtual bool intoXml( XmlElement * elem, T const * thisPtr)
    {
        MT const & mv = mvPolicy_->getMemberValue(thisPtr);
        StringStream strm;
        strm << mv;
        elem->SetAttribute( IMemberHolder<T>::tag(), strm.str() );
        return true;
    }

    virtual bool isAttributeMember() { return true; }
};

template<class T, class MT>
IMemberHolder<T> * Member(  MT T::*mp )
{
    typedef FromXmlChildElement<T, MT> XmlPolicy;
    typedef MemberPtrHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.memberPtr_ = mp;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * Member(MT & (T::*mp)() )
{
    typedef FromXmlChildElement<T, MT> XmlPolicy;
    typedef MemberRefFuncHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.memberRefFunc_ = mp;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * Member(  MT (T::*getter)(), void (T::*setter)(MT) )
{
    typedef FromXmlChildElement<T, MT> XmlPolicy;
    typedef MemberFuncHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * Member(  MT (T::*getter)()const, void (T::*setter)(MT) )
{
    typedef FromXmlChildElement<T, MT> XmlPolicy;
    typedef MemberFuncHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = (MT (T::*)())getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * Member
(
    MT const & (T::*getter)(),
    void (T::*setter)(MT const &)
)
{
    typedef FromXmlChildElement<T, MT> XmlPolicy;
    typedef MemberFuncHolderConstRef<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}

// BEGIN ATTRIBUTE MAKERS
template<class T, class MT>
IMemberHolder<T> * MemberAttribute(  MT T::*mp )
{
    typedef FromXmlAttribute<T, MT> XmlPolicy;
    typedef MemberPtrHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.memberPtr_ = mp;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * MemberAttribute(  MT (T::*getter)(), void (T::*setter)(MT) )
{
    typedef FromXmlAttribute<T, MT> XmlPolicy;
    typedef MemberFuncHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * MemberAttribute(  MT (T::*getter)() const, void (T::*setter)(MT) )
{
    typedef FromXmlAttribute<T, MT> XmlPolicy;
    typedef MemberFuncHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = (MT (T::*)())getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * MemberAttribute
(
    MT const & (T::*getter)(),
    void (T::*setter)(MT const &)
)
{
    typedef FromXmlAttribute<T, MT> XmlPolicy;
    typedef MemberFuncHolderConstRef<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}
// END ATTRIBUTE MAKERS

// BEGIN PEER MAKERS
template<class T, class MT>
IMemberHolder<T> * MemberPeer(  MT T::*mp )
{
    typedef FromXmlElement<T, MT> XmlPolicy;
    typedef MemberPtrHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.memberPtr_ = mp;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * MemberPeer(  MT (T::*getter)(), void (T::*setter)(MT) )
{
    typedef FromXmlElement<T, MT> XmlPolicy;
    typedef MemberFuncHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * MemberPeer
(
    MT const & (T::*getter)(),
    void (T::*setter)(MT const &)
)
{
    typedef FromXmlElement<T, MT> XmlPolicy;
    typedef MemberFuncHolderConstRef<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.getter_ = getter;
    mph->mvPolicy_.setter_ = setter;
    return &mph->xmlPolicy_;
}

template<class T, class MT>
IMemberHolder<T> * MemberPeer(MT & (T::*mp)() )
{
    typedef FromXmlElement<T, MT> XmlPolicy;
    typedef MemberRefFuncHolder<T, MT> MemberValuePolicy;
    typedef MemberHolder<T, MT, XmlPolicy, MemberValuePolicy> MH_Type;
    MH_Type * mph = LDK_CREATE0(MH_Type);
    mph->mvPolicy_.memberRefFunc_ = mp;
    return &mph->xmlPolicy_;
}

// END PEER MAKERS

template<class T>
class MemberXmlBinding : public XmlBinding<T>
{
private:
    std::vector<IMemberHolder<T>*> members_;

public:
    virtual ~MemberXmlBinding()
    {
        for(size_t i=0;i<members_.size();i++)
        {
            LDK::destroy(members_[i]);
        }
    }

    bool empty() const
    {
        return members_.empty();
    }

    IMemberHolder<T> * AddMember( Tag tag, IMemberHolder<T> * mph )
    {
        mph->flags_ = MemberSerializeFlagsNone;
        mph->tag_ = tag;
        members_.push_back( mph );
        return mph;
    }

    virtual bool fromXml( XmlElement const & elem, T * data, SerializeParams const & params ) const
    {
        XmlElement const * child = elem.FirstChildElement();
        for( size_t i = 0; i < members_.size(); i++ )
        {
            IMemberHolder<T> * mph = members_[i];
            bool error = false;

            bool ret;
            if( mph->isAttributeMember() )
            {
                ret = mph->fromXml( elem, data );
            }
            else
            {
                if( !child )
                {
                    return false;
                }
                ret = mph->fromXml( *child, data );
            }
            error = !ret;
            if( mph->isAttributeMember() ) {} //????
            else if( !error )
            {
                child = child->NextSiblingElement();
            }

            if( error )
            {
                if( mph->isAttributeMember() )
                {
                    // no problem
                    continue;
                }
                else
                {
                    // error
                    return false;
                }
            }
        }
        return true;
    }

    virtual bool intoXml( XmlElement * elem, T const & data, SerializeParams const & ) const
    {
        for( size_t i = 0; i < members_.size(); i++ )
        {
            IMemberHolder<T> * mph = members_[i];
            mph->intoXml( elem, &data );
        }
        return true;
    }
};

template<class T>
class GenericXmlBinding : public XmlBinding<T>
{
public:
    virtual bool fromXml( XmlElement const & elem, T * data, SerializeParams const & ) const
    {
        const XmlNode * node = elem.FirstChild();
        const XmlText * nodedata = node->ToText();
        StringStream strm;
        strm << nodedata->Value();
        strm >> *data;
        return true;
    }

    virtual bool intoXml( XmlElement * elem, T const & data, SerializeParams const & ) const
    {
        StringStream strm;
        strm << data;
        XmlText textData( strm.str() );
        elem->InsertEndChild( textData );
        return true;
    }
};

#ifdef _MSC_VER
#pragma warning (default : 4251)
#endif

template<>
class LDK_API GenericXmlBinding<const char*> : public XmlBinding<const char*>
{
static TLSKey mKey;
static bool mInitialised;
static Mutex mMutex;

    static void dtor(void* tls)
    {
        LDK::destroy(reinterpret_cast<std::string*>(tls));
    }
public:
    GenericXmlBinding()
    {
        Lock lock(mMutex);
        if(!mInitialised)
        {
            mKey = threadLocalCreateKey(dtor);
            mInitialised = true;
        }
    }
    virtual bool fromXml( XmlElement const & elem, const char ** data, SerializeParams const & ) const
    {
        if(!mInitialised)
            Lock lock(mMutex);
        const XmlNode * node = elem.FirstChild();
        const XmlText * nodedata = node->ToText();

        std::string* strHolder = reinterpret_cast<std::string*>(threadLocalGet(mKey));
        if(!strHolder)
        {
            strHolder = new std::string;
            threadLocalSet(mKey,strHolder);
        }
        *strHolder = nodedata->Value();;
        *data = strHolder->c_str();
        return true;
    }

    virtual bool intoXml( XmlElement * elem, const char* const & data, SerializeParams const & ) const
    {
        if(!mInitialised)
            Lock lock(mMutex);
        StringStream strm;
        strm << data;
        XmlText textData( strm.str() );
        elem->InsertEndChild( textData );
        return true;
    }
};

template<class T, class VecT>
class StlContainerXmlBinding : public XmlBinding<VecT>
{
public:

    char const * subTag_;
    bool useSubTag_;
    char const * sizeAttributeName_;

    StlContainerXmlBinding(bool useSubTag, char const * st = NULL, char const * sizeAttributeName = NULL)
    :subTag_(st), useSubTag_(useSubTag), sizeAttributeName_(sizeAttributeName)
    {
    }

    virtual bool fromXml( XmlElement const & elem, VecT * data, SerializeParams const & params ) const
    {
        data->clear();
        XmlElement const * child;
        child = elem.FirstChildElement();
        if( sizeAttributeName_ )
        {
            int sz = 0;
            StringStream strm;
            strm << sizeAttributeName_;
            strm >> sz;

            if( sz )
            {
                //data->reserve(sz);
            }
        }

        T value;
        while(child)
        {
            SmartPointer<XmlBinding<T> > binding = GetXmlBinding( value,  Identity<T>()  );
            bool ret = binding->fromXml( *child, &value, params );
            data->push_back(value);
            if( ! ret )
            {
                return false;
            }
            child = child->NextSiblingElement();
        }
        return true;
    }

    virtual bool intoXml( XmlElement * elem, VecT const & data, SerializeParams const & params ) const
    {
        if( sizeAttributeName_ )
        {
            StringStream strm;
            strm << data.size();
            elem->SetAttribute( sizeAttributeName_, strm.str() );
        }
        for( typename VecT::const_iterator i = data.begin(); i != data.end(); i++ )
        {
            T const & value = *i;
            SmartPointer<XmlBinding<T> > binding = GetXmlBinding( value,  Identity<T>()  );
            char const * tag;
            if( useSubTag_ )
            {
                tag = subTag_;
            }
            else
            {
                tag = elem->Value();
            }
            XmlElement child(tag);
            if( ! binding->intoXml( &child, value, params ) )
            {
                return false;
            }
            elem->InsertEndChild(child);
        }
        return true;
    }
  };

template<class T, class VecT>
class StlContainerPtrBinding : public XmlBinding<VecT>
{
public:

    char const * subTag_;
    bool useSubTag_;
    char const * sizeAttributeName_;
    StlContainerPtrBinding(bool useSubTag, char const * st = NULL, char const * sizeAttributeName = NULL)
    :subTag_(st), useSubTag_(useSubTag), sizeAttributeName_(sizeAttributeName)
    {
    }

    virtual bool fromXml( XmlElement const & elem, VecT * data, SerializeParams const & params ) const
    {
        data->clear();
        XmlElement const * child;
        child = elem.FirstChildElement();
        if( sizeAttributeName_ )
        {
            int sz = 0;
            StringStream strm;
            strm << sizeAttributeName_;
            strm >> sz;
            if( sz )
            {
                //data->reserve(sz);
            }
        }
        while(child)
        {
            T * value = LDK_CREATE0(T);
            if( !value->create() )
            {
                return false;
            }
            SmartPointer<XmlBinding<T> > binding = GetXmlBinding( *value,  Identity<T>()  );
            bool ret = binding->fromXml( *child, value, params );
            data->push_back(value);
            if( ! ret )
            {
                return false;
            }
            child = child->NextSiblingElement();
        }
        return true;
    }

    virtual bool intoXml( XmlElement * elem, VecT const & data, SerializeParams const & params ) const
    {
        if( sizeAttributeName_ )
        {
            StringStream strm;
            strm << data.size();
            elem->SetAttribute( sizeAttributeName_, strm.str() );
        }
        for( typename VecT::const_iterator i = data.begin(); i != data.end(); i++ )
        {
            T const * value = *i;
            if( ! value )
            {
                continue;
            }
            SmartPointer<XmlBinding<T> > binding = GetXmlBinding( *value,  Identity<T>()  );
            char const * tag;
            if( useSubTag_ )
            {
                tag = subTag_;
            }
            else
            {
                tag = elem->Value();
            }
            XmlElement child(tag);
            if( ! binding->intoXml( &child, *value, params ) )
            {
                return false;
            }
            elem->InsertEndChild(child);
        }
        return true;
    }
};


template<class T>
XmlBinding<T>*
GetXmlBinding( T const &, IdentityBase  )
{
    return LDK_CREATE0(GenericXmlBinding<T>);
}

template<class T, class VecT>
XmlBinding<VecT>*
GetXmlBinding( std::vector<T> const &, Identity<VecT>  )
{
    typedef StlContainerXmlBinding<T,VecT> Bind;
    return LDK_CREATE1(Bind,false);
}


template<class T, class VecT>
XmlBinding<VecT>*
GetXmlBinding( std::list<T> const &, Identity<VecT>  )
{
    typedef StlContainerXmlBinding<T,VecT> Bind;
    return LDK_CREATE1(Bind,false);
}

}//namespace LDK


#endif //__LDK_XMLBIND_HH__

---