dbase.h

Go to the documentation of this file.

/**
 * \file rvc/dbase.h 
 * \brief interface for the RVCDBASE class.
 *
 * \if NODOC
 * $Id: dbase.h_v 1.23 2004/10/13 19:46:53 scowan Exp $
 *
 * $Log: dbase.h_v $
 * Revision 1.23  2004/10/13 19:46:53  scowan
 * Added flag.
 *
 * Revision 1.22  2004/10/06 20:05:00  dfriberg
 * Modified JOINFLAGS comments
 *
 * Revision 1.21  2004/07/02 15:43:16  scowan
 * Added remove dup rec method.
 *
 * Revision 1.20  2004/04/07 23:18:36  scowan
 * Added new copy flag.
 *
 * Revision 1.19  2004/02/19 22:47:11  scowan
 * Added static method.
 *
 * Revision 1.18  2004/01/02 15:53:18  scowan
 * Added resize to elem trans list.
 *
 * Revision 1.17  2003/12/03 21:28:03  scowan
 * Added methods to compare structures of database tables for a match.
 *
 * Revision 1.16  2003/11/12 18:49:42  dwilliss
 * new filter didn't implement a pure-virtual method that it needed to.
 *
 * Revision 1.15  2003/11/12 18:39:18  dwilliss
 * Added new getobjfilter
 *
 * Revision 1.14  2003/10/16 20:16:17  scowan
 * Passed mi string instead of file pointer for log in validate.
 *
 * Revision 1.13  2003/10/07 17:35:50  scowan
 * Object virtual method changes.
 *
 * Revision 1.12  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.11  2003/09/25 21:20:04  dwilliss
 * Fixed doxygen comment
 *
 * Revision 1.10  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.9  2003/09/02 17:29:43  dwilliss
 * Added COPYTABLE_FreezeComputedFields flag
 * Removed COPYTABLE_SkipIdentity and COPYTABLE_ConvertIdentity per Steve's
 *    instructions
 *
 * Revision 1.8  2003/06/25 22:16:57  scowan
 * Added shape database to filter.
 *
 * Revision 1.7  2003/05/27 20:15:39  scowan
 * Added another filter.
 *
 * Revision 1.6  2003/05/27 17:57:51  scowan
 * Added is empty filter.
 *
 * Revision 1.5  2003/02/17 18:15:46  scowan
 * Added validate method.
 *
 * Revision 1.4  2002/12/06 15:15:08  scowan
 * Fixed for genator docs to establish the correct parent object.
 *
 * Revision 1.3  2002/10/04 22:04:52  scowan
 * Added new virtual method.
 *
 * Revision 1.2  2002/09/03 21:23:59  scowan
 * Updated elem trans list.
 *
 * Revision 1.1  2002/08/13 21:25:36  scowan
 * Initial revision
 *
 * Revision 1.29  2002/04/09 15:33:37  scowan
 * Moved open as subobject to dbase element.
 *
 * Revision 1.28  2002/04/05 17:55:34  scowan
 * Added a new friend.
 *
 * Revision 1.27  2002/04/05 17:19:38  scowan
 * Added open methods.
 *
 * Revision 1.26  2002/03/22 22:55:59  scowan
 * Added flag.
 *
 * Revision 1.25  2002/02/25 18:17:35  scowan
 * Made an elem trans list class for translaytion list management.
 *
 * Revision 1.24  2002/02/25 17:52:37  scowan
 * Added default "None" flag for enum flag types.
 *
 * Revision 1.23  2002/02/14 00:08:24  scowan
 * Added the bulk modify class.
 *
 * Revision 1.22  2002/02/11 17:39:23  scowan
 * Added another join database method.
 *
 * Revision 1.21  2002/01/31 16:22:31  scowan
 * Comment out protected methods for genator docs.
 *
 * Revision 1.20  2002/01/30 15:57:00  scowan
 * Added sml context creation method.
 *
 * Revision 1.19  2002/01/09 23:58:06  scowan
 * Moved some nested classes out for genator docs.
 *
 * Revision 1.18  2001/10/08 17:32:49  scowan
 * Nothing.
 *
 * Revision 1.17  2001/08/22 23:06:02  scowan
 * Added copy database method between different types.
 *
 * Revision 1.16  2001/06/26 16:54:59  scowan
 * Define label elemtype to find no database table.
 *
 * Revision 1.15  2001/06/25 20:48:18  scowan
 * Added new virtual method.
 *
 * Revision 1.14  2001/06/21 15:15:44  scowan
 * Added copy and join database methods.
 *
 * Revision 1.13  2001/06/19 22:16:44  scowan
 * Added ELEMTYPE to database filter.
 *
 * Revision 1.11  2001/06/14 16:04:57  scowan
 * Changed source trype.
 *
 * Revision 1.10  2001/06/13 21:27:58  scowan
 * Added rvc to method parameters.
 *
 * Revision 1.9  2001/06/13 20:09:52  scowan
 * Moved to RVC namespace.
 * Added make method.
 *
 * Revision 1.7  2001/06/11 22:52:34  scowan
 * Added simple copy method for tables.
 *
 * Revision 1.4  2001/05/31 19:35:55  scowan
 * Added method to append one list entry to a dblist.
 *
 * Revision 1.3  2001/05/24 20:43:46  scowan
 * Removed redundant methods.
 *
 * Revision 1.2  2001/05/24 14:53:24  scowan
 * Fixed UNIX, MAc errors.
 *
 * Revision 1.1  2001/05/23 20:36:09  scowan
 * Initial revision
 *
 * \endif
**/

