MultiVar.h

#pragma once
 
#include "FLBase.h"
#include "FLString.h"
 
#include <vector>
 
namespace FLImaging
{
    namespace Base
    {
        template <typename T>
        class FL_EXPORT CMultiVar : public CFLBase
        {
            SupportToDuplicateObject(CMultiVar<T>,*this);
        public:
            enum ETemplateType
            {
                ETemplateType_Int32,
 
                ETemplateType_Uint32,
 
                ETemplateType_Int64,
 
                ETemplateType_Uint64,
 
                ETemplateType_Float,
 
                ETemplateType_Double
            };
 
            CMultiVar();
 
            virtual ~CMultiVar();
 
            CMultiVar(const CMultiVar<int32_t>& mvMultiVar);
 
            CMultiVar(const CMultiVar<uint32_t>& mvMultiVar);
 
            CMultiVar(const CMultiVar<int64_t>& mvMultiVar);
 
            CMultiVar(const CMultiVar<uint64_t>& mvMultiVar);
 
            CMultiVar(const CMultiVar<float>& mvMultiVar);
 
            CMultiVar(const CMultiVar<double>& mvMultiVar);
 
            CMultiVar(const T& tVar1);
 
            CMultiVar(const T& tVar1, const T& tVar2);
 
            CMultiVar(const T& tVar1, const T& tVar2, const T& tVar3);
 
            CMultiVar(const T& tVar1, const T& tVar2, const T& tVar3, const T& tVar4);
 
            CMultiVar(const CFLString<wchar_t>& strValues);
 
            const CMultiVar<T>& operator=(const CMultiVar<int32_t>& mvMultiVar);
 
            const CMultiVar<T>& operator=(const CMultiVar<uint32_t>& mvMultiVar);
 
            const CMultiVar<T>& operator=(const CMultiVar<int64_t>& mvMultiVar);
 
            const CMultiVar<T>& operator=(const CMultiVar<uint64_t>& mvMultiVar);
 
            const CMultiVar<T>& operator=(const CMultiVar<float>& mvMultiVar);
 
            const CMultiVar<T>& operator=(const CMultiVar<double>& mvMultiVar);
 
            const CMultiVar<T>& operator=(const T& tVar1);
 
            T& operator[](int64_t i64Idx);
 
            T operator[](int64_t i64Idx) const;
 
            bool operator==(const CMultiVar<T>& mv) const;
 
            bool operator!=(const CMultiVar<T>& mv) const;
 
            operator CFLString<wchar_t>() const;
 
            virtual ETemplateType GetTemplateType() const sealed;
 
            virtual void Clear() sealed;
 
            virtual const CResult Assign(const T& tVar1);
 
            virtual const CResult Assign(const T& tVar1, const T& tVar2);
 
            virtual const CResult Assign(const T& tVar1, const T& tVar2, const T& tVar3);
 
            virtual const CResult Assign(const T& tVar1, const T& tVar2, const T& tVar3, const T& tVar4);
 
            virtual const CResult Assign(const CMultiVar<int32_t>& mvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<uint32_t>& mvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<int64_t>& mvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<uint64_t>& mvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<float>& mvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<double>& mvMultiVar) sealed;
 
 
            virtual const CResult Assign(const CMultiVar<int32_t>* pMvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<uint32_t>* pMvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<int64_t>* pMvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<uint64_t>* pMvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<float>* pMvMultiVar) sealed;
 
            virtual const CResult Assign(const CMultiVar<double>* pMvMultiVar) sealed;
 
            virtual const CResult Assign(const CFLString<wchar_t>& strValues) sealed;
 
            virtual const CResult SetAt(int64_t i64Index, const T& tVal) sealed;
 
            virtual T GetAt(int64_t i64Index) const sealed;
 
            virtual const CResult InsertAt(int64_t i64Index, const T& tVal) sealed;
 
            virtual const CResult DeleteAt(int64_t i64Index) sealed;
 
            virtual void PushBack(const T& tValue) sealed;
 
            virtual int64_t GetCount() const sealed;
 
            virtual bool Equal(const CMultiVar<T>& mv) const sealed;
 
            virtual bool Equal(const CMultiVar<T>* pMv) const sealed;
 
            virtual CFLString<wchar_t> ToString() const sealed;
 
            DeclareGetClassType();
 
        protected:
            const T* m_pTVars;
            size_t m_stCount;
            std::vector<T>* m_pVctVars;
 
            friend class CMultiVar;
        };
 
        typedef CMultiVar<int32_t> CMultiVarL;
 
        typedef CMultiVar<uint32_t> CMultiVarUL;
 
        typedef CMultiVar<int64_t> CMultiVarLL;
 
        typedef CMultiVar<uint64_t> CMultiVarULL;
 
        typedef CMultiVar<float> CMultiVarF;
 
        typedef CMultiVar<double> CMultiVarD;
    }
}