rvc/dbtable.h

Go to the documentation of this file.

#ifndef INC_RVC_DBTABLE_H
#define INC_RVC_DBTABLE_H

#ifndef INC_RVC_DBASE_H
   #include <rvc/dbase.h>
#endif

#ifndef INC_RVC_DBFIELDCONSTRAINT_H
   #include <rvc/dbfieldconstraint.h>
#endif

#ifndef INC_RVC_STYLETYPE_H
   #include <rvc/styletype.h>
#endif

#ifndef INC_MI32_BITSET_H
   #include <mi32/bitset.h>
#endif

#ifndef INC_MI32_RANGE_H
   #include <mi32/range.h>
#endif

#ifndef  INC_MI32_GREMODE_H
   #include <mi32/gremode.h>
#endif

#ifndef  INC_MI32_ENUMSET_H
   #include <mi32/enumset.h>
#endif

#ifndef  INC_MI32_DATETIME_H
   #include <mi32/datetime.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef  INC_MI32_UOM_H
   #include <mi32/uom.h>
#endif

#ifndef  INC_VECTOR
#include <vector>
#define INC_VECTOR
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
struct UNITCONV;
struct DBFIELDINFO;
struct DBCONSTRAINT;
namespace SML {
   class TABLEDATA;
   }
namespace SPATMOD {
   namespace IMAGE {
      class STAGE;
      }
   }
namespace RVC {
   struct DBCALLBACKSTRUCT;
   class SHAPE;
   class STYLE;
   class DBASE_ELEMENT;
   class TABLEJOININFO;
   class DBTRANSINFO;
   }
#endif


namespace RVC {

class DBTABLE : public RVC::OBJECT {
   public:

      enum ATTACHMENT {
         ATTACHMENT_Unknown = 0,          
         ATTACHMENT_OneRecordPerElement,  
         ATTACHMENT_OneElementPerRecord,  
         ATTACHMENT_OneToOne,             
         ATTACHMENT_RelatedOnly,          
         ATTACHMENT_Identity,             
         ATTACHMENT_NoRestrictions        
         };
         
      enum DEFINEDID {
         DEFINEDID_Internal =     -1,        
         DEFINEDID_InternalNode = -2,        
         DEFINEDID_Invalid =     -98,
         DEFINEDID_New =          -9
         };
         
      enum FINDFLAG {
         FINDFLAG_AllAttached = 0,
         FINDFLAG_OnlyDirect = 2,
         FINDFLAG_FirstMatch = 8
         };

      enum INDEXSEARCH {
         INDEXSEARCH_ReturnIndexOffset =  0x00000000,
         INDEXSEARCH_CheckExists =        0x00000001,
         INDEXSEARCH_ReturnRecordNumber = 0x00000002,
         INDEXSEARCH_ReturnInsertOffset = 0x00000004  
         };
         
      enum ITERATERECORD {
         ITERATERECORD_None =          0x0000,
         ITERATERECORD_SkipDeleted =   0x0001,
         ITERATERECORD_Sort =          0x0002,
         ITERATERECORD_UniqueOnly =    0x0004,
         ITERATERECORD_SaveIndex =     0x0008,
         ITERATERECORD_SingleKey =     0x8000
         };
         
      enum LINKTYPE {
         LINKTYPE_Internal = 0,  
         LINKTYPE_MIPS,          
         LINKTYPE_DBASE3,        
         LINKTYPE_INFO,          
         LINKTYPE_DBASE4,        
         LINKTYPE_RBASE,         
         LINKTYPE_DBASE2,        
         LINKTYPE_ODBC,          
         LINKTYPE_CSV,           
         LINKTYPE_TAB,           
         LINKTYPE_ORACLE,        
         LINKTYPE_RDBMS,         
         LINKTYPE_LAS,           
         LINKTYPE_NUMTYPES       
         };

      enum KEYFLAGS {
         KEYFLAG_None =             0x0000,
         KEYFLAG_PrimaryKey =       0x0001,  
         KEYFLAG_ForeignKey =       0x0002,  
         KEYFLAG_Indexed =          0x0004,  
         KEYFLAG_RebuildIndex =     0x2000,  
         KEYFLAG_Sorted =           0x4000   
         };

      enum RECORDREFTYPE {
         RECORDREFTYPE_New =        0,    
         RECORDREFTYPE_Absolute =   1,    
         RECORDREFTYPE_Bookmark =   2     
         };

      enum REFELEM {
         REFELEM_All       = 0x00000000,
         REFELEM_Node      = 0x00000010,
         REFELEM_Edge      = 0x00000020,
         REFELEM_Triangle  = 0x00000040,
         REFELEM_Hull      = 0x00000080   
         };
         
      enum STRUCTCOMPARE {
         STRUCTCOMPARE_DoNotMatch = 0,    
         STRUCTCOMPARE_Exact,             
         STRUCTCOMPARE_Compatible,        
         STRUCTCOMPARE_SameTable          
         };
      
      enum CAPABILITY {
         CAPABILITY_Create = 2048,
         CAPABILITY_Link,
         CAPABILITY_ReadMemo,
         CAPABILITY_WriteMemo,
         CAPABILITY_WriteRecord,
         CAPABILITY_MultiTable,     
         CAPABILITY_Server,
         CAPABILITY_Import,
         CAPABILITY_Export,
         CAPABILITY_DeleteRecord,
         CAPABILITY_UserWritable,
         CAPABILITY_CanSetUserWrite,
         CAPABILITY_ChangeFields,
         CAPABILITY_AddFields,
         CAPABILITY_DeleteFields,
         CAPABILITY_AddRecord,
         CAPABILITY_RandomAccess,
         CAPABILITY_ReadBinary,
         CAPABILITY_WriteBinary,
         CAPABILITY_WriteIfOpenForWrite,  
         CAPABILITY_BookmarksAreNotAbsolute 
         };
         
      enum PERMISSIONS {
         PERMISSION_View = 0,
         PERMISSION_Modify,
         PERMISSION_Delete,
         PERMISSION_ViewStructure,
         PERMISSION_ModifyStructure,
         PERMISSION_Duplicate,
         PERMISSION_ReadACL,
         PERMISSION_ChangeACL
         };

      enum USAGE {
         USAGE_UserDefined =        0,
         USAGE_StdStats =           2,
         USAGE_ElementID =          3,
         USAGE_NodeTurn =           4,
         USAGE_ScaleSelect =        5,
         USAGE_Section =            6,
         USAGE_Internal =           7,
         USAGE_PointStyle =         8,
         USAGE_LineStyle =          9,
         USAGE_PolyStyle =          10,
         USAGE_TextStyle =          11,
         USAGE_MultiStyle =         12,
         USAGE_CADStyle =           USAGE_MultiStyle,
         USAGE_EditLog =            13,
         USAGE_Selection =          14,
         USAGE_FlightPath =         15,
         USAGE_PointOfInterest =    16,
         USAGE_LegendElement =      17,
         USAGE_StyleParameters =    18,
         USAGE_SelectParameters =   19,
         USAGE_ExtrudedPoints =     20,
         USAGE_InfluenceSphere =    21,
         USAGE_Sketch =             22,   
         USAGE_ClumpRaster =        23,   
         USAGE_Enumeration =        24,
         USAGE_Shape =              25,   
         USAGE_PickList =           26,   
         USAGE_Properties =         27,   
         USAGE_FieldOfView =        28,   
         USAGE_LAST
         };

      enum VIEWMODE {
         VIEWMODE_Tabular        = 0,
         VIEWMODE_SingleRecord   = 1
         };
         
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class BOOKMARK;
      class CURSOR;
      class FIELDINFO;
      class GETOBJFILTER_ISSELECTABLE;
      class GETOBJFILTER_ISUSAGEVALID;
      class GETOBJFILTER_ISUSERDEFINED;
      class RECORD;
      friend class RECORD;
      class RECORD_ID_ELEMENT;
      class RECORD_ID_POINT;
      class RECORD_LEGENDELEMENT;
      class RECORD_NODETURN;
      class RECORD_SCALESELECT;
      class RECORD_SELECTION;
      class RECORD_STYLE_CAD;
      typedef RECORD_STYLE_CAD RECORD_STYLE_MULTI;
      class RECORD_STYLE_ELEMENT;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      typedef ENUMSET<USAGE, USAGE_LAST> USAGESET;
      typedef std::vector<FIELDINFO> FIELDINFOARRAY;
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class CONSTRAINT;
      class LINKPARMS;
      class MAKEPARMS;
      class MAKEPARM_ID_ELEMENT;
      class MAKEPARM_ID_POINT;
      class MAKEPARM_STYLE_ELEMENT;
      class MAKEPARM_STYLE_CAD;
      typedef MAKEPARM_STYLE_CAD MAKEPARM_STYLE_MULTI;
      class MAKEPARM_STYLE_LINE;
      class MAKEPARM_STYLE_POINT;
      class MAKEPARM_STYLE_POLYGON;
      class MAKEPARM_SCALESELECT;
      class MAKEPARM_SELECTION;
      class MAKEPARM_LEGENDELEMENT;
      class MAKEPARM_NODETURN;
      class MAKEPARM_ORACLE;
      class RECORDITERATOR;
      class CONST_RECORDITERATOR;
      class OBSERVER;
      #endif // GENERATING_DOXYGEN_OUTPUT

      class CONSTRAINT {
         public:
            enum CASE {
               CASE_None =             0,
               CASE_ForceUpperCase =   DBFIELDCONSTRAINT_Case_AllUpper,
               CASE_ForceLowerCase =   DBFIELDCONSTRAINT_Case_AllLower,
               CASE_CapFirstLetter =   DBFIELDCONSTRAINT_Case_FirstLetterCap,
               CASE_CapFirstWord =     DBFIELDCONSTRAINT_Case_FirstWordCap,
               };
               
            enum PKTABLE {
               PKTABLE_None =             0,
               PKTABLE_MustExist =        DBFIELDCONSTRAINT_PrimaryKey_MustExist,
               PKTABLE_AutoAdd =          DBFIELDCONSTRAINT_PrimaryKey_AutoAdd,
               PKTABLE_AutoAddPrompt =    DBFIELDCONSTRAINT_PrimaryKey_PromptAdd,
               };
         
            enum KEYMODE {
               KEYMODE_None =             0,
               KEYMODE_ComboBox =         DBFIELDCONSTRAINT_UI_ComboBox,
               KEYMODE_OptionMenu =       DBFIELDCONSTRAINT_UI_OptionMenu,
               KEYMODE_CSVListAllowDups = DBFIELDCONSTRAINT_ValueList_AllowDups,
               KEYMODE_CSVListUnique =    DBFIELDCONSTRAINT_ValueList_NoDups,
               };
         