//!   \class RVC::DBASE rvc/dbase.h
//!   \brief Manages OBJTYPE_Database RVC objects.  
//!
//!   The interface currently wraps the MfDatabase functions.
//!   
//!   RVC Object Types that this class supports:
//!      - OBJTYPE_Database
//!      - OBJTYPE_RastDBase
//!      - OBJTYPE_PointDBase
//!      - OBJTYPE_LineDBase
//!      - OBJTYPE_PolyDBase
//!      - OBJTYPE_CADDBase
//!      - OBJTYPE_TINDBase
//!
//!   Default RVC Object Type for this class: OBJTYPE_Database.
//!
//!   Valid parents for this class:
//!      - OBJTYPE_File
//!      - OBJTYPE_Folder


#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_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

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

#ifndef INC_RVC_GETOBJF_H
   #include <rvc/getobjf.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
struct DBCALLBACKSTRUCT;      // Forward Declarations
struct SMLCONTEXT;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class DBTABLE;
class DBTABLE_STYLE;
#endif // GENERATING_DOXYGEN_OUTPUT

class DBASE : public RVC::OBJECT {
   public:
      enum COPYFLAG {
         COPYFLAG_None =                  0x00000000,
         COPYFLAG_TableLinks =            0x00000004,    //!< Copy table links instead of the tables themselves
         COPYFLAG_DemoteIdentityTables =  0x00000008,    //!< Demote identity tables in MfDatabaseJoin() because they can no longer exist
         COPYFLAG_MinimizeTableSize =     0x00000020,    //!< Minimize table sizes (convert Identity and OneToOne to OneRecordPerElement)
         COPYFLAG_DontRemoveRecords =     0x00000200,    //!< Do not remove records while copying
         COPYFLAG_RemoveStdAttribTables = 0x00000800,    //!< Remove standard attribute tables
         COPYFLAG_IgnoreStdAttribTables = 0x00040000,    //!< Ignore standard attribute tables
         COPYFLAG_CopyThemeTable =        0x01000000     //!< Copy theme tables, only if not joining tables
         };
      
      enum COPYTABLE {
         COPYTABLE_None =                 0x00000000,
         COPYTABLE_CopyLinks =            0x00000004,
         COPYTABLE_RemoveStdAttTables =   0x00000800,
         COPYTABLE_FreezeComputedFields = 0x00080000
         };
         
      //! Search flags for GetAttachedRecordList()
      enum FINDFLAG {
         FINDFLAG_AllAttached = 0,
         FINDFLAG_NoInternal = 1,
         FINDFLAG_OnlyDirect = 2,
         FINDFLAG_FirstMatch = 8
         };

