cel_dsarray.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_dsarray_h_
#define _cel_dsarray_h_

#include "cel_serializable.h"
#include "cel_memory.h"
#include "cel_endian.h"
#include "cel_rational.h"

namespace Celartem
{
    class BasicDataArray : public Serializable
    {
    public:
        //--------------------------------------------------------------------
        virtual bool isValid() const = 0;

        //--------------------------------------------------------------------
        virtual size_t getSize() const = 0;

        //--------------------------------------------------------------------
        virtual u16 getTag() const = 0;

        //--------------------------------------------------------------------
        virtual void setTag(u16 tag) = 0;

        //--------------------------------------------------------------------
        virtual u16 getType() const = 0;

        //--------------------------------------------------------------------
        virtual void setType(u16 type) = 0;

        //--------------------------------------------------------------------
        virtual const void *getVoidPtr() const = 0;

        //--------------------------------------------------------------------
        virtual size_t getAsInt(size_t inIndex) const;

        //--------------------------------------------------------------------
        virtual double getAsDouble(size_t inIndex) const;

        //--------------------------------------------------------------------
        virtual TIFF_RATIONAL getAsRational(size_t inIndex) const;
    };

    //------------------------------------------------------------------------
    template<typename T> class DataArray : public BasicDataArray
    {
    public:
        //--------------------------------------------------------------------
        virtual void serialize(
            Stream *inStream, size_t inLevel, Endian inEndian)
        {
            const size_t size = m_array.getSize();
            write<u16>(inStream, m_tag, inEndian);
            write<u16>(inStream, m_type, inEndian);
            write<u32>(inStream, (u32)size, inEndian);
            for(size_t i = 0; i < size; i++)
                write<T>(inStream, m_array[i], inEndian);
        }

        //--------------------------------------------------------------------
        virtual AutoPtr<Serializable> duplicate() const
        {
            AutoPtr<DataArray<T> > array = new DataArray<T>;
            array->duplicate(this);
            return array.getPtr();
        }

        //--------------------------------------------------------------------
        virtual AutoPtr<DataArray<T> > duplicateDataArray() const
        {
            AutoPtr<DataArray> array = new DataArray<T>;
            array->duplicate(this);
            return array;
        }

        //--------------------------------------------------------------------
        static AutoPtr<Serializable> deserialize(
            Stream *inStream, size_t inLevel, Endian inEndian)
        {
            AutoPtr<DataArray<T> > da = create();

            da->m_tag = read<u16>(inStream, inEndian);
            da->m_type = read<u16>(inStream, inEndian);

            const size_t size = (size_t)read<u32>(inStream, inEndian);
            SimpleArray<T>& array = da->m_array;
            array.allocate(size);
            for(size_t i = 0; i < size; i++)
                array[i] = read<T>(inStream, inEndian);
            return da.getPtr();
        }

        //--------------------------------------------------------------------
        static AutoPtr<DataArray<T> > create()
        {
            return new DataArray<T>;
        }

        //--------------------------------------------------------------------
        static AutoPtr<DataArray<T> > create(
            size_t inSize, size_t inReserve = (size_t)-1)
        {
            AutoPtr<DataArray<T> > array = new DataArray<T>();
            array->allocate(inSize, inReserve);
            return array;
        }

        //--------------------------------------------------------------------
        inline SimpleArray<T>& getReference() {return m_array;}

        //--------------------------------------------------------------------
        inline const SimpleArray<T>& getReference() const {return m_array;}

        //--------------------------------------------------------------------
        inline T *getPtr() {return m_array.getPtr();}

        //--------------------------------------------------------------------
        inline const T *getPtr() const {return m_array.getPtr();}

        //--------------------------------------------------------------------
        virtual const void *getVoidPtr() const {return m_array.getPtr();}

        //--------------------------------------------------------------------
        inline T& at(size_t pos) {return m_array[pos];}

        //--------------------------------------------------------------------
        inline const T& at(size_t pos) const
        {
            return m_array[pos];
        }

        //--------------------------------------------------------------------
        virtual bool isValid() const
        {
            return m_array.isValid();
        }

        //--------------------------------------------------------------------
        virtual size_t getSize() const
        {
            return m_array.getSize();
        }

        //--------------------------------------------------------------------
        inline void allocate(
            size_t inSize, size_t inReserve = (size_t)-1)
        {
            m_array.allocate(inSize, inReserve);
        }

        //--------------------------------------------------------------------
        inline void reserve(size_t inSize)
        {
            m_array.reserve(inSize);
        }

        //--------------------------------------------------------------------
        inline void reallocate(size_t inSize)
        {
            m_array.rellocate(inSize);
        }

        //--------------------------------------------------------------------
        inline void resize(size_t inSize)
        {
            m_array.reallocate(inSize);
        }

        //--------------------------------------------------------------------
        inline void free()
        {
            m_array.free();
        }

        //--------------------------------------------------------------------
        inline void duplicate(const SimpleArray<T>& inSa)
        {
            m_array.duplicate(inSa);
            m_array.strictCleanup();
            m_tag = 0;
            m_type = 0;
        }

        //--------------------------------------------------------------------
        inline void duplicate(const Serializable *inDataArray)
        {
            const DataArray<T> *pDa
                = dynamic_cast<const DataArray<T> *>(inDataArray);
            if(!pDa)
                celThrow(errTypeMismatch);
            m_array.duplicate(pDa->m_array);
            m_tag = pDa->m_tag;
            m_type = pDa->m_type;
            m_array.strictCleanup();
        }

        //--------------------------------------------------------------------
        inline void duplicate(
            const T *inBuffer, size_t inSize, Endian inEndian = endianHost)
        {
            m_array.duplicate(inBuffer, inSize, inEndian);
            m_array.strictCleanup();
            m_tag = 0;
            m_type = 0;
        }

        //--------------------------------------------------------------------
        inline void fill(const T& t)
        {
            m_array.fill(t);
        }

        //--------------------------------------------------------------------
        inline void zeroClear()
        {
            m_array.zeroClear();
        }

        //--------------------------------------------------------------------
        inline void swap(SimpleArray<T>& inSa)
        {
            m_array.swap(inSa);
            m_array.strictCleanup();
            m_tag = 0;
            m_type = 0;
        }

        //--------------------------------------------------------------------
        inline void swap(Serializable *inDataArray)
        {
            DataArray<T> *pDa = dynamic_cast<DataArray<T> *>(inDataArray);
            if(!pDa)
                celThrow(errTypeMismatch);
            m_array.swap(pDa->m_array);
            m_array.strictCleanup();

            u16 tmp;
            tmp = m_tag; m_tag = pDa->m_tag; pDa->m_tag = tmp;
            tmp = m_type; m_type = pDa->m_type; pDa->m_type = tmp;
        }

        //--------------------------------------------------------------------
        inline void push_back(T& t)
        {
            m_array.push_back(t);
        }

        //--------------------------------------------------------------------
        inline T pop_back()
        {
            return m_array.pop_back();
        }

        //--------------------------------------------------------------------
        virtual u16 getTag() const
        {
            return m_tag;
        }

        //--------------------------------------------------------------------
        virtual void setTag(u16 tag)
        {
            m_tag = tag;
        }

        //--------------------------------------------------------------------
        virtual u16 getType() const
        {
            return m_type;
        }

        //--------------------------------------------------------------------
        virtual void setType(u16 type)
        {
            m_type = type;
        }

    private:
        SimpleArray<T> m_array;
        u16 m_tag, m_type;

        DataArray()
        {
            m_array.strictCleanup();
        }
    };


    typedef DataArray<int8_t> DataArrayI8;
    typedef DataArray<int16_t> DataArrayI16;
    typedef DataArray<int32_t> DataArrayI32;
    typedef DataArray<int64_t> DataArrayI64;

    typedef DataArray<uint8_t> DataArrayU8;
    typedef DataArray<uint16_t> DataArrayU16;
    typedef DataArray<uint32_t> DataArrayU32;
    typedef DataArray<uint64_t> DataArrayU64;

    typedef DataArray<float> DataArrayFloat;
    typedef DataArray<double> DataArrayDouble;
}

#endif // _cel_dsarray_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.