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;
    }
}