LTP GCOV extension - code coverage report
Current view: directory - ogr/ogrsf_frmts - ogrsf_frmts.h
Test: gdal_filtered.info
Date: 2010-07-12 Instrumented lines: 4
Code covered: 100.0 % Executed lines: 4

       1                 : /******************************************************************************
       2                 :  * $Id: ogrsf_frmts.h 20003 2010-07-10 19:46:28Z rouault $
       3                 :  *
       4                 :  * Project:  OpenGIS Simple Features Reference Implementation
       5                 :  * Purpose:  Classes related to format registration, and file opening.
       6                 :  * Author:   Frank Warmerdam, warmerda@home.com
       7                 :  *
       8                 :  ******************************************************************************
       9                 :  * Copyright (c) 1999,  Les Technologies SoftMap Inc.
      10                 :  *
      11                 :  * Permission is hereby granted, free of charge, to any person obtaining a
      12                 :  * copy of this software and associated documentation files (the "Software"),
      13                 :  * to deal in the Software without restriction, including without limitation
      14                 :  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
      15                 :  * and/or sell copies of the Software, and to permit persons to whom the
      16                 :  * Software is furnished to do so, subject to the following conditions:
      17                 :  *
      18                 :  * The above copyright notice and this permission notice shall be included
      19                 :  * in all copies or substantial portions of the Software.
      20                 :  *
      21                 :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      22                 :  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      23                 :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
      24                 :  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      25                 :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      26                 :  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
      27                 :  * DEALINGS IN THE SOFTWARE.
      28                 :  ****************************************************************************/
      29                 : 
      30                 : #ifndef _OGRSF_FRMTS_H_INCLUDED
      31                 : #define _OGRSF_FRMTS_H_INCLUDED
      32                 : 
      33                 : #include "ogr_feature.h"
      34                 : #include "ogr_featurestyle.h"
      35                 : 
      36                 : /**
      37                 :  * \file ogrsf_frmts.h
      38                 :  *
      39                 :  * Classes related to registration of format support, and opening datasets.
      40                 :  */
      41                 : 
      42                 : class OGRLayerAttrIndex;
      43                 : class OGRSFDriver;
      44                 : 
      45                 : /************************************************************************/
      46                 : /*                               OGRLayer                               */
      47                 : /************************************************************************/
      48                 : 
      49                 : /**
      50                 :  * This class represents a layer of simple features, with access methods.
      51                 :  *
      52                 :  */
      53                 : 
      54                 : class CPL_DLL OGRLayer
      55                 : {
      56                 :   protected:
      57                 :     int          m_bFilterIsEnvelope;
      58                 :     OGRGeometry *m_poFilterGeom;
      59                 :     OGREnvelope  m_sFilterEnvelope;
      60                 :     
      61                 :     int          FilterGeometry( OGRGeometry * );
      62                 :     int          InstallFilter( OGRGeometry * );
      63                 : 
      64                 :   public:
      65                 :     OGRLayer();
      66                 :     virtual     ~OGRLayer();
      67                 : 
      68                 :     virtual OGRGeometry *GetSpatialFilter();
      69                 :     virtual void        SetSpatialFilter( OGRGeometry * );
      70                 :     virtual void        SetSpatialFilterRect( double dfMinX, double dfMinY,
      71                 :                                               double dfMaxX, double dfMaxY );
      72                 : 
      73                 :     virtual OGRErr      SetAttributeFilter( const char * );
      74                 : 
      75                 :     virtual void        ResetReading() = 0;
      76                 :     virtual OGRFeature *GetNextFeature() = 0;
      77                 :     virtual OGRErr      SetNextByIndex( long nIndex );
      78                 :     virtual OGRFeature *GetFeature( long nFID );
      79                 :     virtual OGRErr      SetFeature( OGRFeature *poFeature );
      80                 :     virtual OGRErr      CreateFeature( OGRFeature *poFeature );
      81                 :     virtual OGRErr      DeleteFeature( long nFID );
      82                 : 
      83                 :     virtual OGRFeatureDefn *GetLayerDefn() = 0;
      84                 : 
      85              17 :     virtual OGRSpatialReference *GetSpatialRef() { return NULL; }
      86                 : 
      87                 :     virtual int         GetFeatureCount( int bForce = TRUE );
      88                 :     virtual OGRErr      GetExtent(OGREnvelope *psExtent, int bForce = TRUE);
      89                 : 
      90                 :     virtual int         TestCapability( const char * ) = 0;
      91                 : 
      92                 :     virtual const char *GetInfo( const char * );
      93                 : 
      94                 :     virtual OGRErr      CreateField( OGRFieldDefn *poField,
      95                 :                                      int bApproxOK = TRUE );
      96                 : 
      97                 :     virtual OGRErr      SyncToDisk();
      98                 : 
      99                 :     virtual OGRStyleTable *GetStyleTable();
     100                 :     virtual void        SetStyleTableDirectly( OGRStyleTable *poStyleTable );
     101                 :                             
     102                 :     virtual void        SetStyleTable(OGRStyleTable *poStyleTable);
     103                 : 
     104                 :     virtual OGRErr      StartTransaction();
     105                 :     virtual OGRErr      CommitTransaction();
     106                 :     virtual OGRErr      RollbackTransaction();
     107                 : 
     108                 :     virtual const char *GetFIDColumn();
     109                 :     virtual const char *GetGeometryColumn();
     110                 : 
     111                 :     int                 Reference();
     112                 :     int                 Dereference();
     113                 :     int                 GetRefCount() const;
     114                 : 
     115                 :     GIntBig             GetFeaturesRead();
     116                 :     
     117                 :     /* consider these private */
     118                 :     OGRErr               InitializeIndexSupport( const char * );
     119             184 :     OGRLayerAttrIndex   *GetIndex() { return m_poAttrIndex; }
     120                 : 
     121                 :  protected:
     122                 :     OGRStyleTable       *m_poStyleTable;
     123                 :     OGRFeatureQuery     *m_poAttrQuery;
     124                 :     OGRLayerAttrIndex   *m_poAttrIndex;
     125                 : 
     126                 :     int                  m_nRefCount;
     127                 : 
     128                 :     GIntBig              m_nFeaturesRead;
     129                 : };
     130                 : 
     131                 : 
     132                 : /************************************************************************/
     133                 : /*                            OGRDataSource                             */
     134                 : /************************************************************************/
     135                 : 
     136                 : /**
     137                 :  * This class represents a data source.  A data source potentially
     138                 :  * consists of many layers (OGRLayer).  A data source normally consists
     139                 :  * of one, or a related set of files, though the name doesn't have to be
     140                 :  * a real item in the file system.
     141                 :  *
     142                 :  * When an OGRDataSource is destroyed, all it's associated OGRLayers objects
     143                 :  * are also destroyed.
     144                 :  */ 
     145                 : 
     146                 : class CPL_DLL OGRDataSource
     147                 : {
     148                 :     friend class OGRSFDriverRegistrar;
     149                 : 
     150                 :     void        *m_hMutex;
     151                 : 
     152                 :   public:
     153                 : 
     154                 :     OGRDataSource();
     155                 :     virtual     ~OGRDataSource();
     156                 :     static void         DestroyDataSource( OGRDataSource * );
     157                 : 
     158                 :     virtual const char  *GetName() = 0;
     159                 : 
     160                 :     virtual int         GetLayerCount() = 0;
     161                 :     virtual OGRLayer    *GetLayer(int) = 0;
     162                 :     virtual OGRLayer    *GetLayerByName(const char *);
     163                 :     virtual OGRErr      DeleteLayer(int);
     164                 : 
     165                 :     virtual int         TestCapability( const char * ) = 0;
     166                 : 
     167                 :     virtual OGRLayer   *CreateLayer( const char *pszName, 
     168                 :                                      OGRSpatialReference *poSpatialRef = NULL,
     169                 :                                      OGRwkbGeometryType eGType = wkbUnknown,
     170                 :                                      char ** papszOptions = NULL );
     171                 :     virtual OGRLayer   *CopyLayer( OGRLayer *poSrcLayer, 
     172                 :                                    const char *pszNewName, 
     173                 :                                    char **papszOptions = NULL );
     174                 : 
     175                 :     virtual OGRStyleTable *GetStyleTable();
     176                 :     virtual void        SetStyleTableDirectly( OGRStyleTable *poStyleTable );
     177                 :                             
     178                 :     virtual void        SetStyleTable(OGRStyleTable *poStyleTable);
     179                 : 
     180                 :     virtual OGRLayer *  ExecuteSQL( const char *pszStatement,
     181                 :                                     OGRGeometry *poSpatialFilter,
     182                 :                                     const char *pszDialect );
     183                 :     virtual void        ReleaseResultSet( OGRLayer * poResultsSet );
     184                 : 
     185                 :     virtual OGRErr      SyncToDisk();
     186                 : 
     187                 :     int                 Reference();
     188                 :     int                 Dereference();
     189                 :     int                 GetRefCount() const;
     190                 :     int                 GetSummaryRefCount() const;
     191                 :     OGRErr              Release();
     192                 : 
     193                 :     OGRSFDriver        *GetDriver() const;
     194                 :     void                SetDriver( OGRSFDriver *poDriver );
     195                 : 
     196                 :   protected:
     197                 : 
     198                 :     OGRErr              ProcessSQLCreateIndex( const char * );
     199                 :     OGRErr              ProcessSQLDropIndex( const char * );
     200                 : 
     201                 :     OGRStyleTable      *m_poStyleTable;
     202                 :     int                 m_nRefCount;
     203                 :     OGRSFDriver        *m_poDriver;
     204                 : };
     205                 : 
     206                 : /************************************************************************/
     207                 : /*                             OGRSFDriver                              */
     208                 : /************************************************************************/
     209                 : 
     210                 : /**
     211                 :  * Represents an operational format driver.
     212                 :  *
     213                 :  * One OGRSFDriver derived class will normally exist for each file format
     214                 :  * registered for use, regardless of whether a file has or will be opened.
     215                 :  * The list of available drivers is normally managed by the
     216                 :  * OGRSFDriverRegistrar.
     217                 :  */
     218                 : 
     219                 : class CPL_DLL OGRSFDriver
     220            3280 : {
     221                 :   public:
     222                 :     virtual     ~OGRSFDriver();
     223                 : 
     224                 :     virtual const char  *GetName() = 0;
     225                 : 
     226                 :     virtual OGRDataSource *Open( const char *pszName, int bUpdate=FALSE ) = 0;
     227                 : 
     228                 :     virtual int         TestCapability( const char * ) = 0;
     229                 : 
     230                 :     virtual OGRDataSource *CreateDataSource( const char *pszName,
     231                 :                                              char ** = NULL );
     232                 :     virtual OGRErr      DeleteDataSource( const char *pszName );
     233                 : 
     234                 :     virtual OGRDataSource *CopyDataSource( OGRDataSource *poSrcDS, 
     235                 :                                            const char *pszNewName, 
     236                 :                                            char **papszOptions = NULL );
     237                 : };
     238                 : 
     239                 : 
     240                 : /************************************************************************/
     241                 : /*                         OGRSFDriverRegistrar                         */
     242                 : /************************************************************************/
     243                 : 
     244                 : /**
     245                 :  * Singleton manager for OGRSFDriver instances that will be used to try
     246                 :  * and open datasources.  Normally the registrar is populated with 
     247                 :  * standard drivers using the OGRRegisterAll() function and does not need
     248                 :  * to be directly accessed.  The driver registrar and all registered drivers
     249                 :  * may be cleaned up on shutdown using OGRCleanupAll().
     250                 :  */
     251                 : 
     252                 : class CPL_DLL OGRSFDriverRegistrar
     253                 : {
     254                 :     int         nDrivers;
     255                 :     OGRSFDriver **papoDrivers;
     256                 : 
     257                 :                 OGRSFDriverRegistrar();
     258                 : 
     259                 :     int         nOpenDSCount;
     260                 :     char        **papszOpenDSRawName;
     261                 :     OGRDataSource **papoOpenDS;
     262                 :     OGRSFDriver **papoOpenDSDriver;
     263                 :     GIntBig     *panOpenDSPID;
     264                 : 
     265                 :   public:
     266                 : 
     267                 :                 ~OGRSFDriverRegistrar();
     268                 : 
     269                 :     static OGRSFDriverRegistrar *GetRegistrar();
     270                 :     static OGRDataSource *Open( const char *pszName, int bUpdate=FALSE,
     271                 :                                 OGRSFDriver ** ppoDriver = NULL );
     272                 : 
     273                 :     OGRDataSource *OpenShared( const char *pszName, int bUpdate=FALSE,
     274                 :                                OGRSFDriver ** ppoDriver = NULL );
     275                 :     OGRErr      ReleaseDataSource( OGRDataSource * );
     276                 : 
     277                 :     void        RegisterDriver( OGRSFDriver * poDriver );
     278                 :     void        DeregisterDriver( OGRSFDriver * poDriver );
     279                 : 
     280                 :     int         GetDriverCount( void );
     281                 :     OGRSFDriver *GetDriver( int iDriver );
     282                 :     OGRSFDriver *GetDriverByName( const char * );
     283                 : 
     284               5 :     int         GetOpenDSCount() { return nOpenDSCount; } 
     285                 :     OGRDataSource *GetOpenDS( int );
     286                 : 
     287                 :     void        AutoLoadDrivers();
     288                 : };
     289                 : 
     290                 : /* -------------------------------------------------------------------- */
     291                 : /*      Various available registration methods.                         */
     292                 : /* -------------------------------------------------------------------- */
     293                 : CPL_C_START
     294                 : void CPL_DLL OGRRegisterAll();
     295                 : 
     296                 : void CPL_DLL RegisterOGRShape();
     297                 : void CPL_DLL RegisterOGRNTF();
     298                 : void CPL_DLL RegisterOGRFME();
     299                 : void CPL_DLL RegisterOGRSDTS();
     300                 : void CPL_DLL RegisterOGRTiger();
     301                 : void CPL_DLL RegisterOGRS57();
     302                 : void CPL_DLL RegisterOGRTAB();
     303                 : void CPL_DLL RegisterOGRMIF();
     304                 : void CPL_DLL RegisterOGROGDI();
     305                 : void CPL_DLL RegisterOGRODBC();
     306                 : void CPL_DLL RegisterOGRPG();
     307                 : void CPL_DLL RegisterOGRMySQL();
     308                 : void CPL_DLL RegisterOGROCI();
     309                 : void CPL_DLL RegisterOGRDGN();
     310                 : void CPL_DLL RegisterOGRGML();
     311                 : void CPL_DLL RegisterOGRLIBKML();
     312                 : void CPL_DLL RegisterOGRKML();
     313                 : void CPL_DLL RegisterOGRGeoJSON();
     314                 : void CPL_DLL RegisterOGRAVCBin();
     315                 : void CPL_DLL RegisterOGRAVCE00();
     316                 : void CPL_DLL RegisterOGRREC();
     317                 : void CPL_DLL RegisterOGRMEM();
     318                 : void CPL_DLL RegisterOGRVRT();
     319                 : void CPL_DLL RegisterOGRDODS();
     320                 : void CPL_DLL RegisterOGRSQLite();
     321                 : void CPL_DLL RegisterOGRCSV();
     322                 : void CPL_DLL RegisterOGRILI1();
     323                 : void CPL_DLL RegisterOGRILI2();
     324                 : void CPL_DLL RegisterOGRGRASS();
     325                 : void CPL_DLL RegisterOGRPGeo();
     326                 : void CPL_DLL RegisterOGRDXFDWG();
     327                 : void CPL_DLL RegisterOGRDXF();
     328                 : void CPL_DLL RegisterOGRSDE();
     329                 : void CPL_DLL RegisterOGRIDB();
     330                 : void CPL_DLL RegisterOGRGMT();
     331                 : void CPL_DLL RegisterOGRBNA();
     332                 : void CPL_DLL RegisterOGRGPX();
     333                 : void CPL_DLL RegisterOGRGeoconcept();
     334                 : void CPL_DLL RegisterOGRIngres();
     335                 : void CPL_DLL RegisterOGRPCIDSK();
     336                 : void CPL_DLL RegisterOGRXPlane();
     337                 : void CPL_DLL RegisterOGRNAS();
     338                 : void CPL_DLL RegisterOGRGeoRSS();
     339                 : void CPL_DLL RegisterOGRGTM();
     340                 : void CPL_DLL RegisterOGRVFK();
     341                 : void CPL_DLL RegisterOGRPGDump();
     342                 : void CPL_DLL RegisterOGRGPSBabel();
     343                 : void CPL_DLL RegisterOGRSUA();
     344                 : void CPL_DLL RegisterOGROpenAir();
     345                 : void CPL_DLL RegisterOGRPDS();
     346                 : CPL_C_END
     347                 : 
     348                 : 
     349                 : #endif /* ndef _OGRSF_FRMTS_H_INCLUDED */

Generated by: LTP GCOV extension version 1.5