      enum JOINFLAGS {
         JOINFLAG_None =            0x00000000,
         JOINFLAG_CopyThemeTable =  0x01000000,    //!< Copy theme tables, only if not joining tables
         JOINFLAG_OuterRight =      0x02000000,    //!< Right Outer (for Join)
         JOINFLAG_Union =           0x04000000,    //!< Union (RVC::DBTABLE::Combine only)
         JOINFLAG_Natural =         0x08000000,    //!< Natural Join (RVC::DBTABLE::Combine only)
         JOINFLAG_SameStrc =        0x10000000,    //!< Only table structure has to match
         JOINFLAG_SameNmSt =        0x30000000,    //!< Table structure and name has to match
         JOINFLAG_RemoveDups =      0x40000000,    //!< Remove duplicate records when joining
         JOINFLAG_Outer =           0x80000000     //!< Outer Union or Left Outer Join
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class BULKMODIFY;             //!< Forward Declarations
      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
         
      //! Constant iterator class
      //!
      //! This class is used to iterate through a parent rvc object's children.  This construct replaces the MfGetList() routines.
      //! See methods ChildListBegin() and ChildListEnd() for obtaining an child iterator
      class CONST_TABLEITERATOR {
      public:
         //! Default constructor
         CONST_TABLEITERATOR (
            ) : 
            m_TableNum(TABLE_InternalNode),
            m_CurrentObj(0)
            {}

         //! Internal constructor used by TableEnd() methods
         CONST_TABLEITERATOR (
            const RVC::DBASE* dbase,
            INT32 TableNum
            ) : 
            m_TableNum(TableNum),
            m_CurrentObj(dbase)
            {}

         //! Copy constructor
         CONST_TABLEITERATOR (
            const TABLEITERATOR& rhs
            ) : 
            m_TableNum(rhs.m_TableNum),
            m_CurrentObj(rhs.m_CurrentObj)
            {}

         //! Interanl constructor used by TableBegin() methods
         CONST_TABLEITERATOR (
            const RVC::DBASE* dbase
            );

         //! Destructor
         virtual ~CONST_TABLEITERATOR (
            ) {}

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

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

         //! Dereference arrow
         const INT32* operator-> (
            ) const { return (&**this); }

         //! Pre-increment
         CONST_TABLEITERATOR& operator++ (
            );

         //! Comparison for equality
         bool operator== (
            const CONST_TABLEITERATOR& rhs
            ) const { return (m_TableNum == rhs.m_TableNum && m_CurrentObj == rhs.m_CurrentObj); }

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

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


      //! Iterator class
      //!
      //! This class is used to iterate through a parent rvc object's children.  This construct replaces the MfGetList() routines.
      //! See methods ChildListBegin() and ChildListEnd() for obtaining an child iterator
      class TABLEITERATOR : public CONST_TABLEITERATOR {
         public:

            //! Default constructor
            TABLEITERATOR (
               ) : CONST_TABLEITERATOR() {}

            //! Copy constructor
            TABLEITERATOR (
               CONST_TABLEITERATOR& rhs
               ) : CONST_TABLEITERATOR(rhs) {}

            //! Internal constructor used by TableBegin() methods
            TABLEITERATOR (
               const RVC::DBASE* dbase
               ) : CONST_TABLEITERATOR(dbase) {}

            //! Internal constructor used by TableEnd() methods
            TABLEITERATOR (
               const RVC::DBASE* dbase,
               INT32 TableNum
               ) : CONST_TABLEITERATOR(dbase, TableNum) {}

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

            //! Dereference arrow
            const INT32* operator-> (
               ) const { return (&**this); }

            //! Pre-increment
            TABLEITERATOR& operator++ (
               ) {
               CONST_TABLEITERATOR::operator++();
               return (*this);
               }

            //! Comparison for equality
            bool operator== (
               const TABLEITERATOR& rhs
               ) const { return (m_TableNum == rhs.m_TableNum && m_CurrentObj == rhs.m_CurrentObj); }

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