            enum RANGEFLAG {
               RANGEFLAG_None =           0,
               RANGEFLAG_MinExclusive =   DBFIELDCONSTRAINT_Range_MinExclusive,
               RANGEFLAG_MaxExclusive =   DBFIELDCONSTRAINT_Range_MaxExclusive,
               RANGEFLAG_MinInclusive =   DBFIELDCONSTRAINT_Range_MinInclusive,
               RANGEFLAG_MaxInclusive =   DBFIELDCONSTRAINT_Range_MaxInclusive,
               RANGEFLAG_MINMASK =        DBFIELDCONSTRAINT_Range_Min_MASK,
               RANGEFLAG_MAXMASK =        DBFIELDCONSTRAINT_Range_Max_MASK,
               };
         
            enum DEFAULTFLAG {
               DEFAULT_Zero =             0,
               DEFAULT_Constant =         DBFIELDCONSTRAINT_Default_Constant,
               DEFAULT_Blank =            DBFIELDCONSTRAINT_Default_Empty,
               };

            CONSTRAINT (
               );
         
            CONSTRAINT (
               const CONSTRAINT& rhs
               );
         
            ~CONSTRAINT (
               ) {}

         #ifndef NO_DEPRECATED
            DEPRECATED bool CanBeEmpty (
               ) const {return (!m_NotNull);}
         #endif
               
            void Clear (
               );

            CASE GetCaseFlags (
               ) const {return (m_Case);}
            
            double GetDefaultNum (
               ) const {return (m_DefaultNum);}
               
            DEFAULTFLAG GetDefaultFlags (
               ) const {return (m_DefaultFlags);}
               
            KEYMODE GetKeyMode (
               ) const {return (m_KeyMode);}
               
            const MISTRING& GetPrefixLabel (
               ) const {return (m_Label);}
               
            const MISTRING& GetPostfixLabel (
               ) const {return (m_LabelAfter);}
               
            PKTABLE GetPkTableFlags (
               ) const {return (m_PkTable);}
            
            const DOUBLE_RANGE& GetRange (
               ) const {return (m_Range);}
               
            RANGEFLAG GetRangeFlags (
               ) const {return (m_RangeFlags);}
               
            bool IsAutoComplete (
               ) const {return (m_AutoComplete);}
               
            void SetAutoComplete (
               bool value
               ) {m_AutoComplete = value;}
               
            void SetCaseFlags (
               CASE flags
               ) {m_Case = flags;}
            
            void SetDefaultNum (
               double number
               ) {m_DefaultNum = number;}
               
         #ifndef NO_DEPRECATED
            DEPRECATED void SetEmpty (
               bool value
               ) {m_NotNull = !value;}
         #endif
               
            void SetDefaultFlags (
               DEFAULTFLAG flags
               ) {m_DefaultFlags = flags;}
               
            void SetKeyMode (
               KEYMODE flags
               ) {m_KeyMode = flags;}
               
            void SetPrefixLabel (
               const MISTRING& label
               ) {m_Label = label;}
               
            void SetPostfixLabel (
               const MISTRING& label
               ) {m_LabelAfter = label;}
               
            void SetPkTableFlags (
               PKTABLE flags
               ) {m_PkTable = flags;}
            
            void SetRange (
               const DOUBLE_RANGE& range
               ) {m_Range = range;}
         
            void SetRangeFlags (
               RANGEFLAG flags
               ) {m_RangeFlags = flags;}
               
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
         
            RANGEFLAG m_RangeFlags;
            DEFAULTFLAG m_DefaultFlags;
            KEYMODE m_KeyMode;
            CASE m_Case;
            PKTABLE m_PkTable;
            DOUBLE_RANGE m_Range;
            double m_DefaultNum;
            bool m_NotNull;
            bool m_AutoComplete;
            MISTRING m_Label;
            MISTRING m_LabelAfter;
            
            void GetConstraint (DBCONSTRAINT& rhs) const;
            void SetConstraint (const DBCONSTRAINT& rhs);

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


      class FIELDINFO {
         public:

            enum NEXTFIELD {
               NEXTFIELD_ThisFieldName = 0xFFFF,   
               NEXTFIELD_ThisTableName = 0xFFFE,   
               NEXTFIELD_DomID         = 0xFFFD,   
               NEXTFIELD_PseudoField   = 0xFFFC    
               };
               
            enum FLAGS {
               FLAG_None =             0x0000,
               FLAG_PrimaryKey =       0x0001,  
               FLAG_PK =               FLAG_PrimaryKey,
               FLAG_ForeignKey =       0x0002,  
               FLAG_Indexed =          0x0004,  
               FLAG_ComputeOnRead =    0x0008,  
               FLAG_NotNULL =          0x0010,  
               FLAG_Unique =           0x0020,  
               FLAG_ReadOnly =         0x0040,  
               FLAG_SecondaryKey =     0x0080,  
               FLAG_Invisible =        0x0100,  
               FLAG_Closest =          0x0200,  
               FLAG_RangeAbove =       0x0400,  
               FLAG_RangeBelow =       0x0800,  
               FLAG_ComputeOnWrite =   0x1000,  
               FLAG_ComputedMASK =     0x1008,
               FLAG_LocalTime =        0x2000,  
               FLAG_AutoIncrement =    0x4000,  
               FLAG_SSIndex =          0x10000, 
               FLAG_Searchable =       (FLAG_Indexed | FLAG_SSIndex)
               };

            enum TYPE { 
               TYPE_Invalid = 0,       
               TYPE_String = 1,        
               TYPE_Char = 2,          
               TYPE_UINT8 = 3,         
               TYPE_SINT8 = 4,         
               TYPE_UINT16 = 5,        
               TYPE_SINT16 = 6,        
               TYPE_UINT32 = 7,        
               TYPE_SINT32 = 8,        
               TYPE_Float = 9,         
               TYPE_Double = 10,       
               TYPE_Logical = 11,      
               TYPE_Date = 12,         
               TYPE_UINT64 = 13,       
               TYPE_SINT64 = 14,       
               TYPE_Color = 15,        
               TYPE_Binary = 16,       
               TYPE_Memo = 17,         
               TYPE_Unicode = 18,      
               TYPE_DateTime = 19,     
               TYPE_NUMTYPES,          
            #ifndef GENERATING_DOXYGEN_OUTPUT
               TYPE_UByte = TYPE_UINT8,
               TYPE_Byte = TYPE_SINT8,
               TYPE_UWord = TYPE_UINT16,
               TYPE_Word = TYPE_SINT16,
               TYPE_ULong = TYPE_UINT32,
               TYPE_Long = TYPE_SINT32,
               TYPE_UDLong = TYPE_UINT64,
               TYPE_DLong = TYPE_SINT64,
            #endif
               };
               
            enum USAGE {         
               USAGE_Undefined = 0,
               USAGE_XCoord = 1,
               USAGE_YCoord,
               USAGE_ZCoord,
               USAGE_Label,
               USAGE_Filename,
               USAGE_ObjName,
               USAGE_ImageBLOB,           //<! For Binary BLOBs only
               USAGE_ImageFile,           //<! Field holds a filename pointing to an image
               USAGE_ImageURL,            //<! Field holds a URL pointing to an image
               USAGE_ImageName,
               USAGE_Spatial,
               USAGE_HyperLink,           //<! A URL to anything
               USAGE_DataTip,
               USAGE_Heading,             
               USAGE_Velocity,            
               USAGE_CRS,
               USAGE_DateTime,
               USAGE_ImageThumbnail,      
               USAGE_ImageDescription,    
               USAGE_RecordModTime,       
               USAGE_EnumLabel,
               USAGE_EnumToolTip,
               USAGE_ElementID,           
               USAGE_ElementName,
               USAGE_ElementDesc,
               USAGE_LAST
               };
               
            // Note: format is stored as a UINT8 in the fieldinfo
            enum FORMAT {        
               FORMAT_Undefined = 0,
               FORMAT_OGC_WKB = 1,     
               FORMAT_OGC_WKT,         
               FORMAT_ImageJPG,           
               FORMAT_ImagePNG,           
               };
               
            typedef ENUMSET<USAGE, USAGE_LAST> USAGESET;
               
            FIELDINFO (
               );

            FIELDINFO (
               const FIELDINFO& rhs
               );

            ~FIELDINFO (
               );

            FIELDINFO& operator= (
               const FIELDINFO& rhs
               );    
            
            void Clear (
               );
               
            void ClearFlag (
               FLAGS flag
               );
               
            void ClearLink (
               );
               
            void ClearNextLinkField (
               );
               
            TYPE CompareFieldTypes (
               const FIELDINFO& rhs,
               bool& ExactMatch              
               ) const;
               
            UINT32 GetAutoIncrement (
               ) const;
         
            int GetDecimalPlaces (
               ) const;
               
            int GetDispUnits (
               ) const;
               
            int GetDispWidth (
               ) const;
               
            const RVC::OBJECTNAME& GetDomainID (
               ) const;
               
            FLAGS GetFlags (
               ) const;
               
            FORMAT GetFormat (
               ) const;
               
            const RVC::DBTABLE::CONSTRAINT& GetConstraint (
               ) const { return (m_Constraint); }

            const RVC::DESCRIPTOR& GetDescriptor (
               ) const { return (m_Descriptor); }

         #ifndef NO_DEPRECATED
            DEPRECATED const RVC::OBJECTNAME& GetName (
               ) const {return (GetShortName());}
         #endif

            const RVC::OBJECTNAME& GetShortName (
               ) const;
               
            const MISTRING& GetFullName (
               ) const {return (m_Descriptor.GetFullName());}

            INT32 GetNextLinkField (
               ) const;
               
            INT32 GetOffset (
               ) const;

            NEXTFIELD GetPseudoNextLinkField (
               ) const;
               
            INT32 GetRelatedField (
               ) const;
               
            INT32 GetRelatedTable (
               ) const;
               
            INT32 GetSize (
               ) const;
               
            TYPE GetType (
               ) const;
         
            void GetUnits (
               UNITCONV& conv,
               bool bGetUnitsShown = false
               ) const;

            UOM::UNIT GetUnits (
               bool bGetUnitsShown = false
               ) const;
               
            int GetUnitType () const;

            USAGE GetUsage () const;
               
            bool HasRelation () const;
         
            bool HasNextKey () const;
         
            bool HasPseudoNextKey () const;
               
            bool IsNumeric () const;

            bool IsString () const;

            void ResetPosition ();
               
            void SetAutoIncrement (
               UINT32 count
               );

            void SetConstraint (
               const RVC::DBTABLE::CONSTRAINT& Constraint
               ) { m_Constraint = Constraint; }
         
            void SetDescription (
               const MISTRING& Description
               ) { m_Descriptor.SetDescription(Description); }

            void SetDescriptor (
               const RVC::DESCRIPTOR& Descriptor
               ) { m_Descriptor = Descriptor; }

            void SetDecimalPlaces (
               int decplaces
               );
               
            void SetDispUnits (
               int unit
               );
               
            void SetDispWidth (
               int width
               );
               
