rvc/shape.h

Go to the documentation of this file.

#ifndef INC_RVC_SHAPE_H
#define INC_RVC_SHAPE_H

#ifndef INC_RVC_GEOMETRC_H
   #include <rvc/geometrc.h>
#endif

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

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class SHAPEHANDLE;
#endif // GENERATING_DOXYGEN_OUTPUT

class SHAPE : public GEOMETRIC {
   public:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class ELEMITERATOR;
      class LINKPARM_ARCSHAPE;
      class LINKPARM_LAS;
      class LINKPARM_ORACLE;
      class LINKPARM_ORACLE_OO4O;
      class LINKPARM_GEODATABASE;
      class LINKPARM_POSTGIS;
      class LINKPARM_MYSQL;
      class LINKPARMS;
      class MAKEPARMS;
      class MAKEPARM_ARCSHAPE;
      class MAKEPARM_ORACLE;
//    class MAKEPARM_GEODATABASE;
//    class MAKEPARM_POSTGIS;
//    class MAKEPARM_MYSQL;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      // Type of elements stored in the database
      enum ELEMENTTYPE {
         ELEMENTTYPE_Unknown = 0,
         ELEMENTTYPE_Point,
         ELEMENTTYPE_Line,
         ELEMENTTYPE_SubRegion,
         ELEMENTTYPE_MultiPoint,
         ELEMENTTYPE_MultiLine,
         ELEMENTTYPE_Region,
         ELEMENTTYPE_MaxTypes
         };
   
      enum LINKTYPE {
         LINKTYPE_Internal = 0,  
         LINKTYPE_Oracle,        
         LINKTYPE_ArcShape,      
         LINKTYPE_Geodatabase,   
         LINKTYPE_PostGIS,       
         LINKTYPE_MySQL,         
         LINKTYPE_OracleOCCI,    
         LINKTYPE_LAS            
         };
         
      class ELEMENT {
         public:
         
            ELEMENT (
               );
               
            ELEMENT (
               const ELEMENT& rhs
               );
               
            ~ELEMENT (
               );
               
            ELEMENT& operator= (
               const ELEMENT& rhs
               );

            void Clear (
               );

            void ComputeExtents (
               DRECT3D& Extents
               ) const;
               
            void ConvertForward (
               const TRANS2D_AFFINE& taf
               );
            
            ERRVALUE ConvertForward (
               const TRANS2D_MAPGEN& tmg
               );

            void ConvertInverse (
               const TRANS2D_AFFINE& taf
               );
            
            ERRVALUE ConvertInverse (
               const TRANS2D_MAPGEN& tmg
               );

            DIMENSION GetDimension (
               ) const { return (m_PolyLine.GetDimension()); }

            ELEMTYPE GetElemType (
               ) const { return (m_ElemType); }
               
            const DRECT2D* GetExtentsIfKnown (
               ) const { return (m_PolyLine.GetExtentsIfKnown()); }

            void GetLines (
               POLYLINELIST& PolyLineList       
               ) const;

            INT32 GetNumComponents (
               ) const;

            const POLYLINE& GetPoints (
               ) const { return (m_PolyLine); }
               
            void GetPolygons (
               REGION2D& region              
               ) const;

            const DBTABLE::RECORD& GetRecord (
               ) const { return (m_Record); }

            DBTABLE::RECORD& GetRecord (
               ) { return (m_Record); }

            bool IsValid (
               ) const;

            void SetPoints (
               const POLYLINE& PointList
               );
               
            void SetLine (
               const POLYLINE& PolyLine
               );

            void SetLines (
               const POLYLINELIST& PolyLineList
               );

            void SetPolygon (
               const POLYLINE& Polygon
               );

            void SetPolygons (
               const REGION2D& region
               );

