rvc/dbase.h

Go to the documentation of this file.

#ifndef INC_RVC_DBASE_H
#define INC_RVC_DBASE_H

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

#ifndef INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef INC_MI32_RVCDBASE_H
   #include <mi32/rvcdbase.h>
#endif

#ifndef INC_RVC_GETOBJFILTER_H
   #include <rvc/getobjfilter.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
struct DBELEMTRANSLIST;
namespace SML {
   class CONTEXT;
   }
namespace RVC {
   struct DBCALLBACKSTRUCT;
   class DBASE_ELEMENT;
   class DBTABLE;
   class DBTABLE_STYLE;
   class DATABASEHANDLE;
   }
#endif


namespace RVC {

class DBASE : public RVC::OBJECT {
   public:
      enum COPYFLAG {
         COPYFLAG_None =                  0x00000000,
         COPYFLAG_TableLinks =            0x00000004,    
         COPYFLAG_DemoteIdentityTables =  0x00000008,    
         COPYFLAG_MinimizeTableSize =     0x00000020,    
         COPYFLAG_DontRemoveRecords =     0x00000200,    
         COPYFLAG_RemoveStdAttribTables = 0x00000800,    
         COPYFLAG_IgnoreStdAttribTables = 0x00040000,    
         COPYFLAG_CopyThemeTable =        0x01000000,    
         COPYFLAG_CopyElementIDTable =    0x02000000     
         };
      
      enum COPYTABLE {
         COPYTABLE_None =                 0x00000000,
         COPYTABLE_CopyLinks =            0x00000004,
         COPYTABLE_RemoveStdAttTables =   0x00000800,
         COPYTABLE_FreezeComputedFields = 0x00080000
         };
         
      enum FINDFLAG {
         FINDFLAG_AllAttached = 0,
         FINDFLAG_NoInternal = 1,
         FINDFLAG_OnlyDirect = 2,
         FINDFLAG_FirstMatch = 8
         };

      enum JOINFLAGS {
         JOINFLAG_None =            0x00000000,
         JOINFLAG_CopyThemeTable =  0x01000000,    
         JOINFLAG_OuterRight =      0x02000000,    
         JOINFLAG_Union =           0x04000000,    
         JOINFLAG_Natural =         0x08000000,    
         JOINFLAG_SameStrc =        0x10000000,    
         JOINFLAG_SameNmSt =        0x30000000,    
         JOINFLAG_RemoveDups =      0x40000000,    
         JOINFLAG_Outer =           0x80000000,    
         JOINFLAG_AttachDestIfSrc1Attached = 0x00800000,
         JOINFLAG_AttachDestIfSrc2Attached = 0x00400000,
         JOINFLAG_AttachDestIfEitherSrcAttached = 0x00000000,
         JOINFLAG_AttachDestIfBothSrcAttached = 0x000C0000,
         JOINFLAG_NoAttachDest = 0x00020000,
         JOINFLAG_NoAttachDestMASK = 0x000E0000
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class BULKMODIFY;             
      friend class BULKMODIFY;
      class ELEMTRANSLIST;
      class GETOBJFILTER_ISCAPABLE;
      friend class GETOBJFILTER_ISCAPABLE;
      class GETOBJFILTER_ISNOTEMPTY;
      friend class GETOBJFILTER_ISNOTEMPTY;
      class GETOBJFILTER_ISSELECTABLE;
      friend class GETOBJFILTER_ISSELECTABLE;
      class INVERSEDBLISTSUSPEND;
      class OBSERVER;
      class TABLEITERATOR;
      friend class TABLEITERATOR;
      class CONST_TABLEITERATOR;
      friend class CONST_TABLEITERATOR;
      #endif // GENERATING_DOXYGEN_OUTPUT
         
      class CONST_TABLEITERATOR {
      public:
         CONST_TABLEITERATOR (
            ) : 
            m_TableNum(TABLE_InternalNode),
            m_CurrentObj(0)
            {}

         CONST_TABLEITERATOR (
            const RVC::DBASE* dbase,
            INT32 TableNum
            ) : 
            m_TableNum(TableNum),
            m_CurrentObj(dbase)
            {}

         CONST_TABLEITERATOR (
            const TABLEITERATOR& rhs
            ) : 
            m_TableNum(rhs.m_TableNum),
            m_CurrentObj(rhs.m_CurrentObj)
            {}