            void SetDomainID (
               const RVC::OBJECTNAME& name
               );
               
            void SetFlags (
               FLAGS flags
               );
               
            void SetFlag (
               FLAGS flag
               );
               
            void SetFormat (
               FORMAT format
               );
               
            void SetLink (
               INT32 TableNum,
               INT32 FieldNum,
               INT32 NextFieldNum = -1
               );
               
            void SetLink (
               INT32 TableNum,
               INT32 FieldNum,
               NEXTFIELD NextFieldNum
               );
               
            void SetName (
               const RVC::OBJECTNAME& name
               );
               
            void SetName (
               const MISTRING& name
               );
               
            void SetName (
               TEXTID name
               );
               
            void SetNextLinkField (
               INT32 NextFieldNum
               );
               
            void SetNextLinkField (
               NEXTFIELD NextFieldNum
               );
               
            void SetOffset (
               int offset
               );

            void SetSize (
               INT32 size
               );
               
            void SetType (
               TYPE type
               );
         
            void SetUnits (
               const UNITCONV& conv
               );

            void SetUnits (
               const UOM::UNIT& units,
               bool bSetUnitsStored = true,
               bool bSetUnitsShown = true
               );
               
            void SetUnits (
               UOM::IDNUM units,
               bool bSetUnitsStored = true,
               bool bSetUnitsShown = true
               );
               
            void SetUnitsShown (
               const UNITCONV& conv
               );
                        
            void SetUsage (
               USAGE usage
               );
         
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            DBFIELDINFO* m_pFieldInfo;
            RVC::DESCRIPTOR m_Descriptor;
            RVC::DBTABLE::CONSTRAINT m_Constraint;

            const DBFIELDINFO* GetFieldInfoPtr () const {return (m_pFieldInfo); }
            DBFIELDINFO* GetFieldInfoPtr () {return (m_pFieldInfo); }
            
            friend class DBTABLE;
            friend class DBTABLE::CURSOR;
            friend class DBTABLE::RECORD;
            friend class SHAPE;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      static TEXTID GetAttachmentTextID (
         ATTACHMENT attachment         
         );
      
      static bool HasDBTypeCapability (
         LINKTYPE LinkType,
         CAPABILITY Capability
         );

      DBTABLE (
         );

      DBTABLE (                        
         const RVC::DBTABLE& rhs
         );

      virtual ~DBTABLE (
         );

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

      INT32 AddRecord (
         RECORD& Record
         );
      
      ERRVALUE AddRecord (
         RECORD& Record,      
         BOOKMARK& Bookmark   
         );
      
      ERRVALUE BuildIndex (
         INT32 FieldNum,
         KEYFLAGS flags = KEYFLAG_Indexed    
         );

      ERRVALUE ChangeAttachmentType (
         ATTACHMENT Attachment,
         ELEMTYPE ElemType = ELEMTYPE_Empty  
         );

   #ifndef NO_DEPRECATED
      DEPRECATED ERRVALUE Combine (
         const RVC::DBTABLE& rhs,
         RVC::DBASE::JOINFLAGS flags,
         RVC::DBASE& dest,          
         const MISTRING& name,            
         const MISTRING& desc             
         );
   #endif

      ERRVALUE Combine (
         const RVC::DBTABLE& rhs,
         RVC::DBASE::JOINFLAGS flags,
         RVC::DBASE& dest,          
         const RVC::DESCRIPTOR& DestDescriptor  
         );

      STRUCTCOMPARE CompareStructures (
         const RVC::DBTABLE& rhs
         ) const;
         
      ATTACHMENT ComputeMinimumAttachmentType (
         ELEMTYPE ElemType = ELEMTYPE_Empty
         ) const;

      ERRVALUE CopyRecordAttachmentsTo (
         RVC::DBTABLE& DestTable,
         const SIMPLE_ARRAY<INT32>& SrcToDestTrans
         ) const;

      ERRVALUE CopyTo (
         RVC::DBASE& DestDatabase,
         RVC::DESCRIPTOR *pDestDescriptor = 0, 
         INT32* pNewTableNumber = 0,
         SIMPLE_ARRAY<INT32>* pRecordTrans = 0, 
         DELEGATE_BOOL_UINT32 Filter = 0, 
         const RVC::CREDENTIALS *pCredentials = 0,
         RVC::DBASE::COPYFLAG flags = RVC::DBASE::COPYFLAG_None
         ) const;

      ERRVALUE Drop (
         bool CleanDBList                 
         );

      ERRVALUE DeleteRecord (
         INT32 RecordNum
         );

      ERRVALUE DeleteRecord (
         CURSOR& cursor,
         const BOOKMARK& bookmark
         );

   #ifndef NO_DEPRECATED
      DEPRECATED INT32 FindField (
         const RVC::OBJECTNAME& name
         ) const;
   #endif
         
      INT32 FindField (
         const MISTRING& name
         ) const;
         
      INT32 FindFieldByShortName (
         const RVC::OBJECTNAME& name
         ) const;
         
      INT32 FindFieldByUsage (
         RVC::DBTABLE::FIELDINFO::USAGE Usage
         ) const;
         
      INT32 FindRecords (
         INT32 FieldNum,
         double value,                       
         SIMPLE_ARRAY<INT32>& FoundRecList
         ) const;
         
      INT32 FindRecords (
         INT32 FieldNum,
         const char* string,              
         SIMPLE_ARRAY<INT32>& FoundRecList,
         CHAR_ENCODING Encoding = CHAR_ENCODING_UTF8
         ) const;
         
      INT32 FindRecords (
         INT32 FieldNum,
         const MIUNICODE* string,               
         SIMPLE_ARRAY<INT32>& FoundRecList
         ) const;
         
      INT32 FindRecords (
         INT32 FieldNum,
         const MISTRING& string,             
         SIMPLE_ARRAY<INT32>& FoundRecList
         ) const;
         
      INT32 FindRecords (
         INT32 FieldNum,
         const RECORD& record,               
         SIMPLE_ARRAY<INT32>& FoundRecList,
         INT32 RecordFieldNum = -1           
         ) const;
         
      INT32 GetAttachedRecords (
         INT32 ElementNum,
         ELEMTYPE ElemType,
         SIMPLE_ARRAY<INT32>& RecordList,
         FINDFLAG FindFlags = FINDFLAG_AllAttached,
         DBTABLE* SourceTable = 0   
         ) const;

      ATTACHMENT GetAttachmentType (
         ) const;

      bool HasCapability (
         CAPABILITY capability
         ) const;

      ERRVALUE GetComputedFieldQuery (
         INT32 FieldNum, 
         MISTRING& QueryStr
         ) const;

      CHAR_ENCODING GetEncoding (
         ) const;
         
      ERRVALUE GetFieldIndex (
         INT32 FieldNum,
         SIMPLE_ARRAY<INT32>& Index,            
         BITSET& DuplicateBits                  
         );

      ERRVALUE GetFieldDescriptor (
         INT32 FieldNum,
         RVC::DESCRIPTOR& Descriptor
         ) const;

      ERRVALUE GetFieldInfo (
         INT32 FieldNum,
         FIELDINFO& FieldInfo
         ) const;

      ERRVALUE GetFieldInfo (
         FIELDINFOARRAY& FieldArray
         ) const;

      ERRVALUE GetLinkFields (
         INT32 StartFieldNum,                      
         SIMPLE_ARRAY<INT32>& FieldNumArray        
         ) const;     

      LINKTYPE GetLinkType (
         ) const;

      INT32 GetNumDeletedRecords (
         ) const;

      INT32 GetNumFields (
         ) const;

      INT32 GetNumRecords (
         ) const;

      REFELEM GetReferenceElement (
         ) const;
         
      INT32 GetRelatedRecords (
         INT32 RecordNum,                                   
         INT32 BaseTableNum,                                
         SIMPLE_ARRAY<INT32>& RecordList,                   
         FINDFLAG FindFlags = FINDFLAG_AllAttached          
         ) const;

      INT32 GetRelatedRecords (
         const RECORD& record,                              
         SIMPLE_ARRAY<INT32>& RecordList,                   
         FINDFLAG FindFlags = FINDFLAG_AllAttached          
         ) const;

      ERRVALUE GetTableMetadata (
         SIMPLE_ARRAY<UINT8>& buffer
         ) const;

      INT32 GetTableNumber (
         ) const;
         
      USAGE GetUsage (
         ) const;
         
      VIEWMODE GetViewMode (
         ) const;

      LRECT2D GetWindowRect (
         ) const;
         
      bool IsHidden (
         ) const;

      bool IsInternal (
         ) const;

      bool IsMissing (
         ) const;
         
      bool IsPrompt (
         ) const;

      bool IsUserDefined (
         ) const;

      bool IsValid (
         ) const;

      bool IsWritable (
         ) const;

      ERRVALUE Link (
         RVC::DBASE& parent,
         const DESCRIPTOR& Descriptor,
         const LINKPARMS& LinkParms,
         const CREDENTIALS *pCredentials RVC_DEFAULT_CREDENTIALS           
         );

      ERRVALUE Make (
         RVC::DBASE& parent,
         const DESCRIPTOR& Descriptor,
         MAKEPARMS& MakeParms,
         const CREDENTIALS *pCredentials RVC_DEFAULT_CREDENTIALS           
         );

      ERRVALUE MakeDistinctTableFromField (
         RVC::DBASE& parent,
         const RVC::DBTABLE& SourceTable,
         INT32 Field,               
         const DESCRIPTOR& Descriptor,
         const CREDENTIALS *pCredentials RVC_DEFAULT_CREDENTIALS           
         );

      ERRVALUE Open (
         const RVC::DBASE& parent,
         const MISTRING& TableName,
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT dlgparent,               
         const CREDENTIALS *pCredentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT dlgparent = 0,              
         const CREDENTIALS *pCredentials = 0          
#endif
         );

      ERRVALUE Open (
         const RVC::DBASE& parent,
         const RVC::OBJECTNAME& ShortName,
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT dlgparent,               
         const CREDENTIALS *pCredentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT dlgparent = 0,              
         const CREDENTIALS *pCredentials = 0          
#endif
         );

      ERRVALUE Open (
         const RVC::DBASE& parent,
         INT32 TableNum,
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT dlgparent,               
         const CREDENTIALS *pCredentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT dlgparent = 0,              
         const CREDENTIALS *pCredentials = 0          
#endif
         );

      ERRVALUE Open (
         const DBTABLE& twin,
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT dlgparent,               
         const CREDENTIALS *pCredentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT dlgparent = 0,              
         const CREDENTIALS *pCredentials = 0          
#endif
         );

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

      ERRVALUE Open (
#ifdef RVC_CREDENTIALS_MANDATORY
         OPENMODE OpenMode,   
         MDLGPARENT dlgparent,               
         const CREDENTIALS *pCredentials 
#else
         OPENMODE OpenMode = OPENMODE_Read,  
         MDLGPARENT dlgparent = 0,              
         const CREDENTIALS *pCredentials = 0          
#endif
         );

