FLArray.h

#pragma once
 
#include "FLBase.h"
 
#include <vector>
 
namespace FLImaging
{
    namespace Base
    {
        template <typename T>
        class FL_EXPORT CFLArray : public Base::CFLBase
        {
            SupportToDuplicateObject(CFLArray<T>,*this);
        public:
            CFLArray();
 
            CFLArray(const CFLArray<T>& flArray);
 
            CFLArray(const CFLArray<T>* pFlArray);
 
            CFLArray(int64_t i64Count, const T& tValue);
 
            CFLArray(const T* pArrData, int64_t i64Count);
 
 
            virtual ~CFLArray();
 
            virtual void Clear();
 
            virtual bool IsEmpty() const;
 
            virtual int64_t GetCount() const;
 
            virtual T& GetAt(int64_t i64Index) const;
 
            virtual void SetAt(int64_t i64Index, const T& tValue);
 
            virtual T& Front() const;
 
            virtual T& Back() const;
 
            virtual T* GetBuffer() const;
 
            virtual T* PushBack(const CFLArray<T>& flArray);
 
            virtual T* PushBack(const T* pArrData, int64_t i64Count);
 
            virtual T* PushBack(const T& tValue);
 
            virtual T* PushFront(const CFLArray<T>& flArray);
 
            virtual T* PushFront(const T* pArrData, int64_t i64Count);
 
            virtual T* PushFront(const T& tValue);
 
            virtual void PopBack();
 
            virtual void PopFront();
 
            virtual T* Append(const CFLArray<T>& flArray);
 
            virtual T* Append(const T* pArrData, int64_t i64Count);
 
            virtual T* Append(const T& tValue);
 
            virtual T* InsertAt(int64_t i64Index, const CFLArray<T>& flArray);
 
            virtual T* InsertAt(int64_t i64Index, const T* pArrData, int64_t i64Count);
 
            virtual T* InsertAt(int64_t i64Index, const T& tValue);
 
            virtual void RemoveAt(int64_t i64Index);
 
            virtual void Reserve(int64_t i64Size);
 
            virtual T* Resize(int64_t i64Size);
 
            virtual void ShrinkToFit();
 
            virtual void Reverse(int64_t i64BeginIndex = 0, int64_t i64EndIndex = -1);
 
            void Sort(int64_t i64BeginIndex, int64_t i64EndIndex, bool(*pFnComparator)(const T&, const T&));
 
            virtual const CFLArray<T>& Assign(const CFLArray<T>& flArray);
 
            virtual const CFLArray<T>& Assign(const CFLArray<T>* pFlArray);
 
            const CFLArray<T>& Assign(const T& tValue);
 
            const CFLArray<T>& Assign(int64_t i64Count, const T& tValue);
 
            const CFLArray<T>& Assign(const T* pArrData, int64_t i64Count);
 
            void Swap(CFLArray<T>& flaArray);
 
            void Swap(CFLArray<T>* pFlaArray);
 
            const CFLArray<T>& operator=(const CFLArray<T>& flArray);
 
            const CFLArray<T>& operator=(const T& tValue);
 
            T& operator[](int32_t i32Index) const;
 
            T& operator[](int64_t i64Index) const;
 
            T& operator[](uint32_t u32Index) const;
 
            T& operator[](uint64_t u64Index) const;
 
            const CFLArray<T>& operator+=(const CFLArray<T>& flArray);
 
            const CFLArray<T>& operator+=(const T& tValue);
 
            friend CFLArray<T> operator+(const CFLArray<T>& flArray1, const CFLArray<T>& flArray2)
            {
                CFLArray<T> flArray(flArray1);
                flArray.Append(flArray2);
                return flArray;
            }
 
            friend CFLArray<T> operator+(const CFLArray<T>& flArray1, const T& tValue2)
            {
                CFLArray<T> flArray(flArray1);
                flArray.Append(tValue2);
                return flArray;
            }
 
            friend CFLArray<T> operator+(const T& tValue1, const CFLArray<T>& flArray2)
            {
                CFLArray<T> flArray(1, tValue1);
                flArray.Append(flArray2);
                return flArray;
            }
 
            DeclareGetClassType();
 
        protected:
            
            const T* m_pTData;
            size_t m_stCount;
 
            std::vector<T>& m_vctArray;
            DeclareFLArrayContainerObject;
        };
 
        typedef CFLArray<int32_t> CFLArrayL;
        typedef CFLArray<uint32_t> CFLArrayUL;
        typedef CFLArray<int64_t> CFLArrayLL;
        typedef CFLArray<uint64_t> CFLArrayULL;
        typedef CFLArray<float> CFLArrayF;
        typedef CFLArray<double> CFLArrayD;
    }
}