      //! Default constructor
      DBASE (
         );

      //! Copy constructor
      DBASE (                       //! Copy Constructor
         const RVC::DBASE& rhs
         );

      //! Destructor
      virtual ~DBASE (
         );

      //! Assignment
      RVC::DBASE& operator= (
         const RVC::DBASE& rhs
         );

      //! Copy a database from the source to under the destination object using an element translation list
      ERRVALUE CopyDatabaseTo (
         RVC::OBJECT& DestParentObj,
         const SIMPLE_ARRAY<INT32>& TransList,
         COPYFLAG flags
         );

      //! Copy a database from the source to under the destination object using an element translation list
      ERRVALUE CopyDatabaseTo (
         RVC::OBJECT& DestParentObj,
         RVC::DBASE& DestDBaseObj,                 //!< To be filled in with the new database object
         const ELEMTRANSLIST& TransList,
         COPYFLAG flags
         );

      //! Copy a table from the source database to the destination database
      //! @return Table number of copied table or error if < 0 
      INT32 CopyTableTo (
         INT32 SrcTableNum,
         RVC::DBASE& DestDBase,
         COPYTABLE flags
         ) const;

      //! Create an SML context for the given database class instance
      ERRVALUE CreateSMLContext (
         SMLCONTEXT **pcontext               //!< SML context allocated and RETURNED
         );

      //! Compare table structures between two databases to determine which tables structurally
      //! match.  Returns the set of exact matching tables In the TableMatch array if the entry != -1
      ERRVALUE FindTableMatches (
         const RVC::DBASE& rhs,
         SIMPLE_ARRAY<INT32>& TableMatch     //!< Translation from lhs table number to rhs table number, -1 if no other table matches
         ) const;

      //! Flush cached records and build indexes if necessary
      ERRVALUE Flush (
         );

      //! Get list of field names that are key fields
      //! @return Number of key field names
      ERRVALUE GetKeyFieldNames (
         SIMPLE_ARRAY<RVC::OBJECTNAME>& FieldNames
         ) const;

      //! Determine the number of tables in the database
      //! @return Number of tables in the database
      INT32 GetNumTables (
         ) const;
         
      //! Get correct OBJTYPESET for all database OBJTYPE's
      //! @return OBJTYPESET for all database OBJTYPE's
      static RVC::OBJTYPESET GetObjTypeSet (
         );
         
      //! Build an inverse DB list for all DBlist entries
      ERRVALUE InverseDBListBuild (
         );

      //! Resume maintainence of the inverse DB list from a InverseDBListSuspend() call
      void InverseDBListResume (
         );

      //! Suspend maintainence of the inverse DB lists.  Used if doing multiple database changes
      void InverseDBListSuspend (
         );

      //! Join a database from the source to the destination database object using an element translation list
      ERRVALUE JoinDatabaseTo (
         RVC::DBASE& DestDBaseObj,
         const SIMPLE_ARRAY<INT32>& TransList,
         COPYFLAG CopyFlags,
         JOINFLAGS JoinFlags
         );

      //! Join a database from the source to the destination database object using an element translation list
      ERRVALUE JoinDatabaseTo (
         RVC::DBASE& DestDBaseObj,
         const ELEMTRANSLIST& TransList,
         COPYFLAG CopyFlags,
         JOINFLAGS JoinFlags
         );

      //! Make a new database object
      ERRVALUE Make (
         const RVC::OBJECT& parent,          //!< Parent object to create database under
         const RVC::OBJECTNAME& name,           //!< Name of database object
         const RVC::OBJECTDESC& desc,           //!< Database object description
         const char* Source = 0                 //!< Source of database creation, default is GetAppName()
         );

      //! Make a new database object
      ERRVALUE Make (
         const RVC::OBJITEM& ObjItem,
         const char* Source = 0                 //!< Source of database creation, default is GetAppName()
         );

      //! Remove duplicate records from all tables (except for ATTACHMENT_Identity and ATTACHMENT_OneToOne) tables
      ERRVALUE RemoveDuplicateRecords (
         );
         
