dbtable.h

Go to the documentation of this file.

/**
 * \file rvc/dbtable.h
 * \brief interface for the RVC::DBTABLE class.
 *
 * \if NODOC
 * $Id: dbtable.h_v 1.109 2004/10/06 19:52:42 dfriberg Exp $
 *
 * $Log: dbtable.h_v $
 * Revision 1.109  2004/10/06 19:52:42  dfriberg
 * Added DBTABLE::Combine method (uses MfTableCombine)
 *
 * Revision 1.108  2004/09/10 17:06:16  mju
 * Add typedef for STYLE_MULTI for future renaming of classes so not specific to cad.
 *
 * Revision 1.107  2004/06/03 18:06:35  scowan
 * Added break's for inline switch statements.
 *
 * Revision 1.106  2004/05/27 17:56:56  scowan
 * Added inline methods for cad style assign table.
 *
 * Revision 1.105  2004/03/04 18:44:05  scowan
 * Added virtual dtor to filter class.
 *
 * Revision 1.104  2004/02/18 23:02:34  scowan
 * Added clear method to fieldinfo.
 *
 * Revision 1.103  2003/12/03 21:27:53  scowan
 * Added methods to compare structures of two tables.
 *
 * Revision 1.102  2003/10/17 14:56:26  scowan
 * Added another open method.
 *
 * Revision 1.101  2003/10/16 13:45:25  scowan
 * Fixed g++ complaint.
 *
 * Revision 1.100  2003/10/15 19:32:45  scowan
 * Added another get object filter for tables.
 *
 * Revision 1.99  2003/10/07 17:34:27  scowan
 * Object virtual method changes.
 *
 * Revision 1.98  2003/10/06 21:39:18  scowan
 * Added method to invalidate a node turn entry.
 *
 * Revision 1.97  2003/10/01 21:45:46  scowan
 * Added node turn table definition.
 *
 * Revision 1.96  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.95  2003/09/25 21:20:04  dwilliss
 * Fixed doxygen comment
 *
 * Revision 1.94  2003/09/19 22:25:59  scowan
 * Moved get name and get desc to virtual methods.
 *
 * Revision 1.93  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.92  2003/08/20 16:10:02  scowan
 * nc.
 *
 * Revision 1.91  2003/06/25 22:17:57  scowan
 * oops.
 *
 * Revision 1.90  2003/06/25 22:16:45  scowan
 * Added oracle stuff.
 *
 * Revision 1.89  2003/05/21 22:01:23  msmith
 * Added reference to original record for Extruded Points
 * and Influence Sphere.
 *
 * Revision 1.88  2003/05/02 21:25:00  scowan
 * Added methods to style cad class.
 *
 * Revision 1.87  2003/04/09 20:15:33  dwilliss
 * Don't use _T in templates. Mac's ctype.h defines global _T. Thanks Apple!
 *
 * Revision 1.86  2003/03/10 18:08:06  mju
 * Add FIELDINFO::FLAG_None and spell out other flag values.
 *
 * Revision 1.85  2003/01/22 17:01:18  scowan
 * Added method to get the index for a field.
 *
 * Revision 1.84  2002/12/16 17:53:57  scowan
 * Added binary field handling code to the record class.
 *
 * Revision 1.83  2002/12/03 17:06:41  scowan
 * Added more comments.
 *
 * Revision 1.82  2002/10/18 22:06:23  vdronov
 * modifyed extruded points design
 *
 * Revision 1.81  2002/10/17 22:23:16  vdronov
 * added INFLUENCE_SPHERE
 *
 * Revision 1.80  2002/10/03 22:09:29  mju
 * Make ctor public in makeparm for style_element.
 *
 * Revision 1.79  2002/09/05 20:53:13  vdronov
 * changed EXTRUDED_POINTS and PARAMETERS_SELECT
 *
 * Revision 1.78  2002/08/28 14:15:40  scowan
 * nc.
 *
 * Revision 1.77  2002/08/21 20:39:04  scowan
 * Deprecate old object name define.
 *
 * Revision 1.76  2002/08/19 15:13:28  scowan
 * Fixed g++ 3.1 warnings.
 *
 * Revision 1.75  2002/08/13 21:37:18  scowan
 * Moved database include file.
 *
 * Revision 1.74  2002/04/22 17:52:56  scowan
 * Added twin open method.
 *
 * Revision 1.73  2002/04/18 16:29:11  scowan
 * Added open using database id methods.
 *
 * Revision 1.72  2002/04/15 17:01:45  scowan
 * Add methods for record table and record numbers.
 *
 * Revision 1.71  2002/04/12 14:14:44  scowan
 * Include enum defines for select and style mode.
 *
 * Revision 1.51  2002/03/13 21:36:34  vdronov
 * added get/set methods for flightpath and pointofinterest
 *
 * Revision 1.50  2002/03/08 23:02:14  vdronov
 * added records for flightpath and pointofinterest
 *
 * Revision 1.49  2002/03/08 22:34:50  vdronov
 * added makeparms for flightpath and pointofinterest
 *
 * Revision 1.48  2002/03/08 17:49:57  dwilliss
 * added USAGEs for flight paths
 *
 * Revision 1.47  2002/02/18 18:46:07  scowan
 * Added template makeparm constructor.
 *
 * Revision 1.46  2002/02/18 18:11:50  scowan
 * Remove assignment and copy from iterators.
 *
 * Revision 1.45  2002/02/18 16:22:02  scowan
 * Fix cursor problems.
 *
 * Revision 1.44  2002/02/15 21:40:56  scowan
 * Fixed operator ==.
 *
 * Revision 1.43  2002/02/15 20:14:12  scowan
 * Added more methods.
 *
 * Revision 1.42  2002/02/14 23:28:12  scowan
 * Updated inheritance to fully qualified named for genator docs.
 *
 * Revision 1.41  2002/02/14 21:58:50  scowan
 * Added a methof for field info.
 *
 * Revision 1.40  2002/02/14 21:08:12  scowan
 * Added flag.
 *
 * Revision 1.39  2002/02/14 21:04:54  scowan
 * Doc update.
 *
 * Revision 1.38  2002/02/14 17:42:07  scowan
 * Nothing.
 *
 * Revision 1.37  2002/02/14 17:17:40  scowan
 * Removed relation get methods.
 * Added choice for related field for special table creation.
 *
 * Revision 1.36  2002/02/14 16:37:08  scowan
 * Added record number from iterator method.
 *
 * Revision 1.35  2002/02/14 15:09:37  scowan
 * More small changes.
 *
 * Revision 1.34  2002/02/14 00:00:55  scowan
 * Yet more changes.
 *
 * Revision 1.33  2002/02/13 22:58:02  scowan
 * More suggested changes done.
 *
 * Revision 1.32  2002/02/13 20:55:10  scowan
 * Many changes and class renaming.
 *
 * Revision 1.31  2002/02/13 15:57:43  scowan
 * Renamed specialty record classes.
 *
 * Revision 1.30  2002/02/11 20:29:44  scowan
 * Moved many classes to be documented.
 *
 * Revision 1.29  2002/01/30 00:09:25  scowan
 * Chagned FindRecords methods to not take a void pointer.
 *
 * Revision 1.28  2002/01/02 17:13:03  scowan
 * Nothing.
 *
 * Revision 1.27  2001/09/20 15:26:03  scowan
 * Added enum values for DateTime field type.
 *
 * Revision 1.26  2001/09/18 21:35:57  scowan
 * Fixed record iterators.
 *
 * Revision 1.25  2001/09/07 22:00:54  scowan
 * Record class now keeps track of table closings.
 *
 * Revision 1.24  2001/07/25 22:16:34  scowan
 * n/c.
 *
 * Revision 1.23  2001/07/19 19:11:03  scowan
 * Add support for creating linked tables.
 *
 * Revision 1.22  2001/06/20 21:04:29  scowan
 * Clean up more constraints.
 *
 * Revision 1.21  2001/06/20 17:10:43  scowan
 * Removed unused items in the constraint wrapper.
 *
 * Revision 1.20  2001/06/20 16:08:22  scowan
 * Added constraint class and read and write methods.
 *
 * Revision 1.19  2001/06/19 17:32:12  scowan
 * Added method to determine table prompt set.
 *
 * Revision 1.18  2001/06/14 17:42:03  scowan
 * Added to RVC namespace.
 *
 * Revision 1.17  2001/06/11 16:13:44  scowan
 * Fixed warnings.
 *
 * Revision 1.15  2001/06/11 16:04:15  scowan
 * Changed field type Time to DateTime.
 *
 * Revision 1.14  2001/06/07 15:48:02  scowan
 * New constructor for element id record.
 *
 * Revision 1.13  2001/06/07 15:45:34  scowan
 * Added non-=moving field info update method.
 *
 * Revision 1.12  2001/06/06 21:46:08  scowan
 * Record write method const sting.
 *
 * Revision 1.11  2001/06/06 20:59:41  scowan
 * Added time field type and edit log table usage field.
 *
 * Revision 1.10  2001/05/31 21:49:51  scowan
 * Added invalid field type.
 *
 * Revision 1.9  2001/05/31 19:36:35  scowan
 * Added a method to clear a record.
 *
 * Revision 1.8  2001/05/29 21:51:43  scowan
 * Added method ishidden.
 *
 * Revision 1.7  2001/05/25 17:07:27  scowan
 * Initialize record method.
 *
 * Revision 1.6  2001/05/25 16:46:12  scowan
 * More comments.
 *
 * Revision 1.5  2001/05/25 15:04:27  scowan
 * Stupid G++ error.
 *
 * Revision 1.4  2001/05/24 14:53:37  scowan
 * Fixed UNIX MAC errors.
 *
 * Revision 1.3  2001/05/23 22:43:40  scowan
 * Used ERRORPOSNDIABLE class in appropriate places.
 *
 * Revision 1.2  2001/05/23 21:55:08  scowan
 * Finished wrapper for now.
 *
 * Revision 1.1  2001/05/23 20:24:54  scowan
 * Initial revision
 *
 * \endif
**/

