dbelem.h

Go to the documentation of this file.

/**
 * \file rvc/dbelem.h
 * \brief interface for the RVC::ELEMDBASE class.
 *
 * \if NODOC
 * $Id: dbelem.h_v 1.30 2005/04/05 14:28:50 dwilliss Exp $
 *
 * $Log: dbelem.h_v $
 * Revision 1.30  2005/04/05 14:28:50  dwilliss
 * Added a new get object filter
 *
 * Revision 1.29  2004/05/27 19:48:22  scowan
 * Added method to transfer style assignment tables.
 *
 * Revision 1.28  2003/12/04 21:18:31  scowan
 * Added element record compare methodd.
 *
 * Revision 1.27  2003/10/07 17:34:56  scowan
 * Object virtual method changes.
 *
 * Revision 1.26  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.25  2003/09/25 21:56:37  dwilliss
 * doxygen
 *
 * Revision 1.24  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.23  2003/01/21 21:57:21  scowan
 * More const.
 *
 * Revision 1.22  2002/09/16 15:32:26  mju
 * Add GetElemType().
 *
 * Revision 1.21  2002/08/15 17:02:19  scowan
 * Fixed inline method.
 *
 * Revision 1.20  2002/08/13 21:37:13  scowan
 * Moved database include file.
 *
 * Revision 1.19  2002/05/01 15:31:24  scowan
 * Added get attachment method.
 *
 * Revision 1.18  2002/04/19 20:50:30  scowan
 * Added another get attached elements.
 *
 * Revision 1.17  2002/04/15 17:26:20  scowan
 * Removed record assignments to attachment item.
 *
 * Revision 1.16  2002/04/11 20:25:17  mju
 * Add flags to GetAttachedRecordNumbers().
 *
 * Revision 1.15  2002/04/11 19:52:30  mju
 * Add GetAttachedRecordNumbers and addl ATTACHMENTITEM ctor.
 *
 * Revision 1.14  2002/04/11 17:46:21  scowan
 * MOved element to its own include file.
 *
 * Revision 1.13  2002/04/11 17:28:09  scowan
 * Fixed stuff.
 *
 * Revision 1.12  2002/04/11 16:14:57  scowan
 * More Mike changes.
 *
 * Revision 1.11  2002/04/11 15:42:32  scowan
 * Added some more classes.
 *
 * Revision 1.10  2002/04/11 14:18:55  scowan
 * Moved from dblist.h.
 *
 * Revision 1.9  2002/04/09 15:33:59  scowan
 * Added open as subobject methods.
 *
 * Revision 1.8  2002/04/08 20:53:09  scowan
 * Added new methods.
 *
 * Revision 1.7  2002/04/08 16:00:07  scowan
 * Name Change.
 *
 * Revision 1.6  2001/10/08 17:32:46  scowan
 * Nothing.
 *
 * Revision 1.5  2001/06/26 16:53:55  scowan
 * Specify issmultiobject() to turn off base class setting.
 *
 * Revision 1.4  2001/06/14 15:16:01  scowan
 * Added to RVC namespace.
 *
 * Revision 1.3  2001/05/31 19:36:59  scowan
 * Added a method to append one list entry to a dbelem.
 *
 * Revision 1.2  2001/05/25 16:53:56  scowan
 * Changed class name.
 *
 * Revision 1.1  2001/05/24 15:13:17  scowan
 * Initial revision
 *
 * \endif
**/

//!   \class RVC::DBASE_ELEMENT rvc/dbelem.h
//!   \brief Interface for RVC database objects that support attachment of records to geospatial object "elements".
//!
//!   This includes methods to read, write, append, and modify element-record attachment lists.
//!
//!   RVC Object Types that this class supports: Derived class
//!
//!   Default RVC Object Type for this class: Derived class
//!
//!   Valid parents for this class: Derived class

#ifndef INC_RVC_DBELEM_H
#define INC_RVC_DBELEM_H

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

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

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

#ifndef GENERATING_DOXYGEN_OUTPUT
struct DBLISTELMT;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class GEOSPATIAL;    // Forward declarations
#endif // GENERATING_DOXYGEN_OUTPUT