         CONST_TABLEITERATOR (
            const RVC::DBASE* dbase
            );

         virtual ~CONST_TABLEITERATOR (
            ) {}

         CONST_TABLEITERATOR& operator= (
            const CONST_TABLEITERATOR& rhs
            ) {
            if (this != &rhs) {
               m_TableNum = rhs.m_TableNum;
               m_CurrentObj = rhs.m_CurrentObj;
               }
            return (*this);
            }

         const INT32& operator* (
            ) const { return (m_TableNum); }

         const INT32* operator-> (
            ) const { return (&**this); }

         CONST_TABLEITERATOR& operator++ (
            );

         bool operator== (
            const CONST_TABLEITERATOR& rhs
            ) const { return (m_TableNum == rhs.m_TableNum && m_CurrentObj == rhs.m_CurrentObj); }

         bool operator!= (
            const CONST_TABLEITERATOR& rhs
            ) const { return (!(*this == rhs)); }

      protected:
         INT32 m_TableNum;
         const DBASE *m_CurrentObj;
         };

      class TABLEITERATOR : public CONST_TABLEITERATOR {
         public:

            TABLEITERATOR (
               ) : CONST_TABLEITERATOR() {}

            TABLEITERATOR (
               CONST_TABLEITERATOR& rhs
               ) : CONST_TABLEITERATOR(rhs) {}

            TABLEITERATOR (
               const RVC::DBASE* dbase
               ) : CONST_TABLEITERATOR(dbase) {}

            TABLEITERATOR (
               const RVC::DBASE* dbase,
               INT32 TableNum
               ) : CONST_TABLEITERATOR(dbase, TableNum) {}

            const INT32& operator* (
               ) const { return (m_TableNum); }

            const INT32* operator-> (
               ) const { return (&**this); }

            TABLEITERATOR& operator++ (
               ) {
               CONST_TABLEITERATOR::operator++();
               return (*this);
               }

            bool operator== (
               const TABLEITERATOR& rhs
               ) const { return (m_TableNum == rhs.m_TableNum && m_CurrentObj == rhs.m_CurrentObj); }

            bool operator!= (
               const TABLEITERATOR& obj
               ) const { return (!(*this == obj)); }
         };

      DBASE (
         );

      DBASE (                       
         const RVC::DBASE& rhs
         );

      virtual ~DBASE (
         );

      RVC::DBASE& operator= (
         const RVC::DBASE& rhs
         );
         
      ERRVALUE CanCreateTables (
         ) const;

      ERRVALUE CopyDatabaseTo (
         RVC::DBASE& DestDBaseObj,
         RVC::DBASE::COPYFLAG CopyFlags = RVC::DBASE::COPYFLAG_None
         );

      ERRVALUE CopyDatabaseTo (
         RVC::DBASE_ELEMENT& DestDBaseObj,
         const RVC::DBTABLE& SourceTable,
         const SIMPLE_ARRAY<INT32>& TransList,
         ELEMTYPE ElemType = ELEMTYPE_Empty,
         RVC::DBASE::COPYFLAG CopyFlags = RVC::DBASE::COPYFLAG_None
         );

      ERRVALUE CopyDatabaseTo (
         RVC::DBASE_ELEMENT& DestDBaseObj,
         const RVC::DBTABLE& SourceTable,
         const RVC::DBASE::ELEMTRANSLIST& TransList,
         ELEMTYPE ElemType = ELEMTYPE_Empty,
         RVC::DBASE::COPYFLAG CopyFlags = RVC::DBASE::COPYFLAG_None
         );

      INT32 CopyTableTo (
         INT32 SrcTableNum,
         RVC::DBASE& DestDBase,
         COPYTABLE flags = COPYTABLE_None
         ) const;

      INT32 CopyTableTo (
         INT32 SrcTableNum,
         RVC::DBASE& DestDBase,
         RVC::DESCRIPTOR& DestTableDescriptor,
         SIMPLE_ARRAY<INT32>* RecordTrans = 0,  
         COPYTABLE flags = COPYTABLE_None
         ) const;

      ERRVALUE CreateSMLContext (
         SML::CONTEXT **pcontext             
         );

      ERRVALUE ExtractTablesFrom (
         const DBASE& SrcDbObj,                 
         const DESCRIPTOR& BaseTable,           
         const MISTRING& ConnectString,         
         bool IsGeometricExtract = false        
         );
         