   #ifndef GENERATING_DOXYGEN_OUTPUT
      // Open an existing table
      // This is a private version used by SML, which really already has the
      // table open, but since RVC interface classes aren't available inside
      // RVCSYS, it only has internal handles.  
      ERRVALUE Open (
         const SML::TABLEDATA* TableData,
         OPENMODE mode = OPENMODE_Read
         // doesn't need credentials table really already open.
         );
   #endif  // doxygen

      ERRVALUE Read (
         const BOOKMARK& Bookmark, 
         RECORD& Record
         ) const {return (Read(0, 0, &Bookmark, Record, RECACC_Bookmark));}

      ERRVALUE Read (
         INT32 RecordNum, 
         RECORD& Record
         ) const {return (Read(0, RecordNum, 0, Record, RECACC_RecordNum));}

      ERRVALUE Read (
         CURSOR& cursor,
         RECORD& Record
         ) const {return (Read(&cursor, 0, 0, Record, RECACC_Cursor));}
         
      ERRVALUE Read (
         CURSOR& cursor,
         const BOOKMARK& bookmark,
         RECORD& Record
         ) const {return (Read(&cursor, 0, &bookmark, Record, RECACC_Bookmark));}
         
      ERRVALUE ReadDefault (
         RECORD& Record
         ) const {return (Read(0, RECORD_New, 0, Record, RECACC_RecordNum));}

      ERRVALUE ReadConstraint (
         std::vector<CONSTRAINT>& ConstraintList
         ) const;

      INT32 ReadInverseDBList (
         INT32 RecNum,
         SIMPLE_ARRAY<DBLISTELMT>& List
         );

      void RecordBegin (
         CONST_RECORDITERATOR& Iterator, 
         ITERATERECORD IterateRecord = ITERATERECORD_SkipDeleted,
         INT32 FieldNum = 0
         ) const;

      void RecordBegin (
         RECORDITERATOR& Iterator, 
         ITERATERECORD IterateRecord = ITERATERECORD_SkipDeleted,
         INT32 FieldNum = 0
         );

      ERRVALUE RemoveDuplicateRecords (
         );

      ERRVALUE RemoveUnattachedRecords (
         );

      ERRVALUE Resize (
         INT32 NewNumRecords,
         bool CleanDBList
         );

      template <class _CT>
      INT32 SearchIndex (
         INT32 FieldNum,
         const _CT& item,
         const FIELDINFO& finfo, 
         INT32& offset, 
         INDEXSEARCH flag = INDEXSEARCH_ReturnIndexOffset,
         CHAR_ENCODING Encoding = CHAR_ENCODING_ASCII 
         ) const {return (SearchIndex(FieldNum, &item, &finfo, &offset, flag));}

      template <class _CT>
      INT32 SearchIndex (
         INT32 FieldNum,
         const _CT& item,           
         INT32& offset, 
         INDEXSEARCH flag = INDEXSEARCH_ReturnIndexOffset,
         CHAR_ENCODING Encoding = CHAR_ENCODING_ASCII 
         ) const {return (SearchIndex(FieldNum, &item, 0, &offset, flag, Encoding));}

      INT32 SearchIndex (
         INT32 FieldNum,
         double value,
         INT32& offset, 
         INDEXSEARCH flag
         ) const;
         
      INT32 SearchIndex (
         INT32 FieldNum,
         const MISTRING& value,
         INT32& offset, 
         INDEXSEARCH flag
         ) const;
         
      INT32 SearchIndex (
         INT32 FieldNum,
         const RECORD& Record, 
         INT32 RecFieldNum,
         INT32& offset, 
         INDEXSEARCH flag
         ) const;
      
      ERRVALUE SetAttachmentType (
         ATTACHMENT Attachment
         );

      ERRVALUE SetComputedFieldQuery (
         INT32 FieldNum,
         const MISTRING& QueryStr
         );
         
      void SetEncoding (
         CHAR_ENCODING Encoding
         );

      ERRVALUE SetFieldDescriptor (
         const RVC::DESCRIPTOR& Descriptor
         );

      ERRVALUE SetFieldInfo (
         INT32 FieldNum,
         const FIELDINFO& FieldInfo
         );

      ERRVALUE SetFieldInfo (
         FIELDINFOARRAY& FieldArray
         );

      ERRVALUE SetFieldInfo (
         FIELDINFOARRAY& FieldArray,
         const SIMPLE_ARRAY<int>& NewToOld
         );

      ERRVALUE SetPromptOnAddElement (
         bool prompt = true
         );

      ERRVALUE SetReferenceElement (
         REFELEM RefElem
         );

      ERRVALUE SetReadOnly (
         bool bReadOnly = true
         );

      ERRVALUE SetUsage (
         DBTABLE::USAGE usage
         );

      ERRVALUE SetViewMode (
         VIEWMODE ViewMode
         );

      void SetWindowRect (
         const LRECT2D& rect
         );

      ERRVALUE UpgradeLinkToOLEDB (
         );

      ERRVALUE ValidateAccess (
         PERMISSIONS Permission,
         bool bGenerateErrorMsg = true 
         ) const;

      ERRVALUE ValidateAccess (
         INT32 FieldNum,
         PERMISSIONS Permission,
         bool bGenerateErrorMsg = true 
         ) const;

      ERRVALUE ValidateTableName (
         OBJECTNAME& NewTableName,
         SIMPLE_ARRAY<OBJECTNAME>& NewFieldNames
         );

      ERRVALUE Write (
         INT32 RecordNum, 
         RECORD& Record
         ) {return (Write(0, RecordNum, 0, Record, RECACC_RecordNum));}

      ERRVALUE Write (
         const BOOKMARK& Bookmark, 
         RECORD& Record
         ) {return (Write(0, 0, &Bookmark, Record, RECACC_Bookmark));}

      ERRVALUE Write (
         CURSOR& cursor,
         RECORD& Record
         ) {return (Write(&cursor,0, 0, Record, RECACC_Cursor));}

      ERRVALUE Write (
         CURSOR& cursor,
         const BOOKMARK& bookmark,
         RECORD& Record
         ) {return (Write(&cursor, 0, &bookmark, Record, RECACC_Bookmark));}

      ERRVALUE WriteConstraint (
         const std::vector<CONSTRAINT>& ConstraintList
         );

   protected:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      RVC::DBASE m_ParentObj; // Not currently used (8-Nov-05) but can't remove without requiring full rebuild.  Do at the end of the day.
      DATABASEHANDLE* m_DBHandle;
      OBJITEM m_DBObjItem;
      int m_TableID;    // Actually the table number
      
      DATABASEHANDLE* GetDBHandle() const {return (m_DBHandle);}

      virtual bool v_IsValidTable (const RVC::DBTABLE& table);
      virtual bool v_IsObjectOpen () const;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class TABLELIST;

      enum RECACC {
         RECACC_RecordNum,
         RECACC_Cursor,
         RECACC_Bookmark
         };

      virtual ERRVALUE v_CloseObject ();
      virtual ERRVALUE v_GetDescriptor (RVC::DESCRIPTOR& Descriptor, const CREDENTIALS *pCredentials) const;
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual ERRVALUE v_GetParent (RVC::OBJECT& ObjParent) const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenMode, MDLGPARENT parent, const CREDENTIALS *pCredentials);

      ERRVALUE CopyRecordAttachmentsLow (
         const RVC::DBTABLE* SrcTable1,
         TABLEJOININFO* TableJoinInfo1,
         const RVC::DBTABLE* SrcTable2,
         TABLEJOININFO* TableJoinInfo2,
         DBASE::JOINFLAGS
         );


      INT32 GetRecordSize () const;

      // Joins "this" table to another database
      // can return number of records?
      INT32 AppendTo (
         RVC::DBASE& DestDBase,
         const BITSET& recbit,
         RVC::DBTRANSINFO& TransInfo,
         RVC::DBTABLE::TABLELIST* TableEntry,
         INT32& rNextElemID,
         RVC::DBASE::JOINFLAGS flags
         );

      static INT32 TestIsJoinable (
         const DBTABLE& src,
         const DBTABLE& dest,
         TABLELIST* TableEntry,
         RVC::DBASE::COPYFLAG CopyFlags,
         RVC::DBASE::JOINFLAGS JoinFlags
         );
         
      ERRVALUE Read (
         CURSOR* cursor,
         INT32 RecordNum,
         const BOOKMARK* bookmark,
         RECORD& Record,
         RECACC flags
         ) const;

      INT32 SearchIndex (
         INT32 FieldNum,
         void* buf,
         const FIELDINFO* finfo,
         INT32& offset, 
         INDEXSEARCH flag = INDEXSEARCH_ReturnIndexOffset,
         CHAR_ENCODING = CHAR_ENCODING_ASCII
         ) const;

      static void TableCallbackFunc (DBCALLBACKSTRUCT *cb, void *data);

      ERRVALUE Write (
         CURSOR* cursor,
         INT32 RecordNum,
         const BOOKMARK* bookmark,
         RECORD& Record,
         RECACC flags
         );

      ERRVALUE WriteBinary (
         CURSOR* cursor,
         INT32 RecordNum,
         const BOOKMARK* bookmark,
         INT32 FieldNum,
         const SIMPLE_ARRAY<UINT8>& binary,
         RECACC flags
         );

      ERRVALUE WriteMemo (
         CURSOR* cursor,
         INT32 RecordNum,
         const BOOKMARK* bookmark,
         INT32 FieldNum,
         const MISTRING& string,
         RECACC flags
         );

      friend class CURSOR;
      friend class DBASE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   
   };


class DBTABLE::BOOKMARK {
   public:
      
      explicit BOOKMARK (
         UINT32 Bookmark = 0
         ) : m_Bookmark(Bookmark) {}
   
      BOOKMARK (
         const BOOKMARK& rhs
         ) : m_Bookmark(rhs.m_Bookmark) {}

      BOOKMARK& operator= (
         const BOOKMARK& rhs
         ) {
         if (this != &rhs) m_Bookmark = rhs.m_Bookmark;
         return (*this);
         }
   
      bool operator== (
         const BOOKMARK& rhs
         ) const {return (m_Bookmark == rhs.m_Bookmark);}
      