class DBASE_ELEMENT : public DBASE {
   public:
   
      class ATTACHMENTITEM;
      class GETOBJFILTER_ISSELECTABLE;
      typedef SIMPLE_ARRAY<ATTACHMENTITEM> ATTACHMENTARRAY;
      
      typedef SIMPLE_ARRAY<DBLISTELMT> DBLIST;
      
      //! Default constructor
      explicit DBASE_ELEMENT (
         ELEMTYPE ElemType
         );

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

      //! Destructor
      virtual ~DBASE_ELEMENT (
         );

      //! Assignment
      RVC::DBASE_ELEMENT& operator= (
         const RVC::DBASE_ELEMENT& rhs
         );
         
      //! Attach the record to the element
      ERRVALUE AddAttachment (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTITEM& item
         );

      //! Attach the array of records to the element
      ERRVALUE AddAttachments (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTARRAY& items
         );

      //! Append list entries to this element.
      //! This method will remove duplicates.
      INT32 AppendDBList (
         INT32 ElemNum,
         const DBLIST& DBList
         );

      //! Append one list entry to this element.
      //! This method will remove duplicates.
      INT32 AppendDBList (
         INT32 ElemNum,
         const DBLISTELMT& item
         );

      //! Remove invalid entries from the element database attachment list
      ERRVALUE CleanDBList (
         );

      //! Compare attached element records from two databases to determine if the element attachmets are to the same records
      //! @return 'True' if they are, false if not.               
      bool CompareElementRecords (
         INT32 LhsElemNum,                         //!< Left side element number
         const DBASE_ELEMENT& rhs,                 //!< Other database to compare to
         INT32 RhsElemNum,                         //!< Right side element number
         const SIMPLE_ARRAY<INT32>& TableMatch     //!< Table translation array from Lhs database to Rhs database, See DBASE::FindTableMatches()
         ) const;

      //! Convert style assignment table from 'this' to 'DestDBaseObj' based on the 
      //! database object types
      ERRVALUE ConvertStyleAssignTableTo (
         DBASE_ELEMENT& DestDBaseObj               //!< Must be created outside this function and be open
         );

      //! Get the list of attached elements to a specific record        
      int GetAttachedElements (
         const RVC::DBTABLE::RECORD& record,       //!< Record to find attached elements of
         SIMPLE_ARRAY<INT32>& ElementList,
         ELEMTYPE ElemType = ELEMTYPE_Empty        //!< Defaults to DBASE_ELEMENT ElemType
         ) const;

      //! Get the list of attached elements to a specific record        
      int GetAttachedElements (
         const RVC::DBTABLE::RECORD& record,       //!< Record to find attached elements of
         SIMPLE_ARRAY<RVC::ELEMENT>& ElementList,
         ELEMTYPE ElemType = ELEMTYPE_Empty        //!< Defaults to DBASE_ELEMENT ElemType
         ) const;

      //! Get records attached to the specified element for all tables
      ERRVALUE GetAttachedRecordList (
         INT32 ElemNum,
         DBLIST& DBList,                     //!< List of attachments allocated and returned
         FINDFLAG FindFlag = FINDFLAG_AllAttached,
         INT32 BaseTableNum = -1
         ) const;
         
      //! Get the record numbers attached to the element for this table.
      //! @return Number of records attached or <0 if error 
      INT32 GetAttachedRecordNumbers (
         const RVC::ELEMENT& element,              //!< Element
         const RVC::DBTABLE& table,                //!< Table to get attached records for
         SIMPLE_ARRAY<INT32>& recordnums,          //!< Array of record numbers returned
         FINDFLAG findflags = FINDFLAG_AllAttached
         ) const;

      //! Get array of attachments to this element
      INT32 GetAttachments (
         const RVC::ELEMENT& elem,
         RVC::DBASE_ELEMENT::ATTACHMENTARRAY& items
         ) const;

