stltypes.hpp

ncbi源码

    static void AddElementIn(const CContainerTypeInfo* containerType,
                             TObjectPtr containerPtr, CObjectIStream& in)
        {
            TElementType data;
            containerType->GetElementType()->ReadData(in, &data);
            InsertElement(containerPtr, data);
        }

    static void SetAddElementFunctions(CStlOneArgTemplate* info)
        {
            info->SetAddElementFunctions(&AddElement, &AddElementIn);
        }
};

template<class Container, class StlIterator,
    typename ContainerPtr, typename ElementRef,
    class TypeInfoIterator>
class CStlClassInfoFunctionsIBase :
    public CStlClassInfoFunctions<Container>
{
public:
    typedef StlIterator TStlIterator;
    typedef TypeInfoIterator TTypeInfoIterator;
    typedef typename TTypeInfoIterator::TObjectPtr TObjectPtr;

    static TStlIterator& It(TTypeInfoIterator& iter)
        {
            if ( sizeof(TStlIterator) <= sizeof(iter.m_IteratorData) ) {
                void* data = &iter.m_IteratorData;
                return *static_cast<TStlIterator*>(data);
            }
            else {
                void* data = iter.m_IteratorData;
                return *static_cast<TStlIterator*>(data);
            }
        }
    static const TStlIterator& It(const TTypeInfoIterator& iter)
        {
            if ( sizeof(TStlIterator) <= sizeof(iter.m_IteratorData) ) {
                const void* data = &iter.m_IteratorData;
                return *static_cast<const TStlIterator*>(data);
            }
            else {
                const void* data = iter.m_IteratorData;
                return *static_cast<const TStlIterator*>(data);
            }
        }
    static bool InitIterator(TTypeInfoIterator& iter)
        {
            TStlIterator stl_iter = Get(iter.GetContainerPtr()).begin();
            if ( sizeof(TStlIterator) <= sizeof(iter.m_IteratorData) ) {
                void* data = &iter.m_IteratorData;
                new (data) TStlIterator(stl_iter);
            }
            else {
                iter.m_IteratorData = new TStlIterator(stl_iter);
            }
            return stl_iter != Get(iter.GetContainerPtr()).end();
        }
    static void ReleaseIterator(TTypeInfoIterator& iter)
        {
            if ( sizeof(TStlIterator) <= sizeof(iter.m_IteratorData) ) {
                void* data = &iter.m_IteratorData;
                static_cast<TStlIterator*>(data)->~StlIterator();
            }
            else {
                void* data = iter.m_IteratorData;
                delete static_cast<TStlIterator*>(data);
            }
        }
    static void CopyIterator(TTypeInfoIterator& dst,
                             const TTypeInfoIterator& src)
        {
            It(dst) = It(src);
        }

    static bool NextElement(TTypeInfoIterator& iter)
        {
            return ++It(iter) != Get(iter.GetContainerPtr()).end();
        }
    static TObjectPtr GetElementPtr(const TTypeInfoIterator& iter)
        {
            ElementRef e= *It(iter);
            return &e;
        }
};

template<class Container>
class CStlClassInfoFunctionsCI :
    public CStlClassInfoFunctionsIBase<Container, typename Container::const_iterator, const Container*, const typename Container::value_type&, CContainerTypeInfo::CConstIterator>
{
    typedef CStlClassInfoFunctionsIBase<Container, typename Container::const_iterator, const Container*, const typename Container::value_type&, CContainerTypeInfo::CConstIterator> CParent;
public:
    static void SetIteratorFunctions(CStlOneArgTemplate* info)
        {
            info->SetConstIteratorFunctions(&CParent::InitIterator,
                                            &CParent::ReleaseIterator,
                                            &CParent::CopyIterator,
                                            &CParent::NextElement,
                                            &CParent::GetElementPtr);
        }
};