      UINT32 GetValue (
         ) const { return m_Bookmark; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT32 m_Bookmark;
   
      friend class DBTABLE;
      friend class DBTABLE::CURSOR;
      friend class DBTABLE::RECORD;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class DBTABLE::CURSOR {
   public:
      enum FUNCTION {
         FUNCTION_None =         0x00000000,
         FUNCTION_Unique =       0x00000001,
         FUNCTION_Sorted =       0x00000002,
         FUNCTION_Equal =        0x00000004,
         FUNCTION_GreaterThan =  0x00000008,
         FUNCTION_LessThan =     0x00000010,
         FUNCTION_NotEqual =     0x00000020,
         FUNCTION_AND =          0x00000040,
         FUNCTION_OR =           0x00000080,
         FUNCTION_NoClear =      0x00000100, 
         FUNCTION_ForUpdate =    0x00000200  
         };
      
      enum INDEXFLAG {
         INDEXFLAG_None = 0,
         INDEXFLAG_IndexOffset = 0x00000001, //<! Give index offset indstead of record number
         INDEXFLAG_LeaveRunBit = 0x00000002 //<! Leave the high bit set on the record number if the record is the first in a run of same-value records
         };

      explicit CURSOR (
         const RVC::DBTABLE& table
         );
         
      ~CURSOR (
         );
         
      bool operator== (
         const CURSOR& rhs
         ) const;
         
      ERRVALUE GetBookmark (
         BOOKMARK& Bookmark
         ) const;
         
      ERRVALUE GetIndex (
         INT32& Index,
         INDEXFLAG flags = INDEXFLAG_None
         ) const;

   #ifndef NO_DEPRECATED
      DEPRECATED INT32 GetRecordNum (
         ) const;
   #endif
         
      bool IsDone (
         ) const { return (!IsValid()); }

      bool IsValid (
         ) const;

      int Next (
         );
         
      ERRVALUE Rewind (
         );

      INT32 SeekValue (
         INT32 FieldNum,
         const void* vbuf,
         const FIELDINFO* finfo,
         bool bSingleField = true
         );

      INT32 SeekValue (
         INT32 FieldNum,
         const MISTRING& value
         );

      ERRVALUE SetFunction (
         INT32 FieldNum,
         FUNCTION Function
         );
   
      ERRVALUE SetSort (
         const SIMPLE_ARRAY<INT32>& FieldList   
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const DBTABLE& m_Table;

      class PRIV;

      PRIV* m_Cursor;   

      CURSOR (const CURSOR& rhs);
      CURSOR& operator=(const CURSOR& rhs);
      
      friend class DBTABLE;
      friend class DBTABLE::RECORD;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

class DBTABLE::GETOBJFILTER_ISSELECTABLE : public RVC::GETOBJFILTER {
   public:
      GETOBJFILTER_ISSELECTABLE() : GETOBJFILTER() { }
      virtual ~GETOBJFILTER_ISSELECTABLE() { }

   private:
      virtual bool v_IsSelectable (
         const RVC::OBJITEM& objitem,
         int position
         );

      virtual bool v_HasSelectableSubObjects (
         const RVC::OBJITEM& objitem
         );

      virtual bool v_IsValidParent (
         const RVC::OBJITEM& objitem
         );
   };

class DBTABLE::GETOBJFILTER_ISUSAGEVALID : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISUSAGEVALID (
         const RVC::OBJITEM& DBaseObjItem,
         const USAGESET& UsageSet
         );
         
      virtual ~GETOBJFILTER_ISUSAGEVALID () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const RVC::OBJITEM& m_DBaseObjItem;
      RVC::DBASE m_DBaseObj;
      const USAGESET m_UsageSet;
      
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class DBTABLE::GETOBJFILTER_ISUSERDEFINED : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISUSERDEFINED (
         const RVC::OBJITEM& DBaseObjItem
         );
         
      virtual ~GETOBJFILTER_ISUSERDEFINED () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      GETOBJFILTER_ISUSAGEVALID m_UsageValidFilter;
      
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class DBTABLE::LINKPARMS {
   public:

      enum LINKFLAG {
         LINKFLAG_None =            0,
         LINKFLAG_KeepPassword =    0x00800000
         };

      LINKPARMS (
         const FILEPATH& filepath,              
         DBTABLE::LINKTYPE LinkType,            
         CHAR_ENCODING Encoding,                
         LINKFLAG LinkFlag = LINKFLAG_None,     
         char Delimiter = ','                   
         );

      LINKPARMS (
         const MISTRING& LinkString,            
         DBTABLE::LINKTYPE LinkType,            
         CHAR_ENCODING Encoding,                
         LINKFLAG LinkFlag = LINKFLAG_None,     
         char Delimiter = ','                   
         );
   
      ~LINKPARMS ();

      char GetDelimiter () const
         { return (m_Delimiter); }

      CHAR_ENCODING GetEncoding () const
         { return (m_Encoding); }

      LINKFLAG GetLinkFlag () const
         { return (m_LinkFlag); }

      const MISTRING& GetLinkString () const
         { return (m_LinkString); }

      DBTABLE::LINKTYPE GetLinkType () const
         { return (m_LinkType); }

   private: 
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTRING m_LinkString;
      DBTABLE::LINKTYPE m_LinkType;
      CHAR_ENCODING m_Encoding;
      LINKFLAG m_LinkFlag;
      char m_Delimiter;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================
// DBTABLE::MAKEPARMS and derived classes

class DBTABLE::MAKEPARMS {
   public:  
      MAKEPARMS (
         const DBTABLE::FIELDINFOARRAY& FieldInfoArray,
         DBTABLE::ATTACHMENT Attachment = ATTACHMENT_RelatedOnly,
         CHAR_ENCODING Encoding = CHAR_ENCODING_ASCII,
         DBTABLE::USAGE Usage = USAGE_UserDefined
         ) :
         m_FieldInfoArray(FieldInfoArray),
         m_Attachment(Attachment),
         m_Encoding(Encoding),
         m_Usage(Usage),
         m_RefElem(REFELEM_All),
         m_LinkObject(0),
         m_LinkType(LINKTYPE_Internal),
         m_Delimiter(0),
         m_bPromptTable(false),
         m_UseFieldNamesAsHeading(false)
         {}
         
      MAKEPARMS (
         DBTABLE::ATTACHMENT Attachment = ATTACHMENT_RelatedOnly,
         CHAR_ENCODING Encoding = CHAR_ENCODING_ASCII,
         DBTABLE::USAGE Usage = USAGE_UserDefined
         ) :
         m_Attachment(Attachment),
         m_Encoding(Encoding),
         m_Usage(Usage),
         m_RefElem(REFELEM_All),
         m_LinkObject(0),
         m_LinkType(LINKTYPE_Internal),
         m_Delimiter(0),
         m_bPromptTable(false),
         m_UseFieldNamesAsHeading(false)
         {}
         
      MAKEPARMS (
         const DBTABLE& Template
         );
         
      virtual ~MAKEPARMS (){}

      DBTABLE::ATTACHMENT GetAttachmentType (
         ) const {return (m_Attachment);}

      char GetDelimiter (
         ) const { return (m_Delimiter); }

      CHAR_ENCODING GetEncoding (
         ) const {return (m_Encoding);}

      const DBTABLE::FIELDINFOARRAY& GetFieldInfo (
         ) const {return (m_FieldInfoArray);}

      const MISTRING& GetLinkFile (
         ) const {return (m_NewLinkFile);}
         
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const RVC::OBJECT* GetLinkObject (
         ) const {return (m_LinkObject);}
      #endif // GENERATING_DOXYGEN_OUTPUT
         
      DBTABLE::LINKTYPE GetLinkType (
         ) const {return (m_LinkType);}
         
      bool GetPromptOnAddElement (
         ) const { return m_bPromptTable; }

      DBTABLE::REFELEM GetReferenceElement (
         ) const {return (m_RefElem);}
         
      DBTABLE::USAGE GetUsage (
         ) const {return (m_Usage);}

      bool GetUseFieldNamesAsHeading () const
         { return (m_UseFieldNamesAsHeading); }

      void SetAttachmentType (
         ATTACHMENT Attachment
         ) {m_Attachment = ((Attachment == ATTACHMENT_Unknown) ? ATTACHMENT_NoRestrictions : Attachment);}

      void SetDelimiter (
         char delim
         ) { m_Delimiter = delim; }

      void SetEncoding (
         CHAR_ENCODING Encoding
         ) {m_Encoding = Encoding;}

      void SetFieldInfo (
         const FIELDINFOARRAY& FieldInfoArray
         ) {m_FieldInfoArray = FieldInfoArray;}

      void SetLinkFile (
         const MISTRING& filename
         ) {m_NewLinkFile = filename;}
         
      void SetLinkType (
         LINKTYPE LinkType
         ) {m_LinkType = LinkType;}
         
      void SetPromptOnAddElement (
         bool prompt = true
         ) { m_bPromptTable = prompt; }

      void SetReferenceElement (
         REFELEM RefElem
         ) {m_RefElem = RefElem;}
         
      void SetUsage (
         USAGE Usage
         ) {m_Usage = Usage;}

      void SetUseFieldNamesAsHeading (
         bool UseFieldNamesAsHeading
         ) { m_UseFieldNamesAsHeading = UseFieldNamesAsHeading; }
         
   protected:

      DBTABLE::FIELDINFOARRAY& GetFieldArray (
         ) {return (m_FieldInfoArray);}
         
      void SetLinkObject (
         const OBJECT& object
         ) {m_LinkObject = &object;}
         
      void SetupRelatedFields (
         const DBTABLE& RelTable,
         INT32 RelFieldNum,
         FIELDINFO::FLAGS RelFieldFlags,           
         INT32 FirstFieldNum,
         INT32 NumStaticFields,
         bool UseRelatedSingle
         );
         
   private: 
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FIELDINFOARRAY m_FieldInfoArray;
      DBTABLE::ATTACHMENT m_Attachment;
      CHAR_ENCODING m_Encoding;
      DBTABLE::USAGE m_Usage;
      DBTABLE::REFELEM m_RefElem;
      const OBJECT* m_LinkObject;
      DBTABLE::LINKTYPE m_LinkType;
      MISTRING m_NewLinkFile;
      char m_Delimiter; 
      bool m_bPromptTable;
      bool m_UseFieldNamesAsHeading;

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

class DBTABLE::MAKEPARM_ID_ELEMENT : public RVC::DBTABLE::MAKEPARMS {
   public:  
      MAKEPARM_ID_ELEMENT ();
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_ID_POINT : public RVC::DBTABLE::MAKEPARMS {
   public:  
      MAKEPARM_ID_POINT ();
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_STYLE_ELEMENT : public RVC::DBTABLE::MAKEPARMS {
   public:

      static void SetupStaticFields (
         FIELDINFOARRAY& FieldInfoArray,           
         USAGE Usage                               
         );

      MAKEPARM_STYLE_ELEMENT (
         const RVC::DBTABLE& RelTable,             
         INT32 RelFieldNum,                        
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,  
         USAGE Usage,                              
         bool UseRelatedSingle
         );

      MAKEPARM_STYLE_ELEMENT (
         const RVC::DBTABLE& RelTable,             
         INT32 RelFieldNum,                        
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,  
         const RVC::STYLE& StyleObj,               
         USAGE Usage,                              
         bool UseRelatedSingle
         );

      void SetStyleLink (
         const RVC::STYLE& StyleObj                
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      void Setup (
         const RVC::DBTABLE& RelTable,             
         INT32 RelFieldNum,                        
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,  
         USAGE Usage,                              
         bool UseRelatedSingle
         );
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_STYLE_CAD : public RVC::DBTABLE::MAKEPARM_STYLE_ELEMENT {
   public:
      MAKEPARM_STYLE_CAD (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         const RVC::STYLE& StyleObj,
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, StyleObj, USAGE_MultiStyle, UseRelatedSingle) {}
      MAKEPARM_STYLE_CAD (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, USAGE_MultiStyle, UseRelatedSingle) {}
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_STYLE_LINE : public RVC::DBTABLE::MAKEPARM_STYLE_ELEMENT {
   public:
      MAKEPARM_STYLE_LINE (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         const RVC::STYLE& StyleObj,
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, StyleObj, USAGE_LineStyle, UseRelatedSingle) {}
      MAKEPARM_STYLE_LINE (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, USAGE_LineStyle, UseRelatedSingle) {}
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_STYLE_POINT : public RVC::DBTABLE::MAKEPARM_STYLE_ELEMENT {
   public:
      MAKEPARM_STYLE_POINT (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         const RVC::STYLE& StyleObj,
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, StyleObj, USAGE_PointStyle, UseRelatedSingle) {}
      MAKEPARM_STYLE_POINT (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, USAGE_PointStyle, UseRelatedSingle) {}
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_STYLE_POLYGON : public RVC::DBTABLE::MAKEPARM_STYLE_ELEMENT {
   public:
      MAKEPARM_STYLE_POLYGON (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         const RVC::STYLE& StyleObj,
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, StyleObj, USAGE_PolyStyle, UseRelatedSingle) {}
      MAKEPARM_STYLE_POLYGON (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         bool UseRelatedSingle
         ) : MAKEPARM_STYLE_ELEMENT(RelTable, RelFieldNum, RelFieldFlags, USAGE_PolyStyle, UseRelatedSingle) {}
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_SCALESELECT : public RVC::DBTABLE::MAKEPARMS {
   public:  
      MAKEPARM_SCALESELECT (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         bool UseRelatedSingle
         );
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_SELECTION : public RVC::DBTABLE::MAKEPARMS {
   public:  
      MAKEPARM_SELECTION (
         const RVC::DBTABLE& RelTable,
         INT32 RelFieldNum,
         DBTABLE::FIELDINFO::FLAGS RelFieldFlags,           
         bool UseRelatedSingle
         );
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_LEGENDELEMENT : public RVC::DBTABLE::MAKEPARMS {
   public:
      MAKEPARM_LEGENDELEMENT (
         );
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_NODETURN : public RVC::DBTABLE::MAKEPARMS {
   public:
      MAKEPARM_NODETURN (
         );
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::MAKEPARM_ORACLE : public DBTABLE::MAKEPARMS {
   public:
      MAKEPARM_ORACLE (
         ) : MAKEPARMS(ATTACHMENT_RelatedOnly, CHAR_ENCODING_UTF8) { 
         SetLinkType(LINKTYPE_ORACLE); 
         }
         
      MAKEPARM_ORACLE (
         const DBTABLE::FIELDINFOARRAY& FieldInfoArray
         ) : MAKEPARMS(FieldInfoArray, ATTACHMENT_RelatedOnly, CHAR_ENCODING_UTF8) {
         SetLinkType(LINKTYPE_ORACLE); 
         }
   
      MAKEPARM_ORACLE (
         const DBTABLE& Template
         ) : MAKEPARMS(Template) {
         SetLinkType(LINKTYPE_ORACLE);
         SetAttachmentType(ATTACHMENT_RelatedOnly);
         SetUsage(USAGE_UserDefined);
         }
   };
   

//===================================================================================================================
// DBTABLE::RECORD and derived classes

class DBTABLE::RECORD {
   public:

      enum FIELDFLAG {
         FIELDFLAG_None =           0x0000,
         FIELDFLAG_NaN =            0x0010,  
         FIELDFLAG_NoUnitConv =     0x0020,  
         FIELDFLAG_MultiKey =       0x0040,  
         FIELDFLAG_LocalTime =      0x0080,  
         FIELDFLAG_MemoEncoding =   0x8000   
         };

      // Container for either string or numeric value.
      class VALUE {
         public:
            enum TYPE {
               TYPE_Invalid,
               TYPE_Double,
               TYPE_String,
               TYPE_DateTime,
               TYPE_Color
               };

            VALUE (
               ) : m_type(TYPE_Invalid), m_pValue(0) { }
            VALUE (
               const VALUE& rhs
               ) { Copy(rhs); }
            VALUE (
               double value
               ) : m_type(TYPE_Double), m_pValue(new double(value)) { }
            VALUE (
               const MISTRING& value
               ) : m_type(TYPE_String), m_pValue(new MISTRING(value)) { }
            VALUE (
               const DATETIME& value
               ) : m_type(TYPE_String), m_pValue(new DATETIME(value)) { }
            VALUE (
               const COLOR& value
               ) : m_type(TYPE_String), m_pValue(new COLOR(value)) { }
            ~VALUE ()
               { Free(); }
            VALUE& operator= (const VALUE& rhs)
               { if (this != &rhs) { Free(); Copy(rhs); return (*this); } }
            VALUE& operator= (double rhs)
               { Free(); m_type = TYPE_Double; m_pValue = new double(rhs); return (*this); }
            VALUE& operator= (const MISTRING& rhs)
               { Free(); m_type = TYPE_String; m_pValue = new MISTRING(rhs); return (*this); }
            VALUE& operator= (const DATETIME& rhs)
               { Free(); m_type = TYPE_DateTime; m_pValue = new DATETIME(rhs); return (*this); }
            VALUE& operator= (const COLOR& rhs)
               { Free(); m_type = TYPE_Color; m_pValue = new COLOR(rhs); return (*this); }
            bool operator== (const VALUE& rhs) const
               { return (IsEqual(rhs)); }
            bool operator!= (const VALUE& rhs) const
               { return (!IsEqual(rhs)); }
            bool operator< (const VALUE& rhs) const;
            COLOR GetColor () const { return ((m_type == TYPE_Color) ? *static_cast<const COLOR*>(m_pValue) : COLOR()); }
            DATETIME GetDateTime () const { return ((m_type == TYPE_DateTime) ? *static_cast<const DATETIME*>(m_pValue) : DATETIME()); }
            double GetDouble () const { return ((m_type == TYPE_Double) ? *static_cast<const double*>(m_pValue) : 0); }
            const MISTRING& GetString () const { return ((m_type == TYPE_String) ? *static_cast<const MISTRING*>(m_pValue) : MISTRING::GetEmpty()); }
            TYPE GetType () const
               { return (m_type); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            TYPE m_type;
            void *m_pValue;

            void Copy (const VALUE& rhs);
            void Free ();
            bool IsEqual (const VALUE& rhs) const;
            #endif
         };

   
      RECORD (
         );
         
      RECORD (
         const RECORD& rhs
         );
         
      RECORD (
         const RVC::DBTABLE& table
         );

      virtual ~RECORD (
         );
         
      RECORD& operator= (
         const RECORD& rhs
         );    
      
      bool operator== (
         RECORD& rhs
         );    
      
      //bcolombe: added new CompareRecords function which works same as operator== but takes threshold value
      bool CompareRecords (
         RECORD& rhs,
         double threshhold = 0.0
         );

      bool operator!= (
         RECORD& rhs
         ) { return (!(*this == rhs)); }
      
      ERRVALUE AssignTable (
         const RVC::DBTABLE& table
         );
         
      void Clear (
         );

      void ClearAttachment ();

      bool CompareField (
         INT32 FieldNum,
         const RECORD& record,
         double threshhold = 0.0
         ) const;

      INT32 CompareFieldOrdered (
         INT32 FieldNum,
         const RECORD& record,
         double threshhold = 0.0
         ) const;

      INT32 ComputeHash (
         ) const;

      ERRVALUE CopyMatchingFieldsTo (
         RECORD& DestRecord
         ) const;

      ERRVALUE CopyTo (
         RECORD& DestRecord
         ) const;

      ERRVALUE Initialize (
         );

      void GetData (
         SIMPLE_ARRAY<UINT8>& Data
         ) const;

      const FIELDINFO& GetFieldInfo (
         INT32 FieldNum
         ) const;

      INT32 GetRecordNumber (
         ) const;

      inline const DBTABLE *GetTable (
         ) const { return (m_Table); }

      INT32 GetTableNumber (
         ) const;

      ERRVALUE GetValue (
         INT32 FieldNum,
         RECORD::VALUE& value,
         FIELDFLAG FieldFlag = FIELDFLAG_None
         ) const;

      ERRVALUE GetValue (
         INT32 FieldNum,
         MISTRING& string,
         FIELDFLAG FieldFlag = FIELDFLAG_None,
         int DecimalPlaces = -1,
         const UNITCONV* UnitConv = 0
         ) const;

      double GetValue (
         INT32 FieldNum,
         FIELDFLAG FieldFlag = FIELDFLAG_None
         ) const;
         
      ERRVALUE GetValue (
         INT32 FieldNum,
         COLOR& color
         ) const;

      ERRVALUE GetValue (
         INT32 FieldNum,
         DATETIME& datetime
         ) const;

      ERRVALUE GetValueBinary (
         INT32 FieldNum,
         SIMPLE_ARRAY<UINT8>& binary
         ) const;

      ERRVALUE GetValueImage (
         INT32 FieldNum,
         SPATMOD::IMAGE::STAGE*& pImage,     
         bool bForThumbnail = false,
         INT32 MaxThumbnailSize = 100
         ) const;

      bool IsAssigned (
         ) const;

      ERRVALUE SetKeyValues (
         INT32 StartFieldNum,
         const RECORD& SourceRecord
         );
         
      void SetData (
         const SIMPLE_ARRAY<UINT8>& Data
         );

   #ifndef NO_DEPRECATED
      DEPRECATED void SetData (
         const void* buf
         );
   #endif

      ERRVALUE SetValue (
         INT32 FieldNum,
         const RECORD::VALUE& value,
         FIELDFLAG FieldFlag = FIELDFLAG_None
         );

      ERRVALUE SetValue (
         INT32 FieldNum,
         const COLOR& color
         );

      ERRVALUE SetValue (
         INT32 FieldNum,
         const DATETIME& datetime
         ) ;

      ERRVALUE SetValue (
         INT32 FieldNum,
         const MISTRING& string,
         FIELDFLAG FieldFlag = FIELDFLAG_None,
         const UNITCONV* conv = 0
         );

      void SetValue (
         INT32 FieldNum,
         double value,
         bool NoUnitConv = false
         );
         
      ERRVALUE SetValue (
         INT32 FieldNum,
         const RECORD& SourceRecord,
         INT32 SourceFieldNum
         );
         
      ERRVALUE SetValueBinary (
         INT32 FieldNum,
         const SIMPLE_ARRAY<UINT8>& binary
         ) const;

   protected:
   
      virtual bool IsValidTable (const RVC::DBTABLE& /*table*/) {return (true);}
   
      const void *const GetFieldPtr (
         INT32 FieldNum
         ) const;

      void *GetFieldPtr (
         INT32 FieldNum
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      struct BINARY {
         SIMPLE_ARRAY<UINT8> m_Binary;
         INT32 m_FieldNum;
         bool m_HasChanged;
         
         BINARY () : m_FieldNum(-1), m_HasChanged(false) {}
         };

      struct MEMO {
         MISTRING m_Memo;
         INT32 m_FieldNum;
         bool m_HasChanged;
         
         MEMO () : m_FieldNum(-1), m_HasChanged(false) {}
         };

      mutable void *m_Buffer;
      const DBTABLE* m_Table;
      RVC::DBTABLE::FIELDINFOARRAY m_DBFields;
      INT32 m_RecordNum;
      CURSOR* m_Cursor;
      BOOKMARK m_Bookmark;
      UINT32 m_Flags;
      int m_BufSize;
      mutable BITSET m_CompFieldRead;
      mutable MILIST<MEMO> m_MemoList;
      class TABLEOBSERVER;
      friend class TABLEOBSERVER;
      TABLEOBSERVER* m_TableObserver;
      mutable MILIST<BINARY> m_BinaryList;
      CHAR_ENCODING m_TableEncoding;
      
      INT32 CompareBinaryField (INT32 FieldNum, const RECORD& record) const;
      INT32 CompareMemoField (INT32 FieldNum, const RECORD& record) const;
      ERRVALUE ReadComputed (INT32 FieldNum) const;
      ERRVALUE ReadMemo (MEMO& Memo, INT32 FieldNum) const;
      ERRVALUE ReadBinary (BINARY& Binary, INT32 FieldNum) const;
      friend class DBTABLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_ID_ELEMENT : public RVC::DBTABLE::RECORD {
   public:
   
      RECORD_ID_ELEMENT (
         ) : RECORD() {}
   
      RECORD_ID_ELEMENT (
         const RECORD_ID_ELEMENT& rhs
         ) : RECORD(rhs) {}
         
      RECORD_ID_ELEMENT (
         const RECORD& rhs
         ) : RECORD(rhs) {}
         
      RECORD_ID_ELEMENT (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}

      virtual ~RECORD_ID_ELEMENT (
         ) {}
   
      RECORD_ID_ELEMENT& operator= (
         const RECORD_ID_ELEMENT& rhs
         ) {
         RECORD::operator=(rhs);
         return (*this);
         }
      
      INT32 GetCurrent (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(0)));}
         
      INT32 GetOriginal (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(1)));}
         
      void SetCurrent (
         INT32 current
         ) {*static_cast<INT32*>(GetFieldPtr(0)) = current;}
         
      void SetOriginal (
         INT32 original
         ) {*static_cast<INT32*>(GetFieldPtr(1)) = original;}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (const RVC::DBTABLE& table) {return (table.GetUsage() == DBTABLE::USAGE_ElementID);}
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_ID_POINT : public RVC::DBTABLE::RECORD {
   public:
   
      RECORD_ID_POINT (
         ) : RECORD() {}
   
      RECORD_ID_POINT (
         const RECORD_ID_POINT& rhs
         ) : RECORD(rhs) {}
         
      RECORD_ID_POINT (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}
         
      virtual ~RECORD_ID_POINT (
         ) {}
   
      RECORD_ID_POINT& operator= (
         const RECORD_ID_POINT& rhs
         ) {      
         RECORD::operator=(rhs);
         return (*this);
         }
      
      INT32 GetCurrent (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(0)));}
         
      void SetCurrent (
         INT32 current
         ) {*static_cast<INT32*>(GetFieldPtr(0)) = current;}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (const RVC::DBTABLE& table) {return (table.GetUsage() == DBTABLE::USAGE_ElementID);}
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_STYLE_ELEMENT : public RVC::DBTABLE::RECORD {
   public:
      RECORD_STYLE_ELEMENT (
         ) : RECORD() {}
   
      RECORD_STYLE_ELEMENT (
         const RECORD_STYLE_ELEMENT& rhs
         ) : RECORD(rhs) {}
         
      RECORD_STYLE_ELEMENT (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}
         
      virtual ~RECORD_STYLE_ELEMENT (
         ) {}
   
      RECORD_STYLE_ELEMENT& operator= (
         const RECORD_STYLE_ELEMENT& rhs
         ) {      
         RECORD::operator=(rhs);
         return (*this);
         }
         
      static INT32 GetRelationFieldNum (
         ) {return (SAFIELD_SINGLE_RelField);}
      
      static INT32 GetSelectionFieldNum (
         ) {return (SAFIELD_SINGLE_DrawFlag);}
   
      INT32 GetStyleIndex (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(SAFIELD_SINGLE_StyleIndex)));}

      const RVC::OBJECTNAME& GetStyleName (
         ) const {return (*static_cast<const OBJECTNAME*>(GetFieldPtr(SAFIELD_SINGLE_StyleName)));}

      bool IsSelected (
         ) const {return (*static_cast<const INT8*>(GetFieldPtr(SAFIELD_SINGLE_DrawFlag)) != 0);}

      ERRVALUE SetRelationValues (
         const RECORD& record
         ) {return (SetKeyValues(SAFIELD_SINGLE_RelField, record));}
      
      void SetSelected (
         bool Selected
         ) {*static_cast<INT8*>(GetFieldPtr(SAFIELD_SINGLE_DrawFlag)) = Selected;}
         
      void SetStyleIndex (
         INT32 index
         ) {*static_cast<INT32*>(GetFieldPtr(SAFIELD_SINGLE_StyleIndex)) = index;}

      void SetStyleName (
         const RVC::OBJECTNAME& name
         ) {*static_cast<OBJECTNAME*>(GetFieldPtr(SAFIELD_SINGLE_StyleName)) = name;}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (
         const RVC::DBTABLE& table
         ) {
         DBTABLE::USAGE usage = table.GetUsage();
         return (usage == DBTABLE::USAGE_PointStyle || usage == DBTABLE::USAGE_LineStyle || usage == DBTABLE::USAGE_PolyStyle);
         }
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_STYLE_CAD : public RVC::DBTABLE::RECORD {
   public:
      RECORD_STYLE_CAD (
         ) : RECORD() {}
   
      RECORD_STYLE_CAD (
         const RECORD_STYLE_CAD& rhs
         ) : RECORD(rhs) {}
         
      RECORD_STYLE_CAD (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}
         
      virtual ~RECORD_STYLE_CAD (
         ) {}
   
      RECORD_STYLE_CAD& operator= (
         const RECORD_STYLE_CAD& rhs
         ) {      
         RECORD::operator=(rhs);
         return (*this);
         }
         
      INT32 GetLineStyleIndex (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(SAFIELD_CAD_LineStyleIndex)));}

      const RVC::OBJECTNAME& GetLineStyleName (
         ) const {return (*static_cast<const OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_LineStyleName)));}

      INT32 GetPointStyleIndex (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(SAFIELD_CAD_PointStyleIndex)));}

      const RVC::OBJECTNAME& GetPointStyleName (
         ) const {return (*static_cast<const OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_PointStyleName)));}

      INT32 GetPolyStyleIndex (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(SAFIELD_CAD_PolyStyleIndex)));}

      const RVC::OBJECTNAME& GetPolyStyleName (
         ) const {return (*static_cast<const OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_PolyStyleName)));}

      static INT32 GetRelationFieldNum (
         ) {return (SAFIELD_CAD_RelField);}
      
      static INT32 GetSelectionFieldNum (
         ) {return (SAFIELD_CAD_DrawFlag);}
   
      INT32 GetStyleIndex (
         RVC::STYLETYPE StyleType
         ) const {
         switch (StyleType) {
            case STYLETYPE_Point: return (GetPointStyleIndex());
            case STYLETYPE_Line: return (GetLineStyleIndex());
            case STYLETYPE_Polygon: return (GetPolyStyleIndex());
            case STYLETYPE_Text: return (GetTextStyleIndex());
            }
         return (-1);
         }

      const RVC::OBJECTNAME& GetStyleName (
         RVC::STYLETYPE StyleType
         ) const {
         switch (StyleType) {
            case STYLETYPE_Point: return (GetPointStyleName());
            case STYLETYPE_Line: return (GetLineStyleName());
            case STYLETYPE_Polygon: return (GetPolyStyleName());
            }
         return (GetTextStyleName());     
         }

      INT32 GetTextStyleIndex (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(SAFIELD_CAD_TextStyleIndex)));}

      const RVC::OBJECTNAME& GetTextStyleName (
         ) const {return (*static_cast<const OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_TextStyleName)));}

