fbxsdk/core/base/fbxset.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2013 Autodesk, Inc.
   All rights reserved.
 
   Use of this software is subject to the terms of the Autodesk license agreement
   provided at the time of installation or download, or which otherwise accompanies
   this software in either electronic or hard copy form.
 
****************************************************************************************/

#ifndef _FBXSDK_CORE_BASE_SET_H_
#define _FBXSDK_CORE_BASE_SET_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/base/fbxredblacktree.h>
#include <fbxsdk/core/base/fbxmap.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FBXSDK_DLL FbxSet
{
public:
                FbxSet(int pItemPerBlock=20);

                FbxSet(const FbxSet& other);

                ~FbxSet();

    // Add and remove
    bool Add(FbxHandle pReference, FbxHandle pItem);
        
    bool Remove(FbxHandle pReference);
        
    bool RemoveItem(FbxHandle pItem);

    bool SetItem(FbxHandle pReference, FbxHandle pItem);

    FbxHandle Get(FbxHandle pReference, int* pIndex=NULL) const;

    void Clear();

    // Index manipulation
    FbxHandle GetFromIndex(int pIndex, FbxHandle* pReference=NULL) const;

    bool RemoveFromIndex(int pIndex);

    // Get The Count
    int GetCount() const { return mSetCount; }

    // Sorting
    bool Swap()const;

        //The array can be sorted only if the private member:mIsChanged be true.
    bool Sort()const;

    const FbxSet& operator=(const FbxSet&);

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
        struct SSet;

private:
    // internal functions for Sets manipulation
    SSet* FindEqual(FbxHandle pReference) const;

private:
    SSet*                       mSetArray;
    int                         mSetCount;
    int                         mBlockCount;
    int                         mItemPerBlock;
    mutable bool        mIsChanged;
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

template <typename Type, typename Compare=FbxLessCompare<Type>, typename Allocator=FbxBaseAllocator> class FbxSet2
{
protected:
        class Value
        {
        /*****************************************************************************************************************************
        ** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
        *****************************************************************************************************************************/
        #ifndef DOXYGEN_SHOULD_SKIP_THIS
        public:
                typedef const Type KeyType;
                typedef const Type ConstKeyType;
                typedef const Type ValueType;
                typedef const Type ConstValueType;

                inline Value(const Type& pValue) : mValue(pValue){}
                inline KeyType& GetKey() const { return mValue; }
                inline ConstKeyType& GetKey(){ return mValue; }
                inline ValueType& GetValue() const { return mValue; }
                inline ConstValueType& GetValue(){ return mValue; }

        protected:
                ValueType mValue;

        private:
                Value& operator=(const Value&);
        #endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
        };

        typedef FbxRedBlackTree<Value, Compare, Allocator> StorageType;

public:
        typedef Type ValueType;
        typedef typename StorageType::RecordType        RecordType;
        typedef typename StorageType::IteratorType      Iterator;
        typedef typename StorageType::ConstIteratorType ConstIterator;

        inline void Reserve(unsigned int pRecordCount)
        {
                mTree.Reserve(pRecordCount);
        }

        inline int GetSize() const
        {
                return mTree.GetSize();
        }

        inline FbxPair<RecordType*, bool> Insert(const ValueType& pValue)
        {
                return mTree.Insert(Value(pValue));
        }

        inline int Remove(const ValueType& pValue)
        {
                return mTree.Remove(pValue);
        }

        inline void Clear()
        {
                mTree.Clear();
        }

        inline bool Empty() const
        {
                return mTree.Empty();
        }

        Iterator Begin()
        {
                return Iterator(Minimum());
        }

        Iterator End()
        {
                return Iterator();
        }

        ConstIterator Begin() const
        {
                return ConstIterator(Minimum());
        }

        ConstIterator End() const
        {
                return ConstIterator();
        }

        inline const RecordType* Find(const ValueType& pValue) const
        {
                return mTree.Find(pValue);
        }

        inline RecordType* Find(const ValueType& pValue)
        {
                return mTree.Find(pValue);
        }

        inline const RecordType* Minimum() const
        {
                return mTree.Minimum();
        }

        inline RecordType* Minimum()
        {
                return mTree.Minimum();
        }

        inline const RecordType* Maximum() const
        {
                return mTree.Maximum();
        }

        inline RecordType* Maximum()
        {
                return mTree.Maximum();
        }

        inline bool operator==(const FbxSet2<Type, Compare, Allocator>& pOther) const
        {
                return (this == &pOther) || (mTree == pOther.mTree);
        }

        inline bool operator != (const FbxSet2<Type, Compare, Allocator>& pOther) const
        {
                return !(*this == pOther);
        }

        inline FbxSet2 Intersect(const FbxSet2& pOther) const
        {
                FbxSet2 lReturn;
                ConstIterator lBegin = Begin();
                for (; lBegin != End(); ++lBegin)
                {
                        if (pOther.Find(lBegin->GetValue()) != NULL)
                                lReturn.Insert(lBegin->GetValue());
                }
                return lReturn;
        }

        inline FbxSet2 Union(const FbxSet2& pOther) const
        {
                FbxSet2 lReturn(*this);
                ConstIterator lBegin = pOther.Begin();
                for (; lBegin != End(); ++lBegin)
                {
                        if (Find(lBegin->GetValue()) == NULL)
                                lReturn.Insert(lBegin->GetValue());
                }
                return lReturn;
        }

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline FbxSet2(){}
    inline FbxSet2(const FbxSet2& pSet) : mTree(pSet.mTree){}
    inline ~FbxSet2(){ Clear(); }

private:
    StorageType mTree;
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_BASE_SET_H_ */