      ERRVALUE FindTableMatches (
         const RVC::DBASE& rhs,
         SIMPLE_ARRAY<INT32>& TableMatch     
         ) const;

      ERRVALUE Flush (
         );

      ERRVALUE GetAttachedRecordList (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         SIMPLE_ARRAY<DBLISTELMT>& dblist,   
         FINDFLAG FindFlag = FINDFLAG_AllAttached,
         INT32 BaseTableNum = -1
         ) const;
         
      ERRVALUE GetKeyFieldNames (
         SIMPLE_ARRAY<RVC::OBJECTNAME>& FieldNames
         ) const;

      INT32 GetNumTables (
         ) const;
         
      static RVC::OBJTYPESET GetObjTypeSet (
         );

      // Returns the "distance" between related tables in # of hops it takes
      // to get from one to the other
      INT32 GetRelationshipDistance (
         const DBTABLE& SrcTable,
         const DBTABLE& DestTable
         );
         
      ERRVALUE InverseDBListBuild (
         );

      void InverseDBListResume (
         );

      void InverseDBListSuspend (
         );

      bool IsTableInternal (
         INT32 TableNum
         ) const;

      bool IsTableValid (
         INT32 TableNum
         ) const;

      bool IsTableValid (
         const RVC::OBJECTNAME& name
         ) const;

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

      ERRVALUE RemoveDuplicateRecords (
         );
         
      ERRVALUE RemoveUnattachedRecords (
         );
         
      CONST_TABLEITERATOR TableBegin (
         ) const {
         m_NumTables = (IsOpen()) ? GetNumTables() : 0;
         return (CONST_TABLEITERATOR(this));
         }

      TABLEITERATOR TableBegin (
         ) {
         m_NumTables = (IsOpen()) ? GetNumTables() : 0;
         return (TABLEITERATOR(this));
         }

      CONST_TABLEITERATOR TableEnd (
         ) const { return (CONST_TABLEITERATOR(this, m_NumTables)); }

      TABLEITERATOR TableEnd (
         ) { return (TABLEITERATOR(this, m_NumTables)); }
         
      ERRVALUE Validate (
         MISTRING& LogString
         );

      ERRVALUE ValidateTableName (
         RVC::OBJECTNAME& name,                 
         SIMPLE_ARRAY<RVC::OBJECTNAME>& finfo   
         ) const;

   protected:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      INT32 AppendDBList (
         ELEMTYPE ElemType, 
         INT32 ElemNum,
         const SIMPLE_ARRAY<DBLISTELMT>& DBList
         );

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

      ERRVALUE CleanDBList (
         ELEMTYPE ElemType
         );

      INT32 GetDBListItemSize (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         bool ExcludeInternal = false
         ) const;

      INT32 GetDBListMaxItemSize (
         ELEMTYPE ElemType
         ) const;

      INT32 GetDBListNumElements (
         ELEMTYPE ElemType
         ) const;

      bool IsNodeAPoint (
         INT32 NodeNum,
         SIMPLE_ARRAY<DBLISTELMT>& DBList
         ) const;
               
      ERRVALUE JoinLow (
         const RVC::DBASE& SrcDBase,
         const SIMPLE_ARRAY<INT32>* PointTransList,
         const SIMPLE_ARRAY<INT32>* NodeTransList,
         const SIMPLE_ARRAY<DBELEMTRANSLIST>* ExtTransList,
         INT32& NextElemID,      // Next ElemID RETURNED
         ELEMTYPE SrcElemType = ELEMTYPE_Empty,// Do we need this?
         ELEMTYPE DestElemType = ELEMTYPE_Empty,// Do we need this?
         RVC::DBASE::COPYFLAG CopyFlags = RVC::DBASE::COPYFLAG_None,
         RVC::DBASE::JOINFLAGS JoinFlags = RVC::DBASE::JOINFLAG_None,
         const RVC::DBTABLE* SourceTable = 0
         );
   
      ERRVALUE OpenAsSubobject (
         const OBJECT& parent,            
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE mode,
         MDLGPARENT widget,               
         const CREDENTIALS* Credentials 
#else
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT widget = 0,              
         const CREDENTIALS* Credentials = 0           
#endif
         );

      INT32 ReadDBList (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         SIMPLE_ARRAY<DBLISTELMT>& DBList
         ) const;

      ERRVALUE ResizeDBList (
         ELEMTYPE ElemType,
         INT32 NumItems
         );