            void SetRecord (
               DBTABLE::RECORD& Record
               ) { m_Record = Record; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            ELEMTYPE m_ElemType;    
            POLYLINE m_PolyLine;    
            SIMPLE_ARRAY<INT32> m_Index;
            DBTABLE::RECORD m_Record;
            
            friend class SHAPE;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      SHAPE (
         );

      SHAPE (
         const RVC::SHAPE& rhs
         );

      virtual ~SHAPE (
         );

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

      INT32 Add (
         const ELEMENT& Element
         );

      ERRVALUE AssignTable (
         ELEMENT& Element
         );
         
      ERRVALUE Delete (
         INT32 ElemNum
         );
         
      ELEMITERATOR ElementBegin (
         ) const;

      ELEMITERATOR ElementEnd (
         ) const;

      ERRVALUE GenerateRegionSubobject (
         );
         
      ERRVALUE GetConnectionString (
         MISTRING& ConnectString
         );
         
      ELEMENTTYPE GetElementType (
         ) const;
         
      LINKTYPE GetLinkType (
         ) const;

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

      ERRVALUE Link (
         const RVC::OBJITEM& ObjItem,
         const LINKPARMS& LinkParms,
         #ifdef RVC_CREDENTIALS_MANDATORY
            const char* Source,
            const CREDENTIALS* Credentials 
         #else
            const char* Source = 0,
            const CREDENTIALS* Credentials = 0           
         #endif
         );

      ERRVALUE Make (
         const RVC::OBJECT& parent,
         const DESCRIPTOR& Descriptor,
         const MAKEPARMS& MakeParms,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );
      
      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,                       
         const MAKEPARMS& MakeParms,
         #ifdef RVC_CREDENTIALS_MANDATORY
            const char* Source,
            const CREDENTIALS* Credentials
         #else
            const char* Source = 0,
            const CREDENTIALS* Credentials = 0           
         #endif
         );

      ERRVALUE Read (
         INT32 ElemNum,
         ELEMENT& Element
         ) const;
         
      ERRVALUE Refresh (
         );
         
      ERRVALUE Write (
         INT32 ElemNum,
         const ELEMENT& Element
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      virtual ERRVALUE v_CloseObject ();
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenMode, MDLGPARENT parent, const CREDENTIALS* Credentials);

      virtual void v_GetExtents (DRECT3D &extents) const;
      virtual void v_GetScale (double& xscale, double& yscale) const;
      virtual double v_GetZOffset () const;
      virtual double v_GetZScale () const;
      virtual bool v_HasCapability (int Capability) const;
      virtual ERRVALUE v_ScanAutoLink ();
      virtual void v_SetScale (double xscale, double yscale);
      virtual void v_SetZOffset (double zoffset);
      virtual void v_SetZScale (double zscale);