//!
//!   \class RVC::DBTABLE rvc/dbtable.h
//!   \brief Manages RVC::OBJTYPE_Table objects.  
//!
//!   The RVC::DBTABLE class manages RVC::OBJTYPE_Table objects.  The interface currently wraps the MfDatabaseTable functions.
//!
//!   RVC Object Types that this class supports: RVC::OBJTYPE_Table.
//!
//!   Default RVC Object Type for this class: RVC::OBJTYPE_Table.
//!
//!   Valid parents for this class:
//!      - RVC::OBJTYPE_Database
//!      - RVC::OBJTYPE_Database_Raster
//!      - RVC::OBJTYPE_Database_VectorPoint
//!      - RVC::OBJTYPE_Database_VectorLine
//!      - RVC::OBJTYPE_Database_VectorPolygon
//!      - RVC::OBJTYPE_Database_CAD
//!      - RVC::OBJTYPE_Database_TIN
//!      - RVC::OBJTYPE_Database_Shape
//!

#ifndef INC_RVC_DBTABLE_H
#define INC_RVC_DBTABLE_H

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

#ifndef INC_RVC_STYLE_H
   #include <rvc/style.h>
#endif

#ifndef INC_MI32_UNITCONV_H
   #include <mi32/unitconv.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_TEXTID_H
   #include <mi32/textid.h>