template<class Container>
class CStlClassInfoFunctionsI :
    public CStlClassInfoFunctionsIBase<Container, typename Container::iterator, Container*, typename Container::value_type&, CContainerTypeInfo::CIterator>
{
    typedef CStlClassInfoFunctionsIBase<Container, typename Container::iterator, Container*, typename Container::value_type&, CContainerTypeInfo::CIterator> CParent;
public:
    typedef typename CParent::TStlIterator TStlIterator;
    typedef typename CParent::TTypeInfoIterator TTypeInfoIterator;
    typedef typename CParent::TObjectPtr TObjectPtr;
    
    static bool EraseElement(TTypeInfoIterator& iter)
        {
            TStlIterator& it = It(iter);
            Container* c = static_cast<Container*>(iter.GetContainerPtr());
            it = c->erase(it);
            return it != c->end();
        }
    static void EraseAllElements(TTypeInfoIterator& iter)
        {
            Container* c = static_cast<Container*>(iter.GetContainerPtr());
            c->erase(It(iter), c->end());
        }

    static void SetIteratorFunctions(CStlOneArgTemplate* info)
        {
            info->SetIteratorFunctions(&CParent::InitIterator,
                                       &CParent::ReleaseIterator,
                                       &CParent::CopyIterator,
                                       &CParent::NextElement,
                                       &CParent::GetElementPtr,
                                       &EraseElement, &EraseAllElements);
        }
};

template<class Container>
class CStlClassInfoFunctionsI_set :
    public CStlClassInfoFunctionsIBase<Container, typename Container::iterator, Container*, typename Container::value_type&, CContainerTypeInfo::CIterator>
{
    typedef CStlClassInfoFunctionsIBase<Container, typename Container::iterator, Container*, typename Container::value_type&, CContainerTypeInfo::CIterator> CParent;
public:
    typedef typename CParent::TStlIterator TStlIterator;
    typedef typename CParent::TTypeInfoIterator TTypeInfoIterator;
    typedef typename CParent::TObjectPtr TObjectPtr;
    
    static TObjectPtr GetElementPtr(const TTypeInfoIterator& /*data*/)
        {
            CStlClassInfoUtil::CannotGetElementOfSet();
            return 0;
        }
    static bool EraseElement(TTypeInfoIterator& iter)
        {
            TStlIterator& it = It(iter);
            Container* c = static_cast<Container*>(iter.GetContainerPtr());
            TStlIterator erase = it++;
            c->erase(erase);
            return it != c->end();
        }
    static void EraseAllElements(TTypeInfoIterator& iter)
        {
            Container* c = static_cast<Container*>(iter.GetContainerPtr());
            c->erase(It(iter), c->end());
        }

    static void SetIteratorFunctions(CStlOneArgTemplate* info)
        {
            info->SetIteratorFunctions(&CParent::InitIterator,
                                       &CParent::ReleaseIterator,
                                       &CParent::CopyIterator,
                                       &CParent::NextElement,
                                       &GetElementPtr,
                                       &EraseElement, &EraseAllElements);
        }
};

template<typename Data>
class CStlClassInfo_list
{
public:
    typedef list<Data> TObjectType;

    static TTypeInfo GetTypeInfo(TTypeInfo elementType)
        {
            return CStlClassInfoUtil::Get_list(elementType, &CreateTypeInfo);
        }
    static CTypeInfo* CreateTypeInfo(TTypeInfo elementType)
        {
            CStlOneArgTemplate* info =
                new CStlOneArgTemplate(sizeof(TObjectType), elementType,
                                       false);
            SetFunctions(info);
            return info;
        }
    static CTypeInfo* CreateTypeInfo(TTypeInfo elementType, const string& name)
        {
            CStlOneArgTemplate* info =
                new CStlOneArgTemplate(sizeof(TObjectType), elementType,
                                       false, name);
            SetFunctions(info);
            return info;
        }

    static TTypeInfo GetSetTypeInfo(TTypeInfo elementType)
        {
            return CStlClassInfoUtil::GetSet_list(elementType,
                                                  &CreateSetTypeInfo);
        }
    static CTypeInfo* CreateSetTypeInfo(TTypeInfo elementType)
        {
            CStlOneArgTemplate* info =
                new CStlOneArgTemplate(sizeof(TObjectType), elementType,
                                       true);
            SetFunctions(info);
            return info;
        }