      virtual ERRVALUE v_ExtractTo (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      virtual INT32 v_FindClosestElementLow (ELEMTYPE ElemType, const DPOINT2D& SearchPt, GEOMETRIC::SEARCHFILTER* SearchFilter, double SearchDist, double* DistFromElem) const;
      virtual ERRVALUE v_GetElementExtents (ELEMTYPE ElemType, INT32 ElemNum, DRECT3D& Extents) const;
      virtual INT32 v_GetNextElementID (ELEMTYPE ElemType) const;
      virtual INT32 v_GetNumElements (ELEMTYPE ElemType) const;
      virtual POINTTYPE v_GetPointType () const;
      virtual INT32 v_GetPointSize () const;
      virtual QSEARCHTREE* v_GetSearchTree (ELEMTYPE ElemType) const;
      virtual double v_GetTotalLineLength () const;
      virtual bool v_IsElementDeleted (const RVC::ELEMENT& Element) const;
      virtual bool v_IsEmpty () const;
      virtual ERRVALUE v_SetExtents (const DRECT3D &extents);
      virtual ERRVALUE v_SetNextElementID (ELEMTYPE ElemType, INT32 NextElementID);
      virtual void v_SetSearchTree (ELEMTYPE ElemType, QSEARCHTREE* SearchTree) const;
      virtual ERRVALUE v_SetTotalLineLength (double length);
      virtual int v_SetupElemTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      virtual bool v_TestElementAgainstRegion (const RVC::ELEMENT& Element, const REGION2D& region, TESTCRITERIA TestMode) const;
      virtual ERRVALUE v_UpdateExtents (const DRECT3D &extents);
      
      virtual ERRVALUE v_FindClosestElementsLow (const DPOINT2D& SearchPt, double SearchDist, SEARCHFILTER* SearchFilter, SIMPLE_ARRAY<RVC::ELEMENT>& ElementList, COMPONENT Component) const;
      virtual ERRVALUE v_FindElementDrawSet (ELEMTYPE ElemType, const DRECT2D& SearchExtents, SEARCHRESULT& SearchResult) const;
      virtual ERRVALUE v_FindElementSearchSet (ELEMTYPE ElemType, const DRECT2D& SearchExtents, SEARCHRESULT& SearchResult) const;
      virtual ERRVALUE v_FindElementSet (ELEMTYPE ElemType, const DRECT2D& SearchExtents, UNSIGNEDSET& ElemSet, bool BuildIndex) const;
      virtual ERRVALUE v_ReadElement (INT32 ElemNum, POLYLINELIST& LineList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadElement (INT32 ElemNum, POLYLINE& PointList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadElement (INT32 ElemNum, REGION2D& Region, DIMENSION dim) const;
      virtual ERRVALUE v_ReadNextLine (RVC::ELEMENT& Element, POLYLINELIST& LineList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadNextPoint (RVC::ELEMENT& Element, POLYLINE& PointList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadNextRegion (RVC::ELEMENT& Element, REGION2D& Region, DIMENSION dim) const;
      virtual ERRVALUE v_ReadRegion (const BITSET_UNOWNED& ElemSet, REGION2D& Region, DIMENSION dim, bool NoIslands) const;
      
      ERRVALUE ExtractToCAD (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractToRegion (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractToShape (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractToVector (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      
      SHAPEHANDLE *m_ShapeHandle;
      mutable QSEARCHTREE *m_ShapeQTree;
      mutable ELEMENT m_WorkElement;
      mutable bool m_SetInstanceData;     
      DBTABLE m_ShapeTable;
      mutable SIMPLE_ARRAY<UINT8> m_RecBuffer;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

class SHAPE::ELEMITERATOR {
   public:

      ELEMITERATOR (
         ) : 
         m_ElemNum(-1),
         m_CurrentObj(0),
         m_Element(0)
         {}

      ELEMITERATOR (
         const RVC::SHAPE* shape,
         INT32 ElemNum
         ) : 
         m_ElemNum(ElemNum),
         m_CurrentObj(shape),
         m_Element(0)
         {}

      ELEMITERATOR (
         const ELEMITERATOR& rhs
         );

      ELEMITERATOR (
         const RVC::SHAPE* shape
         );

      virtual ~ELEMITERATOR (
         );

      ELEMITERATOR& operator= (
         const ELEMITERATOR& rhs
         );

      const SHAPE::ELEMENT& operator* (
         ) const { return (*m_Element); }

      const SHAPE::ELEMENT* operator-> (
         ) const { return (&**this); }

      ELEMITERATOR& operator++ (
         );

      ELEMITERATOR& operator-- (
         );

      bool operator== (
         const ELEMITERATOR& rhs
         ) const { return (m_ElemNum == rhs.m_ElemNum && m_CurrentObj == rhs.m_CurrentObj); }

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

      INT32 GetElemNum (
         ) const { return (m_ElemNum); }

   protected:
      INT32 m_ElemNum;
      const SHAPE *m_CurrentObj;
      SHAPE::ELEMENT* m_Element;
   };
         
         
//===================================================================================================================
// SHAPE::LINKPARMS and derived classes

class SHAPE::LINKPARMS {
   public:

      virtual ~LINKPARMS (
         ) {}

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

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

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

      bool GetStorePasswordInLinkObject (
         ) const { return (m_bStorePasswordInLinkObject); }

      const MISTRING& GetTableName (
         ) const {return (m_LinkTable);}

   protected:
   
      LINKPARMS (
         const MISTRING& LinkString,
         SHAPE::LINKTYPE LinkType,
         CHAR_ENCODING Encoding,
         bool StorePasswordInLinkObject
         ) :
         m_LinkString(LinkString),
         m_LinkType(LinkType),
         m_Encoding(Encoding),
         m_bStorePasswordInLinkObject(StorePasswordInLinkObject)
         {}
         
      void SetTableName (
         const MISTRING& TableName
         ) { m_LinkTable = TableName; }
   
   private: 
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTRING m_LinkString;
      MISTRING m_LinkTable;
      SHAPE::LINKTYPE m_LinkType;
      CHAR_ENCODING m_Encoding;
      bool  m_bStorePasswordInLinkObject;
      
      friend class SHAPE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

   
class SHAPE::LINKPARM_ARCSHAPE : public RVC::SHAPE::LINKPARMS {
   public:  
      LINKPARM_ARCSHAPE (
         const FILEPATH& filename,
         CHAR_ENCODING Encoding = CHAR_ENCODING_UTF8
         ) : LINKPARMS(filename.GetOSPath(), LINKTYPE_ArcShape, Encoding, false) {}
   };

   
class SHAPE::LINKPARM_LAS : public RVC::SHAPE::LINKPARMS {
   public:  
      LINKPARM_LAS (
         const FILEPATH& filename,
         CHAR_ENCODING Encoding = CHAR_ENCODING_ASCII
         ) : LINKPARMS(filename.GetOSPath(), LINKTYPE_LAS, Encoding, false) {}
   };


class SHAPE::LINKPARM_ORACLE : public RVC::SHAPE::LINKPARMS {
   public:  
      LINKPARM_ORACLE (
         const MISTRING& LinkString,
         const MISTRING& TableName,
         CHAR_ENCODING Encoding = CHAR_ENCODING_ASCII,
         bool StorePasswordInLinkObject = false
         ) : 
         LINKPARMS(LinkString, LINKTYPE_OracleOCCI, Encoding, StorePasswordInLinkObject)
         {
         SetTableName(TableName);
         }
   };

class SHAPE::LINKPARM_ORACLE_OO4O : public RVC::SHAPE::LINKPARMS {
   public:  
      LINKPARM_ORACLE_OO4O (
         const MISTRING& LinkString,
         const MISTRING& TableName,
         CHAR_ENCODING Encoding = CHAR_ENCODING_ASCII,
         bool StorePasswordInLinkObject = false
         ) : 
         LINKPARMS(LinkString, LINKTYPE_Oracle, Encoding, StorePasswordInLinkObject)
         {
         SetTableName(TableName);
         }
   };

class SHAPE::LINKPARM_GEODATABASE : public RVC::SHAPE::LINKPARMS {
   public:  
      LINKPARM_GEODATABASE (
         const MISTRING& LinkString,
         const MISTRING& TableName,
         bool StorePasswordInLinkObject = false
         ) : 
         LINKPARMS(LinkString, LINKTYPE_Geodatabase, CHAR_ENCODING_Unicode, StorePasswordInLinkObject)
         {
         SetTableName(TableName);
         }
   };


class SHAPE::LINKPARM_POSTGIS : public RVC::SHAPE::LINKPARMS {
   public:  
      LINKPARM_POSTGIS (
         const MISTRING& LinkString,
         const MISTRING& TableName,
         bool StorePasswordInLinkObject = false
         ) : 
         LINKPARMS(LinkString, LINKTYPE_PostGIS, CHAR_ENCODING_Unicode, StorePasswordInLinkObject)
         {
         SetTableName(TableName);
         }
   };

class SHAPE::LINKPARM_MYSQL : public RVC::SHAPE::LINKPARMS {
   public:  
      LINKPARM_MYSQL (
         const MISTRING& LinkString,
         const MISTRING& TableName,
         bool StorePasswordInLinkObject = false
         ) : 
         LINKPARMS(LinkString, LINKTYPE_MySQL, CHAR_ENCODING_Unicode, StorePasswordInLinkObject)
         {
         SetTableName(TableName);
         }
   };


class SHAPE::MAKEPARMS : public GEOMETRIC::MAKEPARMSBASE {
   public:

      virtual ~MAKEPARMS (
         ) {}
         
      const MISTRING& GetConnectionString (
         ) const {return (m_ConnectString);}
         
      const SPATREF::COORDREFSYS& GetCoordRefSys (
         ) const { return (m_CoordRefSys); }
         
      ELEMENTTYPE GetElemType (
         ) const {return (m_ElemType);}

      const DBTABLE::FIELDINFOARRAY& GetFieldInfo (
         ) const { return (m_FieldArray); }
         
      SHAPE::LINKTYPE GetLinkType (
         ) const {return (m_LinkType);}

      bool IsValidElementType (
         ELEMENTTYPE ElementType
         ) const { return (v_IsValidElementType(ElementType)); }
         
   protected:

      MAKEPARMS (
         LINKTYPE LinkType,
         ELEMENTTYPE ElemType,
         const MISTRING& ConnectString,
         const DBTABLE::FIELDINFOARRAY& FieldArray,
         const SPATREF::COORDREFSYS& CoordRefSys,
         POINTTYPE PointType = POINTTYPE_2DXY
         );

      MAKEPARMS (
         const SHAPE& Template,
         LINKTYPE LinkType,
         const MISTRING& ConnectString,
         const SPATREF::COORDREFSYS* CoordRefSys = 0     
         );
         
      MAKEPARMS (
         const GEOMETRIC& GeometricObj,
         ELEMENTTYPE ElemType,
         LINKTYPE LinkType,
         const MISTRING& ConnectString,
         const DESCRIPTOR& BaseTable,
         const SPATREF::COORDREFSYS* CoordRefSys = 0     
         );
         
   private:
      LINKTYPE m_LinkType;
      ELEMENTTYPE m_ElemType;
      MISTRING m_ConnectString;
      DBTABLE::FIELDINFOARRAY m_FieldArray;
      SPATREF::COORDREFSYS m_CoordRefSys;

      bool v_IsValidElementType (ELEMENTTYPE ElementType) const;
   };


class SHAPE::MAKEPARM_ARCSHAPE : public SHAPE::MAKEPARMS {
   public:  
      MAKEPARM_ARCSHAPE (
         ELEMENTTYPE ElemType,
         const FILEPATH& filename,
         const DBTABLE::FIELDINFOARRAY& FieldArray,
         const SPATREF::COORDREFSYS& CoordRefSys,
         POINTTYPE PointType = POINTTYPE_2DXY
         ) : MAKEPARMS(LINKTYPE_ArcShape, ElemType, filename.GetOSPath(), FieldArray, CoordRefSys, PointType) {}
         
      MAKEPARM_ARCSHAPE (
         const SHAPE& Template,
         const FILEPATH& filename,
         const SPATREF::COORDREFSYS* CoordRefSys = 0     
         ) : MAKEPARMS(Template, LINKTYPE_ArcShape, filename.GetOSPath(), CoordRefSys) {}
         
      MAKEPARM_ARCSHAPE (
         const GEOMETRIC& GeometricObj,
         ELEMENTTYPE ElemType,
         const FILEPATH& filename,
         const DESCRIPTOR& BaseTable,
         const SPATREF::COORDREFSYS* CoordRefSys = 0     
         ) : MAKEPARMS(GeometricObj, ElemType, LINKTYPE_ArcShape, filename.GetOSPath(), BaseTable, CoordRefSys) {}
         
   private:
      bool v_IsValidElementType (ELEMENTTYPE ElementType) const;
   };


class SHAPE::MAKEPARM_ORACLE : public SHAPE::MAKEPARMS {
   public:  
      MAKEPARM_ORACLE (
         ELEMENTTYPE ElemType,
         const MISTRING& ConnectString,
         const DBTABLE::FIELDINFOARRAY& FieldArray,
         const SPATREF::COORDREFSYS& CoordRefSys,
         POINTTYPE PointType = POINTTYPE_2DXY
         ) : MAKEPARMS(LINKTYPE_OracleOCCI, ElemType, ConnectString, FieldArray, CoordRefSys, PointType) {}
         
      MAKEPARM_ORACLE (
         const SHAPE& Template,
         const MISTRING& ConnectString,
         const SPATREF::COORDREFSYS* CoordRefSys = 0     
         ) : MAKEPARMS(Template, LINKTYPE_OracleOCCI, ConnectString, CoordRefSys) {}
         
      MAKEPARM_ORACLE (
         const GEOMETRIC& GeometricObj,
         ELEMENTTYPE ElemType,
         const MISTRING& ConnectString,
         const DESCRIPTOR& BaseTable,
         const SPATREF::COORDREFSYS* CoordRefSys = 0     
         ) : MAKEPARMS(GeometricObj, ElemType, LINKTYPE_OracleOCCI, ConnectString, BaseTable, CoordRefSys) {}
         
   private:
      bool v_IsValidElementType (ELEMENTTYPE ElementType) const;
   };

}     

#endif   

---