      //! Get the size of an individual entries for an element database attachment list
      //! @return Number of items for an individual DBList entry
      INT32 GetDBListItemSize (
         INT32 ItemNum,
         bool ExcludeInternal = false
         ) const;

      //! Get the maximum number of entries for an element database attachment list
      //! @return Maximum number of DBList entries
      INT32 GetDBListMaxItemSize (
         ) const;

      //! Get the number of element database attachment list entries
      //! @return Number of DBList entries
      INT32 GetDBListNumElements (
         ) const;

      //! Get element type database is associated with.
      ELEMTYPE GetElemType (
         ) const { return (m_ElemType); }

      //! Determine if the given record has any elements attached
      //! @return 'True' if elements are attached, 'false' if not
      bool HasAttachedElements (
         const RVC::DBTABLE::RECORD& record,
         ELEMTYPE ElemType = ELEMTYPE_All
         ) const;
         
      //! Open the database.  If a database object does not exist, make one
      ERRVALUE OpenAsSubobject (
         const RVC::OBJITEM& ParentObjItem,           //!< Parent object to find and/or create database under
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT widget = 0               //!< Parent dialog handle, 0 for default handle
         );

      //! Open the database.  If a database object does not exist, make one
      ERRVALUE OpenAsSubobject (
         const RVC::GEOSPATIAL& parent,            //!< Parent object to find and/or create database under
         OPENMODE mode = OPENMODE_Read,
         MDLGPARENT widget = 0               //!< Parent dialog handle, 0 for default handle
         );

      //! Read an individual entry from the element database attachment list
      //! @return Number of entries read
      INT32 ReadDBList (
         INT32 ElemNum,
         DBLIST& DBList
         ) const;

      //! Remove the record attachment to the element
      ERRVALUE RemoveAttachment (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTITEM& item
         );

      //! Remove the array of record attachments to the element
      ERRVALUE RemoveAttachments (
         const RVC::ELEMENT& elem,
         const RVC::DBASE_ELEMENT::ATTACHMENTARRAY& items
         );

      //! Resize the number of entries in the element database attachment list
      ERRVALUE ResizeDBList (
         INT32 NumItems
         );

      //! Resize an individual entry from the element database attachment list
      ERRVALUE ResizeDBListItem (
         INT32 ElemNum,
         INT32 NumItems
         );

      //! Swap individual entries from the element database attachment list
      ERRVALUE SwapDBList (
         INT32 Item1,
         INT32 Item2
         );

      //! Write an individual entry from the element database attachment list
      //! @return Number of entries written
      INT32 WriteDBList (
         INT32 ElemNum,
         const DBLIST& DBList
         );

      //! Unattach items from an individual entry from the element database attachment list
      //! @return Number of entries unattached
      INT32 UnattachDBList (
         INT32 ElemNum,
         const DBLIST& DBList
         );

      //! Inform the database code that the number of elements has changed
      //! May not be needed
      ERRVALUE UpdateDBListNumElements (
         INT32 NumElements
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      //! Implementation of RVC::OBJECT virtual methods
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsMultiObject () const;
         
      ELEMTYPE m_ElemType;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };
   
   
class DBASE_ELEMENT::ATTACHMENTITEM {
   public:

      //! Default constructor.      
      ATTACHMENTITEM (
         ) : m_TableNum(TABLE_Invalid), m_RecordNum(RECORD_New) {}
      
      //! Construct from DBTABLE and record number.
      ATTACHMENTITEM (
         const RVC::DBTABLE& table,
         INT32 recordnum
         );

      //! Get the table number
      //! @return Table Number
      INT32 GetTableNum (
         ) const {return (m_TableNum);}

      //! Get the record number
      //! @return Record number
      INT32 GetRecordNum (
         ) const {return (m_RecordNum);}

      //! Set the table number
      void SetTableNum (
         INT32 TableNum
         ) {m_TableNum = TableNum;}

      //! Set the record number
      void SetRecordNum (
         INT32 RecordNum
         ) {m_RecordNum = RecordNum;}

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

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

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


}     //! End of RVC namespace

#endif   //!< INC_RVC_DBELEM_H

---