LCOV - code coverage report
Current view: directory - ogr/ogrsf_frmts/tiger - tigerfilebase.cpp (source / functions) Found Hit Coverage
Test: gdal_filtered.info Lines: 218 190 87.2 %
Date: 2012-12-26 Functions: 21 18 85.7 %

       1                 : /******************************************************************************
       2                 :  * $Id: tigerfilebase.cpp 23871 2012-02-02 03:24:07Z warmerdam $
       3                 :  *
       4                 :  * Project:  TIGER/Line Translator
       5                 :  * Purpose:  Implements TigerBaseFile class, providing common services to all
       6                 :  *           the tiger file readers.
       7                 :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       8                 :  *
       9                 :  ******************************************************************************
      10                 :  * Copyright (c) 1999, Frank Warmerdam
      11                 :  *
      12                 :  * Permission is hereby granted, free of charge, to any person obtaining a
      13                 :  * copy of this software and associated documentation files (the "Software"),
      14                 :  * to deal in the Software without restriction, including without limitation
      15                 :  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
      16                 :  * and/or sell copies of the Software, and to permit persons to whom the
      17                 :  * Software is furnished to do so, subject to the following conditions:
      18                 :  *
      19                 :  * The above copyright notice and this permission notice shall be included
      20                 :  * in all copies or substantial portions of the Software.
      21                 :  *
      22                 :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      23                 :  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      24                 :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
      25                 :  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      26                 :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      27                 :  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
      28                 :  * DEALINGS IN THE SOFTWARE.
      29                 :  ****************************************************************************/
      30                 : 
      31                 : #include "ogr_tiger.h"
      32                 : #include "cpl_conv.h"
      33                 : #include "cpl_error.h"
      34                 : #include "cpl_string.h"
      35                 : 
      36                 : CPL_CVSID("$Id: tigerfilebase.cpp 23871 2012-02-02 03:24:07Z warmerdam $");
      37                 : 
      38                 : /************************************************************************/
      39                 : /*                           TigerFileBase()                            */
      40                 : /************************************************************************/
      41                 : 
      42             180 : TigerFileBase::TigerFileBase( const TigerRecordInfo *psRTInfoIn,
      43             180 :                               const char            *m_pszFileCodeIn )
      44                 : 
      45                 : {
      46             180 :     pszShortModule = NULL;
      47             180 :     pszModule = NULL;
      48             180 :     fpPrimary = NULL;
      49             180 :     poFeatureDefn = NULL;
      50             180 :     nFeatures = 0;
      51             180 :     nVersionCode = 0;
      52             180 :     nVersion = TIGER_Unknown;
      53                 : 
      54             180 :     psRTInfo = psRTInfoIn;
      55             180 :     m_pszFileCode = m_pszFileCodeIn;
      56             180 : }
      57                 : 
      58                 : /************************************************************************/
      59                 : /*                           ~TigerFileBase()                           */
      60                 : /************************************************************************/
      61                 : 
      62             180 : TigerFileBase::~TigerFileBase()
      63                 : 
      64                 : {
      65             180 :     CPLFree( pszModule );
      66             180 :     CPLFree( pszShortModule );
      67                 : 
      68             180 :     if( poFeatureDefn != NULL )
      69                 :     {
      70             180 :         poFeatureDefn->Release();
      71             180 :         poFeatureDefn = NULL;
      72                 :     }
      73                 : 
      74             180 :     if( fpPrimary != NULL )
      75                 :     {
      76              56 :       VSIFCloseL( fpPrimary );
      77              56 :         fpPrimary = NULL;
      78                 :     }
      79             180 : }
      80                 : 
      81                 : /************************************************************************/
      82                 : /*                              OpenFile()                              */
      83                 : /************************************************************************/
      84                 : 
      85             561 : int TigerFileBase::OpenFile( const char * pszModuleToOpen,
      86                 :                              const char *pszExtension )
      87                 : 
      88                 : {
      89                 :     char        *pszFilename;
      90                 : 
      91             561 :     CPLFree( pszModule );
      92             561 :     pszModule = NULL;
      93             561 :     CPLFree( pszShortModule );
      94             561 :     pszShortModule = NULL;
      95                 :     
      96             561 :     if( fpPrimary != NULL )
      97                 :     {
      98             323 :         VSIFCloseL( fpPrimary );
      99             323 :         fpPrimary = NULL;
     100                 :     }
     101                 : 
     102             561 :     if( pszModuleToOpen == NULL )
     103             180 :         return TRUE;
     104                 : 
     105             381 :     pszFilename = poDS->BuildFilename( pszModuleToOpen, pszExtension );
     106                 : 
     107             381 :     fpPrimary = VSIFOpenL( pszFilename, "rb" );
     108                 : 
     109             381 :     CPLFree( pszFilename );
     110                 : 
     111             381 :     if( fpPrimary != NULL )
     112                 :     {
     113             363 :         pszModule = CPLStrdup(pszModuleToOpen);
     114             363 :         pszShortModule = CPLStrdup(pszModuleToOpen);
     115            4356 :         for( int i = 0; pszShortModule[i] != '\0'; i++ )
     116                 :         {
     117            3993 :             if( pszShortModule[i] == '.' )
     118             363 :                 pszShortModule[i] = '\0';
     119                 :         }
     120                 : 
     121             363 :         SetupVersion();
     122                 : 
     123             363 :         return TRUE;
     124                 :     }
     125                 :     else
     126              18 :         return FALSE;
     127                 : }
     128                 : 
     129                 : /************************************************************************/
     130                 : /*                            SetupVersion()                            */
     131                 : /************************************************************************/
     132                 : 
     133             363 : void TigerFileBase::SetupVersion()
     134                 : 
     135                 : {
     136                 :     char        aszRecordHead[6];
     137                 : 
     138             363 :     VSIFSeekL( fpPrimary, 0, SEEK_SET );
     139             363 :     VSIFReadL( aszRecordHead, 1, 5, fpPrimary );
     140             363 :     aszRecordHead[5] = '\0';
     141             363 :     nVersionCode = atoi(aszRecordHead+1);
     142             363 :     VSIFSeekL( fpPrimary, 0, SEEK_SET );
     143                 : 
     144             363 :     nVersion = TigerClassifyVersion( nVersionCode );
     145             363 : }
     146                 : 
     147                 : /************************************************************************/
     148                 : /*                       EstablishRecordLength()                        */
     149                 : /************************************************************************/
     150                 : 
     151             384 : int TigerFileBase::EstablishRecordLength( VSILFILE * fp )
     152                 : 
     153                 : {
     154                 :     char        chCurrent;
     155             384 :     int         nRecLen = 0;
     156                 :     
     157             384 :     if( fp == NULL || VSIFSeekL( fp, 0, SEEK_SET ) != 0 )
     158               0 :         return -1;
     159                 : 
     160                 : /* -------------------------------------------------------------------- */
     161                 : /*      Read through to the end of line.                                */
     162                 : /* -------------------------------------------------------------------- */
     163             384 :     chCurrent = '\0';
     164           37252 :     while( VSIFReadL( &chCurrent, 1, 1, fp ) == 1
     165                 :            && chCurrent != 10
     166                 :            && chCurrent != 13 )
     167                 :     {
     168           36484 :         nRecLen++;
     169                 :     }
     170                 : 
     171                 : /* -------------------------------------------------------------------- */
     172                 : /*      Is the file zero length?                                        */
     173                 : /* -------------------------------------------------------------------- */
     174             384 :     if( nRecLen == 0 )
     175                 :     {
     176               0 :         return -1;
     177                 :     }
     178                 :     
     179             384 :     nRecLen++; /* for the 10 or 13 we encountered */
     180                 : 
     181                 : /* -------------------------------------------------------------------- */
     182                 : /*      Read through line terminator characters.  We are trying to      */
     183                 : /*      handle cases of CR, CR/LF and LF/CR gracefully.                 */
     184                 : /* -------------------------------------------------------------------- */
     185            1152 :     while( VSIFReadL( &chCurrent, 1, 1, fp ) == 1
     186                 :            && (chCurrent == 10 || chCurrent == 13 ) )
     187                 :     {
     188             384 :         nRecLen++;
     189                 :     }
     190                 : 
     191             384 :     VSIFSeekL( fp, 0, SEEK_SET );
     192                 : 
     193             384 :     return nRecLen;
     194                 : }
     195                 : 
     196                 : /************************************************************************/
     197                 : /*                       EstablishFeatureCount()                        */
     198                 : /************************************************************************/
     199                 : 
     200             543 : void TigerFileBase::EstablishFeatureCount()
     201                 : 
     202                 : {
     203             543 :     if( fpPrimary == NULL )
     204             180 :         return;
     205                 : 
     206             363 :     nRecordLength = EstablishRecordLength( fpPrimary );
     207                 : 
     208             363 :     if( nRecordLength == -1 )
     209                 :     {
     210               0 :         nRecordLength = 1;
     211               0 :         nFeatures = 0;
     212               0 :         return;
     213                 :     }
     214                 : 
     215                 : /* -------------------------------------------------------------------- */
     216                 : /*      Now we think we know the fixed record length for the file       */
     217                 : /*      (including line terminators).  Get the total file size, and     */
     218                 : /*      divide by this length to get the presumed number of records.    */
     219                 : /* -------------------------------------------------------------------- */
     220                 :     long        nFileSize;
     221                 :     
     222             363 :     VSIFSeekL( fpPrimary, 0, SEEK_END );
     223             363 :     nFileSize = VSIFTellL( fpPrimary );
     224                 : 
     225             363 :     if( (nFileSize % nRecordLength) != 0 )
     226                 :     {
     227                 :         CPLError( CE_Warning, CPLE_FileIO,
     228                 :                   "TigerFileBase::EstablishFeatureCount(): "
     229                 :                   "File length %d doesn't divide by record length %d.\n",
     230               0 :                   (int) nFileSize, (int) nRecordLength );
     231                 :     }
     232                 : 
     233             363 :     nFeatures = nFileSize / nRecordLength;
     234                 : }
     235                 : 
     236                 : /************************************************************************/
     237                 : /*                              GetField()                              */
     238                 : /************************************************************************/
     239                 : 
     240        27870114 : const char* TigerFileBase::GetField( const char * pachRawDataRecord,
     241                 :                                      int nStartChar, int nEndChar )
     242                 : 
     243                 : {
     244                 :     char         aszField[128];
     245        27870114 :     int                 nLength = nEndChar - nStartChar + 1;
     246                 :     
     247        27870114 :     CPLAssert( nEndChar - nStartChar + 2 < (int) sizeof(aszField) );
     248                 : 
     249        27870114 :     strncpy( aszField, pachRawDataRecord + nStartChar - 1, nLength );
     250                 : 
     251        27870114 :     aszField[nLength] = '\0';
     252       119255502 :     while( nLength > 0 && aszField[nLength-1] == ' ' )
     253        63515274 :         aszField[--nLength] = '\0';
     254                 : 
     255        27870114 :     return CPLSPrintf("%s", aszField);
     256                 : }
     257                 : 
     258                 : /************************************************************************/
     259                 : /*                              SetField()                              */
     260                 : /*                                                                      */
     261                 : /*      Set a field on an OGRFeature from a tiger record, or leave      */
     262                 : /*      NULL if the value isn't found.                                  */
     263                 : /************************************************************************/
     264                 : 
     265        19381443 : void TigerFileBase::SetField( OGRFeature *poFeature, const char *pszField,
     266                 :                               const char *pachRecord, int nStart, int nEnd )
     267                 : 
     268                 : {
     269        19381443 :     const char *pszFieldValue = GetField( pachRecord, nStart, nEnd );
     270                 : 
     271        19381443 :     if( pszFieldValue[0] == '\0' )
     272         9685101 :         return;
     273                 : 
     274         9696342 :     poFeature->SetField( pszField, pszFieldValue );
     275                 : }
     276                 : 
     277                 : /************************************************************************/
     278                 : /*                             WriteField()                             */
     279                 : /*                                                                      */
     280                 : /*      Write a field into a record buffer with the indicated           */
     281                 : /*      formatting, or leave blank if not found.                        */
     282                 : /************************************************************************/
     283                 : 
     284         1999075 : int TigerFileBase::WriteField( OGRFeature *poFeature, const char *pszField, 
     285                 :                                char *pachRecord, int nStart, int nEnd, 
     286                 :                                char chFormat, char chType )
     287                 : 
     288                 : {
     289         1999075 :     int         iField = poFeature->GetFieldIndex( pszField );
     290                 :     char        szValue[512], szFormat[32];
     291                 : 
     292         1999075 :     CPLAssert( nEnd - nStart + 1 < (int) sizeof(szValue)-1 );
     293                 : 
     294         1999075 :     if( iField < 0 || !poFeature->IsFieldSet( iField ) )
     295          933690 :         return FALSE;
     296                 : 
     297         1481547 :     if( chType == 'N' && chFormat == 'L' )
     298                 :     {
     299          416162 :         sprintf( szFormat, "%%0%dd", nEnd - nStart + 1 );
     300          416162 :         sprintf( szValue, szFormat, poFeature->GetFieldAsInteger( iField ) );
     301                 :     }
     302         1019006 :     else if( chType == 'N' && chFormat == 'R' )
     303                 :     {
     304          369783 :         sprintf( szFormat, "%%%dd", nEnd - nStart + 1 );
     305          369783 :         sprintf( szValue, szFormat, poFeature->GetFieldAsInteger( iField ) );
     306                 :     }
     307          499399 :     else if( chType == 'A' && chFormat == 'L' )
     308                 :     {
     309                 :         strncpy( szValue, poFeature->GetFieldAsString( iField ), 
     310          219959 :                  sizeof(szValue) - 1 );
     311          219959 :         szValue[sizeof(szValue) - 1] = 0;
     312          219959 :         if( (int) strlen(szValue) < nEnd - nStart + 1 )
     313                 :             memset( szValue + strlen(szValue), ' ', 
     314           32822 :                     nEnd - nStart + 1 - strlen(szValue) );
     315                 :     }
     316          118962 :     else if( chType == 'A' && chFormat == 'R' )
     317                 :     {
     318           59481 :         sprintf( szFormat, "%%%ds", nEnd - nStart + 1 );
     319           59481 :         sprintf( szValue, szFormat, poFeature->GetFieldAsString( iField ) );
     320                 :     }
     321                 :     else
     322                 :     {
     323               0 :         CPLAssert( FALSE );
     324               0 :         return FALSE;
     325                 :     }
     326                 : 
     327         1065385 :     strncpy( pachRecord + nStart - 1, szValue, nEnd - nStart + 1 );
     328                 : 
     329         1065385 :     return TRUE;
     330                 : }
     331                 : 
     332                 : /************************************************************************/
     333                 : /*                             WritePoint()                             */
     334                 : /************************************************************************/
     335                 : 
     336          351775 : int TigerFileBase::WritePoint( char *pachRecord, int nStart, 
     337                 :                                double dfX, double dfY )
     338                 : 
     339                 : {
     340                 :     char        szTemp[20];
     341                 : 
     342          440420 :     if( dfX == 0.0 && dfY == 0.0 )
     343                 :     {
     344           88645 :         strncpy( pachRecord + nStart - 1, "+000000000+00000000", 19 );
     345                 :     }
     346                 :     else
     347                 :     {
     348                 :         sprintf( szTemp, "%+10d%+9d", 
     349                 :                  (int) floor(dfX * 1000000 + 0.5),
     350          263130 :                  (int) floor(dfY * 1000000 + 0.5) );
     351          263130 :         strncpy( pachRecord + nStart - 1, szTemp, 19 );
     352                 :     }
     353                 : 
     354          351775 :     return TRUE;
     355                 : }
     356                 : 
     357                 : /************************************************************************/
     358                 : /*                            WriteRecord()                             */
     359                 : /************************************************************************/
     360                 : 
     361          160092 : int TigerFileBase::WriteRecord( char *pachRecord, int nRecLen, 
     362                 :                                 const char *pszType, VSILFILE * fp )
     363                 : 
     364                 : {
     365          160092 :     if( fp == NULL )
     366          124787 :         fp = fpPrimary;
     367                 : 
     368          160092 :     pachRecord[0] = *pszType;
     369                 : 
     370                 : 
     371                 :     /*
     372                 :      * Prior to TIGER_2002, type 5 files lacked the version.  So write
     373                 :      * the version in the record iff we're using TIGER_2002 or higher,
     374                 :      * or if this is not type "5"
     375                 :      */
     376          160092 :     if ( (poDS->GetVersion() >= TIGER_2002) ||
     377                 :          (!EQUAL(pszType, "5")) )
     378                 :     {
     379                 :         char    szVersion[5];
     380          160092 :         sprintf( szVersion, "%04d", poDS->GetVersionCode() );
     381          160092 :         strncpy( pachRecord + 1, szVersion, 4 );
     382                 :     }
     383                 : 
     384          160092 :     VSIFWriteL( pachRecord, nRecLen, 1, fp );
     385          160092 :     VSIFWriteL( (void *) "\r\n", 2, 1, fp );
     386                 : 
     387          160092 :     return TRUE;
     388                 : }
     389                 : 
     390                 : /************************************************************************/
     391                 : /*                           SetWriteModule()                           */
     392                 : /*                                                                      */
     393                 : /*      Setup our access to be to the module indicated in the feature.  */
     394                 : /************************************************************************/
     395                 : 
     396          124787 : int TigerFileBase::SetWriteModule( const char *pszExtension, int nRecLen,
     397                 :                                    OGRFeature *poFeature )
     398                 : 
     399                 : {
     400                 : /* -------------------------------------------------------------------- */
     401                 : /*      Work out what module we should be writing to.                   */
     402                 : /* -------------------------------------------------------------------- */
     403          124787 :     const char *pszTargetModule = poFeature->GetFieldAsString( "MODULE" );
     404                 :     char        szFullModule[30];
     405                 : 
     406                 :     /* TODO/notdef: eventually more logic based on FILE and STATE/COUNTY can 
     407                 :        be inserted here. */
     408                 : 
     409          124787 :     if( pszTargetModule == NULL )
     410               0 :         return FALSE;
     411                 : 
     412          124787 :     sprintf( szFullModule, "%s.RT", pszTargetModule );
     413                 : 
     414                 : /* -------------------------------------------------------------------- */
     415                 : /*      Is this our current module?                                     */
     416                 : /* -------------------------------------------------------------------- */
     417          124787 :     if( pszModule != NULL && EQUAL(szFullModule,pszModule) )
     418          124771 :         return TRUE;
     419                 : 
     420                 : /* -------------------------------------------------------------------- */
     421                 : /*      Cleanup the previous file, if any.                              */
     422                 : /* -------------------------------------------------------------------- */
     423              16 :     if( fpPrimary != NULL )
     424                 :     {
     425               0 :         VSIFCloseL( fpPrimary );
     426               0 :         fpPrimary = NULL;
     427                 :     }
     428                 : 
     429              16 :     if( pszModule != NULL )
     430                 :     {
     431               0 :         CPLFree( pszModule );
     432               0 :         pszModule = NULL;
     433                 :     }
     434                 : 
     435                 : /* -------------------------------------------------------------------- */
     436                 : /*      Is this a module we have never written to before?  If so, we    */
     437                 : /*      will try to blow away any existing files in this file set.      */
     438                 : /* -------------------------------------------------------------------- */
     439              16 :     if( !poDS->CheckModule( szFullModule ) )
     440                 :     {
     441               1 :         poDS->DeleteModuleFiles( szFullModule );
     442               1 :         poDS->AddModule( szFullModule );
     443                 :     }
     444                 :     
     445                 : /* -------------------------------------------------------------------- */
     446                 : /*      Does this file already exist?                                   */
     447                 : /* -------------------------------------------------------------------- */
     448                 :     char *pszFilename;
     449                 : 
     450              16 :     pszFilename = poDS->BuildFilename( szFullModule, pszExtension );
     451                 : 
     452              16 :     fpPrimary = VSIFOpenL( pszFilename, "ab" );
     453              16 :     CPLFree(pszFilename);
     454              16 :     if( fpPrimary == NULL )
     455               0 :         return FALSE;
     456                 : 
     457              16 :     pszModule = CPLStrdup( szFullModule );
     458                 : 
     459              16 :     return TRUE;
     460                 : }
     461                 : 
     462                 : /************************************************************************/
     463                 : /*                           AddFieldDefns()                            */
     464                 : /************************************************************************/
     465             190 : void TigerFileBase::AddFieldDefns(const TigerRecordInfo *psRTInfo,
     466                 :                                   OGRFeatureDefn  *poFeatureDefn)
     467                 : {
     468             190 :     OGRFieldDefn        oField("",OFTInteger);
     469                 :     int i, bLFieldHack;
     470                 : 
     471                 :     bLFieldHack = 
     472             190 :         CSLTestBoolean( CPLGetConfigOption( "TIGER_LFIELD_AS_STRING", "NO" ) );
     473                 :     
     474            3070 :     for (i=0; i<psRTInfo->nFieldCount; ++i) {
     475            2880 :         if (psRTInfo->pasFields[i].bDefine) {
     476            2830 :             OGRFieldType eFT = (OGRFieldType)psRTInfo->pasFields[i].OGRtype;
     477                 : 
     478            2830 :             if( bLFieldHack 
     479               0 :                 && psRTInfo->pasFields[i].cFmt == 'L' 
     480               0 :                 && psRTInfo->pasFields[i].cType == 'N' )
     481               0 :                 eFT = OFTString;
     482                 : 
     483            2830 :             oField.Set( psRTInfo->pasFields[i].pszFieldName, eFT, 
     484            5660 :                         psRTInfo->pasFields[i].nLen );
     485            2830 :             poFeatureDefn->AddFieldDefn( &oField );
     486                 :         }
     487             190 :     }
     488             190 : }
     489                 : 
     490                 : /************************************************************************/
     491                 : /*                             SetFields()                              */
     492                 : /************************************************************************/
     493                 : 
     494         1154138 : void TigerFileBase::SetFields(const TigerRecordInfo *psRTInfo,
     495                 :                               OGRFeature      *poFeature,
     496                 :                               char            *achRecord)
     497                 : {
     498                 :   int i;
     499        21854477 :   for (i=0; i<psRTInfo->nFieldCount; ++i) {
     500        20700339 :     if (psRTInfo->pasFields[i].bSet) {
     501                 :       SetField( poFeature,
     502        19381443 :                 psRTInfo->pasFields[i].pszFieldName,
     503                 :                 achRecord, 
     504        19381443 :                 psRTInfo->pasFields[i].nBeg,
     505        58144329 :                 psRTInfo->pasFields[i].nEnd );
     506                 :     }
     507                 :   }
     508         1154138 : }
     509                 : 
     510                 : /************************************************************************/
     511                 : /*                             WriteField()                             */
     512                 : /************************************************************************/
     513          129231 : void TigerFileBase::WriteFields(const TigerRecordInfo *psRTInfo,
     514                 :                                 OGRFeature      *poFeature,
     515                 :                                 char            *szRecord)
     516                 : {
     517                 :   int i;
     518         2225044 :   for (i=0; i<psRTInfo->nFieldCount; ++i) {
     519         2095813 :     if (psRTInfo->pasFields[i].bWrite) {
     520                 :       WriteField( poFeature,
     521         1968214 :                   psRTInfo->pasFields[i].pszFieldName,
     522                 :                   szRecord, 
     523         1968214 :                   psRTInfo->pasFields[i].nBeg,
     524         1968214 :                   psRTInfo->pasFields[i].nEnd,
     525         1968214 :                   psRTInfo->pasFields[i].cFmt,
     526         9841070 :                   psRTInfo->pasFields[i].cType );
     527                 :     }
     528                 :   }
     529          129231 : }
     530                 : 
     531                 : 
     532                 : 
     533                 : /************************************************************************/
     534                 : /*                             SetModule()                              */
     535                 : /************************************************************************/
     536                 : 
     537             489 : int TigerFileBase::SetModule( const char * pszModule )
     538                 : 
     539                 : {
     540             489 :     if (m_pszFileCode == NULL)
     541               0 :         return FALSE;
     542                 : 
     543             489 :     if( !OpenFile( pszModule, m_pszFileCode ) )
     544              18 :         return FALSE;
     545                 : 
     546             471 :     EstablishFeatureCount();
     547                 : 
     548             471 :     return TRUE;
     549                 : }
     550                 : 
     551                 : /************************************************************************/
     552                 : /*                             GetFeature()                             */
     553                 : /************************************************************************/
     554                 : 
     555          748461 : OGRFeature *TigerFileBase::GetFeature( int nRecordId )
     556                 : 
     557                 : {
     558                 :     char        achRecord[OGR_TIGER_RECBUF_LEN];
     559                 : 
     560          748461 :     if (psRTInfo == NULL)
     561               0 :         return NULL;
     562                 : 
     563          748461 :     if( nRecordId < 0 || nRecordId >= nFeatures )
     564                 :     {
     565                 :         CPLError( CE_Failure, CPLE_FileIO,
     566                 :                   "Request for out-of-range feature %d of %s",
     567               0 :                   nRecordId, pszModule );
     568               0 :         return NULL;
     569                 :     }
     570                 : 
     571                 : /* -------------------------------------------------------------------- */
     572                 : /*      Read the raw record data from the file.                         */
     573                 : /* -------------------------------------------------------------------- */
     574          748461 :     if( fpPrimary == NULL )
     575               0 :         return NULL;
     576                 : 
     577          748461 :     if( VSIFSeekL( fpPrimary, nRecordId * nRecordLength, SEEK_SET ) != 0 )
     578                 :     {
     579                 :         CPLError( CE_Failure, CPLE_FileIO,
     580                 :                   "Failed to seek to %d of %s",
     581               0 :                   nRecordId * nRecordLength, pszModule );
     582               0 :         return NULL;
     583                 :     }
     584                 : 
     585          748461 :     if( VSIFReadL( achRecord, psRTInfo->nRecordLength, 1, fpPrimary ) != 1 )
     586                 :     {
     587                 :         CPLError( CE_Failure, CPLE_FileIO,
     588                 :                   "Failed to read record %d of %s",
     589               0 :                   nRecordId, pszModule );
     590               0 :         return NULL;
     591                 :     }
     592                 : 
     593                 : /* -------------------------------------------------------------------- */
     594                 : /*      Set fields.                                                     */
     595                 : /* -------------------------------------------------------------------- */
     596          748461 :     OGRFeature  *poFeature = new OGRFeature( poFeatureDefn );
     597                 : 
     598          748461 :     SetFields( psRTInfo, poFeature, achRecord );
     599                 : 
     600          748461 :     return poFeature;
     601                 : }
     602                 : 
     603                 : /************************************************************************/
     604                 : /*                           CreateFeature()                            */
     605                 : /************************************************************************/
     606                 : 
     607           93531 : OGRErr TigerFileBase::CreateFeature( OGRFeature *poFeature )
     608                 : 
     609                 : {
     610                 :     char        szRecord[OGR_TIGER_RECBUF_LEN];
     611                 : 
     612           93531 :     if (psRTInfo == NULL)
     613               0 :         return OGRERR_FAILURE;
     614                 : 
     615           93531 :     if( !SetWriteModule( m_pszFileCode, psRTInfo->nRecordLength+2, poFeature ) )
     616               0 :         return OGRERR_FAILURE;
     617                 : 
     618           93531 :     memset( szRecord, ' ', psRTInfo->nRecordLength );
     619                 : 
     620           93531 :     WriteFields( psRTInfo, poFeature, szRecord );
     621                 : 
     622           93531 :     WriteRecord( szRecord, psRTInfo->nRecordLength, m_pszFileCode );
     623                 : 
     624           93531 :     return OGRERR_NONE;
     625                 : }

Generated by: LCOV version 1.7