mi32/doublear.h

Go to the documentation of this file.

#ifndef  INC_MI32_DOUBLEAR_H
#define  INC_MI32_DOUBLEAR_H

#ifndef  INC_MI32_MIDBLARY_H
#include <mi32/midblary.h>    
#endif

#ifndef  INC_MI32_MEMBUF_H
#include <mi32/membuf.h>      
#endif

#ifndef  INC_MEMORY_H
#include <memory.h>           
#define  INC_MEMORY_H
#endif


template <class _CT> class DOUBLE_ARRAY {

   public:

      DOUBLE_ARRAY (
         ):
         m_data(0),
         m_numitems(0),
         m_RefCount(1)
         { }

      DOUBLE_ARRAY (
         const DOUBLE_ARRAY<_CT>& rhs
         ) :
         m_items(rhs.m_items),
         m_numitems(rhs.m_numitems),
         m_RefCount(1)
         {
         m_data = reinterpret_cast<_CT*>(m_items.GetPointer());
         }

      ~DOUBLE_ARRAY (
         ) {}

      DOUBLE_ARRAY<_CT>& operator= (
         const DOUBLE_ARRAY<_CT>& rhs
         ) {
         if (this != &rhs) {
            m_items = rhs.m_items;
            m_numitems = rhs.m_numitems;
            m_data = reinterpret_cast<_CT*>(m_items.GetPointer());
            }
         return (*this);
         }

      bool operator== (
         const DOUBLE_ARRAY<_CT>& rhs
         ) const {
         if (m_numitems != rhs.m_numitems) return (false);
         if (m_numitems == 0) return (true);
         return (memcmp(m_data,m_data,m_numitems*sizeof(_CT)) == 0);
         }

      bool operator!= (
         const DOUBLE_ARRAY<_CT>& rhs
         ) const {
         return (!operator==(rhs));
         }

      operator const _CT*(
         ) const {
         return (m_data);
         }

      operator _CT*(
         ) {
         return (m_data);
         }

      template <typename _IDXTYPE> const _CT& operator[] (
         _IDXTYPE index
         ) const {
         return (m_data[index]);
         }

      template <typename _IDXTYPE> _CT& operator[] (
         _IDXTYPE index
         ) {
         return (m_data[index]);
         }

      void AddRef (
         ) { ++m_RefCount; }

      ERRVALUE Append (
         const _CT& item
         ) {
         if (m_numitems >= GetMaxItems()) {
            int err;
            if ((err = m_items.Reserve(MAX(16,(2*m_numitems*sizeof(_CT) + sizeof(double) - 1) / sizeof(double)), true)) < 0) return (err);
            m_data = reinterpret_cast<_CT*>(m_items.GetPointer());
            }
         m_data[m_numitems++] = item;
         return (0);
         }
         
      ERRVALUE Append (
         const _CT *items,                
         unsigned numitems                
         ) {
         ERRVALUE err;
         if ((err = Reserve(m_numitems+numitems)) < 0) return (err);
         memcpy(m_data+m_numitems,items,numitems*sizeof(_CT));
         m_numitems += numitems;
         return (0);
         }

      ERRVALUE Assign (
         const _CT *items,                
         int numitems                     
         ) {
         ERRVALUE err;
         if ((err = Reserve(numitems,true)) < 0) return (err);
         memcpy(m_data,items,numitems*sizeof(_CT));
         m_numitems = numitems;
         return (0);
         }

      void Attach (
         MIDOUBLEARRAY& items,
         int numitems
         ) {
         m_items.Attach(items);
         m_numitems = numitems;
         m_data = reinterpret_cast<_CT*>(m_items.GetPointer());
         }
         
      void Clear (
         ) { m_numitems = 0; }

      void ClearItems (
         int start = 0,
         int end = -1                  
         ) {
         if (end < start) end = m_numitems - 1;
         memset(m_data + start, 0, (end - start + 1) * sizeof(_CT));
         }

      ERRVALUE Copy (
         const DOUBLE_ARRAY<_CT>& rhs
         ) {
         if (this != &rhs) {
            return (SetItems(0, rhs, rhs.m_numitems));
            }
         return (0);
         }

      void DeleteItem (
         int index
         ) {
         if (index >= 0 && index < m_numitems) {
            --m_numitems;
            if (index < m_numitems) {
               memmove(m_data+index,m_data+index+1,(m_numitems-index)*sizeof(_CT));
               }
            }
         }
         
      void Detach (
         MIDOUBLEARRAY& items
         ) {
         items.Attach(m_items);
         m_numitems = 0;
         m_data = 0;
         }
         
      // See above comment on Attach() for Detach() method bad idea.

      void Free (
         ) {
         m_items.Free();
         m_numitems = 0;
         m_data = 0;
         }

      void GetItems (
         _CT *items,                      
         int numitems,                    
         int firstitem = 0                
         ) const {
         memcpy(items,m_data+firstitem,MIN(m_numitems-firstitem, numitems)*sizeof(_CT));
         }

      const _CT& GetLast (
         ) const { return (m_data[m_numitems-1]); }

      int GetMaxItems (
         ) const {
         return (m_items.GetNumReserved() * sizeof(double) / sizeof(_CT));
         }

      int GetNumItems (
         ) const { return (m_numitems); }

      UINT32 GetRefCount (
         ) const { return (m_RefCount); }

      int GetSizeInBytes (
         ) const { return (m_numitems*sizeof(_CT)); }

      bool IsEmpty (
         ) const { return (m_numitems == 0); }

      void Release (
         ) { if (--m_RefCount == 0) delete this; }

      void RemoveItem (
         INT32 item
         ) {
         if (item < m_numitems && item >= 0) {
            --m_numitems;
            if (item < m_numitems) { memmove(&m_data[item], &m_data[item+1], (m_numitems - item) * sizeof(_CT)); }
            }
         }

      ERRVALUE Reserve (
         int newmaxitems,                 
         bool clear = false               
         ) {
         if (clear) m_numitems = 0;
         if (newmaxitems > GetMaxItems()) {
            ERRVALUE err;
            if ((err = m_items.Reserve((newmaxitems * sizeof(_CT) + sizeof(double) - 1) / sizeof(double), true)) < 0) return (err);
            m_data = reinterpret_cast<_CT*>(m_items.GetPointer());
            }
         return (0);
         }

      void ReserveExc (
         int newmaxitems,                 
         bool clear = false               
         ) {
         if (clear) m_numitems = 0;
         if (newmaxitems > GetMaxItems()) {
            m_items.ReserveExc((newmaxitems * sizeof(_CT) + sizeof(double) - 1) / sizeof(double), true);
            m_data = reinterpret_cast<_CT*>(m_items.GetPointer());
            }
         }

      ERRVALUE Resize (
         int numitems,                    
         bool keepold = true,             
         bool clear = false               
         ) {
         int err;
         if ((err = Reserve(numitems,!keepold)) < 0) return (err);
         if (clear && numitems > m_numitems) memset(m_data+m_numitems,0,(numitems-m_numitems)*sizeof(_CT));
         m_numitems = numitems;
         return (0);
         }

      void ResizeExc (
         int numitems,                    
         bool keepold = true,             
         bool clear = false               
         ) {
         ReserveExc(numitems,!keepold);
         if (clear && numitems > m_numitems) memset(m_data+m_numitems,0,(numitems-m_numitems)*sizeof(_CT));
         m_numitems = numitems;
         }

      void Reverse (
         ) {
         for (int i = 0; (i < m_numitems/2); ++i) {
            _CT temp(m_data[i]);
            m_data[i] = m_data[m_numitems-i-1];
            m_data[m_numitems-i-1] = temp;
            }
         }

      ERRVALUE SetItems (
         int firstitem,                   
         const _CT *items,                
         int numitems                     
         ) {
         ERRVALUE err;
         if ((err = Reserve(firstitem+numitems)) < 0) return (err);
         memcpy(m_data+firstitem,items,numitems*sizeof(_CT));
         if (m_numitems < firstitem + numitems) m_numitems = firstitem + numitems;
         return (0);
         }

      void Sort (
         int (*CompFunc)(_CT*, _CT*, void*),    
         void *data = 0
         ) {
         heapsort(m_data, m_numitems, sizeof(_CT), reinterpret_cast<int (*)(void*, void*, void*)>(CompFunc), data);
         }
         
      void Swap (
         DOUBLE_ARRAY<_CT>& rhs
         ) {
         m_items.Swap(rhs.m_items);
         _CT *t_data = m_data;
         m_data = rhs.m_data;
         rhs.m_data = t_data;
         int t_numitems = m_numitems;
         m_numitems = rhs.m_numitems;
         rhs.m_numitems = t_numitems;
         }
         
      void SwapBytes (
         ) { for (int i = 0;(i < m_numitems);++i) ::SwapBytes(m_data[i]); }
         
      void TransferOwnerFrom (
         DOUBLE_ARRAY<_CT>& rhs
         ) {
         MIDOUBLEARRAY temp;
         int numitems = rhs.GetNumItems();
         rhs.Detach(temp);
         Attach(temp, numitems);
         return;
         }
         
      template <class _T2> void TransferOwnerFromExt (
         DOUBLE_ARRAY<_T2>& rhs
         ) {
         MIDOUBLEARRAY temp;
         UINT32 numbytes = rhs.GetNumItems() * sizeof(_T2);
         rhs.Detach(temp);
         int numitems = static_cast<int>(numbytes / sizeof(_CT));
         Attach(temp, numitems);
         }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      MIDOUBLEARRAY m_items;              // The accessed array
      _CT* m_data;                        // Pointer to the data for fast access
      int m_numitems;                     // Number of valid items
      UINT32 m_RefCount;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#endif   // INC_MI32_DOUBLEAR_H

---