/************************************************************************//*                         OGR_L_CreateField()                          *//************************************************************************/OGRErr OGR_L_CreateField( OGRLayerH hLayer, OGRFieldDefnH hField,                           int bApproxOK ){    return ((OGRLayer *) hLayer)->CreateField( (OGRFieldDefn *) hField,                                                bApproxOK );}/************************************************************************//*                          StartTransaction()                          *//************************************************************************/OGRErr OGRLayer::StartTransaction(){    return OGRERR_NONE;}/************************************************************************//*                       OGR_L_StartTransaction()                       *//************************************************************************/OGRErr OGR_L_StartTransaction( OGRLayerH hLayer ){    return ((OGRLayer *)hLayer)->StartTransaction();}/************************************************************************//*                         CommitTransaction()                          *//************************************************************************/OGRErr OGRLayer::CommitTransaction(){    return OGRERR_NONE;}/************************************************************************//*                       OGR_L_CommitTransaction()                      *//************************************************************************/OGRErr OGR_L_CommitTransaction( OGRLayerH hLayer ){    return ((OGRLayer *)hLayer)->CommitTransaction();}/************************************************************************//*                        RollbackTransaction()                         *//************************************************************************/OGRErr OGRLayer::RollbackTransaction(){    return OGRERR_UNSUPPORTED_OPERATION;}/************************************************************************//*                     OGR_L_RollbackTransaction()                      *//************************************************************************/OGRErr OGR_L_RollbackTransaction( OGRLayerH hLayer ){    return ((OGRLayer *)hLayer)->RollbackTransaction();}/************************************************************************//*                         OGR_L_GetLayerDefn()                         *//************************************************************************/OGRFeatureDefnH OGR_L_GetLayerDefn( OGRLayerH hLayer ){    return (OGRFeatureDefnH) ((OGRLayer *)hLayer)->GetLayerDefn();}/************************************************************************//*                        OGR_L_GetSpatialRef()                         *//************************************************************************/OGRSpatialReferenceH OGR_L_GetSpatialRef( OGRLayerH hLayer ){    return (OGRSpatialReferenceH) ((OGRLayer *) hLayer)->GetSpatialRef();}/************************************************************************//*                        OGR_L_TestCapability()                        *//************************************************************************/int OGR_L_TestCapability( OGRLayerH hLayer, const char *pszCap ){    return ((OGRLayer *) hLayer)->TestCapability( pszCap );}/************************************************************************//*                          GetSpatialFilter()                          *//************************************************************************/OGRGeometry *OGRLayer::GetSpatialFilter(){    return m_poFilterGeom;}/************************************************************************//*                       OGR_L_GetSpatialFilter()                       *//************************************************************************/OGRGeometryH OGR_L_GetSpatialFilter( OGRLayerH hLayer ){    return (OGRGeometryH) ((OGRLayer *) hLayer)->GetSpatialFilter();}/************************************************************************//*                          SetSpatialFilter()                          *//************************************************************************/void OGRLayer::SetSpatialFilter( OGRGeometry * poGeomIn ){    if( InstallFilter( poGeomIn ) )        ResetReading();}/************************************************************************//*                       OGR_L_SetSpatialFilter()                       *//************************************************************************/void OGR_L_SetSpatialFilter( OGRLayerH hLayer, OGRGeometryH hGeom ){    ((OGRLayer *) hLayer)->SetSpatialFilter( (OGRGeometry *) hGeom );}/************************************************************************//*                        SetSpatialFilterRect()                        *//************************************************************************/void OGRLayer::SetSpatialFilterRect( double dfMinX, double dfMinY,                                      double dfMaxX, double dfMaxY ){    OGRLinearRing  oRing;    OGRPolygon oPoly;    oRing.addPoint( dfMinX, dfMinY );    oRing.addPoint( dfMinX, dfMaxY );    oRing.addPoint( dfMaxX, dfMaxY );    oRing.addPoint( dfMaxX, dfMinY );    oRing.addPoint( dfMinX, dfMinY );    oPoly.addRing( &oRing );    SetSpatialFilter( &oPoly );}/************************************************************************//*                     OGR_L_SetSpatialFilterRect()                     *//************************************************************************/void OGR_L_SetSpatialFilterRect( OGRLayerH hLayer,                                  double dfMinX, double dfMinY,                                  double dfMaxX, double dfMaxY ){    ((OGRLayer *) hLayer)->SetSpatialFilterRect( dfMinX, dfMinY,                                                  dfMaxX, dfMaxY );}/************************************************************************//*                           InstallFilter()                            *//*                                                                      *//*      This method is only intended to be used from within             *//*      drivers, normally from the SetSpatialFilter() method.           *//*      It installs a filter, and also tests it to see if it is         *//*      rectangular.  If so, it this is kept track of alongside the     *//*      filter geometry itself so we can do cheaper comparisons in      *//*      the FilterGeometry() call.                                      *//*                                                                      *//*      Returns TRUE if the newly installed filter differs in some      *//*      way from the current one.                                       *//************************************************************************/int OGRLayer::InstallFilter( OGRGeometry * poFilter ){    if( m_poFilterGeom == NULL && poFilter == NULL )        return FALSE;/* -------------------------------------------------------------------- *//*      Replace the existing filter.                                    *//* -------------------------------------------------------------------- */    if( m_poFilterGeom != NULL )    {        delete m_poFilterGeom;        m_poFilterGeom = NULL;    }    if( poFilter != NULL )        m_poFilterGeom = poFilter->clone();    m_bFilterIsEnvelope = FALSE;    if( m_poFilterGeom == NULL )        return TRUE;    if( m_poFilterGeom != NULL )        m_poFilterGeom->getEnvelope( &m_sFilterEnvelope );/* -------------------------------------------------------------------- *//*      Now try to determine if the filter is really a rectangle.       *//* -------------------------------------------------------------------- */    if( wkbFlatten(m_poFilterGeom->getGeometryType()) != wkbPolygon )        return TRUE;    OGRPolygon *poPoly = (OGRPolygon *) m_poFilterGeom;    if( poPoly->getNumInteriorRings() != 0 )        return TRUE;    OGRLinearRing *poRing = poPoly->getExteriorRing();    if( poRing->getNumPoints() > 5 || poRing->getNumPoints() < 4 )        return TRUE;    // If the ring has 5 points, the last should be the first.     if( poRing->getNumPoints() == 5         && ( poRing->getX(0) != poRing->getX(4)             || poRing->getY(0) != poRing->getY(4) ) )        return TRUE;    // Polygon with first segment in "y" direction.     if( poRing->getX(0) == poRing->getX(1)        && poRing->getY(1) == poRing->getY(2)        && poRing->getX(2) == poRing->getX(3)        && poRing->getY(3) == poRing->getY(0) )        m_bFilterIsEnvelope = TRUE;    // Polygon with first segment in "x" direction.     if( poRing->getY(0) == poRing->getY(1)        && poRing->getX(1) == poRing->getX(2)        && poRing->getY(2) == poRing->getY(3)        && poRing->getX(3) == poRing->getX(0) )        m_bFilterIsEnvelope = TRUE;    return TRUE;}/************************************************************************//*                           FilterGeometry()                           *//*                                                                      *//*      Compare the passed in geometry to the currently installed       *//*      filter.  Optimize for case where filter is just an              *//*      envelope.                                                       *//************************************************************************/int OGRLayer::FilterGeometry( OGRGeometry *poGeometry ){/* -------------------------------------------------------------------- *//*      In trivial cases of new filter or target geometry, we accept    *//*      an intersection.  No geometry is taken to mean "the whole       *//*      world".                                                         *//* -------------------------------------------------------------------- */    if( m_poFilterGeom == NULL )        return TRUE;    if( poGeometry == NULL )        return TRUE;/* -------------------------------------------------------------------- *//*      Compute the target geometry envelope, and if there is no        *//*      intersection between the envelopes we are sure not to have      *//*      any intersection.                                               *//* -------------------------------------------------------------------- */    OGREnvelope sGeomEnv;    poGeometry->getEnvelope( &sGeomEnv );    if( sGeomEnv.MaxX < m_sFilterEnvelope.MinX        || sGeomEnv.MaxY < m_sFilterEnvelope.MinY        || m_sFilterEnvelope.MaxX < sGeomEnv.MinX        || m_sFilterEnvelope.MaxY < sGeomEnv.MinY )        return FALSE;/* -------------------------------------------------------------------- *//*      Fallback to full intersect test (using GEOS) if we still        *//*      don't know for sure.                                            *//* -------------------------------------------------------------------- */    if( m_bFilterIsEnvelope )        return TRUE;    else    {        if( OGRGeometryFactory::haveGEOS() )            return m_poFilterGeom->Intersects( poGeometry );        else            return TRUE;    }}/************************************************************************//*                         OGR_L_ResetReading()                         *//************************************************************************/void OGR_L_ResetReading( OGRLayerH hLayer ){    ((OGRLayer *) hLayer)->ResetReading();}/************************************************************************//*                       InitializeIndexSupport()                       *//*                                                                      *//*      This is only intended to be called by driver layer              *//*      implementations but we don't make it protected so that the      *//*      datasources can do it too if that is more appropriate.          *//************************************************************************/OGRErr OGRLayer::InitializeIndexSupport( const char *pszFilename ){    OGRErr eErr;    m_poAttrIndex = OGRCreateDefaultLayerIndex();    eErr = m_poAttrIndex->Initialize( pszFilename, this );    if( eErr != OGRERR_NONE )    {        delete m_poAttrIndex;        m_poAttrIndex = NULL;    }    return eErr;}/************************************************************************//*                             SyncToDisk()                             *//************************************************************************/OGRErr OGRLayer::SyncToDisk(){    return OGRERR_NONE;}/************************************************************************//*                          OGR_L_SyncToDisk()                          *//************************************************************************/OGRErr OGR_L_SyncToDisk( OGRLayerH hDS ){    return ((OGRLayer *) hDS)->SyncToDisk();}/************************************************************************//*                           DeleteFeature()                            *//************************************************************************/OGRErr OGRLayer::DeleteFeature( long nFID ){    return OGRERR_UNSUPPORTED_OPERATION;}/************************************************************************//*                        OGR_L_DeleteFeature()                         *//************************************************************************/OGRErr OGR_L_DeleteFeature( OGRLayerH hDS, long nFID ){    return ((OGRLayer *) hDS)->DeleteFeature( nFID );}/************************************************************************//*                          GetFeaturesRead()                           *//************************************************************************/GIntBig OGRLayer::GetFeaturesRead(){    return m_nFeaturesRead;}/************************************************************************//*                       OGR_L_GetFeaturesRead()                        *//************************************************************************/GIntBig OGR_L_GetFeaturesRead( OGRLayerH hLayer ){    return ((OGRLayer *) hLayer)->GetFeaturesRead();}/************************************************************************//*                             GetFIDColumn                             *//************************************************************************/const char *OGRLayer::GetFIDColumn(){    return "";}/************************************************************************//*                         OGR_L_GetFIDColumn()                         *//************************************************************************/const char *OGR_L_GetFIDColumn( OGRLayerH hLayer ){    return ((OGRLayer *) hLayer)->GetFIDColumn();}/************************************************************************//*                         GetGeometryColumn()                          *//************************************************************************/const char *OGRLayer::GetGeometryColumn(){    return "";}/************************************************************************//*                      OGR_L_GetGeometryColumn()                       *//************************************************************************/const char *OGR_L_GetGeometryColumn( OGRLayerH hLayer ){    return ((OGRLayer *) hLayer)->GetGeometryColumn();}