rvc/dbelem.h

Go to the documentation of this file.

#ifndef INC_RVC_DBELEM_H
#define INC_RVC_DBELEM_H

#ifndef INC_RVC_DBTABLE_H
   #include <rvc/dbtable.h>
#endif

#ifndef INC_RVC_ELEMENT_H
   #include <rvc/element.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
struct DBLISTELMT;
namespace RVC {
   class GEOSPATIAL;
   }
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

class DBASE_ELEMENT : public DBASE {
   public:
   
      class ATTACHMENTITEM;
      class GETOBJFILTER_ISSELECTABLE;
      typedef SIMPLE_ARRAY<ATTACHMENTITEM> ATTACHMENTARRAY;
      
      typedef SIMPLE_ARRAY<DBLISTELMT> DBLIST;
      
      DBASE_ELEMENT (
         OBJTYPE ObjTypeParent,
         ELEMTYPE ElemType
         );

      DBASE_ELEMENT (
         const RVC::DBASE_ELEMENT& rhs
         );

      virtual ~DBASE_ELEMENT (
         );

      RVC::DBASE_ELEMENT& operator= (
         const RVC::DBASE_ELEMENT& rhs
         );
         
      ERRVALUE AddAttachment (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTITEM& item
         );

      ERRVALUE AddAttachments (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTARRAY& items
         );

      INT32 AppendDBList (
         INT32 ElemNum,
         const DBLIST& DBList
         );

      INT32 AppendDBList (
         INT32 ElemNum,
         const DBLISTELMT& item
         );

      ERRVALUE CleanDBList (
         );

      bool CompareElementRecords (
         INT32 LhsElemNum,                   
         const DBASE_ELEMENT& rhs,              
         INT32 RhsElemNum,                   
         const SIMPLE_ARRAY<INT32>& TableMatch,    
         double threshhold = 0.0                //bcolombe: Added optional threshold value (10/4/06)  
         ) const;                         

      ERRVALUE ConvertStyleAssignTableTo (
         DBASE_ELEMENT& DestDBaseObj               
         );

      ERRVALUE CopyDatabaseTo (
         RVC::GEOSPATIAL& DestParentObj,
         const SIMPLE_ARRAY<INT32>& TransList,
         COPYFLAG flags
         );

      ERRVALUE CopyDatabaseTo (
         RVC::GEOSPATIAL& DestParentObj,
         RVC::DBASE_ELEMENT& DestDBaseObj,      
         const DBASE::ELEMTRANSLIST& TransList, 
         COPYFLAG flags
         );

      int GetAttachedElements (
         const RVC::DBTABLE::RECORD& record,       
         SIMPLE_ARRAY<INT32>& ElementList,
         ELEMTYPE ElemType = ELEMTYPE_Empty        
         ) const;

      int GetAttachedElements (
         const RVC::DBTABLE::RECORD& record,       
         SIMPLE_ARRAY<RVC::ELEMENT>& ElementList,
         ELEMTYPE ElemType = ELEMTYPE_Empty        
         ) const;

      ERRVALUE GetAttachedRecordList (
         INT32 ElemNum,
         DBLIST& DBList,                     
         FINDFLAG FindFlag = FINDFLAG_AllAttached,
         INT32 BaseTableNum = -1
         ) const;
         
      INT32 GetAttachedRecordNumbers (
         const RVC::ELEMENT& element,              
         const RVC::DBTABLE& table,                
         SIMPLE_ARRAY<INT32>& recordnums,          
         FINDFLAG findflags = FINDFLAG_AllAttached
         ) const;

      INT32 GetAttachments (
         const RVC::ELEMENT& elem,
         RVC::DBASE_ELEMENT::ATTACHMENTARRAY& items
         ) const;

      INT32 GetDBListItemSize (
         INT32 ItemNum,
         bool ExcludeInternal = false
         ) const;

      INT32 GetDBListMaxItemSize (
         ) const;

      INT32 GetDBListNumElements (
         ) const;

      static ELEMTYPE GetDftElemType (
         RVC::OBJTYPE ObjType
         );

      ELEMTYPE GetElemType (
         ) const { return (m_ElemType); }

      bool HasAttachedElements (
         const RVC::DBTABLE::RECORD& record,
         ELEMTYPE ElemType = ELEMTYPE_All
         ) const;
         

      ERRVALUE JoinDatabaseTo (
         RVC::DBASE_ELEMENT& DestDatabase,   
         const SIMPLE_ARRAY<INT32>& TransList,
         RVC::DBASE::COPYFLAG CopyFlags = RVC::DBASE::COPYFLAG_None,
         RVC::DBASE::JOINFLAGS JoinFlags = RVC::DBASE::JOINFLAG_None,
         INT32 *pNextElemID = 0,    
         ELEMTYPE SrcElemType = ELEMTYPE_Empty,  
         ELEMTYPE DestElemType = ELEMTYPE_Empty  
         );