      //! Remove unattached records from all tables
      ERRVALUE RemoveUnattachedRecords (
         );
         
      //! Get a beginning constant table iterator 
      CONST_TABLEITERATOR TableBegin (
         ) const {
         m_NumTables = (IsOpen()) ? GetNumTables() : 0;
         return (CONST_TABLEITERATOR(this));
         }

      //! Get a beginning table iterator 
      TABLEITERATOR TableBegin (
         ) {
         m_NumTables = (IsOpen()) ? GetNumTables() : 0;
         return (TABLEITERATOR(this));
         }

      //! Get a ending constant table iterator 
      CONST_TABLEITERATOR TableEnd (
         ) const { return (CONST_TABLEITERATOR(this, m_NumTables)); }

      //! Get a ending table iterator 
      TABLEITERATOR TableEnd (
         ) { return (TABLEITERATOR(this, m_NumTables)); }
         
      //! Validate the database
      ERRVALUE Validate (
         MISTRING& LogString
         );

      //! Validate new table and field names against existing tables and fields
      ERRVALUE ValidateTableName (
         RVC::OBJECTNAME& name,                 //!< Table name to validate, can be changed
         SIMPLE_ARRAY<RVC::OBJECTNAME>& finfo   //!< Field names to validate, can be changed
         ) 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
         );

      //! Get records attached to the specified element for all tables
      ERRVALUE GetAttachedRecordList (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         SIMPLE_ARRAY<DBLISTELMT>& dblist,   //!< List of attachments allocated and returned
         FINDFLAG FindFlag = FINDFLAG_AllAttached,
         INT32 BaseTableNum = -1
         ) const;
         
      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;
         
      //! Open the database.  If a database object does not exist, make one
      ERRVALUE OpenAsSubobject (
         const OBJECT& parent,            //!< Parent object to find and/or create database under
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT widget = 0               //!< Parent dialog handle, 0 for default handle
         );

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

      int m_DBaseID;

      #endif // GENERATING_DOXYGEN_OUTPUT
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      mutable INT32 m_NumTables;

      //! Implementation of RVC::OBJECT virtual methods
      virtual ERRVALUE v_CloseObject ();              //! Close the open object
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsMultiObject () const;
      virtual bool v_IsObjectOpen () const;           //!< Is this object opened?
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent);              //! Open the database object
      virtual bool v_ValidateObjectType (const OBJTYPE otype) const;       //!< Validate the object type this class can handle

      INT32 FindTable (const OBJECTNAME& name) const;
         
      static void DatabaseCallbackFunc (DBCALLBACKSTRUCT *cb, void *data);

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

DEFINE_ENUM_OPERATORS(DBASE::COPYFLAG);
DEFINE_ENUM_OPERATORS(DBASE::COPYTABLE);
DEFINE_ENUM_OPERATORS(DBASE::FINDFLAG);
DEFINE_ENUM_OPERATORS(DBASE::JOINFLAGS);

class DBASE::BULKMODIFY {
   public:
      BULKMODIFY (
         RVC::DBASE& dbase
         ) : m_dbase(dbase) {
         MfDatabaseBulkModifyBegin(dbase.m_DBaseID);
         }
         
      ~BULKMODIFY (
         ) {
         MfDatabaseBulkModifyEnd(m_dbase.m_DBaseID);
         }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      RVC::DBASE& m_dbase;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
         

//! This class is used in CopyDatabaseTo() and JoinDatabaseTo() for one <-> many conversions
class DBASE::ELEMTRANSLIST {
   public:
      //! Constructor
      ELEMTRANSLIST (
         );
         
      //! Copy Constructor
      ELEMTRANSLIST (
         const ELEMTRANSLIST& rhs
         ) {Copy(rhs);}
         
      //! Destructor
      ~ELEMTRANSLIST (
         );
         
      //! Assignment operator
      ELEMTRANSLIST& operator= (
         const ELEMTRANSLIST& rhs
         ) {
         if (this != &rhs) Copy(rhs);
         return (*this);
         }
         