      ERRVALUE ResizeDBListItem (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         INT32 NumItems
         );

      ERRVALUE SwapDBList (
         ELEMTYPE ElemType,
         INT32 Item1,
         INT32 Item2
         );

      INT32 WriteDBList (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         const SIMPLE_ARRAY<DBLISTELMT>& DBList
         );

      INT32 UnattachDBList (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         const SIMPLE_ARRAY<DBLISTELMT>& DBList
         );

      ERRVALUE UpdateDBListNumElements (
         ELEMTYPE ElemType, 
         INT32 NumElements
         );

      DATABASEHANDLE* GetDBHandle (
         ) const {
         return m_DBHandle;
         }

      #endif // GENERATING_DOXYGEN_OUTPUT
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      mutable INT32 m_NumTables;
      DATABASEHANDLE* m_DBHandle;

      virtual ERRVALUE v_CloseObject ();              
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsMultiObject () const;
      virtual bool v_IsObjectOpen () const;           
      virtual ERRVALUE v_OpenObject (OPENMODE OpenMode, MDLGPARENT parent, const CREDENTIALS* Credentials);
      virtual bool v_ValidateObjectType (const OBJTYPE otype) const;       
      
      ERRVALUE DuplicateDatabaseRecords (
         INT32 ElemNum,
         SIMPLE_ARRAY<DBLISTELMT>& list
         );

      INT32 FindTable (const MISTRING& name) const;
      INT32 FindTable (const RVC::DESCRIPTOR& name) const;
         
      static void DatabaseCallbackFunc (DBCALLBACKSTRUCT *cb, void *data);

      friend class DBTABLE;
      friend class DBTABLE_STYLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(DBASE::COPYFLAG)
DEFINE_ENUM_OP_BITWISE(DBASE::COPYTABLE)
DEFINE_ENUM_OP_BITWISE(DBASE::FINDFLAG)
DEFINE_ENUM_OP_BITWISE(DBASE::JOINFLAGS)
#endif

class DBASE::BULKMODIFY {
   public:
      // Constructor -- calls BulkModifyBegin on the database
      BULKMODIFY (RVC::DBASE& dbase);

      // Destructor -- calls BulkModifyEnd on the database
      ~BULKMODIFY();
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      RVC::DBASE& m_dbase;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
         

class DBASE::ELEMTRANSLIST {
   public:
      ELEMTRANSLIST (
         );
         
      ELEMTRANSLIST (
         const ELEMTRANSLIST& rhs
         ) {Copy(rhs);}
         
      ~ELEMTRANSLIST (
         );
         
      ELEMTRANSLIST& operator= (
         const ELEMTRANSLIST& rhs
         ) {
         if (this != &rhs) Copy(rhs);
         return (*this);
         }
         
      ERRVALUE AddElement (
         INT32 SourceNum,
         INT32 DestNum
         );
   
      INT32 GetNumItems (
         ) const {return (m_TransList.GetNumItems());}

      ERRVALUE Initialize (
         INT32 NumItems             
         );
         
