rvc/list.h

Go to the documentation of this file.

#ifndef INC_RVC_LIST_H
#define INC_RVC_LIST_H

#ifndef INC_RVC_OBJECT_H
   #include <rvc/object.h>
#endif

#ifndef INC_MI32_DOUBLEAR_H
   #include <mi32/doublear.h>
#endif

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
struct GENLISTINFO;
class LISTHANDLE;
#endif


class LIST : public RVC::OBJECT {
   public:

      LIST (
         );

      LIST (
         const RVC::LIST& obj
         );

      virtual ~LIST (
         );

      RVC::LIST& operator= (
         const RVC::LIST& rhs
         );

      INT32 GetItemSize (
         INT32 ItemNum
         ) const;
         
      INT32 GetMaxItemSize (
         ) const;
         
      INT32 GetNumItems (
         ) const;
      
      ERRVALUE InsertItems (
         INT32 StartPosn,
         INT32 NumItems = 1
         );

      ERRVALUE Make (
         const RVC::OBJECT& parent,             
         const RVC::DESCRIPTOR& Descriptor,     
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS      
         );

      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,                       
#ifdef RVC_CREDENTIALS_MANDATORY
         const char* Source,
         const CREDENTIALS* Credentials 
#else
         const char* Source = 0,                
         const CREDENTIALS* Credentials = 0     
#endif
         );

      INT32 Read (
         INT32 ItemNum,
         void *ptr
         ) const;

      INT32 Read (
         INT32 ItemNum,
         MIDOUBLEARRAY& ptr
         ) const;

      INT32 Read (
         INT32 ItemNum,
         void **buffer,
         INT32 BufferSize
         ) const;

      template <class _CT>
      ERRVALUE Read (
         INT32 ItemNum,
         SIMPLE_ARRAY<_CT>& data
         ) const {
         INT32 MaxItems = data.GetMaxItems();
         _CT* buffer = data.Detach();
         INT32 NumBytes = Read(ItemNum, reinterpret_cast<void**>(&buffer), MaxItems * sizeof(_CT));
         if (NumBytes < 0) {
            data.Attach(buffer, MaxItems);
            data.Clear();
            }
         else {
            if (static_cast<UINT32>(NumBytes) > MaxItems * sizeof(_CT)) MaxItems = NumBytes / sizeof(_CT);
            data.Attach(buffer, MaxItems);
            data.Resize(NumBytes / sizeof(_CT), true, false);  
            NumBytes = 0;
            }
         return (NumBytes);
         }
         
      template <class _CT>
      ERRVALUE Read (
         INT32 ItemNum,
         DOUBLE_ARRAY<_CT>& data
         ) const {
         INT32 MaxItems = data.GetMaxItems();
         MIDOUBLEARRAY items;
         data.Detach(items);
         INT32 NumBytes = Read(ItemNum, items);
         if (NumBytes < 0) {
            data.Attach(items, MaxItems);
            data.Clear();
            }
         else {
            if (static_cast<UINT32>(NumBytes) > MaxItems * sizeof(_CT)) MaxItems = NumBytes / sizeof(_CT);
            data.Attach(items, MaxItems);
            data.Resize(NumBytes / sizeof(_CT), true, false);  
            NumBytes = 0;
            }
         return (NumBytes);
         }
         
      INT32 Read (
         INT32 ItemNum,
         INT32 StartPosn,
         INT32 Length,
         void *ptr
         ) const;

      template <class _CT>
      ERRVALUE Read (
         INT32 ItemNum,
         INT32 StartPosn,
         INT32 Length,        
         SIMPLE_ARRAY<_CT>& data
         ) const {
         INT32 NumBytes = Read(ItemNum, StartPosn * sizeof(_CT), Length * sizeof(_CT), static_cast<void*>(data));
         if (NumBytes >= 0) {
            data.Resize(NumBytes / sizeof(_CT), true, false);  
            NumBytes = 0;
            }
         return (NumBytes);
         }
         
      ERRVALUE Resize (
         INT32 NewNumItems
         );

      ERRVALUE ResizeItem (
         INT32 ItemNum,
         INT32 NewItemSize
         );
         
      ERRVALUE SwapItems (
         INT32 Item1,
         INT32 Item2
         );
         
      INT32 Write (
         INT32 ItemNum,
         INT32 Length,
         const void* ptr
         );
         
      INT32 Write (
         INT32 ItemNum,
         INT32 TotalSize,
         INT32 StartPosn,
         INT32 Length,
         const void* ptr
         );
         
      template <class _CT>
      ERRVALUE Write (
         INT32 ItemNum,
         const SIMPLE_ARRAY<_CT>& data
         ) {
         ERRVALUE err = Write(ItemNum, data.GetNumItems() * sizeof(_CT), data);
         if (err > 0) err = 0;
         return (err);
         }
         
      template <class _CT>
      ERRVALUE Write (
         INT32 ItemNum,
         const DOUBLE_ARRAY<_CT>& data
         ) {
         ERRVALUE err = Write(ItemNum, data.GetNumItems() * sizeof(_CT), data);
         if (err > 0) err = 0;
         return (err);
         }
         
   protected:     
      
      ERRVALUE Make (const OBJECT& parent, const DESCRIPTOR& Descriptor, GENLISTINFO& newinfo, int HeaderSize, int HeaderType, const CREDENTIALS* Credentials);

      ERRVALUE OpenObject (OPENMODE OpenFlags, GENLISTINFO& newinfo, int HeaderSize, int HeaderType, MDLGPARENT parent, const CREDENTIALS* Credentials);
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      virtual ERRVALUE v_CloseObject ();           
      virtual OBJTYPE v_GetDftObjectType () const;    
      virtual bool v_IsObjectOpen () const;              
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent, const CREDENTIALS* Credentials);            

      LISTHANDLE* m_ListHandle;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     

#endif   

---