#endif

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

#include <vector>

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class STYLE;         // Forward Declarations
class DBASE_ELEMENT;
#endif // GENERATING_DOXYGEN_OUTPUT

class DBTABLE : public RVC::OBJECT {
   public:

      //! Database table attachment type 
      enum ATTACHMENT {
         ATTACHMENT_Unknown = 0,          //!< Your standard free-for-all
         ATTACHMENT_OneRecordPerElement,  //!< But may use record for multiple elements
         ATTACHMENT_OneElementPerRecord,  //!< But element may have multiple records
         ATTACHMENT_OneToOne,             //!< At most one record per element and one element per record
         ATTACHMENT_RelatedOnly,          //!< No attachments at all, only related
         ATTACHMENT_Identity,             //!< Record number is element number
         ATTACHMENT_NoRestrictions        //!< Your standard attached to element free-for-all
         };
         
      //! Flags for finding attached record methods (i.e. RVCDBTABLE::GetAttachedRecords())
      enum FINDFLAG {
         FINDFLAG_AllAttached = 0,
         FINDFLAG_OnlyDirect = 2,
         FINDFLAG_FirstMatch = 8
         };

      //! Flags for searching on an index methods (i.e. RVCDBTABLE::SearchIndex())
      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
         };
         
      //! Type of external table
      enum LINKTYPE {
         LINKTYPE_Internal = 0,  //!< TNTmips internal format
         LINKTYPE_MIPS,          //!< MIPS external format (old RVF style) 
         LINKTYPE_DBASE3,        //!< dBase III+ format (external only)
         LINKTYPE_INFO,          //!< INFO format (external only)
         LINKTYPE_DBASE4,        //!< dBase IV (external only)
         LINKTYPE_RBASE,         //!< R:BASE (external only)
         LINKTYPE_DBASE2,        //!< Dbase 2 (external only)
         LINKTYPE_ODBC,          //!< Link to ODBC server (external only)
         LINKTYPE_CSV,           //!< Comma Seperated values (export only)
         LINKTYPE_TAB,           //!< MapInfo TAB files
         LINKTYPE_ORACLE         //!< Oracle server
         };

      //! Flags for element referenced tables  (TIN is the only one so far)
      enum REFELEM {
         REFELEM_All       = 0x00000000,
         REFELEM_Node      = 0x00000010,
         REFELEM_Edge      = 0x00000020,
         REFELEM_Triangle  = 0x00000040,
         REFELEM_Hull      = 0x00000080   
         };
         
      //! Result values for CompareStructures() method
      enum STRUCTCOMPARE {
         STRUCTCOMPARE_DoNotMatch = 0,    //!< Table structures do not match
         STRUCTCOMPARE_Exact,             //!< Table structures match exactly
         STRUCTCOMPARE_Compatible,        //!< Table structures are compatible, record fields can be converted without loss of data
         STRUCTCOMPARE_SameTable          //!< Both tables point to the same linked table
         };
      
      //! Table capability flags, returned by RVCDBTABLE::GetCapability()
      enum TABLECAP {
         TABLECAP_None =            0x00000000,
         TABLECAP_CanCreate =       0x00000001,
         TABLECAP_CanLink =         0x00000002,
         TABLECAP_ReadMemo =        0x00000004,
         TABLECAP_WriteMemo =       0x00000008,
         TABLECAP_WriteRecord =     0x00000010,    //!< Can written via API, regardless of TABLECAP_UserWritable
         TABLECAP_MultiTable =      0x00000020,
         TABLECAP_Server =          0x00000040,
         TABLECAP_Import =          0x00000080,
         TABLECAP_Export =          0x00000100,
         TABLECAP_DeleteRecord =    0x00000200,
         TABLECAP_UserWritable =    0x00000400,    //!< ! TABLE_ReadOnly (Only used by editor)
         TABLECAP_CanSetUserWrite = 0x00000800,    //!< User can toggle TABLE_ReadOnly
         TABLECAP_ChangeFields =    0x00001000,
         TABLECAP_AddFields =       0x00002000,
         TABLECAP_DeleteFields =    0x00004000,
         TABLECAP_AddRecord =       0x00008000,
         TABLECAP_RandomAccess =    0x00010000,
         TABLECAP_ReadBinary =      0x00020000,
         TABLECAP_WriteBinary =     0x00040000
         };
         
      //! Table usage, defines specialized tables
      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_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
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class BOOKMARK;
      class CURSOR;
      class FIELDINFO;
      class GETOBJFILTER_ISUSERDEFINED;
      class RECORD;
      friend class RECORD;
      class RECORD_EXTRUDED_POINTS;
      class RECORD_FLIGHTPATH;
      class RECORD_ID_ELEMENT;
      class RECORD_ID_POINT;
      class RECORD_INFLUENCE_SPHERE;
      class RECORD_LEGENDELEMENT;
      class RECORD_NODETURN;
      class RECORD_PARAMETERS_SELECT;
      class RECORD_PARAMETERS_STYLE;
      class RECORD_POINTOFINTEREST;
      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 SIMPLE_ARRAY<FIELDINFO> FIELDINFOARRAY;
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class CONSTRAINT;
      class LINKPARMS;
      class LINKPARM_CSV;
      class LINKPARM_DBASE2;
      class LINKPARM_DBASE3;
      class LINKPARM_DBASE4;
      class LINKPARM_INFO;
      class LINKPARM_MIPS;
      class LINKPARM_ODBC;
      class LINKPARM_ORACLE;
      class LINKPARM_RBASE;
      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_FLIGHTPATH;
      class MAKEPARM_POINTOFINTEREST;
      class MAKEPARM_LEGENDELEMENT;
      class MAKEPARM_NODETURN;
      class MAKEPARM_PARAMETERS_STYLE;
      class MAKEPARM_PARAMETERS_SELECT;
      class MAKEPARM_EXTRUDED_POINTS;
      class MAKEPARM_INFLUENCE_SPHERE;
      class RECORDITERATOR;
      class CONST_RECORDITERATOR;
      class OBSERVER;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      //! Default constructor
      DBTABLE (
         );

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

      //! Destructor
      virtual ~DBTABLE (
         );

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

      //! Add a record to the table
      //! @return Record number for the new record
      INT32 AddRecord (
         RECORD& Record
         );

      //! Combine rhs table with this table
      ERRVALUE RVC::DBTABLE::Combine (
         const RVC::DBTABLE& rhs,
         const RVC::DBASE::JOINFLAGS flags,
         const RVC::DBASE& dest,          //!< Database in which to store table
         const MISTRING& name,            //!< Output table name
         const MISTRING& desc             //!< Output table description
         );

      //! Compare two table structures
      //! @return STRUCTCOMPARE enum value describing if and how the table structures match
      STRUCTCOMPARE CompareStructures (
         const RVC::DBTABLE& rhs
         ) const;
         
      //! Drop a table (delete)
      ERRVALUE Drop (
         bool CleanDBList                 //!< Remove the entries in the DBlist that refer to this table
         );

      //! Delete a record from the table using the record number
      ERRVALUE DeleteRecord (
         INT32 RecordNum
         );

      //! Delete a record from the table using the cursor and a bookmark
      ERRVALUE DeleteRecord (
         CURSOR& cursor,
         const BOOKMARK& bookmark
         );

      //! Find the field cooresponding to the name
      //! @return Field number of >= 0, R_FieldNotFound if field does not exist, < 0 Error code
      INT32 FindField (
         const RVC::OBJECTNAME& name
         ) const;
         
      //! Find the records that match the record data for a given field
      //! @return Number of records found or <0 if error 
      INT32 FindRecords (
         INT32 FieldNum,
         double value,                       //!< Buffer containing value to compare to
         SIMPLE_ARRAY<INT32>& FoundRecList
         ) const;
         
      //! Find the records that match the record data for a given field
      //! @return Number of records found or <0 if error 
      INT32 FindRecords (
         INT32 FieldNum,
         const char* string,              //!< Buffer containing string to compare to
         SIMPLE_ARRAY<INT32>& FoundRecList
         ) const;
         
      //! Find the records that match the record data for a given field
      //! @return Number of records found or <0 if error 
      INT32 FindRecords (
         INT32 FieldNum,
         const UNICODE* string,              //!< Buffer containing string to compare to
         SIMPLE_ARRAY<INT32>& FoundRecList
         ) const;
         
      //! Find the records that match the record data for a given field
      //! @return Number of records found or <0 if error 
      INT32 FindRecords (
         INT32 FieldNum,
         const MISTRING& string,             //!< Buffer containing string to compare to
         SIMPLE_ARRAY<INT32>& FoundRecList
         ) const;
         
      //! Find the records that match the record data for a given field
      //! @return Number of records found or <0 if error 
      INT32 FindRecords (
         INT32 FieldNum,
         const RECORD& record,               //!< Record containing stuff to compare to
         SIMPLE_ARRAY<INT32>& FoundRecList,
         INT32 RecordFieldNum = -1           //!< Record field number to use, default is 'FieldNum'
         ) const;
         
      //! Get the records attached to the element for this table
      //! @return Number of records attached or <0 if error 
      INT32 GetAttachedRecords (
         INT32 ElementNum,
         ELEMTYPE ElemType,
         SIMPLE_ARRAY<INT32>& RecordList,
         FINDFLAG FindFlags = FINDFLAG_AllAttached
         ) const;

      //! Get table attachment type
      //! @return Table attachment type
      ATTACHMENT GetAttachmentType (
         ) const;

      //! Get table capability
      //! @return Table capability
      TABLECAP GetCapability (
         ) const;

      //! Get the computed field query for a field
      ERRVALUE GetComputedFieldQuery (
         INT32 FieldNum, 
         MISTRING& QueryStr
         ) const;

      //! Get table encoding
      //! @return Table encoding
      CHAR_ENCODING GetEncoding (
         ) const;
         
      //! Get the index for a field, will build one if needed
      ERRVALUE GetFieldIndex (
         INT32 FieldNum,
         SIMPLE_ARRAY<INT32>& Index,            //!< List of record numbers in sorted order
         BITSET& DuplicateBits                  //!< Bit set to true if value in the record for that field is equal to the previous record
         );

      //! Get the FIELDINFO for a single field
      ERRVALUE GetFieldInfo (
         INT32 FieldNum,
         FIELDINFO& FieldInfo
         ) const;

      //! Get the FIELDINFO's for the table
      ERRVALUE GetFieldInfo (
         FIELDINFOARRAY& FieldArray
         ) const;

      //! Get the list of fields linked to the starting field     
      ERRVALUE GetLinkFields (
         INT32 StartFieldNum,                      //!< Field to start checking on
         SIMPLE_ARRAY<INT32>& FieldNumArray        //!< One item 'StartFieldNum' if no next_key links, > 1 items if next_key links exists
         ) const;     

      //! Get the number of field in the table
      //! @return Number of fields
      INT32 GetNumFields (
         ) const;

      //! Get the number of field in the table
      //! @return Number of fields
      INT32 GetNumRecords (
         ) const;

      //! Get reference element (This table belongs to what element?)
      //! @return Reference flags
      REFELEM GetReferenceElement (
         ) const;
         
      //! Get the records from this table attached to the record in the basetable
      //! @return Number of records attached or <0 if error 
      INT32 GetRelatedRecords (
         INT32 RecordNum,                                   //!< Record in the base table to get attachments for
         INT32 BaseTableNum,                                //!< Basetable that contains the record stated above
         SIMPLE_ARRAY<INT32>& RecordList,                   //!< List of records that are related RETURNED
         FINDFLAG FindFlags = FINDFLAG_AllAttached          //!< find flags
         ) const;

      //! Get the records from this table attached to the given record
      //! @return Number of records attached or <0 if error 
      INT32 GetRelatedRecords (
         const RECORD& record,                              //!< Record to get attachments for
         SIMPLE_ARRAY<INT32>& RecordList,                   //!< List of records that are related RETURNED
         FINDFLAG FindFlags = FINDFLAG_AllAttached          //!< find flags
         ) const;

      //! Get table number
      //! @return Table number
      INT32 GetTableNumber (
         ) const;
         
      //! Get table usage
      //! @return Table usage
      USAGE GetUsage (
         ) const;
         
      //! Get view position of table
      //! @return Table view position
      LRECT2D GetWindowRect (
         ) const;
         
      //! Is the table hidden?
      //! @return 'True' if the table is hidden
      bool IsHidden (
         ) const;

      //! Is table an internal (no storage representation) table
      //! @return 'True' if the table is internal
      bool IsInternal (
         ) const;

      //! Is table missing.  Occurs with linked tables
      //! @return 'True' if the table is missing
      bool IsMissing (
         ) const;
         
      //! Is table a prompt table.  Used for adding elements
      //! @return 'True' if the table is a prompt table
      bool IsPrompt (
         ) const;

      //! Is table valid.  Occurs with deleted tables
      //! @return 'True' if the table is valid
      bool IsValid (
         ) const;

      //! Can the table be written to?
      //! @return 'True' if the table is writable
      bool IsWritable (
         ) const;

      //! Link to an external table, field info returned in the LINKPARMS
      ERRVALUE Link (
         RVC::DBASE& parent,
         const RVC::OBJECTNAME& name,
         const RVC::OBJECTDESC& desc,
         const LINKPARMS& LinkParms,
         const char* Source = 0
         );

      //! Make a table
      ERRVALUE Make (
         RVC::DBASE& parent,
         const RVC::OBJECTNAME& name,
         const RVC::OBJECTDESC& desc,
         MAKEPARMS& MakeParms,
         const char* Source = 0
         );

      //! Open an existing table using the table name
      ERRVALUE Open (
         const RVC::DBASE& parent,
         const RVC::OBJECTNAME& TableName,
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT pwidget = 0
         );

      //! Open an existing table using the table name
      ERRVALUE Open (
         int DBaseID,
         const RVC::OBJECTNAME& TableName,
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT pwidget = 0
         );

      //! Open an existing table using the table index
      ERRVALUE Open (
         const RVC::DBASE& parent,
         INT32 TableNum,
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT pwidget = 0
         );

      //! Open an existing table using the table index
      ERRVALUE Open (
         int DBaseID,
         INT32 TableNum,
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT pwidget = 0
         );

      //! Open a table using another instance of that table
      ERRVALUE Open (
         const DBTABLE& twin,
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT pwidget = 0
         );

      //! Open an RVC::DBTABLE instance using a RVC::OBJITEM instance
      //!
      //! This method will attach and open the file and database table object if possible
      ERRVALUE Open (
         const RVC::OBJITEM& ObjItem,        //!< This contains the file and rvc object location information
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0               //!< Parent dialog handle, 0 for default handle
         );

      //! Open an <b>attached</b> RVC::DBTABLE instance.
      //! The instance must be attached for this to work.
      ERRVALUE Open (
         OPENMODE OpenMode = OPENMODE_Read,  //!< Mode in which to open the rvc object
         MDLGPARENT widget = 0               //!< Parent dialog handle, 0 for default handle
         );

      //! Read a record from the table using a record number into a pre-allocated buffer
      ERRVALUE Read (
         INT32 RecordNum, 
         RECORD& Record
         ) const {return (Read(0, RecordNum, 0, Record, RECACC_RecordNum));}

      //! Read a record from the table using a cursor into a pre-allocated buffer
      ERRVALUE Read (
         CURSOR& cursor,
         RECORD& Record
         ) const {return (Read(&cursor, 0, 0, Record, RECACC_Cursor));}
         
      //! Read a record from the table using a cursor / bookmark pair into a pre-allocated buffer
      ERRVALUE Read (
         CURSOR& cursor,
         const BOOKMARK& bookmark,
         RECORD& Record
         ) const {return (Read(&cursor, 0, &bookmark, Record, RECACC_Bookmark));}
         
      //! Read a record from the table using a record number into a pre-allocated buffer
      ERRVALUE ReadDefault (
         RECORD& Record
         ) const {return (Read(0, RECORD_New, 0, Record, RECACC_RecordNum));}

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

      //! Get a constant iterator to the first viable record in the table
      void RecordBegin (
         CONST_RECORDITERATOR& Iterator, 
         ITERATERECORD IterateRecord = ITERATERECORD_SkipDeleted,
         INT32 FieldNum = 0
         ) const;

      //! Get an iterator to the first viable record in the table
      void RecordBegin (
         RECORDITERATOR& Iterator, 
         ITERATERECORD IterateRecord = ITERATERECORD_SkipDeleted,
         INT32 FieldNum = 0
         );

      //! Remove duplicate records from the table
      ERRVALUE RemoveDuplicateRecords (
         );

      //! Remove unattached records from the table
      ERRVALUE RemoveUnattachedRecords (
         );

      //! Set the number of records in the table.  Does not work with ATTACHMENT_Identity tables
      ERRVALUE Resize (
         INT32 NewNumRecords,
         bool CleanDBList
         );

      //! Search field index with a value for the record match
      //! @return Number of matches or error < 0
      template <class _CT>
      INT32 SearchIndex (
         INT32 FieldNum,
         const _CT& item,
         const FIELDINFO& finfo, 
         INT32& offset, 
         INDEXSEARCH flag = INDEXSEARCH_ReturnIndexOffset
         ) const {return (MfIndexSearch(GetDatabaseID(), m_TableID, FieldNum, &item, finfo.GetFieldInfoPtr(), &offset, flag));}

      //! Search field index with a value that matches the field to search for the record match
      //! @return Number of matches or error < 0
      template <class _CT>
      INT32 SearchIndex (
         INT32 FieldNum,
         const _CT& item,           //!< MUST MATCH 'FieldNum' field type and size
         INT32& offset, 
         INDEXSEARCH flag = INDEXSEARCH_ReturnIndexOffset
         ) const {return (MfIndexSearch(GetDatabaseID(), m_TableID, FieldNum, &item, 0, &offset, flag));}

      //! Search field index with a double value for the match
      //! @return Number of matches or error < 0
      INT32 SearchIndex (
         INT32 FieldNum,
         double value,
         INT32& offset, 
         INDEXSEARCH flag
         ) const;
         
      //! Search field index with a string value for the match
      //! @return Number of matches or error < 0
      INT32 SearchIndex (
         INT32 FieldNum,
         const MISTRING& value,
         INT32& offset, 
         INDEXSEARCH flag
         ) const;
         
      //! Search field index with a value in the RECORD for the match
      //! @return Number of matches or error < 0
      INT32 SearchIndex (
         INT32 FieldNum,
         const RECORD& Record, 
         INT32 RecFieldNum,
         INT32& offset, 
         INDEXSEARCH flag
         ) const;
      
      //! Set table attachment type
      ERRVALUE SetAttachmentType (
         ATTACHMENT Attachment
         );

      //! Set the computed field query for a field
      ERRVALUE SetComputedFieldQuery (
         INT32 FieldNum,
         const MISTRING& QueryStr
         );
         
      //! Set table encoding
      void SetEncoding (
         CHAR_ENCODING Encoding
         );

      //! Modify specific table FIELDINFO
      ERRVALUE SetFieldInfo (
         INT32 FieldNum,
         const FIELDINFO& FieldInfo
         );

      //! Modify all table FIELDINFO's
      ERRVALUE SetFieldInfo (
         FIELDINFOARRAY& FieldArray
         );

      //! Modify all table FIELDINFO's
      ERRVALUE SetFieldInfo (
         FIELDINFOARRAY& FieldArray,
         const SIMPLE_ARRAY<int>& NewToOld
         );

      //! Set view position of table
      void SetWindowRect (
         const LRECT2D& rect
         );

      //! Write a record in the table using a record number from a buffer
      ERRVALUE Write (
         INT32 RecordNum, 
         RECORD& Record
         ) {return (Write(0, RecordNum, 0, Record, RECACC_RecordNum));}

      //! Write a record in the table using a cursor from a buffer
      ERRVALUE Write (
         CURSOR& cursor,
         RECORD& Record
         ) {return (Write(&cursor,0, 0, Record, RECACC_Cursor));}

      //! Write a record in the table using a cursor / bookmark pair from a buffer
      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
      DBASE m_ParentObj;
      int m_TableID;
      
      int GetDatabaseID () const {return (m_ParentObj.m_DBaseID);}

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

      enum RECACC {
         RECACC_RecordNum,
         RECACC_Cursor,
         RECACC_Bookmark
         };

      //! Implementation of RVC::OBJECT virtual methods
      virtual ERRVALUE v_CloseObject ();
      virtual ERRVALUE v_GetDescription (RVC::OBJECTDESC& Desc) const;
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual ERRVALUE v_GetName (RVC::OBJECTNAME& Name) const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent);

      INT32 GetRecordSize () const;
         
      ERRVALUE Read (
         CURSOR* cursor,
         INT32 RecordNum,
         const BOOKMARK* bookmark,
         RECORD& Record,
         RECACC flags
         ) 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_ELEMENT;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Class to represent database bookmarks used in ODBC