      ERRVALUE JoinDatabaseTo (
         RVC::DBASE_ELEMENT& DestDatabase,   
         const DBASE::ELEMTRANSLIST& TransList,
         RVC::DBASE::COPYFLAG CopyFlags = RVC::DBASE::COPYFLAG_None,
         RVC::DBASE::JOINFLAGS JoinFlags = RVC::DBASE::JOINFLAG_None,
         INT32 *pNextElemID = 0,    
         ELEMTYPE SrcElemType = ELEMTYPE_Empty,  
         ELEMTYPE DestElemType = ELEMTYPE_Empty  
         );

      ERRVALUE OpenAsSubobject (
         const RVC::OBJITEM& ParentObjItem,           
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE mode,
         MDLGPARENT dlgparent,               
         const CREDENTIALS *pCredentials 
#else
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT dlgparent = 0,              
         const CREDENTIALS *pCredentials = 0          
#endif
         );

      ERRVALUE OpenAsSubobject (
         const RVC::GEOSPATIAL& parent,            
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE mode,
         MDLGPARENT dlgparent,               
         const CREDENTIALS *pCredentials 
#else
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT dlgparent = 0,              
         const CREDENTIALS *pCredentials = 0          
#endif
         );

      INT32 ReadDBList (
         INT32 ElemNum,
         DBLIST& DBList
         ) const;

      ERRVALUE RemoveAttachment (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTITEM& item
         );

      ERRVALUE RemoveAttachments (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTARRAY& items
         );

      ERRVALUE ResizeDBList (
         INT32 NumItems
         );

      ERRVALUE ResizeDBListItem (
         INT32 ElemNum,
         INT32 NumItems
         );

      ERRVALUE SwapDBList (
         INT32 Item1,
         INT32 Item2
         );

      INT32 WriteDBList (
         INT32 ElemNum,
         const DBLIST& DBList
         );

      INT32 UnattachDBList (
         INT32 ElemNum,
         const DBLIST& DBList
         );

      ERRVALUE UpdateDBListNumElements (
         INT32 NumElements
         );

   protected:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      ERRVALUE JoinPointDatabaseToLow (
         RVC::DBASE_ELEMENT& DestDatabase,   
         const SIMPLE_ARRAY<INT32>& PointTransList,
         const SIMPLE_ARRAY<INT32>& NodeTransList,
         RVC::DBASE::COPYFLAG CopyFlags = RVC::DBASE::COPYFLAG_None,
         RVC::DBASE::JOINFLAGS JoinFlags = RVC::DBASE::JOINFLAG_None,
         INT32 *pNextElemID = 0,    
         ELEMTYPE SrcElemType = ELEMTYPE_Empty,  
         ELEMTYPE DestElemType = ELEMTYPE_Empty  
         );
      #endif // GENERATING_DOXYGEN_OUTPUT

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      OBJTYPE m_ObjType;
      ELEMTYPE m_ElemType;

      // Implementation of RVC::OBJECT virtual methods
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsMultiObject () const;

      #endif // GENERATING_DOXYGEN_OUTPUT

   };
   
   
class DBASE_ELEMENT::ATTACHMENTITEM {
   public:

      ATTACHMENTITEM (
         ) : m_TableNum(TABLE_Invalid), m_RecordNum(RECORD_New) {}
      
      ATTACHMENTITEM (
         const RVC::DBTABLE& table,
         INT32 recordnum
         );

      INT32 GetTableNum (
         ) const {return (m_TableNum);}

      INT32 GetRecordNum (
         ) const {return (m_RecordNum);}

      void SetTableNum (
         INT32 TableNum
         ) {m_TableNum = TableNum;}

      void SetRecordNum (
         INT32 RecordNum
         ) {m_RecordNum = RecordNum;}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      
      INT32 m_TableNum;
      INT32 m_RecordNum;
      
      operator const DBLISTELMT* (
         ) const {return (reinterpret_cast<const DBLISTELMT*>(this));}
      
      operator DBLISTELMT* (
         ) {return (reinterpret_cast<DBLISTELMT*>(this));}
      
      friend class DBASE_ELEMENT;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
class DBASE_ELEMENT::GETOBJFILTER_ISSELECTABLE : public RVC::GETOBJFILTER {
   public:
      // Default constructor.
      // If bCreateIfNotExist is true, navigating under a geospatial object
      // with this filter will force it to create the database subobjects
      // if they don't already exist.  You would normally only use this if
      // your filter is for the purposes of selecting an destination database.
      GETOBJFILTER_ISSELECTABLE (
         bool bCreateIfNotExist = false
         );

      // Constructor for a specific database subobject type.
      // If bCreateIfNotExist is true, navigating under a geospatial object
      // with this filter will force it to create the database subobjects
      // if they don't already exist.  You would normally only use this if
      // your filter is for the purposes of selecting an destination database.
      GETOBJFILTER_ISSELECTABLE (
         RVC::OBJTYPESET& type, 
         bool bCreateIfNotExist = false
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_HasSelectableSubObjects (const RVC::OBJITEM& objitem);
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      virtual bool v_IsValidParent (const RVC::OBJITEM& objitem);
      RVC::OBJTYPESET m_Types;
      bool m_bCreateIfNotExist;
      #endif // GENERATING_DOXYGEN_OUTPUT
   }; 
   
}     // End of RVC namespace

#endif   // INC_RVC_DBELEM_H

---