      //! Conversion operator for MfDatabaseJoinExt() call
      operator const DBELEMTRANSLIST* (
         ) const {return (m_TransList);}
         
      //! Add a destination element to the list
      ERRVALUE AddElement (
         INT32 SourceNum,
         INT32 DestNum
         );
   
      //! Get the number of source items in the translation list
      //! @return Number of source translation list items
      INT32 GetNumItems (
         ) const {return (m_TransList.GetNumItems());}

      //! Initialize the translist to the number of source elements
      ERRVALUE Initialize (
         INT32 NumItems             //!< Number of source elements
         );
         
      //! Resize the translist to the new number of source elements
      ERRVALUE Resize (
         INT32 NumItems             //!< Number of source elements
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<DBELEMTRANSLIST> m_TransList;
      
      void Copy (const ELEMTRANSLIST& rhs);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Database object selection filter to select either a database object or a geospatial object capable of holding a database subobject (existing or not)
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
   }; 
   

//! Database object selection filter to determine if the database is not empty (has tables) and is selectable under the parent object
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
   }; 
   

//! Database object selection filter to determine if the database exists and is selectable under the parent object
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
   }; 


//! Manage suspend and resume state on inverse db list operations 
class DBASE::INVERSEDBLISTSUSPEND {
   public:
      //! Constructor
      INVERSEDBLISTSUSPEND (
         RVC::DBASE& DBase,                  //!< Database to suspend
         bool Rebuild = false,            //!< Rebuild inverse DB lists after resume if true
         bool Condition = true            //!< Condition to suspend inverse DB lists, true to suspend
         ) :
         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
   };

   
//! OBSERVER class for DBASE objects.  The SUBJECT class is DBASE.
class DBASE::OBSERVER : public OBJECTOBSERVER {
   public:

      //! Types of table structural changes made, used in DBTABLE::OBSERVER::OnStructChanged()
      enum STRUCTCHANGE {
         STRUCTCHANGE_Name =              0x00000001,
         STRUCTCHANGE_Desc =              0x00000002,
         STRUCTCHANGE_ViewMode =          0x00000004,
         STRUCTCHANGE_Field =             0x00000008,       //!< Something in one or more fields changed 
         STRUCTCHANGE_FieldsAdded =       0x00000010,
         STRUCTCHANGE_Flags =             0x00000020,
         STRUCTCHANGE_AttachmentType =    0x00000040,
         STRUCTCHANGE_Encoding =          0x00000080,
         STRUCTCHANGE_DBEditorUpdate =    0x00000100,
         STRUCTCHANGE_DBEditorRebuild =   0x00000200
         }; 

      //! Constructor
      explicit OBSERVER (
         RVC::DBASE& dbase
         ) : OBJECTOBSERVER(dbase) {}
         
      //! Destructor
      virtual ~OBSERVER (
         ) {}
         
      //! Called if any change has occured, useful for setting IsDirty flags
      virtual void OnAnyChange (
         ) { return; }

      //! Called if an element entry is added to the dblist
      virtual void OnDBListAdd (
         ELEMTYPE ElemType,
         INT32 ElemNum
         ) { return; }

      //! Called if an element entry is modified in the dblist
      virtual void OnDBListChanged (
         ELEMTYPE ElemType,
         INT32 ElemNum
         ) { return; }
         
      //! Called when table structure information has changed
      virtual void OnStructChanged (
         INT32 TableNum,
         STRUCTCHANGE SubReason
         ) { return; }
         
      //! Called when a table is added to the database
      virtual void OnTableAdd (
         INT32 TableNum
         ) { return; }
         
      //! Called if a table is being dropped from the database
      virtual void OnTableDropBegin (
         INT32 TableNum
         ) { return; }
      
      //! Called if a table is dropped from the database
      virtual void OnTableDropEnd (
         INT32 TableNum
         ) { return; }
         
   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;    //!< Database cannot exist for this type
            }
         }

      virtual bool Filter (
         const RVC::OBJECT& object
         ) {
         if (m_ObjType == OBJTYPE_All) {        //! Vector or TIN node database
            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

---