class DBTABLE::BOOKMARK {
   public:
      
      //! Default constructor
      explicit BOOKMARK (
         UINT32 Bookmark = 0
         ) : m_Bookmark(Bookmark) {}
   
      //! Copy constructor
      BOOKMARK (
         const BOOKMARK& rhs
         ) : m_Bookmark(rhs.m_Bookmark) {}

      //! Assignment
      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);}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT32 m_Bookmark;
   
      friend class DBTABLE;
      friend class DBTABLE::CURSOR;
      friend class DBTABLE::RECORD;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Class to represent database table cursors used in ODBC
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, //!< Add to previous function
         FUNCTION_ForUpdate =    0x00000200  //!< To allow writes
         };
      
      //! Default constructor
      explicit CURSOR (
         const RVC::DBTABLE& table
         );
         
      //! Destructor
      ~CURSOR (
         );
         
      //! Equality
      bool operator== (
         const CURSOR& rhs
         ) const;
         
      //! Get the current bookmark     
      ERRVALUE GetBookmark (
         BOOKMARK& Bookmark
         ) const;
         
      //! Get the current record number or < 0 if error
      INT32 GetRecordNum (
         ) const;
         
      //! Is the cursor valid
      //! @return True for a valid cursor
      bool IsValid (
         ) const;

      //! Increment cursor
      //! @return > 0 if still valid, 0 if not, < 0 error
      int Next (
         );
         
      //! Reset cursor to the beginning
      ERRVALUE Rewind (
         );

      //! Set cursor behavior
      ERRVALUE SetFunction (
         INT32 FieldNum,
         FUNCTION Function
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const DBTABLE& m_Table;
      INT32 m_Value;

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

//! Constraint class for the field in the table
class DBTABLE::CONSTRAINT {
   public:
      enum CASE {
         CASE_None = 0,
         CASE_ForceUpperCase = 0x0100,
         CASE_ForceLowerCase = 0x0200,
         CASE_CapFirstLetter = 0x0400,
         CASE_CapFirstWord = 0x0800
         };
         
      enum PKTABLE {
         PKTABLE_None = 0,
         PKTABLE_MustExist = 0x00008000,
         PKTABLE_AutoAdd = 0x00010000,
         PKTABLE_AutoAddPrompt = 0x00020000
         };
   
      enum RANGEFLAG {
         RANGEFLAG_None = 0,
         RANGEFLAG_MinExclusive = 0x0001,
         RANGEFLAG_MaxExclusive = 0x0002,
         RANGEFLAG_MinInclusive = 0x0004,
         RANGEFLAG_MaxInclusive = 0x0008
         };
   
      //! Default Constructor
      CONSTRAINT (
         );
   
      //! Destructor
      ~CONSTRAINT (
         ) {}

      bool CanBeEmpty (
         ) const {return (!m_NotNull);}
         
      CASE GetCaseFlags (
         ) const {return (m_Case);}
      
      double GetDefaultNum (
         ) const {return (m_DefaultNum);}
         
      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;}
         
      void SetEmpty (
         bool value
         ) {m_NotNull = !value;}
         
      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;
      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;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class DBTABLE::FIELDINFO {
   public:

      //!   pseudo fields for FIELDINFO.next_field.  Some database schemas
      //! require a 2 part key where the primary key is made up of 2 fields
      //! but the foreign key is made up of 1 field and the name of the field
      //! or one field and a "domid" which is looked up from a 3rd table by
      //! using the table/field name.  We look those up on import and record
      //! them in the FIELDINFO.domid.  I don't know of anything that would
      //! use the table name, but I added it for completeness 
      enum NEXTFIELD {
         NEXTFIELD_ThisFieldName = 0xFFFF,   //!< Name of this field is the key data 
         NEXTFIELD_ThisTableName = 0xFFFE,   //!< Name of this table is the key data 
         NEXTFIELD_DomID         = 0xFFFD,   //!< Key data is the "domid" field of this field 
         NEXTFIELD_PseudoField   = 0xFFFC    //!< If next_field is > this, it's one of these 
         };
         
      enum FLAGS {
         FLAG_None =             0x0000,
         FLAG_PrimaryKey =       0x0001,  //!< Field is a primary key (force index)
         FLAG_PK =               FLAG_PrimaryKey,
         FLAG_ForeignKey =       0x0002,  //!< Field is a foreign key (index optional)
         FLAG_FK =               FLAG_ForeignKey,
         FLAG_Indexed =          0x0004,  //!< Field has index 
         FLAG_NotNULL =          0x0010,  //!< Value cannot be NULL 
         FLAG_Unique =           0x0020,  //!< value must be unique 
         FLAG_ReadOnly =         0x0040,  //!< User can't change value 
         FLAG_SecondaryKey =     0x0080,  //!< Secondary (or higher) key 
         FLAG_SK =               FLAG_SecondaryKey,
         FLAG_Invisible =        0x0100,  //!< Don't show the field at all 
         FLAG_Closest =          0x0200,  
         FLAG_RangeAbove =       0x0400,  
         FLAG_RangeBelow =       0x0800,  
         FLAG_ComputeOnRead =    0x0008,  //!< Field is computed 
         FLAG_ComputeOnWrite =   0x1000,  //!< Compute field on write 
         FLAG_Computed =         0x1008,
         FLAG_LocalTime =        0x2000,  //!< TYPE_DateTime field is stored in local time
         FLAG_AutoIncrement =    0x4000   //!< Assignes the "AutoIncrement" value to the field and then increments "AutoIncrement" (default start is '1')
         };

      enum TYPE { 
         TYPE_Invalid = 0,       //!< Invalid field type
         TYPE_String = 1,        //!< ASCII character string, null-terminated 
         TYPE_Char = 2,          //!< Single ASCII character 
         TYPE_UByte = 3,         //!< Unsigned 1-byte integer (0-255)
         TYPE_Byte = 4,          //!< Signed 1-byte integer (-128-128)
         TYPE_UWord = 5,         //!< Unsigned 2-byte integer (0-65535)
         TYPE_Word = 6,          //!< Signed 2-byte integer (-32768-32767)
         TYPE_ULong = 7,         //!< Unsigned 4-byte integer (0 - 2^32-1)
         TYPE_Long = 8,          //!< Signed 4-byte integer (-2^31 - 2^31-1)
         TYPE_Float = 9,         //!< 4-byte floating-point number
         TYPE_Double = 10,       //!< 8-byte floating-point number
         TYPE_Logical = 11,      //!< 1-byte logical (?/Y/y/N/n/T/t/F/f/0/1)
         TYPE_Date = 12,         //!< 4-byte integer date YYYYMMDD
         TYPE_Color = 15,        //!< Color spec. Always 8 bytes (COLOR)
         TYPE_Binary = 16,       //!< Binary field
         TYPE_Memo = 17,         //!< Memo field
         TYPE_Unicode = 18,      //!< UNICODE string, null-terminated
         TYPE_DateTime = 19      //!< Date/Time field, 100-nanosecond intervals from 1-Jan-1601
         };
         
      enum USAGE {         
         USAGE_Undefined = 0,
         USAGE_XCoord = 1,
         USAGE_YCoord,
         USAGE_ZCoord,
         USAGE_Label,
         USAGE_Filename,
         USAGE_ObjName
         };
         
      //! Default constructor
      FIELDINFO (
         ) {memset(this, 0, sizeof(*this));}

      //! Clear the field info of current values
      void Clear (
         ) {memset(this, 0, sizeof(*this));}
         
      //! Compare two field types and return best field type to convert to
      //! @return this->GetType() if exact match, TYPE_??? depending if the types are
      //! not the best match but still matchable, TYPE_Invalid if types do not match
      TYPE CompareFieldTypes (
         const FIELDINFO& rhs,
         bool& ExactMatch              //!< Set to 'true' if the two fields match exactly, 'false' if they do not
         ) const;
         
      //! Get the AutoIncrement number for the next added record
      //! @return Next AutoIncrement number
      UINT32 GetAutoIncrement (
         ) const {return (m_FieldInfo.AutoIncrement);}
   
      //! Get number of decimal places to display for floating point fields
      //! @return Number of decimal places to display    
      int GetDecimalPlaces (
         ) const {return (m_FieldInfo.decplaces);}
         
      //! Get the display units for this field
      //! @return Display unit
      int GetDispUnits (
         ) const {return (m_FieldInfo.unitshown);}
         
      //! Get number of columns to display
      //! @return Number of columns to display     
      int GetDispWidth (
         ) const {return (m_FieldInfo.dispwidth);}
         
      //! Get the domain ID for this field
      //! @return Domain ID
      const RVC::OBJECTNAME& GetDomainID (
         ) const {return (m_FieldInfo.domid);}
         
      //! Get the flags for this field
      //! @return Field flags (FIELDINFO::FLAGS_...)
      FLAGS GetFlags (
         ) const {return (static_cast<FLAGS>(m_FieldInfo.flags));}
         
      //! Get the name of this field
      //! @return Field name
      const RVC::OBJECTNAME& GetName (
         ) const {return (m_FieldInfo.name);}
         
      //! Get the next field number that this field is linked to
      //! @return Next link field number
      INT32 GetNextLinkField (
         ) const {return (m_FieldInfo.next_field-1);}
         
      //! Get the next field pseudo number that this field is linked to
      //! @return Next link field pseudo number (FIELDINFO::NEXTFIELD_...)
      NEXTFIELD GetPseudoNextLinkField (
         ) const {return (static_cast<NEXTFIELD>(m_FieldInfo.next_field));}
         
      //! Get the field number that this field is linked to, use HasRelation() to 
      //! determine if the field is related to another table / field
      //! @return Linked field number
      INT32 GetRelatedField (
         ) const {return (m_FieldInfo.key_field-1);}
         
      //! Get the table number that this field is linked to, use HasRelation() to 
      //! determine if the field is related to another table / field
      //! @return Related table number
      INT32 GetRelatedTable (
         ) const {return (m_FieldInfo.key_table);}
         
      //! Get the size of the field in bytes
      //! @return Size of field in bytes
      INT32 GetSize (
         ) const {return (m_FieldInfo.size);}
         
      //! Get the type of the field
      //! @return Type of field (FIELDINFO::TYPE_...)
      TYPE GetType (
         ) const {return (static_cast<TYPE>(m_FieldInfo.type));}
   
      //! Get the numeric units for this field for unit conversion
      void GetUnits (
         UNITCONV& conv
         ) const {GetUnitConversion(m_FieldInfo.unittype, m_FieldInfo.unitstored, m_FieldInfo.unitshown, &conv);}
         
      //! Get the usage of the field
      //! @return Field usage (FIELDINFO::USAGE_...)
      USAGE GetUsage (
         ) const {return (static_cast<USAGE>(m_FieldInfo.usage));}
         
      //! Is the field related to another table / field
      //! @return 'True' if field is related
      bool HasRelation (
         ) const {return (m_FieldInfo.key_field > 0);}
   
      //! Does the field have a next key field link?
      //! @return 'True' if field has a next key field
      bool HasNextKey (
         ) const {return (m_FieldInfo.next_field > 0);}
   
      //! Does the field have a next key pseudo field link?
      //! @return 'True' if field has a next pseudo key field
      bool HasPseudoNextKey (
         ) const {return (m_FieldInfo.next_field > NEXTFIELD_PseudoField);}
         
      //! Is the field a nemeric field?  (not a string that can be converted to a number)
      //! @return 'True' if field is a numeric field
      bool IsNumeric (
         ) const {return (m_FieldInfo.type >= TYPE_UByte && m_FieldInfo.type <= TYPE_Double);}

      //! Reset position information about the field        
      void ResetPosition (
         ) {m_FieldInfo.offset = m_FieldInfo.diskoffset = m_FieldInfo.disksize = 0;}
         
      //! Set the AutoIncrement number for the next added record
      void SetAutoIncrement (
         UINT32 count
         ) {m_FieldInfo.AutoIncrement = count;}
   
      //! Set the number of decimal places for floating point fields
      void SetDecimalPlaces (
         int decplaces
         ) {m_FieldInfo.decplaces = static_cast<UINT8>(decplaces);}
         
      //! Set the display units for this field
      void SetDispUnits (
         int unit
         ) {m_FieldInfo.unitshown = static_cast<UINT8>(unit);}
         
      //! Set the display width (number of columns) for the field
      void SetDispWidth (
         int width
         ) {m_FieldInfo.dispwidth = static_cast<UINT8>(width);}
         
      //! Set the Domain ID for this field
      void SetDomainID (
         const RVC::OBJECTNAME& name
         ) {m_FieldInfo.domid = name;}
         
      //! Set field flags
      void SetFlags (
         FLAGS flags
         ) {m_FieldInfo.flags = flags;}
         
      //! Set this field to link to a field in another table