      bool IsSelected (
         ) const {return (*static_cast<const INT8*>(GetFieldPtr(SAFIELD_CAD_DrawFlag)) != 0);}

      void SetLineStyleIndex (
         INT32 index
         ) {*static_cast<INT32*>(GetFieldPtr(SAFIELD_CAD_LineStyleIndex)) = index;}

      void SetLineStyleName (
         const RVC::OBJECTNAME& name
         ) {*static_cast<OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_LineStyleName)) = name;}

      void SetPointStyleIndex (
         INT32 index
         ) {*static_cast<INT32*>(GetFieldPtr(SAFIELD_CAD_PointStyleIndex)) = index;}

      void SetPointStyleName (
         const RVC::OBJECTNAME& name
         ) {*static_cast<OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_PointStyleName)) = name;}

      void SetPolyStyleIndex (
         INT32 index
         ) {*static_cast<INT32*>(GetFieldPtr(SAFIELD_CAD_PolyStyleIndex)) = index;}

      void SetPolyStyleName (
         const RVC::OBJECTNAME& name
         ) {*static_cast<OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_PolyStyleName)) = name;}

      ERRVALUE SetRelationValues (
         const RECORD& record
         ) {return (SetKeyValues(SAFIELD_CAD_RelField, record));}
      
      void SetSelected (
         bool Selected
         ) {*static_cast<INT8*>(GetFieldPtr(SAFIELD_CAD_DrawFlag)) = Selected;}
         
      void SetStyleIndex (
         RVC::STYLETYPE StyleType,
         INT32 index
         ) {
         switch (StyleType) {
            case STYLETYPE_Point: SetPointStyleIndex(index); break;
            case STYLETYPE_Line: SetLineStyleIndex(index); break;
            case STYLETYPE_Polygon: SetPolyStyleIndex(index); break;
            case STYLETYPE_Text: SetTextStyleIndex(index); break;
            }
         return;
         }

      void SetStyleName (
         RVC::STYLETYPE StyleType,
         const RVC::OBJECTNAME& name
         ) {
         switch (StyleType) {
            case STYLETYPE_Point: SetPointStyleName(name); break;
            case STYLETYPE_Line: SetLineStyleName(name); break;
            case STYLETYPE_Polygon: SetPolyStyleName(name); break;
            case STYLETYPE_Text: SetTextStyleName(name); break;
            }
         return;
         }

      void SetTextStyleIndex (
         INT32 index
         ) {*static_cast<INT32*>(GetFieldPtr(SAFIELD_CAD_TextStyleIndex)) = index;}

      void SetTextStyleName (
         const RVC::OBJECTNAME& name
         ) {*static_cast<OBJECTNAME*>(GetFieldPtr(SAFIELD_CAD_TextStyleName)) = name;}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (const RVC::DBTABLE& table) {return (table.GetUsage() == DBTABLE::USAGE_MultiStyle);}
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_SCALESELECT : public RVC::DBTABLE::RECORD {
   public:
      RECORD_SCALESELECT (
         ) : RECORD() {}
   
      RECORD_SCALESELECT (
         const RECORD_SCALESELECT& rhs
         ) : RECORD(rhs) {}
         
      RECORD_SCALESELECT (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}
         
      virtual ~RECORD_SCALESELECT (
         ) {}
   
      RECORD_SCALESELECT& operator= (
         const RECORD_SCALESELECT& rhs
         ) {      
         RECORD::operator=(rhs);
         return (*this);
         }
         
      double GetMaxScale (
         ) const {return (*static_cast<const double*>(GetFieldPtr(SCALESELFIELD_MaxScale)));}

      double GetMinScale (
         ) const {return (*static_cast<const double*>(GetFieldPtr(SCALESELFIELD_MinScale)));}

      static INT32 GetRelationFieldNum (
         ) {return (SCALESELFIELD_RelField);}
   
      void SetMaxScale (
         double scale
         ) {*static_cast<double*>(GetFieldPtr(SCALESELFIELD_MaxScale)) = scale;}

      void SetMinScale (
         double scale
         ) {*static_cast<double*>(GetFieldPtr(SCALESELFIELD_MinScale)) = scale;}

      ERRVALUE SetRelationValues (
         const RECORD& record
         ) {return (SetKeyValues(SCALESELFIELD_RelField, record));}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (const RVC::DBTABLE& table) {return (table.GetUsage() == DBTABLE::USAGE_ScaleSelect);}
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_SELECTION : public RVC::DBTABLE::RECORD {
   public:
      RECORD_SELECTION (
         ) : RECORD() {}
   
      RECORD_SELECTION (
         const RECORD_SELECTION& rhs
         ) : RECORD(rhs) {}
         
      RECORD_SELECTION (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}
         
      virtual ~RECORD_SELECTION (
         ) {}
   
      RECORD_SELECTION& operator= (
         const RECORD_SELECTION& rhs
         ) {      
         RECORD::operator=(rhs);
         return (*this);
         }
         
      bool IsSelected (
         ) const {return (*static_cast<const UINT8*>(GetFieldPtr(GetSelectionFieldNum())) != 0);}

      static INT32 GetRelationFieldNum (
         ) {return (1);}
   
      static INT32 GetSelectionFieldNum (
         ) {return (0);}
   
      void SetSelected (
         bool Selected
         ) {*static_cast<UINT8*>(GetFieldPtr(GetSelectionFieldNum())) = Selected;}

      ERRVALUE SetRelationValues (
         const RECORD& record
         ) {return (SetKeyValues(GetRelationFieldNum(), record));}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (const RVC::DBTABLE& table) {return (table.GetUsage() == DBTABLE::USAGE_Selection);}
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_LEGENDELEMENT : public RVC::DBTABLE::RECORD {
   public:

      enum FIELDNUM {
         FIELDNUM_ID =        0,
         FIELDNUM_PriLabel =  1,
         FIELDNUM_SecLabel =  2
         };

      RECORD_LEGENDELEMENT (
         ) : RECORD() {}
   
      RECORD_LEGENDELEMENT (
         const RECORD_LEGENDELEMENT& rhs
         ) : RECORD(rhs) {}
         
      RECORD_LEGENDELEMENT (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}
         
      virtual ~RECORD_LEGENDELEMENT (
         ) {}
   
      RECORD_LEGENDELEMENT& operator= (
         const RECORD_LEGENDELEMENT& rhs
         ) {      
         RECORD::operator=(rhs);
         return (*this);
         }
         
      static INT32 GetFieldNumID (
         ) { return (FIELDNUM_ID); }
   
      static INT32 GetFieldNumPrimaryLabel (
         ) { return (FIELDNUM_PriLabel); }
   
      static INT32 GetFieldNumSecondaryLabel (
         ) { return (FIELDNUM_SecLabel); }

      UINT32 GetID (
         ) const { return (*static_cast<const UINT32*>(GetFieldPtr(FIELDNUM_ID))); }

      ERRVALUE GetPrimaryLabel (
         MISTRING& str
         ) const { return (GetValue(FIELDNUM_PriLabel,str)); }
   
      ERRVALUE GetSecondaryLabel (
         MISTRING& str
         ) const { return (GetValue(FIELDNUM_SecLabel,str)); }
   
      ERRVALUE SetPrimaryLabel (
         const MISTRING& str
         ) { return (SetValue(FIELDNUM_PriLabel,str)); }
   
      ERRVALUE SetSecondaryLabel (
         const MISTRING& str
         ) { return (SetValue(FIELDNUM_SecLabel,str)); }
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (const RVC::DBTABLE& table) { return (table.GetUsage() == DBTABLE::USAGE_LegendElement); }
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//-------------------------------------------------------------------------------------------------------------------

class DBTABLE::RECORD_NODETURN : public RVC::DBTABLE::RECORD {
   public:
   
      RECORD_NODETURN (
         ) : RECORD() {}
   
      RECORD_NODETURN (
         const RECORD_NODETURN& rhs
         ) : RECORD(rhs) {}
         
      RECORD_NODETURN (
         const RECORD& rhs
         ) : RECORD(rhs) {}
         
      RECORD_NODETURN (
         const RVC::DBTABLE& table
         ) : RECORD(table) {}

      virtual ~RECORD_NODETURN (
         ) {}
   
      RECORD_NODETURN& operator= (
         const RECORD_NODETURN& rhs
         ) {
         RECORD::operator=(rhs);
         return (*this);
         }
         
      void DisableTurn (
         ) {*static_cast<double*>(GetFieldPtr(2)) = -1.0;}
      
      INT32 GetLineIn (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(0)));}
         
      INT32 GetLineOut (
         ) const {return (*static_cast<const INT32*>(GetFieldPtr(1)));}
         
      double GetImpedance (
         ) const {return (*static_cast<const double*>(GetFieldPtr(2)));}
         
      void SetLineIn (
         INT32 LineIn
         ) {*static_cast<INT32*>(GetFieldPtr(0)) = LineIn;}
         
      void SetLineOut (
         INT32 LineOut
         ) {*static_cast<INT32*>(GetFieldPtr(1)) = LineOut;}
      
      void SetImpedance (
         double Impedance
         ) {*static_cast<double*>(GetFieldPtr(2)) = Impedance;}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool IsValidTable (const RVC::DBTABLE& table) {return (table.GetUsage() == DBTABLE::USAGE_NodeTurn);}
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class DBTABLE::CONST_RECORDITERATOR {
   public:
      CONST_RECORDITERATOR (
         ) : 
         m_TableObj(0),
         m_Record(0),
         m_NeedRecord(true),
         m_CheckSingle(false),
         m_FieldNum(0),
         m_Cursor(0)
         {}

      virtual ~CONST_RECORDITERATOR (
         ) {
         delete m_Cursor;
         delete m_Record;
         }

      const RECORD& operator* (
         ) const;

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

      CONST_RECORDITERATOR& operator++ (
         );

      bool Done (
         ) const {return (m_Cursor == 0 || !m_Cursor->IsValid());}
         
      ERRVALUE GetBookmark (
         DBTABLE::BOOKMARK& bookmark
         ) const {return (m_Cursor->GetBookmark(bookmark));}

   protected:
      mutable RECORD* m_Record;
      INT32 m_FieldNum;
      CURSOR* m_Cursor;
      mutable bool m_NeedRecord;
      bool m_CheckSingle;
      const DBTABLE* m_TableObj;
      
      void SetupIterator (const RVC::DBTABLE* table, ITERATERECORD IterateRecord, INT32 FieldNum);
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      CONST_RECORDITERATOR (const CONST_RECORDITERATOR& rhs);
      CONST_RECORDITERATOR& operator= (const CONST_RECORDITERATOR& rhs);
      
      friend class DBTABLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class DBTABLE::RECORDITERATOR : public RVC::DBTABLE::CONST_RECORDITERATOR {
   public:

      RECORDITERATOR (
         ) : CONST_RECORDITERATOR() {}

      RECORD& operator* (
         ) {return (*const_cast<RECORD*>(&CONST_RECORDITERATOR::operator*()));}

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

      RECORDITERATOR& operator++ (
         ) {
         CONST_RECORDITERATOR::operator++();
         return (*this);
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      RECORDITERATOR (CONST_RECORDITERATOR& rhs);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class DBTABLE::OBSERVER : public RVC::OBJECTOBSERVER {
   public:

      enum STRUCTCHANGE {
         STRUCTCHANGE_None =              0x00000000,
         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::DBTABLE& dbtable
         ) : OBJECTOBSERVER(dbtable) {}
         
      virtual ~OBSERVER (
         ) {}
         
      virtual void OnBulkModifyBegin (
         ) {return;}
         
      virtual void OnBulkModifyEnd (
         ) {return;}
         
      virtual void OnRecordAdd (
         INT32                               
         ) {return;}
         
      virtual void OnRecordChangeBegin (
         INT32                               
         ) {return;}
         
      virtual void OnRecordChangeEnd (
         INT32                               
         ) {return;}
         
      virtual void OnRecordDeleteBegin (
         INT32                               
         ) {return;}
         
      virtual void OnRecordDeleteEnd (
         INT32                               
         ) {return;}
         
      virtual void OnStructChanged (
         STRUCTCHANGE                        
         ) {return;}

      virtual void OnTableValid (
         bool                                
         ) {return;}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void OnNotifyRaw (UINT32 reason, void *data);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::INDEXSEARCH);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::ITERATERECORD);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::FINDFLAG);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::KEYFLAGS);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::REFELEM);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::RECORD::FIELDFLAG);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::FIELDINFO::FLAGS);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::CONSTRAINT::RANGEFLAG);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::CONSTRAINT::PKTABLE);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::CURSOR::FUNCTION);
DEFINE_ENUM_OP_BITWISE(RVC::DBTABLE::CURSOR::INDEXFLAG);
DEFINE_ENUM_OP_INCREMENT(RVC::DBTABLE::FIELDINFO::TYPE);
#endif

}     // End of RVC namespace

#endif   // INC_RVC_DBTABLE_H

---