      ERRVALUE Resize (
         INT32 NumItems             
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<DBELEMTRANSLIST> m_TransList;
      
      void Copy (const ELEMTRANSLIST& rhs);

      friend class DBASE_ELEMENT;      // allow JoinDatabaseTo to get at the data
      friend class DBASE;              // allow CopyTableTo to get at the data
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class DBASE::GETOBJFILTER_ISCAPABLE : public RVC::GETOBJFILTER, private RVC::OBJECT::FILTER {
   public:
      GETOBJFILTER_ISCAPABLE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool Filter (const RVC::OBJECT& Object);
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   }; 
   

class DBASE::GETOBJFILTER_ISNOTEMPTY : public RVC::GETOBJFILTER, private RVC::OBJECT::FILTER {
   public:
      GETOBJFILTER_ISNOTEMPTY () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool Filter (const RVC::OBJECT& Object);
      virtual bool v_HasSelectableSubObjects (const RVC::OBJITEM& objitem);
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   }; 
   

class DBASE::GETOBJFILTER_ISSELECTABLE : public RVC::GETOBJFILTER, private RVC::OBJECT::FILTER {
   public:
      GETOBJFILTER_ISSELECTABLE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool Filter (const RVC::OBJECT& Object);
      virtual bool v_HasSelectableSubObjects (const RVC::OBJITEM& objitem);
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   }; 


class DBASE::INVERSEDBLISTSUSPEND {
   public:
      INVERSEDBLISTSUSPEND (
         RVC::DBASE& DBase,                  
         bool Rebuild = false,            
         bool Condition = true            
         ) :
         m_DBase(DBase),
         m_Rebuild(Rebuild),
         m_Condition(Condition)
         {
         if (m_DBase.IsOpen() && Condition) m_DBase.InverseDBListSuspend();
         }
         
      ~INVERSEDBLISTSUSPEND (
         ) {
         if (m_DBase.IsOpen() && m_Condition) {
            m_DBase.InverseDBListResume();
            if (m_Rebuild) m_DBase.InverseDBListBuild();
            }
         }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      DBASE& m_DBase;
      bool m_Rebuild;
      bool m_Condition;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

   
class DBASE::OBSERVER : public OBJECTOBSERVER {
   public:

      enum STRUCTCHANGE {
         STRUCTCHANGE_Name =              0x00000001,
         STRUCTCHANGE_Desc =              0x00000002,
         STRUCTCHANGE_ViewMode =          0x00000004,
         STRUCTCHANGE_Field =             0x00000008,       
         STRUCTCHANGE_FieldsAdded =       0x00000010,
         STRUCTCHANGE_Flags =             0x00000020,
         STRUCTCHANGE_AttachmentType =    0x00000040,
         STRUCTCHANGE_Encoding =          0x00000080,
         STRUCTCHANGE_DBEditorUpdate =    0x00000100,
         STRUCTCHANGE_DBEditorRebuild =   0x00000200
         }; 

      explicit OBSERVER (
         RVC::DBASE& dbase
         ) : OBJECTOBSERVER(dbase) {}
         
      virtual ~OBSERVER (
         ) {}
         
      virtual void OnBulkModifyBegin (
         );
         
      virtual void OnBulkModifyEnd (
         );
      
      virtual void OnAnyChange (
         );

      virtual void OnDBListAdd (
         ELEMTYPE ElemType,            
         INT32 ElemNum                 
         );

      virtual void OnDBListChanged (
         ELEMTYPE ElemType,            
         INT32 ElemNum                 
         );
         
      virtual void OnStructChanged (
         INT32 TableNum,               
         STRUCTCHANGE StructChange     
         );
         
      virtual void OnTableAdd (
         INT32 TableNum                
         );
         
      virtual void OnTableDropBegin (
         INT32 TableNum                
         );
      
      virtual void OnTableDropEnd (
         INT32 TableNum                
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void OnNotifyRaw (UINT32 reason, void *data);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class DBELEMTYPEFILTER : public OBJECT::FILTER {
   public:

      DBELEMTYPEFILTER (
         ELEMTYPE ElemType
         ) :
         m_ObjType(RVC::OBJTYPE_Database)
         {
         switch (ElemType) {
            case ELEMTYPE_Node: m_ObjType = OBJTYPE_All; break;
            case ELEMTYPE_Line: m_ObjType = OBJTYPE_Database_VectorLine; break;
            case ELEMTYPE_Point: m_ObjType = OBJTYPE_Database_VectorPoint; break;
            case ELEMTYPE_Polygon: m_ObjType = OBJTYPE_Database_VectorPolygon; break;
            case ELEMTYPE_Edge:
            case ELEMTYPE_Triangle: m_ObjType = OBJTYPE_Database_TIN; break;
            case ELEMTYPE_CAD: m_ObjType = OBJTYPE_Database_CAD; break;
            case ELEMTYPE_RasterCellValue: m_ObjType = OBJTYPE_Database_Raster; break;
            case ELEMTYPE_All: m_ObjType = OBJTYPE_Database_Shape; break;
            case ELEMTYPE_Label: m_ObjType = OBJTYPE_LAST; break;    
            }
         }

      virtual bool Filter (
         const RVC::OBJECT& object
         ) {
         if (m_ObjType == OBJTYPE_All) {        
            OBJECT parent;
            if (object.GetParent(parent) < 0) return (false);
            m_ObjType = (parent.GetObjectType() == OBJTYPE_Vector) ? OBJTYPE_Database_VectorPoint : OBJTYPE_Database_TIN;
            }
         return (object.GetObjectType() == m_ObjType);
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      OBJTYPE m_ObjType;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     // End of RVC namespace

#endif   //INC_RVC_DBASE_H

---