    static void SetFunctions(CStlOneArgTemplate* info)
        {
            CStlClassInfoFunctions<TObjectType>::SetMemFunctions(info);
            CStlClassInfoFunctions<TObjectType>::SetAddElementFunctions(info);
            CStlClassInfoFunctionsCI<TObjectType>::SetIteratorFunctions(info);
            CStlClassInfoFunctionsI<TObjectType>::SetIteratorFunctions(info);
        }
};

template<typename Data>
class CStlClassInfo_vector
{
public:
    typedef vector<Data> TObjectType;

    static TTypeInfo GetTypeInfo(TTypeInfo elementType)
        {
            return CStlClassInfoUtil::Get_vector(elementType,
                                                 &CreateTypeInfo);
        }
    static CTypeInfo* CreateTypeInfo(TTypeInfo elementType)
        {
            CStlOneArgTemplate* info =
                new CStlOneArgTemplate(sizeof(TObjectType), elementType,
                                       false);

            SetFunctions(info);
            return info;
        }

    static TTypeInfo GetSetTypeInfo(TTypeInfo elementType)
        {
            return CStlClassInfoUtil::GetSet_vector(elementType,
                                                    &CreateSetTypeInfo);
        }
    static CTypeInfo* CreateSetTypeInfo(TTypeInfo elementType)
        {
            CStlOneArgTemplate* info =
                new CStlOneArgTemplate(sizeof(TObjectType), elementType,
                                       true);
            SetFunctions(info);
            return info;
        }

    static void SetFunctions(CStlOneArgTemplate* info)
        {
            CStlClassInfoFunctions<TObjectType>::SetMemFunctions(info);
            CStlClassInfoFunctions<TObjectType>::SetAddElementFunctions(info);
            CStlClassInfoFunctionsCI<TObjectType>::SetIteratorFunctions(info);
            CStlClassInfoFunctionsI<TObjectType>::SetIteratorFunctions(info);
        }
};

template<typename Data>
class CStlClassInfo_set
{
public:
    typedef set<Data> TObjectType;

    static TTypeInfo GetTypeInfo(TTypeInfo elementType)
        {
            return CStlClassInfoUtil::Get_set(elementType, &CreateTypeInfo);
        }
    static CTypeInfo* CreateTypeInfo(TTypeInfo elementType)
        {
            CStlOneArgTemplate* info =
                new CStlOneArgTemplate(sizeof(TObjectType), elementType,
                                       true);

            CStlClassInfoFunctions<TObjectType>::SetMemFunctions(info);
            CStlClassInfoFunctions_set<TObjectType>::SetAddElementFunctions(info);
            CStlClassInfoFunctionsCI<TObjectType>::SetIteratorFunctions(info);
            CStlClassInfoFunctionsI_set<TObjectType>::SetIteratorFunctions(info);

            return info;
        }
};

template<typename Data>
class CStlClassInfo_multiset
{
public:
    typedef multiset<Data> TObjectType;

    static TTypeInfo GetTypeInfo(TTypeInfo elementType)
        {
            return CStlClassInfoUtil::Get_multiset(elementType,
                                                   &CreateTypeInfo);
        }
    static CTypeInfo* CreateTypeInfo(TTypeInfo elementType)
        {
            CStlOneArgTemplate* info =
                new CStlOneArgTemplate(sizeof(TObjectType), elementType,
                                       true);

            CStlClassInfoFunctions<TObjectType>::SetMemFunctions(info);
            CStlClassInfoFunctions_multiset<TObjectType>::SetAddElementFunctions(info);
            CStlClassInfoFunctionsCI<TObjectType>::SetIteratorFunctions(info);
            CStlClassInfoFunctionsI_set<TObjectType>::SetIteratorFunctions(info);

            return info;
        }
};

template<typename Key, typename Value>
class CStlClassInfo_map
{
public:
    typedef map<Key, Value> TObjectType;
    typedef typename TObjectType::value_type TElementType;

    static TTypeInfo GetTypeInfo(TTypeInfo keyType, TTypeInfo valueType)
        {
            return CStlClassInfoUtil::Get_map(keyType, valueType,
                                              &CreateTypeInfo);
        }

    static CTypeInfo* CreateTypeInfo(TTypeInfo keyType, TTypeInfo valueType)