LTP GCOV extension - code coverage report
Current view: directory - ogr/ogrsf_frmts/mitab - mitab_miffile.cpp
Test: gdal_filtered.info
Date: 2010-07-12 Instrumented lines: 758
Code covered: 46.3 % Executed lines: 351

       1                 : /**********************************************************************
       2                 :  * $Id: mitab_miffile.cpp,v 1.49 2008/11/17 22:06:21 aboudreault Exp $
       3                 :  *
       4                 :  * Name:     mitab_miffile.cpp
       5                 :  * Project:  MapInfo TAB Read/Write library
       6                 :  * Language: C++
       7                 :  * Purpose:  Implementation of the MIDFile class.
       8                 :  *           To be used by external programs to handle reading/writing of
       9                 :  *           features from/to MID/MIF datasets.
      10                 :  * Author:   Stephane Villeneuve, stephane.v@videotron.ca
      11                 :  *
      12                 :  **********************************************************************
      13                 :  * Copyright (c) 1999-2003, Stephane Villeneuve
      14                 :  *
      15                 :  * Permission is hereby granted, free of charge, to any person obtaining a
      16                 :  * copy of this software and associated documentation files (the "Software"),
      17                 :  * to deal in the Software without restriction, including without limitation
      18                 :  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
      19                 :  * and/or sell copies of the Software, and to permit persons to whom the
      20                 :  * Software is furnished to do so, subject to the following conditions:
      21                 :  * 
      22                 :  * The above copyright notice and this permission notice shall be included
      23                 :  * in all copies or substantial portions of the Software.
      24                 :  * 
      25                 :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      26                 :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      27                 :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
      28                 :  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      29                 :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      30                 :  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
      31                 :  * DEALINGS IN THE SOFTWARE.
      32                 :  **********************************************************************
      33                 :  *
      34                 :  * $Log: mitab_miffile.cpp,v $
      35                 :  * Revision 1.49  2008/11/17 22:06:21  aboudreault
      36                 :  * Added support to use OFTDateTime/OFTDate/OFTTime type when compiled with
      37                 :  * OGR and fixed reading/writing support for these types.
      38                 :  *
      39                 :  * Revision 1.48  2008/09/26 14:40:24  aboudreault
      40                 :  * Fixed bug: MITAB doesn't support writing DateTime type (bug 1948)
      41                 :  *
      42                 :  * Revision 1.47  2008/03/05 20:35:39  dmorissette
      43                 :  * Replace MITAB 1.x SetFeature() with a CreateFeature() for V2.x (bug 1859)
      44                 :  *
      45                 :  * Revision 1.46  2008/02/01 20:30:59  dmorissette
      46                 :  * Use %.15g instead of %.16g as number precision in .MIF output
      47                 :  *
      48                 :  * Revision 1.45  2008/01/29 21:56:39  dmorissette
      49                 :  * Update dataset version properly for Date/Time/DateTime field types (#1754)
      50                 :  *
      51                 :  * Revision 1.44  2008/01/29 20:46:32  dmorissette
      52                 :  * Added support for v9 Time and DateTime fields (byg 1754)
      53                 :  *
      54                 :  * Revision 1.43  2007/09/14 15:35:21  dmorissette
      55                 :  * Fixed problem with MIF parser being confused by special attribute
      56                 :  * names (bug 1795)
      57                 :  *
      58                 :  * Revision 1.42  2007/06/12 13:52:37  dmorissette
      59                 :  * Added IMapInfoFile::SetCharset() method (bug 1734)
      60                 :  *
      61                 :  * Revision 1.41  2005/10/13 20:12:03  fwarmerdam
      62                 :  * layers with just regions can't be set as type wkbPolygon because they may
      63                 :  * have multipolygons (bug GDAL:958)
      64                 :  *     http://bugzilla.remotesensing.org/show_bug.cgi?id=958
      65                 :  *
      66                 :  * Revision 1.40  2005/10/12 14:03:02  fwarmerdam
      67                 :  * Fixed problem with white space parsing in mitab_miffile.cpp (bug GDAL:954)
      68                 :  *
      69                 :  * Revision 1.39  2005/10/04 19:36:10  dmorissette
      70                 :  * Added support for reading collections from MIF files (bug 1126)
      71                 :  *
      72                 :  * Revision 1.38  2004/02/27 21:04:14  fwarmerdam
      73                 :  * dont write MIF header if file is readonly - gdal bugzilla 509
      74                 :  *
      75                 :  * Revision 1.37  2003/12/19 07:54:50  fwarmerdam
      76                 :  * write mif header on close if not already written out
      77                 :  *
      78                 :  * Revision 1.36  2003/08/13 02:49:02  dmorissette
      79                 :  * Use tab as default delimiter if not explicitly specified (Anthony D, bug 37)
      80                 :  *
      81                 :  * Revision 1.35  2003/01/30 22:42:39  daniel
      82                 :  * Fixed crash in ParseMIFHeader() when .mif doesn't contain a DATA line
      83                 :  *
      84                 :  * Revision 1.34  2002/09/23 12:53:29  warmerda
      85                 :  * fix memory leak of m_pszIndex
      86                 :  *
      87                 :  * Revision 1.33  2002/05/08 15:10:48  julien
      88                 :  * Implement MIFFile::SetMIFCoordSys in mitab_capi.cpp (Bug 984)
      89                 :  *
      90                 :  * Revision 1.32  2002/04/26 14:16:49  julien
      91                 :  * Finishing the implementation of Multipoint (support for MIF)
      92                 :  *
      93                 :  * Revision 1.31  2001/09/19 21:39:15  warmerda
      94                 :  * get extents efficiently
      95                 :  *
      96                 :  * Revision 1.30  2001/09/19 14:31:22  warmerda
      97                 :  * added m_nPreloadedId to keep track of preloaded line
      98                 :  *
      99                 :  * Revision 1.29  2001/09/14 19:14:43  warmerda
     100                 :  * added attribute query support
     101                 :  *
     102                 :  * Revision 1.28  2001/08/10 17:49:01  warmerda
     103                 :  * fixed a few memory leaks
     104                 :  *
     105                 :  * Revision 1.27  2001/03/15 03:57:51  daniel
     106                 :  * Added implementation for new OGRLayer::GetExtent(), returning data MBR.
     107                 :  *
     108                 :  * Revision 1.26  2001/03/09 04:14:19  daniel
     109                 :  * Fixed problem creating new files with mixed case extensions (e.g. ".Tab")
     110                 :  *
     111                 :  * Revision 1.25  2001/03/09 03:51:48  daniel
     112                 :  * Fixed writing MIF header: missing break; for decimal fields
     113                 :  *
     114                 :  * Revision 1.24  2001/02/27 19:59:05  daniel
     115                 :  * Enabled spatial filter in IMapInfoFile::GetNextFeature(), and avoid
     116                 :  * unnecessary feature cloning in GetNextFeature() and GetFeature()
     117                 :  *
     118                 :  * Revision 1.23  2001/01/23 21:23:42  daniel
     119                 :  * Added projection bounds lookup table, called from TABFile::SetProjInfo()
     120                 :  *
     121                 :  * Revision 1.22  2001/01/22 16:03:58  warmerda
     122                 :  * expanded tabs
     123                 :  *
     124                 :  * Revision 1.21  2000/12/15 05:38:38  daniel
     125                 :  * Produce Warning instead of an error when nWidth>254 in AddFieldNative()
     126                 :  *
     127                 :  * Revision 1.20  2000/11/14 06:15:37  daniel
     128                 :  * Handle '\t' as spaces in parsing, and fixed GotoFeature() to avoid calling
     129                 :  * ResetReading() when reading forward.
     130                 :  *
     131                 :  * Revision 1.19  2000/07/04 01:50:40  warmerda
     132                 :  * Removed unprotected debugging printf.
     133                 :  *
     134                 :  * Revision 1.18  2000/06/28 00:32:04  warmerda
     135                 :  * Make GetFeatureCountByType() actually work if bForce is TRUE
     136                 :  * Collect detailed (by feature type) feature counts in PreParse().
     137                 :  *
     138                 :  * Revision 1.17  2000/04/27 15:46:25  daniel
     139                 :  * Make SetFeatureDefn() use AddFieldNative(), scan field names for invalid
     140                 :  * chars, and map field width=0 (variable length in OGR) to valid defaults
     141                 :  *
     142                 :  * Revision 1.16  2000/03/27 03:37:59  daniel
     143                 :  * Handle bounds in CoordSys for read and write, + handle point SYMBOL line as
     144                 :  * optional + fixed reading of bounds in PreParseFile()
     145                 :  *
     146                 :  * Revision 1.15  2000/02/28 17:05:06  daniel
     147                 :  * Added support for index and unique directives for read and write
     148                 :  *
     149                 :  * Revision 1.14  2000/01/28 07:32:25  daniel
     150                 :  * Validate char field width (must be <= 254 chars)
     151                 :  *
     152                 :  * Revision 1.13  2000/01/24 19:51:33  warmerda
     153                 :  * AddFieldNative should not fail for read-only datasets
     154                 :  *
     155                 :  * Revision 1.12  2000/01/18 23:13:41  daniel
     156                 :  * Implemented AddFieldNative()
     157                 :  *
     158                 :  * ...
     159                 :  *
     160                 :  * Revision 1.1  1999/11/08 04:16:07  stephane
     161                 :  * First Revision
     162                 :  *
     163                 :  **********************************************************************/
     164                 : 
     165                 : #include "mitab.h"
     166                 : #include "mitab_utils.h"
     167                 : #include <ctype.h>
     168                 : 
     169                 : /*=====================================================================
     170                 :  *                      class MIFFile
     171                 :  *====================================================================*/
     172                 : 
     173                 : 
     174                 : /**********************************************************************
     175                 :  *                   MIFFile::MIFFile()
     176                 :  *
     177                 :  * Constructor.
     178                 :  **********************************************************************/
     179              18 : MIFFile::MIFFile()
     180                 : {
     181              18 :     m_pszFname = NULL;
     182              18 :     m_nVersion = 300;
     183                 : 
     184                 :     // Tab is default delimiter in MIF spec if not explicitly specified.  Use
     185                 :     // that by default for read mode. In write mode, we will use "," as 
     186                 :     // delimiter since it's more common than tab (we do this in Open())
     187              18 :     m_pszDelimiter = CPLStrdup("\t");
     188                 : 
     189              18 :     m_pszUnique = NULL;
     190              18 :     m_pszIndex = NULL;
     191              18 :     m_pszCoordSys = NULL;
     192                 : 
     193              18 :     m_paeFieldType = NULL;
     194              18 :     m_pabFieldIndexed = NULL;
     195              18 :     m_pabFieldUnique = NULL;
     196                 : 
     197              18 :     m_dfXMultiplier = 1.0;
     198              18 :     m_dfYMultiplier = 1.0;
     199              18 :     m_dfXDisplacement = 0.0;
     200              18 :     m_dfYDisplacement = 0.0;
     201                 : 
     202              18 :     m_poMIDFile = NULL;
     203              18 :     m_poMIFFile = NULL;
     204              18 :     m_nPreloadedId = 0;
     205                 : 
     206              18 :     m_poDefn = NULL;
     207              18 :     m_poSpatialRef = NULL;
     208                 : 
     209              18 :     m_nCurFeatureId = 0;
     210              18 :     m_nFeatureCount = 0;
     211              18 :     m_nWriteFeatureId = -1;
     212              18 :     m_poCurFeature = NULL;
     213                 :    
     214              18 :     m_bPreParsed = FALSE;
     215              18 :     m_nAttribut = 0;
     216              18 :     m_bHeaderWrote = FALSE;
     217              18 :     m_nPoints = m_nLines = m_nRegions = m_nTexts = 0;
     218                 : 
     219              18 :     m_bExtentsSet = FALSE;
     220              18 : }
     221                 : 
     222                 : /**********************************************************************
     223                 :  *                   MIFFile::~MIFFile()
     224                 :  *
     225                 :  * Destructor.
     226                 :  **********************************************************************/
     227              18 : MIFFile::~MIFFile()
     228                 : {
     229              18 :     Close();
     230              18 : }
     231                 : 
     232                 : /**********************************************************************
     233                 :  *                   MIFFile::Open()
     234                 :  *
     235                 :  * Returns 0 on success, -1 on error.
     236                 :  **********************************************************************/
     237                 : int MIFFile::Open(const char *pszFname, const char *pszAccess,
     238              18 :                   GBool bTestOpenNoError /*=FALSE*/ )
     239                 : {
     240              18 :     char *pszTmpFname = NULL;
     241              18 :     int nFnameLen = 0;
     242                 :     
     243              18 :     CPLErrorReset();
     244                 : 
     245              18 :     if (m_poMIDFile)
     246                 :     {
     247                 :         CPLError(CE_Failure, CPLE_FileIO,
     248               0 :                      "Open() failed: object already contains an open file");
     249                 : 
     250               0 :         return -1;
     251                 :     }
     252                 : 
     253                 :     /*-----------------------------------------------------------------
     254                 :      * Validate access mode
     255                 :      *----------------------------------------------------------------*/
     256              18 :     if (EQUALN(pszAccess, "r", 1))
     257                 :     {
     258              11 :         m_eAccessMode = TABRead;
     259              11 :         pszAccess = "rt";
     260                 :     }
     261               7 :     else if (EQUALN(pszAccess, "w", 1))
     262                 :     {
     263               7 :         m_eAccessMode = TABWrite;
     264               7 :         pszAccess = "wt";
     265                 : 
     266                 :         // In write mode, use "," as delimiter since it's more common than tab
     267               7 :         CPLFree(m_pszDelimiter);
     268               7 :         m_pszDelimiter = CPLStrdup(",");
     269                 :     }
     270                 :     else
     271                 :     {
     272               0 :         if (!bTestOpenNoError)
     273                 :             CPLError(CE_Failure, CPLE_FileIO,
     274               0 :                  "Open() failed: access mode \"%s\" not supported", pszAccess);
     275                 :         else
     276               0 :             CPLErrorReset();
     277                 : 
     278               0 :         return -1;
     279                 :     }
     280                 : 
     281                 :     /*-----------------------------------------------------------------
     282                 :      * Make sure filename has a .MIF or .MID extension... 
     283                 :      *----------------------------------------------------------------*/
     284              18 :     m_pszFname = CPLStrdup(pszFname);
     285              18 :     nFnameLen = strlen(m_pszFname);
     286              18 :     if (nFnameLen > 4 && (strcmp(m_pszFname+nFnameLen-4, ".MID")==0 ||
     287                 :                      strcmp(m_pszFname+nFnameLen-4, ".MIF")==0 ) )
     288               0 :         strcpy(m_pszFname+nFnameLen-4, ".MIF");
     289              36 :     else if (nFnameLen > 4 && (EQUAL(m_pszFname+nFnameLen-4, ".mid") ||
     290                 :                                EQUAL(m_pszFname+nFnameLen-4, ".mif") ) )
     291              18 :         strcpy(m_pszFname+nFnameLen-4, ".mif");
     292                 :     else
     293                 :     {
     294               0 :         if (!bTestOpenNoError)
     295                 :             CPLError(CE_Failure, CPLE_FileIO,
     296                 :                      "Open() failed for %s: invalid filename extension",
     297               0 :                      m_pszFname);
     298                 :         else
     299               0 :             CPLErrorReset();
     300                 : 
     301               0 :         CPLFree(m_pszFname);
     302               0 :         return -1;
     303                 :     }
     304                 : 
     305              18 :     pszTmpFname = CPLStrdup(m_pszFname);
     306                 : 
     307                 :     /*-----------------------------------------------------------------
     308                 :      * Open .MIF file
     309                 :      *----------------------------------------------------------------*/
     310                 : 
     311                 : #ifndef _WIN32
     312                 :     /*-----------------------------------------------------------------
     313                 :      * On Unix, make sure extension uses the right cases
     314                 :      * We do it even for write access because if a file with the same
     315                 :      * extension already exists we want to overwrite it.
     316                 :      *----------------------------------------------------------------*/
     317              18 :     TABAdjustFilenameExtension(pszTmpFname);
     318                 : #endif
     319                 : 
     320              18 :     m_poMIFFile = new MIDDATAFile;
     321                 : 
     322              18 :     if (m_poMIFFile->Open(pszTmpFname, pszAccess) != 0)
     323                 :     {
     324               0 :         if (!bTestOpenNoError)
     325                 :             CPLError(CE_Failure, CPLE_NotSupported,
     326               0 :                      "Unable to open %s.", pszTmpFname);
     327                 :         else
     328               0 :             CPLErrorReset();
     329                 : 
     330               0 :         CPLFree(pszTmpFname);
     331               0 :         Close();
     332                 : 
     333               0 :         return -1;
     334                 :     }
     335                 : 
     336                 :     /*-----------------------------------------------------------------
     337                 :      * Open .MID file
     338                 :      *----------------------------------------------------------------*/
     339              18 :     if (nFnameLen > 4 && strcmp(pszTmpFname+nFnameLen-4, ".MIF")==0)
     340               0 :         strcpy(pszTmpFname+nFnameLen-4, ".MID");
     341                 :     else 
     342              18 :         strcpy(pszTmpFname+nFnameLen-4, ".mid");
     343                 : 
     344                 : #ifndef _WIN32
     345              18 :     TABAdjustFilenameExtension(pszTmpFname);
     346                 : #endif
     347                 : 
     348              18 :     m_poMIDFile = new MIDDATAFile;
     349                 : 
     350              18 :     if (m_poMIDFile->Open(pszTmpFname, pszAccess) !=0)
     351                 :     {
     352               0 :         if (!bTestOpenNoError)
     353                 :             CPLError(CE_Failure, CPLE_NotSupported,
     354               0 :                      "Unable to open %s.", pszTmpFname);
     355                 :         else
     356               0 :             CPLErrorReset();
     357                 : 
     358               0 :         CPLFree(pszTmpFname);
     359               0 :         Close();
     360                 : 
     361               0 :         return -1;
     362                 :     }
     363                 : 
     364                 : 
     365              18 :     CPLFree(pszTmpFname);
     366              18 :     pszTmpFname = NULL;
     367                 : 
     368                 :     /*-----------------------------------------------------------------
     369                 :      * Read MIF File Header
     370                 :      *----------------------------------------------------------------*/
     371              18 :     if (m_eAccessMode == TABRead && ParseMIFHeader() != 0)
     372                 :     {
     373               0 :         Close();
     374                 : 
     375               0 :         if (!bTestOpenNoError)
     376                 :             CPLError(CE_Failure, CPLE_NotSupported,
     377               0 :                      "Failed parsing header in %s.", m_pszFname);
     378                 :         else
     379               0 :             CPLErrorReset();
     380                 : 
     381               0 :         return -1;
     382                 :     }
     383                 : 
     384                 :     /*-----------------------------------------------------------------
     385                 :      * In write access, set some defaults
     386                 :      *----------------------------------------------------------------*/
     387              18 :     if (m_eAccessMode == TABWrite)
     388                 :     {
     389               7 :         m_nVersion = 300;
     390               7 :         m_pszCharset = CPLStrdup("Neutral");
     391                 :     }
     392                 : 
     393                 :     /* Put the MID file at the correct location, on the first feature */
     394              18 :     if (m_eAccessMode == TABRead && (m_poMIDFile->GetLine() == NULL))
     395                 :     {
     396               0 :         Close();
     397                 : 
     398               0 :         if (bTestOpenNoError)
     399               0 :             CPLErrorReset();
     400                 : 
     401               0 :         return -1;
     402                 :     }
     403                 : 
     404                 :     m_poMIFFile->SetTranslation(m_dfXMultiplier,m_dfYMultiplier,
     405              18 :                                 m_dfXDisplacement, m_dfYDisplacement);
     406                 :     m_poMIDFile->SetTranslation(m_dfXMultiplier,m_dfYMultiplier,
     407              18 :                                 m_dfXDisplacement, m_dfYDisplacement);
     408              18 :     m_poMIFFile->SetDelimiter(m_pszDelimiter);
     409              18 :     m_poMIDFile->SetDelimiter(m_pszDelimiter);
     410                 : 
     411                 :     /*-------------------------------------------------------------
     412                 :      * Set geometry type if the geometry objects are uniform.
     413                 :      *------------------------------------------------------------*/
     414              18 :     int numPoints=0, numRegions=0, numTexts=0, numLines=0;
     415                 : 
     416              18 :     if( GetFeatureCountByType( numPoints, numLines, numRegions, numTexts, 
     417                 :                                FALSE ) == 0 )
     418                 :     {
     419               0 :         numPoints += numTexts;
     420               0 :         if( numPoints > 0 && numLines == 0 && numRegions == 0 )
     421               0 :             m_poDefn->SetGeomType( wkbPoint );
     422               0 :         else if( numPoints == 0 && numLines > 0 && numRegions == 0 )
     423               0 :             m_poDefn->SetGeomType( wkbLineString );
     424                 :         else
     425                 :             /* we leave it unknown indicating a mixture */;
     426                 :     }
     427                 : 
     428                 :     /* A newly created layer should have OGRFeatureDefn */
     429              18 :     if (m_poDefn == NULL)
     430                 :     {
     431               7 :         char *pszFeatureClassName = TABGetBasename(m_pszFname);
     432               7 :         m_poDefn = new OGRFeatureDefn(pszFeatureClassName);
     433               7 :         CPLFree(pszFeatureClassName);
     434                 :         // Ref count defaults to 0... set it to 1
     435               7 :         m_poDefn->Reference();
     436                 :     }
     437                 : 
     438              18 :     return 0;
     439                 : }
     440                 : 
     441                 : /**********************************************************************
     442                 :  *                   MIFFile::ParseMIFHeader()
     443                 :  *
     444                 :  * Scan the header of a MIF file, and store any useful information into
     445                 :  * class members.  The main piece of information being the fields 
     446                 :  * definition that we use to build the OGRFeatureDefn for this file.
     447                 :  *
     448                 :  * This private method should be used only during the Open() call.
     449                 :  *
     450                 :  * Returns 0 on success, -1 on error.
     451                 :  **********************************************************************/
     452              11 : int MIFFile::ParseMIFHeader()
     453                 : {  
     454              11 :     GBool  bColumns = FALSE;
     455              11 :     int    nColumns = 0;
     456              11 :     GBool  bCoordSys = FALSE;
     457                 :     char  *pszTmp;
     458                 :             
     459                 :     
     460                 :     const char *pszLine;
     461                 :     char **papszToken;
     462                 : 
     463              11 :     char *pszFeatureClassName = TABGetBasename(m_pszFname);
     464              11 :     m_poDefn = new OGRFeatureDefn(pszFeatureClassName);
     465              11 :     CPLFree(pszFeatureClassName);
     466                 :     // Ref count defaults to 0... set it to 1
     467              11 :     m_poDefn->Reference();
     468                 : 
     469                 :     
     470              11 :     if (m_eAccessMode != TABRead)
     471                 :     {
     472                 :         CPLError(CE_Failure, CPLE_NotSupported,
     473               0 :                  "ParseMIDFile() can be used only with Read access.");
     474               0 :         return -1;
     475                 :     }
     476                 :     
     477                 : 
     478                 :     /*-----------------------------------------------------------------
     479                 :      * Parse header until we find the "Data" line
     480                 :      *----------------------------------------------------------------*/
     481             123 :     while (((pszLine = m_poMIFFile->GetLine()) != NULL) && 
     482                 :            !(EQUALN(pszLine,"Data",4)))
     483                 :     {
     484             296 :         while(pszLine && (*pszLine == ' ' || *pszLine == '\t') )
     485              94 :             pszLine++;  // skip leading spaces
     486                 : 
     487             148 :         if (bColumns == TRUE && nColumns >0)
     488                 :         {
     489              47 :             if (nColumns == 0)
     490                 :             {
     491                 :                 // Permit to 0 columns
     492               0 :                 bColumns = FALSE;
     493                 :             }
     494              47 :             else if (AddFields(pszLine) == 0)
     495                 :             {
     496              47 :                 nColumns--;
     497              47 :                 if (nColumns == 0)
     498              11 :                   bColumns = FALSE;
     499                 :             }
     500                 :             else
     501                 :             {
     502               0 :                 bColumns = FALSE;
     503                 :             }
     504                 :         }
     505              54 :         else if (EQUALN(pszLine,"VERSION",7))
     506                 :         {
     507              11 :             papszToken = CSLTokenizeStringComplex(pszLine," ()\t",TRUE,FALSE); 
     508              11 :             bColumns = FALSE; bCoordSys = FALSE;
     509              11 :             if (CSLCount(papszToken)  == 2)
     510              11 :               m_nVersion = atoi(papszToken[1]);
     511                 : 
     512              11 :             CSLDestroy(papszToken);
     513                 :         
     514                 :         }
     515              43 :         else if (EQUALN(pszLine,"CHARSET",7))
     516                 :         {
     517              11 :             papszToken = CSLTokenizeStringComplex(pszLine," ()\t",TRUE,FALSE); 
     518              11 :             bColumns = FALSE; bCoordSys = FALSE;
     519                 :           
     520              11 :             if (CSLCount(papszToken)  == 2)
     521                 :             {
     522              11 :                 CPLFree(m_pszCharset);
     523              11 :                 m_pszCharset = CPLStrdup(papszToken[1]);
     524                 :             }
     525              11 :             CSLDestroy(papszToken);
     526                 :         
     527                 :         }
     528              32 :         else if (EQUALN(pszLine,"DELIMITER",9))
     529                 :         {
     530              11 :             papszToken = CSLTokenizeStringComplex(pszLine," ()\t",TRUE,FALSE); 
     531              11 :              bColumns = FALSE; bCoordSys = FALSE;
     532                 :           
     533              11 :            if (CSLCount(papszToken)  == 2)
     534                 :            {
     535              11 :                CPLFree(m_pszDelimiter);
     536              11 :                m_pszDelimiter = CPLStrdup(papszToken[1]);    
     537                 :            }
     538              11 :           CSLDestroy(papszToken);
     539                 :         
     540                 :         }
     541              21 :         else if (EQUALN(pszLine,"UNIQUE",6))
     542                 :         {
     543               0 :             bColumns = FALSE; bCoordSys = FALSE;
     544                 :           
     545               0 :             m_pszUnique = CPLStrdup(pszLine + 6);
     546                 :         }
     547              21 :         else if (EQUALN(pszLine,"INDEX",5))
     548                 :         {
     549               0 :             bColumns = FALSE; bCoordSys = FALSE;
     550                 :           
     551               0 :             m_pszIndex = CPLStrdup(pszLine + 5);
     552                 :         }
     553              21 :         else if (EQUALN(pszLine,"COORDSYS",8) )
     554                 :         {
     555               5 :             bCoordSys = TRUE;
     556               5 :             m_pszCoordSys = CPLStrdup(pszLine + 9);
     557                 : 
     558                 :             // Extract bounds if present
     559                 :             char  **papszFields;
     560                 :             papszFields = CSLTokenizeStringComplex(m_pszCoordSys, " ,()\t",
     561               5 :                                                    TRUE, FALSE );
     562               5 :             int iBounds = CSLFindString( papszFields, "Bounds" );
     563               5 :             if (iBounds >= 0 && iBounds + 4 < CSLCount(papszFields))
     564                 :             {
     565               5 :                 m_dXMin = atof(papszFields[++iBounds]);
     566               5 :                 m_dYMin = atof(papszFields[++iBounds]);
     567               5 :                 m_dXMax = atof(papszFields[++iBounds]);
     568               5 :                 m_dYMax = atof(papszFields[++iBounds]);
     569               5 :                 m_bBoundsSet = TRUE;
     570                 :             }
     571               5 :             CSLDestroy( papszFields );
     572                 :         }
     573              16 :         else if (EQUALN(pszLine,"TRANSFORM",9))
     574                 :         {
     575               0 :             papszToken = CSLTokenizeStringComplex(pszLine," ,\t",TRUE,FALSE); 
     576               0 :             bColumns = FALSE; bCoordSys = FALSE;
     577                 :           
     578               0 :             if (CSLCount(papszToken) == 5)
     579                 :             {
     580               0 :                 m_dfXMultiplier   = atof(papszToken[1]);
     581               0 :                 m_dfYMultiplier   = atof(papszToken[2]);
     582               0 :                 m_dfXDisplacement = atof(papszToken[3]);
     583               0 :                 m_dfYDisplacement = atof(papszToken[4]);
     584                 :                 
     585               0 :                 if (m_dfXMultiplier == 0.0)
     586               0 :                   m_dfXMultiplier = 1.0;
     587               0 :                 if (m_dfYMultiplier == 0.0)
     588               0 :                   m_dfYMultiplier = 1.0;
     589                 :             }
     590               0 :             CSLDestroy(papszToken);
     591                 :         }
     592              16 :         else if (EQUALN(pszLine,"COLUMNS",7))
     593                 :         {
     594              11 :             papszToken = CSLTokenizeStringComplex(pszLine," ()\t",TRUE,FALSE); 
     595              11 :             bCoordSys = FALSE;
     596              11 :             bColumns = TRUE;
     597              11 :             if (CSLCount(papszToken) == 2)
     598                 :             {
     599              11 :                 nColumns = atoi(papszToken[1]);
     600              11 :                 m_nAttribut = nColumns;
     601                 :             }
     602                 :             else
     603                 :             {
     604               0 :                 bColumns = FALSE;
     605               0 :                 m_nAttribut = 0;
     606                 :             }
     607              11 :             CSLDestroy(papszToken);
     608                 :         }
     609               5 :         else if (bCoordSys == TRUE)
     610                 :         {
     611               0 :             pszTmp = m_pszCoordSys;
     612                 :             m_pszCoordSys = CPLStrdup(CPLSPrintf("%s %s",m_pszCoordSys,
     613               0 :                                                  pszLine));
     614               0 :             CPLFree(pszTmp);
     615                 :             //printf("Reading CoordSys\n");
     616                 :             // Reading CoordSys
     617                 :         }
     618                 : 
     619                 :     }
     620                 :     
     621              11 :     if ((pszLine = m_poMIFFile->GetLastLine()) == NULL || 
     622                 :         EQUALN(m_poMIFFile->GetLastLine(),"DATA",4) == FALSE)
     623                 :     {
     624                 :         CPLError(CE_Failure, CPLE_NotSupported,
     625                 :                  "DATA keyword not found in %s.  File may be corrupt.",
     626               0 :                  m_pszFname);
     627               0 :         return -1;
     628                 :     }
     629                 :     
     630                 :     /*-----------------------------------------------------------------
     631                 :      * Move pointer to first line of first object
     632                 :      *----------------------------------------------------------------*/
     633              17 :     while (((pszLine = m_poMIFFile->GetLine()) != NULL) && 
     634                 :            m_poMIFFile->IsValidFeature(pszLine) == FALSE)
     635                 :         ;
     636                 : 
     637                 :     /*-----------------------------------------------------------------
     638                 :      * Check for Unique and Indexed flags
     639                 :      *----------------------------------------------------------------*/
     640              11 :     if (m_pszIndex)
     641                 :     {
     642               0 :         papszToken = CSLTokenizeStringComplex(m_pszIndex," ,\t",TRUE,FALSE);
     643               0 :         for(int i=0; papszToken && papszToken[i]; i++)
     644                 :         {
     645               0 :             int nVal = atoi(papszToken[i]);
     646               0 :             if (nVal > 0 && nVal <= m_poDefn->GetFieldCount())
     647               0 :                 m_pabFieldIndexed[nVal-1] = TRUE;
     648                 :         }
     649               0 :         CSLDestroy(papszToken);
     650                 :     }
     651                 : 
     652              11 :     if (m_pszUnique)
     653                 :     {
     654               0 :         papszToken = CSLTokenizeStringComplex(m_pszUnique," ,\t",TRUE,FALSE);
     655               0 :         for(int i=0; papszToken && papszToken[i]; i++)
     656                 :         {
     657               0 :             int nVal = atoi(papszToken[i]);
     658               0 :             if (nVal > 0 && nVal <= m_poDefn->GetFieldCount())
     659               0 :                 m_pabFieldUnique[nVal-1] = TRUE;
     660                 :         }
     661               0 :         CSLDestroy(papszToken);
     662                 :     }
     663                 : 
     664              11 :     return 0;
     665                 : 
     666                 : }
     667                 : 
     668                 : /************************************************************************/
     669                 : /*                             AddFields()                              */
     670                 : /************************************************************************/
     671                 : 
     672              47 : int  MIFFile::AddFields(const char *pszLine)
     673                 : {
     674                 :     char **papszToken;
     675              47 :     int nStatus = 0,numTok;
     676                 : 
     677              47 :     CPLAssert(m_bHeaderWrote == FALSE);
     678              47 :     papszToken = CSLTokenizeStringComplex(pszLine," (,)\t",TRUE,FALSE); 
     679              47 :     numTok = CSLCount(papszToken);
     680                 : 
     681              71 :     if (numTok >= 3 && EQUAL(papszToken[1], "char"))
     682                 :     {
     683                 :         /*-------------------------------------------------
     684                 :          * CHAR type
     685                 :          *------------------------------------------------*/
     686                 :         nStatus = AddFieldNative(papszToken[0], TABFChar,
     687              24 :                                  atoi(papszToken[2]));
     688                 :     }
     689              35 :     else if (numTok >= 2 && EQUAL(papszToken[1], "integer"))
     690                 :     {
     691                 :         /*-------------------------------------------------
     692                 :          * INTEGER type
     693                 :          *------------------------------------------------*/
     694              12 :         nStatus = AddFieldNative(papszToken[0], TABFInteger);
     695                 :     }
     696              11 :     else if (numTok >= 2 && EQUAL(papszToken[1], "smallint"))
     697                 :     {
     698                 :         /*-------------------------------------------------
     699                 :          * SMALLINT type
     700                 :          *------------------------------------------------*/
     701               0 :         nStatus = AddFieldNative(papszToken[0], TABFSmallInt);
     702                 :     }
     703              11 :     else if (numTok >= 4 && EQUAL(papszToken[1], "decimal"))
     704                 :     {
     705                 :         /*-------------------------------------------------
     706                 :          * DECIMAL type
     707                 :          *------------------------------------------------*/
     708                 :         nStatus = AddFieldNative(papszToken[0], TABFDecimal,
     709               0 :                                  atoi(papszToken[2]), atoi(papszToken[3]));
     710                 :     }
     711              22 :     else if (numTok >= 2 && EQUAL(papszToken[1], "float"))
     712                 :     {
     713                 :         /*-------------------------------------------------
     714                 :          * FLOAT type
     715                 :          *------------------------------------------------*/
     716              11 :         nStatus = AddFieldNative(papszToken[0], TABFFloat);
     717                 :     }
     718               0 :     else if (numTok >= 2 && EQUAL(papszToken[1], "date"))
     719                 :     {
     720                 :         /*-------------------------------------------------
     721                 :          * DATE type (returned as a string: "DD/MM/YYYY" or "YYYYMMDD")
     722                 :          *------------------------------------------------*/
     723               0 :         nStatus = AddFieldNative(papszToken[0], TABFDate);
     724                 :     }
     725               0 :     else if (numTok >= 2 && EQUAL(papszToken[1], "time"))
     726                 :     {
     727                 :         /*-------------------------------------------------
     728                 :          *  TIME type (v900, returned as a string: "HH:MM:SS" or "HHMMSSmmm")
     729                 :          *------------------------------------------------*/
     730               0 :         nStatus = AddFieldNative(papszToken[0], TABFTime);
     731                 :     }
     732               0 :     else if (numTok >= 2 && EQUAL(papszToken[1], "datetime"))
     733                 :     {
     734                 :         /*-------------------------------------------------
     735                 :          * DATETIME type (v900, returned as a string: "DD/MM/YYYY HH:MM:SS",
     736                 :          * "YYYY/MM/DD HH:MM:SS" or "YYYYMMDDHHMMSSmmm")
     737                 :          *------------------------------------------------*/
     738               0 :         nStatus = AddFieldNative(papszToken[0], TABFDateTime);
     739                 :     }
     740               0 :     else if (numTok >= 2 && EQUAL(papszToken[1], "logical"))
     741                 :     {
     742                 :         /*-------------------------------------------------
     743                 :          * LOGICAL type (value "T" or "F")
     744                 :          *------------------------------------------------*/
     745               0 :         nStatus = AddFieldNative(papszToken[0], TABFLogical);
     746                 :     }
     747                 :     else 
     748               0 :       nStatus = -1; // Unrecognized field type or line corrupt
     749                 :     
     750              47 :     CSLDestroy(papszToken);
     751              47 :     papszToken = NULL;
     752                 : 
     753              47 :     if (nStatus != 0)
     754                 :     {
     755                 :         CPLError(CE_Failure, CPLE_FileIO,
     756               0 :                  "Failed to parse field definition in file %s", m_pszFname);
     757               0 :         return -1;
     758                 :     }
     759                 :     
     760              47 :     return 0;
     761                 : }
     762                 : 
     763                 : /************************************************************************/
     764                 : /*                          GetFeatureCount()                           */
     765                 : /************************************************************************/
     766                 : 
     767               0 : int MIFFile::GetFeatureCount (int bForce)
     768                 : {
     769                 :     
     770               0 :     if( m_poFilterGeom != NULL || m_poAttrQuery != NULL )
     771               0 :         return OGRLayer::GetFeatureCount( bForce );
     772                 :     else
     773                 :     {
     774               0 :         if (bForce == TRUE)
     775               0 :             PreParseFile();
     776                 : 
     777               0 :         if (m_bPreParsed)
     778               0 :             return m_nFeatureCount;
     779                 :         else
     780               0 :             return -1;
     781                 :     }
     782                 : }
     783                 : 
     784                 : /************************************************************************/
     785                 : /*                            ResetReading()                            */
     786                 : /************************************************************************/
     787                 : 
     788              16 : void MIFFile::ResetReading()
     789                 : 
     790                 : {   
     791                 :     const char *pszLine;
     792                 : 
     793              16 :     m_poMIFFile->Rewind();
     794                 : 
     795             184 :     while ((pszLine = m_poMIFFile->GetLine()) != NULL)
     796             168 :       if (EQUALN(pszLine,"DATA",4))
     797              16 :         break;
     798                 : 
     799              40 :     while ((pszLine = m_poMIFFile->GetLine()) != NULL)
     800                 :     {
     801              24 :         if (m_poMIFFile->IsValidFeature(pszLine))
     802              16 :           break;
     803                 :     }
     804                 : 
     805              16 :     m_poMIDFile->Rewind();
     806              16 :     m_poMIDFile->GetLine();
     807                 :     
     808                 :     // We're positioned on first feature.  Feature Ids start at 1.
     809              16 :     if (m_poCurFeature)
     810                 :     {
     811               1 :         delete m_poCurFeature;
     812               1 :         m_poCurFeature = NULL;
     813                 :     }
     814                 : 
     815              16 :     m_nCurFeatureId = 0;
     816              16 :     m_nPreloadedId = 1;
     817              16 : }
     818                 : 
     819                 : /************************************************************************/
     820                 : /*                            PreParseFile()                            */
     821                 : /************************************************************************/
     822                 : 
     823               0 : void MIFFile::PreParseFile()
     824                 : {
     825               0 :     char **papszToken = NULL;
     826                 :     const char *pszLine;
     827                 :     
     828               0 :     GBool bPLine = FALSE;
     829               0 :     GBool bText = FALSE;
     830                 : 
     831               0 :     if (m_bPreParsed == TRUE)
     832               0 :       return;
     833                 : 
     834               0 :     m_poMIFFile->Rewind();
     835                 : 
     836               0 :     while ((pszLine = m_poMIFFile->GetLine()) != NULL)
     837               0 :       if (EQUALN(pszLine,"DATA",4))
     838               0 :         break;
     839                 : 
     840               0 :     m_nPoints = m_nLines = m_nRegions = m_nTexts = 0;
     841                 : 
     842               0 :     while ((pszLine = m_poMIFFile->GetLine()) != NULL)
     843                 :     {
     844               0 :         if (m_poMIFFile->IsValidFeature(pszLine))
     845                 :         {
     846               0 :             bPLine = FALSE;
     847               0 :             bText = FALSE;
     848               0 :             m_nFeatureCount++;
     849                 :         }
     850                 : 
     851               0 :         CSLDestroy(papszToken);
     852               0 :         papszToken = CSLTokenizeString(pszLine);
     853                 : 
     854               0 :         if (EQUALN(pszLine,"POINT",5))
     855                 :         {
     856               0 :             m_nPoints++;
     857               0 :             if (CSLCount(papszToken) == 3)
     858                 :             {
     859                 :                 UpdateExtents(m_poMIFFile->GetXTrans(atof(papszToken[1])),
     860               0 :                              m_poMIFFile->GetYTrans(atof(papszToken[2])));
     861                 :             }
     862                 :               
     863                 :         }
     864               0 :         else if (EQUALN(pszLine,"LINE",4) ||
     865                 :                  EQUALN(pszLine,"RECT",4) ||
     866                 :                  EQUALN(pszLine,"ROUNDRECT",9) ||
     867                 :                  EQUALN(pszLine,"ARC",3) ||
     868                 :                  EQUALN(pszLine,"ELLIPSE",7))
     869                 :         {
     870               0 :             if (CSLCount(papszToken) == 5)
     871                 :             {
     872               0 :                 m_nLines++;
     873                 :                 UpdateExtents(m_poMIFFile->GetXTrans(atof(papszToken[1])), 
     874               0 :                              m_poMIFFile->GetYTrans(atof(papszToken[2])));
     875                 :                 UpdateExtents(m_poMIFFile->GetXTrans(atof(papszToken[3])), 
     876               0 :                              m_poMIFFile->GetYTrans(atof(papszToken[4])));
     877                 :             }
     878                 :         }
     879               0 :         else if (EQUALN(pszLine,"REGION",6) )
     880                 :         {
     881               0 :             m_nRegions++;
     882               0 :             bPLine = TRUE;
     883                 :         }
     884               0 :         else if( EQUALN(pszLine,"PLINE",5))
     885                 :         {
     886               0 :             m_nLines++;
     887               0 :             bPLine = TRUE;
     888                 :         }
     889               0 :         else if (EQUALN(pszLine,"TEXT",4)) 
     890                 :         {
     891               0 :             m_nTexts++;
     892               0 :             bText = TRUE;
     893                 :         }
     894               0 :         else if (bPLine == TRUE)
     895                 :         {
     896               0 :             if (CSLCount(papszToken) == 2 &&
     897                 :                 strchr("-.0123456789", papszToken[0][0]) != NULL)
     898                 :             {
     899                 :                 UpdateExtents( m_poMIFFile->GetXTrans(atof(papszToken[0])),
     900               0 :                               m_poMIFFile->GetYTrans(atof(papszToken[1])));
     901                 :             }
     902                 :         }
     903               0 :         else if (bText == TRUE)
     904                 :         {
     905               0 :            if (CSLCount(papszToken) == 4 &&
     906                 :                 strchr("-.0123456789", papszToken[0][0]) != NULL)
     907                 :             {
     908                 :                 UpdateExtents(m_poMIFFile->GetXTrans(atof(papszToken[0])),
     909               0 :                              m_poMIFFile->GetYTrans(atof(papszToken[1])));
     910                 :                 UpdateExtents(m_poMIFFile->GetXTrans(atof(papszToken[2])),
     911               0 :                              m_poMIFFile->GetYTrans(atof(papszToken[3])));
     912                 :             } 
     913                 :         }
     914                 :         
     915                 :       }
     916                 : 
     917               0 :     CSLDestroy(papszToken);
     918                 :     
     919               0 :     m_poMIFFile->Rewind();
     920                 : 
     921               0 :     while ((pszLine = m_poMIFFile->GetLine()) != NULL)
     922               0 :       if (EQUALN(pszLine,"DATA",4))
     923               0 :         break;
     924                 : 
     925               0 :     while ((pszLine = m_poMIFFile->GetLine()) != NULL)
     926                 :     {
     927               0 :         if (m_poMIFFile->IsValidFeature(pszLine))
     928               0 :           break;
     929                 :     }
     930                 : 
     931               0 :     m_poMIDFile->Rewind();
     932               0 :     m_poMIDFile->GetLine();
     933                 :  
     934               0 :     m_bPreParsed = TRUE;
     935                 : 
     936                 : }
     937                 : 
     938                 : /**********************************************************************
     939                 :  *                   MIFFile::WriteMIFHeader()
     940                 :  *
     941                 :  * Generate the .MIF header.
     942                 :  *
     943                 :  * Returns 0 on success, -1 on error.
     944                 :  **********************************************************************/
     945               7 : int MIFFile::WriteMIFHeader()
     946                 : {
     947                 :     int iField;
     948                 :     GBool bFound;
     949                 : 
     950               7 :     if (m_eAccessMode != TABWrite)
     951                 :     {
     952                 :         CPLError(CE_Failure, CPLE_NotSupported,
     953               0 :                  "WriteMIFHeader() can be used only with Write access.");
     954               0 :         return -1;
     955                 :     }
     956                 : 
     957               7 :     if (m_poDefn==NULL || m_poDefn->GetFieldCount() == 0)
     958                 :     {
     959                 :         CPLError(CE_Failure, CPLE_NotSupported,
     960                 :                  "File %s must contain at least 1 attribute field.",
     961               0 :                  m_pszFname);
     962               0 :         return -1;
     963                 :     }
     964                 : 
     965                 :     /*-----------------------------------------------------------------
     966                 :      * Start writing header.
     967                 :      *----------------------------------------------------------------*/
     968               7 :     m_bHeaderWrote = TRUE;
     969               7 :     m_poMIFFile->WriteLine("Version %d\n", m_nVersion);
     970               7 :     m_poMIFFile->WriteLine("Charset \"%s\"\n", m_pszCharset);
     971                 : 
     972                 :     // Delimiter is not required if you use \t as delimiter
     973               7 :     if ( !EQUAL(m_pszDelimiter, "\t") )
     974               7 :         m_poMIFFile->WriteLine("Delimiter \"%s\"\n", m_pszDelimiter);
     975                 : 
     976               7 :     bFound = FALSE;
     977              20 :     for(iField=0; iField<m_poDefn->GetFieldCount(); iField++)
     978                 :     {
     979              13 :         if (m_pabFieldUnique[iField])
     980                 :         {
     981               0 :             if (!bFound)
     982               0 :                 m_poMIFFile->WriteLine("Unique %d", iField+1);
     983                 :             else
     984               0 :                 m_poMIFFile->WriteLine(",%d", iField+1);
     985               0 :             bFound = TRUE;
     986                 :         }
     987                 :     }
     988               7 :     if (bFound)
     989               0 :         m_poMIFFile->WriteLine("\n");
     990                 : 
     991               7 :     bFound = FALSE;
     992              20 :     for(iField=0; iField<m_poDefn->GetFieldCount(); iField++)
     993                 :     {
     994              13 :         if (m_pabFieldIndexed[iField])
     995                 :         {
     996               0 :             if (!bFound)
     997               0 :                 m_poMIFFile->WriteLine("Index  %d", iField+1);
     998                 :             else
     999               0 :                 m_poMIFFile->WriteLine(",%d", iField+1);
    1000               0 :             bFound = TRUE;
    1001                 :         }
    1002                 :     }
    1003               7 :     if (bFound)
    1004               0 :         m_poMIFFile->WriteLine("\n");
    1005                 : 
    1006               7 :     if (m_pszCoordSys && m_bBoundsSet)
    1007                 :     {
    1008                 :         m_poMIFFile->WriteLine("CoordSys %s "
    1009                 :                                "Bounds (%.15g, %.15g) (%.15g, %.15g)\n",
    1010                 :                                m_pszCoordSys, 
    1011               0 :                                m_dXMin, m_dYMin, m_dXMax, m_dYMax);
    1012                 :     }
    1013               7 :     else if (m_pszCoordSys)
    1014                 :     {
    1015               0 :         m_poMIFFile->WriteLine("CoordSys %s\n",m_pszCoordSys);
    1016                 :     }
    1017                 :     
    1018                 :     /*-----------------------------------------------------------------
    1019                 :      * Column definitions
    1020                 :      *----------------------------------------------------------------*/
    1021               7 :     CPLAssert(m_paeFieldType);
    1022                 : 
    1023               7 :     m_poMIFFile->WriteLine("Columns %d\n", m_poDefn->GetFieldCount());
    1024                 :         
    1025              20 :     for(iField=0; iField<m_poDefn->GetFieldCount(); iField++)
    1026                 :     {
    1027                 :         OGRFieldDefn *poFieldDefn;
    1028              13 :         poFieldDefn = m_poDefn->GetFieldDefn(iField);
    1029                 :         
    1030              13 :         switch(m_paeFieldType[iField])
    1031                 :         {
    1032                 :           case TABFInteger:
    1033                 :             m_poMIFFile->WriteLine("  %s Integer\n",
    1034               2 :                                    poFieldDefn->GetNameRef());
    1035               2 :             break;
    1036                 :           case TABFSmallInt:
    1037                 :             m_poMIFFile->WriteLine("  %s SmallInt\n",
    1038               0 :                                    poFieldDefn->GetNameRef());
    1039               0 :             break;
    1040                 :           case TABFFloat:
    1041                 :             m_poMIFFile->WriteLine("  %s Float\n",
    1042               2 :                                    poFieldDefn->GetNameRef());    
    1043               2 :             break;
    1044                 :           case TABFDecimal:
    1045                 :             m_poMIFFile->WriteLine("  %s Decimal(%d,%d)\n",
    1046                 :                                    poFieldDefn->GetNameRef(),
    1047                 :                                    poFieldDefn->GetWidth(),
    1048               0 :                                    poFieldDefn->GetPrecision());
    1049               0 :             break;
    1050                 :           case TABFLogical:
    1051                 :             m_poMIFFile->WriteLine("  %s Logical\n",
    1052               0 :                                    poFieldDefn->GetNameRef());
    1053               0 :             break;
    1054                 :           case TABFDate:
    1055                 :             m_poMIFFile->WriteLine("  %s Date\n",
    1056               0 :                                    poFieldDefn->GetNameRef());
    1057               0 :             break;
    1058                 :           case TABFTime:
    1059                 :             m_poMIFFile->WriteLine("  %s Time\n",
    1060               0 :                                    poFieldDefn->GetNameRef());
    1061               0 :             break;
    1062                 :           case TABFDateTime:
    1063                 :             m_poMIFFile->WriteLine("  %s DateTime\n",
    1064               0 :                                    poFieldDefn->GetNameRef());
    1065               0 :             break;
    1066                 :           case TABFChar:
    1067                 :           default:
    1068                 :             m_poMIFFile->WriteLine("  %s Char(%d)\n",
    1069                 :                                    poFieldDefn->GetNameRef(),
    1070               9 :                                    poFieldDefn->GetWidth());
    1071                 :         }
    1072                 :     }
    1073                 : 
    1074                 :     /*-----------------------------------------------------------------
    1075                 :      * Ready to write objects
    1076                 :      *----------------------------------------------------------------*/
    1077               7 :     m_poMIFFile->WriteLine("Data\n\n");
    1078                 :    
    1079               7 :     return 0;
    1080                 : }
    1081                 : 
    1082                 : /**********************************************************************
    1083                 :  *                   MIFFile::Close()
    1084                 :  *
    1085                 :  * Close current file, and release all memory used.
    1086                 :  *
    1087                 :  * Returns 0 on success, -1 on error.
    1088                 :  **********************************************************************/
    1089              18 : int MIFFile::Close()
    1090                 : {
    1091                 :     /* flush .mif header if not already written */
    1092              18 :     if ( m_poDefn != NULL && m_bHeaderWrote == FALSE 
    1093                 :          && m_eAccessMode != TABRead )
    1094                 :     {
    1095               1 :         WriteMIFHeader();     
    1096                 :     }
    1097                 : 
    1098              18 :     if (m_poMIDFile)
    1099                 :     {
    1100              18 :         m_poMIDFile->Close();
    1101              18 :         delete m_poMIDFile;
    1102              18 :         m_poMIDFile = NULL;
    1103                 :     }
    1104                 : 
    1105              18 :     if (m_poMIFFile)
    1106                 :     {
    1107              18 :         m_poMIFFile->Close();
    1108              18 :         delete m_poMIFFile;
    1109              18 :         m_poMIFFile = NULL;
    1110                 :     }
    1111                 : 
    1112              18 :     if (m_poCurFeature)
    1113                 :     {
    1114               0 :         delete m_poCurFeature;
    1115               0 :         m_poCurFeature = NULL;
    1116                 :     }
    1117                 : 
    1118                 :     /*-----------------------------------------------------------------
    1119                 :      * Note: we have to check the reference count before deleting 
    1120                 :      * m_poSpatialRef and m_poDefn
    1121                 :      *----------------------------------------------------------------*/
    1122              18 :     if (m_poDefn && m_poDefn->Dereference() == 0)
    1123              13 :         delete m_poDefn;
    1124              18 :     m_poDefn = NULL;
    1125                 :     
    1126              18 :     if (m_poSpatialRef && m_poSpatialRef->Dereference() == 0)
    1127               0 :         delete m_poSpatialRef;
    1128              18 :     m_poSpatialRef = NULL;
    1129                 : 
    1130              18 :     CPLFree(m_pszCoordSys);
    1131              18 :     m_pszCoordSys = NULL;
    1132                 : 
    1133              18 :     CPLFree(m_pszDelimiter);
    1134              18 :     m_pszDelimiter = NULL;
    1135                 : 
    1136              18 :     CPLFree(m_pszFname);
    1137              18 :     m_pszFname = NULL;
    1138                 : 
    1139              18 :     m_nVersion = 0;
    1140                 : 
    1141              18 :     CPLFree(m_pszCharset);
    1142              18 :     m_pszCharset = NULL;
    1143                 : 
    1144              18 :     CPLFree(m_pabFieldIndexed);
    1145              18 :     m_pabFieldIndexed = NULL;
    1146              18 :     CPLFree(m_pabFieldUnique);
    1147              18 :     m_pabFieldUnique = NULL;
    1148                 : 
    1149              18 :     CPLFree( m_pszIndex );
    1150              18 :     m_pszIndex = NULL;
    1151                 : 
    1152              18 :     CPLFree(m_paeFieldType);
    1153              18 :     m_paeFieldType = NULL;
    1154                 : 
    1155              18 :     m_nCurFeatureId = 0;
    1156              18 :     m_nPreloadedId = 0;
    1157              18 :     m_nFeatureCount =0;
    1158                 :    
    1159              18 :     m_bBoundsSet = FALSE;
    1160                 : 
    1161              18 :     return 0;
    1162                 : }
    1163                 : 
    1164                 : /**********************************************************************
    1165                 :  *                   MIFFile::GetNextFeatureId()
    1166                 :  *
    1167                 :  * Returns feature id that follows nPrevId, or -1 if it is the
    1168                 :  * last feature id.  Pass nPrevId=-1 to fetch the first valid feature id.
    1169                 :  **********************************************************************/
    1170              50 : int MIFFile::GetNextFeatureId(int nPrevId)
    1171                 : {
    1172              50 :     if (m_eAccessMode != TABRead)
    1173                 :     {
    1174                 :         CPLError(CE_Failure, CPLE_NotSupported,
    1175               0 :                  "GetNextFeatureId() can be used only with Read access.");
    1176               0 :         return -1;
    1177                 :     }
    1178                 : 
    1179              50 :     if (nPrevId <= 0 && m_poMIFFile->GetLastLine() != NULL)
    1180              12 :         return 1;       // Feature Ids start at 1
    1181              38 :     else if (nPrevId > 0 && m_poMIFFile->GetLastLine() != NULL)
    1182              32 :         return nPrevId + 1;
    1183                 :     else
    1184               6 :         return -1;
    1185                 : 
    1186                 :     return 0;
    1187                 : }
    1188                 : 
    1189                 : /**********************************************************************
    1190                 :  *                   MIFFile::GotoFeature()
    1191                 :  *
    1192                 :  * Private method to move MIF and MID pointers ready to read specified 
    1193                 :  * feature.  Note that Feature Ids start at 1.
    1194                 :  *
    1195                 :  * Returns 0 on success, -1 on error (likely request for invalid feature id)
    1196                 :  **********************************************************************/
    1197              44 : int MIFFile::GotoFeature(int nFeatureId)
    1198                 : {
    1199                 : 
    1200              44 :     if (nFeatureId < 1)
    1201               0 :       return -1;
    1202                 : 
    1203              44 :     if (nFeatureId == m_nPreloadedId) // CorrectPosition
    1204                 :     {
    1205              39 :         return 0;
    1206                 :     }
    1207                 :     else
    1208                 :     {
    1209               5 :         if (nFeatureId < m_nCurFeatureId || m_nCurFeatureId == 0)
    1210               5 :             ResetReading();
    1211                 : 
    1212              10 :         while(m_nPreloadedId < nFeatureId)
    1213                 :         {
    1214               0 :             if (NextFeature() == FALSE)
    1215               0 :               return -1;
    1216                 :         }
    1217                 : 
    1218               5 :         CPLAssert(m_nPreloadedId == nFeatureId);
    1219                 : 
    1220               5 :         return 0;
    1221                 :     }
    1222                 : }
    1223                 : 
    1224                 : /**********************************************************************
    1225                 :  *                   MIFFile::NextFeature()
    1226                 :  **********************************************************************/
    1227                 : 
    1228               0 : GBool MIFFile::NextFeature()
    1229                 : {
    1230                 :     const char *pszLine;
    1231               0 :     while ((pszLine = m_poMIFFile->GetLine()) != NULL)
    1232                 :     {
    1233               0 :         if (m_poMIFFile->IsValidFeature(pszLine))
    1234                 :         {
    1235               0 :             m_poMIDFile->GetLine();
    1236               0 :             m_nPreloadedId++;
    1237               0 :             return TRUE;
    1238                 :         }
    1239                 :     }
    1240               0 :     return FALSE;
    1241                 : }
    1242                 : 
    1243                 : /**********************************************************************
    1244                 :  *                   MIFFile::GetFeatureRef()
    1245                 :  *
    1246                 :  * Fill and return a TABFeature object for the specified feature id.
    1247                 :  *
    1248                 :  * The retruned pointer is a reference to an object owned and maintained
    1249                 :  * by this MIFFile object.  It should not be altered or freed by the 
    1250                 :  * caller and its contents is guaranteed to be valid only until the next
    1251                 :  * call to GetFeatureRef() or Close().
    1252                 :  *
    1253                 :  * Returns NULL if the specified feature id does not exist of if an
    1254                 :  * error happened.  In any case, CPLError() will have been called to
    1255                 :  * report the reason of the failure.
    1256                 :  **********************************************************************/
    1257              44 : TABFeature *MIFFile::GetFeatureRef(int nFeatureId)
    1258                 : {
    1259                 :     const char *pszLine;
    1260                 : 
    1261              44 :     if (m_eAccessMode != TABRead)
    1262                 :     {
    1263                 :         CPLError(CE_Failure, CPLE_NotSupported,
    1264               0 :                  "GetFeatureRef() can be used only with Read access.");
    1265               0 :         return NULL;
    1266                 :     }
    1267                 :     
    1268                 :     /*-----------------------------------------------------------------
    1269                 :      * Make sure file is opened and Validate feature id by positioning
    1270                 :      * the read pointers for the .MAP and .DAT files to this feature id.
    1271                 :      *----------------------------------------------------------------*/
    1272              44 :     if (m_poMIDFile == NULL)
    1273                 :     {
    1274                 :         CPLError(CE_Failure, CPLE_IllegalArg,
    1275               0 :                  "GetFeatureRef() failed: file is not opened!");
    1276               0 :         return NULL;
    1277                 :     }
    1278                 : 
    1279              44 :     if (GotoFeature(nFeatureId)!= 0 )
    1280                 :     {
    1281                 :         CPLError(CE_Failure, CPLE_IllegalArg,
    1282                 :                  "GetFeatureRef() failed: invalid feature id %d", 
    1283               0 :                  nFeatureId);
    1284               0 :         return NULL;
    1285                 :     }
    1286                 : 
    1287                 : 
    1288                 :     /*-----------------------------------------------------------------
    1289                 :      * Create new feature object of the right type
    1290                 :      *----------------------------------------------------------------*/
    1291              44 :     if ((pszLine = m_poMIFFile->GetLastLine()) != NULL)
    1292                 :     {
    1293                 :         // Delete previous feature... we'll start we a clean one.
    1294              44 :         if (m_poCurFeature)
    1295               5 :             delete m_poCurFeature;
    1296              44 :         m_poCurFeature = NULL;
    1297                 : 
    1298              44 :         m_nCurFeatureId = m_nPreloadedId;
    1299                 : 
    1300              44 :         if (EQUALN(pszLine,"NONE",4))
    1301                 :         {
    1302              12 :             m_poCurFeature = new TABFeature(m_poDefn);
    1303                 :         }
    1304              32 :         else if (EQUALN(pszLine,"POINT",5))
    1305                 :         {
    1306                 :             // Special case, we need to know two lines to decide the type
    1307                 :             char **papszToken;
    1308               4 :             papszToken = CSLTokenizeString(pszLine);
    1309                 :             
    1310               4 :             if (CSLCount(papszToken) !=3)
    1311                 :             {
    1312               0 :                 CSLDestroy(papszToken);
    1313                 :                 CPLError(CE_Failure, CPLE_NotSupported,
    1314                 :                          "GetFeatureRef() failed: invalid point line: '%s'",
    1315               0 :                          pszLine);
    1316               0 :                 return NULL;
    1317                 :             }
    1318                 :             
    1319               4 :             m_poMIFFile->SaveLine(pszLine);
    1320                 : 
    1321               4 :             if ((pszLine = m_poMIFFile->GetLine()) != NULL)
    1322                 :             {
    1323               4 :                 CSLDestroy(papszToken);
    1324                 :                 papszToken = CSLTokenizeStringComplex(pszLine," ,()\t",
    1325               4 :                                                       TRUE,FALSE);
    1326               4 :                 if (CSLCount(papszToken)> 0 &&EQUALN(papszToken[0],"SYMBOL",6))
    1327                 :                 {
    1328               4 :                     switch (CSLCount(papszToken))
    1329                 :                     {
    1330                 :                       case 4:
    1331               4 :                         m_poCurFeature = new TABPoint(m_poDefn);
    1332               4 :                         break;
    1333                 :                       case 7:
    1334               0 :                         m_poCurFeature = new TABFontPoint(m_poDefn);
    1335               0 :                         break;
    1336                 :                       case 5:
    1337               0 :                         m_poCurFeature = new TABCustomPoint(m_poDefn);
    1338               0 :                         break;
    1339                 :                       default:
    1340               0 :                         CSLDestroy(papszToken);
    1341                 :                         CPLError(CE_Failure, CPLE_NotSupported,
    1342                 :                                  "GetFeatureRef() failed: invalid symbol "
    1343               0 :                                  "line: '%s'", pszLine);
    1344               0 :                         return NULL;
    1345                 :                         break;
    1346                 :                     }
    1347                 : 
    1348                 :                 }
    1349                 :             }
    1350               4 :             CSLDestroy(papszToken);
    1351                 : 
    1352               4 :             if (m_poCurFeature == NULL)
    1353                 :             {
    1354                 :                 // No symbol clause... default to TABPoint
    1355               0 :                 m_poCurFeature = new TABPoint(m_poDefn);
    1356                 :             }
    1357                 :         }
    1358              28 :         else if (EQUALN(pszLine,"LINE",4) ||
    1359                 :                  EQUALN(pszLine,"PLINE",5))
    1360                 :         {
    1361               0 :             m_poCurFeature = new TABPolyline(m_poDefn);
    1362                 :         }
    1363              28 :         else if (EQUALN(pszLine,"REGION",6))
    1364                 :         {
    1365              28 :             m_poCurFeature = new TABRegion(m_poDefn);
    1366                 :         }  
    1367               0 :         else if (EQUALN(pszLine,"ARC",3))
    1368                 :         { 
    1369               0 :             m_poCurFeature = new TABArc(m_poDefn);
    1370                 :         }
    1371               0 :         else if (EQUALN(pszLine,"TEXT",4))
    1372                 :         {
    1373               0 :             m_poCurFeature = new TABText(m_poDefn);
    1374                 :         }
    1375               0 :         else if (EQUALN(pszLine,"RECT",4) ||
    1376                 :                  EQUALN(pszLine,"ROUNDRECT",9))
    1377                 :         {
    1378               0 :             m_poCurFeature = new TABRectangle(m_poDefn);
    1379                 :         }
    1380               0 :         else if (EQUALN(pszLine,"ELLIPSE",7))
    1381                 :         {
    1382               0 :             m_poCurFeature = new TABEllipse(m_poDefn);       
    1383                 :         }
    1384               0 :         else if (EQUALN(pszLine,"MULTIPOINT",10))
    1385                 :         {
    1386               0 :             m_poCurFeature = new TABMultiPoint(m_poDefn);       
    1387                 :         }
    1388               0 :         else if (EQUALN(pszLine,"COLLECTION",10))
    1389                 :         {
    1390               0 :             m_poCurFeature = new TABCollection(m_poDefn);       
    1391                 :         }
    1392                 :         else
    1393                 :         {
    1394               0 :             if (!EQUAL(pszLine,""))
    1395                 :                CPLError(CE_Failure, CPLE_NotSupported,
    1396                 :                    "Error during reading, unknown type %s.",
    1397               0 :                      pszLine);
    1398                 :         
    1399                 :             //m_poCurFeature = new TABDebugFeature(m_poDefn);
    1400               0 :             return NULL;
    1401                 :         }
    1402                 :     }
    1403                 : 
    1404              44 :     CPLAssert(m_poCurFeature);
    1405              44 :     if (m_poCurFeature == NULL)
    1406               0 :         return NULL;
    1407                 : 
    1408                 :    /*-----------------------------------------------------------------
    1409                 :      * Read fields from the .DAT file
    1410                 :      * GetRecordBlock() has already been called above...
    1411                 :      *----------------------------------------------------------------*/
    1412              44 :     if (m_poCurFeature->ReadRecordFromMIDFile(m_poMIDFile) != 0)
    1413                 :     {
    1414                 :         CPLError(CE_Failure, CPLE_NotSupported,
    1415               0 :                  "Error during reading Record.");
    1416                 :         
    1417               0 :         delete m_poCurFeature;
    1418               0 :         m_poCurFeature = NULL;
    1419               0 :         return NULL;
    1420                 :     }
    1421                 :     
    1422                 :     /*-----------------------------------------------------------------
    1423                 :      * Read geometry from the .MAP file
    1424                 :      * MoveToObjId() has already been called above...
    1425                 :      *----------------------------------------------------------------*/
    1426              44 :     if (m_poCurFeature->ReadGeometryFromMIFFile(m_poMIFFile) != 0)
    1427                 :     {
    1428                 :         CPLError(CE_Failure, CPLE_NotSupported,
    1429               0 :                  "Error during reading Geometry.");
    1430                 :         
    1431               0 :         delete m_poCurFeature;
    1432               0 :         m_poCurFeature = NULL;
    1433               0 :         return NULL;
    1434                 :     }
    1435                 : 
    1436                 :     /*---------------------------------------------------------------------
    1437                 :      * The act of reading the geometry causes the first line of the    
    1438                 :      * next object to be preloaded.  Set the preloaded id appropriately.
    1439                 :      *--------------------------------------------------------------------- */
    1440              44 :     if( m_poMIFFile->GetLastLine() != NULL )
    1441              32 :         m_nPreloadedId++;
    1442                 :     else
    1443              12 :         m_nPreloadedId = 0;
    1444                 :    
    1445                 :     /* Update the Current Feature ID */
    1446              44 :     m_poCurFeature->SetFID(m_nCurFeatureId);
    1447                 : 
    1448              44 :     return m_poCurFeature;
    1449                 : }
    1450                 : 
    1451                 : /**********************************************************************
    1452                 :  *                   MIFFile::CreateFeature()
    1453                 :  *
    1454                 :  * Write a new feature to this dataset. The passed in feature is updated 
    1455                 :  * with the new feature id.
    1456                 :  *
    1457                 :  * Returns OGRERR_NONE on success, or an appropriate OGRERR_ code if an
    1458                 :  * error happened in which case, CPLError() will have been called to
    1459                 :  * report the reason of the failure.
    1460                 :  **********************************************************************/
    1461              20 : OGRErr MIFFile::CreateFeature(TABFeature *poFeature)
    1462                 : {
    1463              20 :     int nFeatureId = -1;
    1464                 : 
    1465              20 :     if (m_eAccessMode != TABWrite)
    1466                 :     {
    1467                 :         CPLError(CE_Failure, CPLE_NotSupported,
    1468               0 :                  "CreateFeature() can be used only with Write access.");
    1469               0 :         return OGRERR_UNSUPPORTED_OPERATION;
    1470                 :     }
    1471                 : 
    1472                 :     /*-----------------------------------------------------------------
    1473                 :      * Make sure file is opened and establish new feature id.
    1474                 :      *----------------------------------------------------------------*/
    1475              20 :     if (m_poMIDFile == NULL)
    1476                 :     {
    1477                 :         CPLError(CE_Failure, CPLE_IllegalArg,
    1478               0 :                  "CreateFeature() failed: file is not opened!");
    1479               0 :         return OGRERR_FAILURE;
    1480                 :     }
    1481                 : 
    1482              20 :     if (m_bHeaderWrote == FALSE)
    1483                 :     {
    1484                 :         /*-------------------------------------------------------------
    1485                 :          * OK, this is the first feature in the dataset... make sure the
    1486                 :          * .MID schema has been initialized.
    1487                 :          *------------------------------------------------------------*/
    1488               6 :         if (m_poDefn == NULL)
    1489               0 :             SetFeatureDefn(poFeature->GetDefnRef(), NULL);
    1490                 : 
    1491               6 :          WriteMIFHeader();     
    1492               6 :          nFeatureId = 1;
    1493                 :     }
    1494                 :     else
    1495                 :     {
    1496              14 :         nFeatureId = ++ m_nWriteFeatureId;
    1497                 :     }
    1498                 : 
    1499                 : 
    1500                 :     /*-----------------------------------------------------------------
    1501                 :      * Write geometry to the .Mif file
    1502                 :      *----------------------------------------------------------------*/
    1503              20 :     if (m_poMIFFile == NULL ||
    1504                 :         poFeature->WriteGeometryToMIFFile(m_poMIFFile) != 0)
    1505                 :     {
    1506                 :         CPLError(CE_Failure, CPLE_FileIO,
    1507                 :                  "Failed writing geometry for feature id %d in %s",
    1508               0 :                  nFeatureId, m_pszFname);
    1509               0 :         return OGRERR_FAILURE;
    1510                 :     }
    1511                 : 
    1512              20 :     if (m_poMIDFile == NULL ||
    1513                 :         poFeature->WriteRecordToMIDFile(m_poMIDFile) != 0 )
    1514                 :     {
    1515                 :         CPLError(CE_Failure, CPLE_FileIO,
    1516                 :                  "Failed writing attributes for feature id %d in %s",
    1517               0 :                  nFeatureId, m_pszFname);
    1518               0 :         return OGRERR_FAILURE;
    1519                 :     }
    1520                 : 
    1521              20 :     poFeature->SetFID(nFeatureId);
    1522                 : 
    1523              20 :     return OGRERR_NONE;
    1524                 : }
    1525                 : 
    1526                 : 
    1527                 : 
    1528                 : /**********************************************************************
    1529                 :  *                   MIFFile::GetLayerDefn()
    1530                 :  *
    1531                 :  * Returns a reference to the OGRFeatureDefn that will be used to create
    1532                 :  * features in this dataset.
    1533                 :  *
    1534                 :  * Returns a reference to an object that is maintained by this MIFFile
    1535                 :  * object (and thus should not be modified or freed by the caller) or
    1536                 :  * NULL if the OGRFeatureDefn has not been initialized yet (i.e. no file
    1537                 :  * opened yet)
    1538                 :  **********************************************************************/
    1539             128 : OGRFeatureDefn *MIFFile::GetLayerDefn()
    1540                 : {
    1541             128 :     return m_poDefn;
    1542                 : }
    1543                 : 
    1544                 : /**********************************************************************
    1545                 :  *                   MIFFile::SetFeatureDefn()
    1546                 :  *
    1547                 :  * Pass a reference to the OGRFeatureDefn that will be used to create
    1548                 :  * features in this dataset.  This function should be called after
    1549                 :  * creating a new dataset, but before writing the first feature.
    1550                 :  * All features that will be written to this dataset must share this same
    1551                 :  * OGRFeatureDefn.
    1552                 :  *
    1553                 :  * This function will use poFeatureDefn to create a local copy that 
    1554                 :  * will be used to build the .MID file, etc.
    1555                 :  *
    1556                 :  * Returns 0 on success, -1 on error.
    1557                 :  **********************************************************************/
    1558                 : int MIFFile::SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,
    1559               0 :                          TABFieldType *paeMapInfoNativeFieldTypes /* =NULL */)
    1560                 : {
    1561                 :     int numFields;
    1562               0 :     int nStatus = 0;
    1563                 : 
    1564                 :     /*-----------------------------------------------------------------
    1565                 :      * Check that call happens at the right time in dataset's life.
    1566                 :      *----------------------------------------------------------------*/
    1567               0 :     if ( m_eAccessMode == TABWrite && m_bHeaderWrote )
    1568                 :     {
    1569                 :         CPLError(CE_Failure, CPLE_AssertionFailed,
    1570                 :                  "SetFeatureDefn() must be called after opening a new "
    1571               0 :                  "dataset, but before writing the first feature to it.");
    1572               0 :         return -1;
    1573                 :     }
    1574                 : 
    1575                 :     /*-----------------------------------------------------------------
    1576                 :      * Delete current feature defn if there is already one.
    1577                 :      * AddFieldNative() will take care of creating a new one for us.
    1578                 :      *----------------------------------------------------------------*/
    1579               0 :     if (m_poDefn && m_poDefn->Dereference() == 0)
    1580               0 :         delete m_poDefn;
    1581               0 :     m_poDefn = NULL;
    1582                 : 
    1583                 :     /*-----------------------------------------------------------------
    1584                 :      * Copy field information
    1585                 :      *----------------------------------------------------------------*/
    1586               0 :     numFields = poFeatureDefn->GetFieldCount();
    1587                 : 
    1588               0 :     for(int iField=0; iField<numFields; iField++)
    1589                 :     {
    1590                 :         TABFieldType eMapInfoType;
    1591               0 :         OGRFieldDefn *poFieldDefn = poFeatureDefn->GetFieldDefn(iField);
    1592                 : 
    1593               0 :         if (paeMapInfoNativeFieldTypes)
    1594                 :         {
    1595               0 :             eMapInfoType = paeMapInfoNativeFieldTypes[iField];
    1596                 :         }
    1597                 :         else
    1598                 :         {
    1599                 :             /*---------------------------------------------------------
    1600                 :              * Map OGRFieldTypes to MapInfo native types
    1601                 :              *--------------------------------------------------------*/
    1602               0 :             switch(poFieldDefn->GetType())
    1603                 :             {
    1604                 :               case OFTInteger:
    1605               0 :                 eMapInfoType = TABFInteger;
    1606               0 :                 break;
    1607                 :               case OFTReal:
    1608               0 :                 eMapInfoType = TABFFloat;
    1609               0 :                 break;
    1610                 :               case OFTDateTime:
    1611               0 :                 eMapInfoType = TABFDateTime;
    1612               0 :                 break;
    1613                 :               case OFTDate:
    1614               0 :                 eMapInfoType = TABFDate;
    1615               0 :                 break;
    1616                 :               case OFTTime:
    1617               0 :                 eMapInfoType = TABFTime;
    1618               0 :                 break;
    1619                 :               case OFTString:
    1620                 :               default:
    1621               0 :                 eMapInfoType = TABFChar;
    1622                 :             }
    1623                 :         }
    1624                 : 
    1625                 :         nStatus = AddFieldNative(poFieldDefn->GetNameRef(), eMapInfoType,
    1626                 :                                  poFieldDefn->GetWidth(),
    1627               0 :                                  poFieldDefn->GetPrecision(), FALSE, FALSE);
    1628                 :     }
    1629                 : 
    1630               0 :     return nStatus;
    1631                 : }
    1632                 : 
    1633                 : /**********************************************************************
    1634                 :  *                   MIFFile::AddFieldNative()
    1635                 :  *
    1636                 :  * Create a new field using a native mapinfo data type... this is an 
    1637                 :  * alternative to defining fields through the OGR interface.
    1638                 :  * This function should be called after creating a new dataset, but before 
    1639                 :  * writing the first feature.
    1640                 :  *
    1641                 :  * This function will build/update the OGRFeatureDefn that will have to be
    1642                 :  * used when writing features to this dataset.
    1643                 :  *
    1644                 :  * A reference to the OGRFeatureDefn can be obtained using GetLayerDefn().
    1645                 :  *
    1646                 :  * Returns 0 on success, -1 on error.
    1647                 :  **********************************************************************/
    1648                 : int MIFFile::AddFieldNative(const char *pszName, TABFieldType eMapInfoType,
    1649                 :                             int nWidth /*=0*/, int nPrecision /*=0*/,
    1650              60 :                             GBool bIndexed /*=FALSE*/, GBool bUnique/*=FALSE*/)
    1651                 : {
    1652                 :     OGRFieldDefn *poFieldDefn;
    1653              60 :     char *pszCleanName = NULL;
    1654              60 :     int nStatus = 0;
    1655                 : 
    1656                 :     /*-----------------------------------------------------------------
    1657                 :      * Check that call happens at the right time in dataset's life.
    1658                 :      *----------------------------------------------------------------*/
    1659              60 :     if ( m_eAccessMode == TABWrite && m_bHeaderWrote )
    1660                 :     {
    1661                 :         CPLError(CE_Failure, CPLE_AssertionFailed,
    1662                 :                  "AddFieldNative() must be called after opening a new "
    1663               0 :                  "dataset, but before writing the first feature to it.");
    1664               0 :         return -1;
    1665                 :     }
    1666                 : 
    1667                 :     /*-----------------------------------------------------------------
    1668                 :      * Validate field width... must be <= 254
    1669                 :      *----------------------------------------------------------------*/
    1670              60 :     if (nWidth > 254)
    1671                 :     {
    1672                 :         CPLError(CE_Warning, CPLE_IllegalArg,
    1673                 :                  "Invalid size (%d) for field '%s'.  "
    1674               0 :                  "Size must be 254 or less.", nWidth, pszName);
    1675               0 :         nWidth = 254;
    1676                 :     }
    1677                 : 
    1678                 :     /*-----------------------------------------------------------------
    1679                 :      * Map fields with width=0 (variable length in OGR) to a valid default
    1680                 :      *----------------------------------------------------------------*/
    1681              60 :     if (eMapInfoType == TABFDecimal && nWidth == 0)
    1682               0 :         nWidth=20;
    1683              60 :     else if (nWidth == 0)
    1684              23 :         nWidth=254; /* char fields */
    1685                 : 
    1686                 :     /*-----------------------------------------------------------------
    1687                 :      * Create new OGRFeatureDefn if not done yet...
    1688                 :      *----------------------------------------------------------------*/
    1689              60 :     if (m_poDefn == NULL)
    1690                 :     {
    1691               0 :         char *pszFeatureClassName = TABGetBasename(m_pszFname);
    1692               0 :         m_poDefn = new OGRFeatureDefn(pszFeatureClassName);
    1693               0 :         CPLFree(pszFeatureClassName);
    1694                 :         // Ref count defaults to 0... set it to 1
    1695               0 :         m_poDefn->Reference();
    1696                 :     }
    1697                 : 
    1698                 :     /*-----------------------------------------------------------------
    1699                 :      * Make sure field name is valid... check for special chars, etc.
    1700                 :      * (pszCleanName will have to be freed.)
    1701                 :      *----------------------------------------------------------------*/
    1702              60 :     pszCleanName = TABCleanFieldName(pszName);
    1703                 : 
    1704                 :     /*-----------------------------------------------------------------
    1705                 :      * Map MapInfo native types to OGR types
    1706                 :      *----------------------------------------------------------------*/
    1707              60 :     poFieldDefn = NULL;
    1708                 : 
    1709              60 :     switch(eMapInfoType)
    1710                 :     {
    1711                 :       case TABFChar:
    1712                 :         /*-------------------------------------------------
    1713                 :          * CHAR type
    1714                 :          *------------------------------------------------*/
    1715              33 :         poFieldDefn = new OGRFieldDefn(pszCleanName, OFTString);
    1716              33 :         poFieldDefn->SetWidth(nWidth);
    1717              33 :         break;
    1718                 :       case TABFInteger:
    1719                 :         /*-------------------------------------------------
    1720                 :          * INTEGER type
    1721                 :          *------------------------------------------------*/
    1722              14 :         poFieldDefn = new OGRFieldDefn(pszCleanName, OFTInteger);
    1723              14 :         break;
    1724                 :       case TABFSmallInt:
    1725                 :         /*-------------------------------------------------
    1726                 :          * SMALLINT type
    1727                 :          *------------------------------------------------*/
    1728               0 :         poFieldDefn = new OGRFieldDefn(pszCleanName, OFTInteger);
    1729               0 :         break;
    1730                 :       case TABFDecimal:
    1731                 :         /*-------------------------------------------------
    1732                 :          * DECIMAL type
    1733                 :          *------------------------------------------------*/
    1734               0 :         poFieldDefn = new OGRFieldDefn(pszCleanName, OFTReal);
    1735               0 :         poFieldDefn->SetWidth(nWidth);
    1736               0 :         poFieldDefn->SetPrecision(nPrecision);
    1737               0 :         break;
    1738                 :       case TABFFloat:
    1739                 :         /*-------------------------------------------------
    1740                 :          * FLOAT type
    1741                 :          *------------------------------------------------*/
    1742              13 :         poFieldDefn = new OGRFieldDefn(pszCleanName, OFTReal);
    1743              13 :         break;
    1744                 :       case TABFDate:
    1745                 :         /*-------------------------------------------------
    1746                 :          * DATE type (V450, returned as a string: "DD/MM/YYYY" or "YYYYMMDD")
    1747                 :          *------------------------------------------------*/
    1748                 :         poFieldDefn = new OGRFieldDefn(pszCleanName, 
    1749                 : #ifdef MITAB_USE_OFTDATETIME
    1750               0 :                                                    OFTDate);
    1751                 : #else
    1752                 :                                                    OFTString);
    1753                 : #endif
    1754               0 :         poFieldDefn->SetWidth(10);
    1755               0 :         m_nVersion = MAX(m_nVersion, 450);
    1756               0 :         break;
    1757                 :       case TABFTime:
    1758                 :         /*-------------------------------------------------
    1759                 :          * TIME type (v900, returned as a string: "HH:MM:SS" or "HHMMSSmmm")
    1760                 :          *------------------------------------------------*/
    1761                 :         poFieldDefn = new OGRFieldDefn(pszCleanName, 
    1762                 : #ifdef MITAB_USE_OFTDATETIME
    1763               0 :                                                    OFTTime);
    1764                 : #else
    1765                 :                                                    OFTString);
    1766                 : #endif
    1767               0 :         poFieldDefn->SetWidth(9);
    1768               0 :         m_nVersion = MAX(m_nVersion, 900);
    1769               0 :         break;
    1770                 :       case TABFDateTime:
    1771                 :         /*-------------------------------------------------
    1772                 :          * DATETIME type (v900, returned as a string: "DD/MM/YYYY HH:MM:SS",
    1773                 :          * "YYYY/MM/DD HH:MM:SS" or "YYYYMMDDHHMMSSmmm")
    1774                 :          *------------------------------------------------*/
    1775                 :         poFieldDefn = new OGRFieldDefn(pszCleanName, 
    1776                 : #ifdef MITAB_USE_OFTDATETIME
    1777               0 :                                                    OFTDateTime);
    1778                 : #else
    1779                 :                                                    OFTString);
    1780                 : #endif
    1781               0 :         poFieldDefn->SetWidth(19);
    1782               0 :         break;
    1783                 :         m_nVersion = MAX(m_nVersion, 900);
    1784                 :       case TABFLogical:
    1785                 :         /*-------------------------------------------------
    1786                 :          * LOGICAL type (value "T" or "F")
    1787                 :          *------------------------------------------------*/
    1788               0 :         poFieldDefn = new OGRFieldDefn(pszCleanName, OFTString);
    1789               0 :         poFieldDefn->SetWidth(1);
    1790               0 :         break;
    1791                 :       default:
    1792                 :         CPLError(CE_Failure, CPLE_NotSupported,
    1793               0 :                  "Unsupported type for field %s", pszName);
    1794               0 :         return -1;
    1795                 :     }
    1796                 : 
    1797                 :     /*-----------------------------------------------------
    1798                 :      * Add the FieldDefn to the FeatureDefn 
    1799                 :      *----------------------------------------------------*/
    1800              60 :     m_poDefn->AddFieldDefn(poFieldDefn);
    1801              60 :     delete poFieldDefn;
    1802                 : 
    1803                 :     /*-----------------------------------------------------------------
    1804                 :      * Keep track of native field type
    1805                 :      *----------------------------------------------------------------*/
    1806                 :     m_paeFieldType = (TABFieldType *)CPLRealloc(m_paeFieldType,
    1807                 :                                                 m_poDefn->GetFieldCount()*
    1808              60 :                                                 sizeof(TABFieldType));
    1809              60 :     m_paeFieldType[m_poDefn->GetFieldCount()-1] = eMapInfoType;
    1810                 : 
    1811                 :     /*-----------------------------------------------------------------
    1812                 :      * Extend array of Indexed/Unique flags
    1813                 :      *----------------------------------------------------------------*/
    1814                 :     m_pabFieldIndexed = (GBool *)CPLRealloc(m_pabFieldIndexed,
    1815                 :                                             m_poDefn->GetFieldCount()*
    1816              60 :                                             sizeof(GBool));
    1817                 :     m_pabFieldUnique  = (GBool *)CPLRealloc(m_pabFieldUnique,
    1818                 :                                             m_poDefn->GetFieldCount()*
    1819              60 :                                             sizeof(GBool));
    1820              60 :     m_pabFieldIndexed[m_poDefn->GetFieldCount()-1] = bIndexed;
    1821              60 :     m_pabFieldUnique[m_poDefn->GetFieldCount()-1] = bUnique;
    1822                 : 
    1823              60 :     CPLFree(pszCleanName);
    1824              60 :     return nStatus;
    1825                 : }
    1826                 : 
    1827                 : 
    1828                 : /**********************************************************************
    1829                 :  *                   MIFFile::GetNativeFieldType()
    1830                 :  *
    1831                 :  * Returns the native MapInfo field type for the specified field.
    1832                 :  *
    1833                 :  * Returns TABFUnknown if file is not opened, or if specified field index is
    1834                 :  * invalid.
    1835                 :  **********************************************************************/
    1836               0 : TABFieldType MIFFile::GetNativeFieldType(int nFieldId)
    1837                 : {
    1838               0 :     if ( m_poDefn==NULL || m_paeFieldType==NULL ||
    1839                 :          nFieldId < 0 || nFieldId >= m_poDefn->GetFieldCount())
    1840               0 :         return TABFUnknown;
    1841                 : 
    1842               0 :     return m_paeFieldType[nFieldId];
    1843                 : }
    1844                 : 
    1845                 : /************************************************************************
    1846                 :  *                       MIFFile::SetFieldIndexed()
    1847                 :  ************************************************************************/
    1848                 : 
    1849               0 : int MIFFile::SetFieldIndexed( int nFieldId )
    1850                 : 
    1851                 : {
    1852               0 :     if ( m_poDefn==NULL || m_pabFieldIndexed==NULL ||
    1853                 :          nFieldId < 0 || nFieldId >= m_poDefn->GetFieldCount())
    1854               0 :         return -1;
    1855                 : 
    1856               0 :     m_pabFieldIndexed[nFieldId] = TRUE;
    1857                 : 
    1858               0 :     return 0;
    1859                 : }
    1860                 : 
    1861                 : /************************************************************************
    1862                 :  *                       MIFFile::IsFieldIndexed()
    1863                 :  ************************************************************************/
    1864                 : 
    1865               0 : GBool MIFFile::IsFieldIndexed( int nFieldId )
    1866                 : 
    1867                 : {
    1868               0 :     if ( m_poDefn==NULL || m_pabFieldIndexed==NULL ||
    1869                 :          nFieldId < 0 || nFieldId >= m_poDefn->GetFieldCount())
    1870               0 :         return FALSE;
    1871                 : 
    1872               0 :     return m_pabFieldIndexed[nFieldId];
    1873                 : }
    1874                 : 
    1875                 : /************************************************************************
    1876                 :  *                       MIFFile::IsFieldUnique()
    1877                 :  ************************************************************************/
    1878                 : 
    1879               0 : GBool MIFFile::IsFieldUnique( int nFieldId )
    1880                 : 
    1881                 : {
    1882               0 :     if ( m_poDefn==NULL || m_pabFieldUnique==NULL ||
    1883                 :          nFieldId < 0 || nFieldId >= m_poDefn->GetFieldCount())
    1884               0 :         return FALSE;
    1885                 : 
    1886               0 :     return m_pabFieldUnique[nFieldId];
    1887                 : }
    1888                 : 
    1889                 : 
    1890                 : /************************************************************************/
    1891                 : /*                       MIFFile::SetSpatialRef()                       */
    1892                 : /************************************************************************/
    1893                 : 
    1894               0 : int MIFFile::SetSpatialRef( OGRSpatialReference * poSpatialRef )
    1895                 : 
    1896                 : {
    1897               0 :     CPLFree( m_pszCoordSys );
    1898                 : 
    1899               0 :     m_pszCoordSys = MITABSpatialRef2CoordSys( poSpatialRef );
    1900                 : 
    1901               0 :     return( m_pszCoordSys != NULL );
    1902                 : }
    1903                 : 
    1904                 : 
    1905                 : /************************************************************************/
    1906                 : /*                      MIFFile::SetMIFCoordSys()                       */
    1907                 : /************************************************************************/
    1908                 : 
    1909               0 : int MIFFile::SetMIFCoordSys(const char * pszMIFCoordSys)
    1910                 : 
    1911                 : {
    1912                 :     char        **papszFields, *pszCoordSys;
    1913                 :     int         iBounds;
    1914                 : 
    1915                 :     // Extract the word 'COORDSYS' if present
    1916               0 :     if (EQUALN(pszMIFCoordSys,"COORDSYS",8) )
    1917                 :     {
    1918               0 :         pszCoordSys = CPLStrdup(pszMIFCoordSys + 9);
    1919                 :     }
    1920                 :     else
    1921                 :     {
    1922               0 :         pszCoordSys = CPLStrdup(pszMIFCoordSys);
    1923                 :     }
    1924                 : 
    1925                 :     // Extract bounds if present
    1926                 :     papszFields = CSLTokenizeStringComplex(pszCoordSys, " ,()\t",
    1927               0 :                                            TRUE, FALSE );
    1928               0 :     iBounds = CSLFindString( papszFields, "Bounds" );
    1929               0 :     if (iBounds >= 0 && iBounds + 4 < CSLCount(papszFields))
    1930                 :     {
    1931               0 :         m_dXMin = atof(papszFields[++iBounds]);
    1932               0 :         m_dYMin = atof(papszFields[++iBounds]);
    1933               0 :         m_dXMax = atof(papszFields[++iBounds]);
    1934               0 :         m_dYMax = atof(papszFields[++iBounds]);
    1935               0 :         m_bBoundsSet = TRUE;
    1936                 : 
    1937               0 :         pszCoordSys[strstr(pszCoordSys, "Bounds") - pszCoordSys] = '\0';
    1938                 :     }
    1939               0 :     CSLDestroy( papszFields );
    1940                 : 
    1941                 :     // Assign the CoordSys
    1942               0 :     CPLFree( m_pszCoordSys );
    1943                 : 
    1944               0 :     m_pszCoordSys = CPLStrdup(pszCoordSys);
    1945               0 :     CPLFree(pszCoordSys);
    1946                 : 
    1947               0 :     return( m_pszCoordSys != NULL );
    1948                 : }
    1949                 : 
    1950                 : /************************************************************************/
    1951                 : /*                       MIFFile::GetSpatialRef()                       */
    1952                 : /************************************************************************/
    1953                 : 
    1954               1 : OGRSpatialReference *MIFFile::GetSpatialRef()
    1955                 : 
    1956                 : {
    1957               1 :     if( m_poSpatialRef == NULL )
    1958               1 :         m_poSpatialRef = MITABCoordSys2SpatialRef( m_pszCoordSys );
    1959                 : 
    1960               1 :     return m_poSpatialRef;
    1961                 : }
    1962                 : 
    1963                 : /**********************************************************************
    1964                 :  *                   MIFFile::UpdateExtents()
    1965                 :  *
    1966                 :  * Private Methode used to update the dataset extents
    1967                 :  **********************************************************************/
    1968               0 : void MIFFile::UpdateExtents(double dfX, double dfY)
    1969                 : {
    1970               0 :     if (m_bExtentsSet == FALSE)
    1971                 :     {
    1972               0 :         m_bExtentsSet = TRUE;
    1973               0 :         m_sExtents.MinX = m_sExtents.MaxX = dfX;
    1974               0 :         m_sExtents.MinY = m_sExtents.MaxY = dfY;
    1975                 :     }
    1976                 :     else
    1977                 :     {
    1978               0 :         if (dfX < m_sExtents.MinX)
    1979               0 :             m_sExtents.MinX = dfX;
    1980               0 :         if (dfX > m_sExtents.MaxX)
    1981               0 :           m_sExtents.MaxX = dfX;
    1982               0 :         if (dfY < m_sExtents.MinY)
    1983               0 :           m_sExtents.MinY = dfY;
    1984               0 :         if (dfY > m_sExtents.MaxY)
    1985               0 :           m_sExtents.MaxY = dfY;
    1986                 :     }
    1987               0 : }
    1988                 : 
    1989                 : /**********************************************************************
    1990                 :  *                   MIFFile::SetBounds()
    1991                 :  *
    1992                 :  * Set projection coordinates bounds of the newly created dataset.
    1993                 :  *
    1994                 :  * This function must be called after creating a new dataset and before any
    1995                 :  * feature can be written to it.
    1996                 :  *
    1997                 :  * Returns 0 on success, -1 on error.
    1998                 :  **********************************************************************/
    1999                 : int MIFFile::SetBounds(double dXMin, double dYMin, 
    2000               0 :                        double dXMax, double dYMax)
    2001                 : {
    2002               0 :     if (m_eAccessMode != TABWrite)
    2003                 :     {
    2004                 :         CPLError(CE_Failure, CPLE_NotSupported,
    2005               0 :                  "SetBounds() can be used only with Write access.");
    2006               0 :         return -1;
    2007                 :     }
    2008                 : 
    2009               0 :     m_dXMin = dXMin;
    2010               0 :     m_dXMax = dXMax;
    2011               0 :     m_dYMin = dYMin;
    2012               0 :     m_dYMax = dYMax;
    2013               0 :     m_bBoundsSet = TRUE;
    2014                 :     
    2015               0 :     return 0; 
    2016                 : }
    2017                 : 
    2018                 : 
    2019                 : /**********************************************************************
    2020                 :  *                   MIFFile::GetFeatureCountByType()
    2021                 :  *
    2022                 :  * Return number of features of each type.
    2023                 :  *
    2024                 :  * NOTE: The current implementation always returns -1 for MIF files
    2025                 :  *       since this would require scanning the whole file.
    2026                 :  *
    2027                 :  * When properly implemented, the bForce flag will force scanning the
    2028                 :  * whole file by default.
    2029                 :  *
    2030                 :  * Returns 0 on success, or silently returns -1 (with no error) if this
    2031                 :  * information is not available.
    2032                 :  **********************************************************************/
    2033                 : int MIFFile::GetFeatureCountByType(int &numPoints, int &numLines,
    2034                 :                                    int &numRegions, int &numTexts,
    2035              18 :                                    GBool bForce )
    2036                 : {
    2037              18 :     if( m_bPreParsed || bForce )
    2038                 :     {
    2039               0 :         PreParseFile();
    2040                 : 
    2041               0 :         numPoints = m_nPoints;
    2042               0 :         numLines = m_nLines;
    2043               0 :         numRegions = m_nRegions;
    2044               0 :         numTexts = m_nTexts;
    2045               0 :         return 0;
    2046                 :     }
    2047                 :     else
    2048                 :     {
    2049              18 :         numPoints = numLines = numRegions = numTexts = 0;
    2050              18 :         return -1;
    2051                 :     }
    2052                 : }
    2053                 : 
    2054                 : /**********************************************************************
    2055                 :  *                   MIFFile::GetBounds()
    2056                 :  *
    2057                 :  * Fetch projection coordinates bounds of a dataset.
    2058                 :  *
    2059                 :  * Pass bForce=FALSE to avoid a scan of the whole file if the bounds
    2060                 :  * are not already available.
    2061                 :  *
    2062                 :  * Returns 0 on success, -1 on error or if bounds are not available and
    2063                 :  * bForce=FALSE.
    2064                 :  **********************************************************************/
    2065                 : int MIFFile::GetBounds(double &dXMin, double &dYMin, 
    2066                 :                        double &dXMax, double &dYMax,
    2067               0 :                        GBool bForce /*= TRUE*/ )
    2068                 : {
    2069                 :     
    2070               0 :     if (m_bBoundsSet == FALSE && bForce == FALSE)
    2071                 :     {
    2072               0 :         return -1;
    2073                 :     }
    2074               0 :     else if (m_bBoundsSet == FALSE)
    2075                 :     {
    2076               0 :         PreParseFile();
    2077                 :     }
    2078                 : 
    2079               0 :     if (m_bBoundsSet == FALSE)
    2080                 :     {
    2081               0 :         return -1;
    2082                 :     }
    2083                 : 
    2084               0 :     dXMin = m_dXMin;
    2085               0 :     dXMax = m_dXMax;
    2086               0 :     dYMin = m_dYMin;
    2087               0 :     dYMax = m_dYMax;
    2088                 :     
    2089               0 :     return 0;
    2090                 : }
    2091                 : 
    2092                 : /**********************************************************************
    2093                 :  *                   MIFFile::GetExtent()
    2094                 :  *
    2095                 :  * Fetch extent of the data currently stored in the dataset.  We collect
    2096                 :  * this information while preparsing the file ... often already done for
    2097                 :  * other reasons, and if not it is still faster than fully reading all
    2098                 :  * the features just to count them.
    2099                 :  *
    2100                 :  * Returns OGRERR_NONE/OGRRERR_FAILURE.
    2101                 :  **********************************************************************/
    2102               0 : OGRErr MIFFile::GetExtent (OGREnvelope *psExtent, int bForce)
    2103                 : {
    2104               0 :     if (bForce == TRUE)
    2105               0 :         PreParseFile();
    2106                 : 
    2107               0 :     if (m_bPreParsed)
    2108                 :     {
    2109               0 :         *psExtent = m_sExtents;
    2110               0 :         return OGRERR_NONE;
    2111                 :     }
    2112                 :     else
    2113               0 :         return OGRERR_FAILURE;
    2114                 : }
    2115                 : 
    2116                 : /************************************************************************/
    2117                 : /*                           TestCapability()                           */
    2118                 : /************************************************************************/
    2119                 : 
    2120               0 : int MIFFile::TestCapability( const char * pszCap )
    2121                 : 
    2122                 : {
    2123               0 :     if( EQUAL(pszCap,OLCRandomRead) )
    2124               0 :         return TRUE;
    2125                 : 
    2126               0 :     else if( EQUAL(pszCap,OLCSequentialWrite) )
    2127               0 :         return TRUE;
    2128                 : 
    2129               0 :     else if( EQUAL(pszCap,OLCSequentialWrite) )
    2130               0 :         return FALSE;
    2131                 : 
    2132               0 :     else if( EQUAL(pszCap,OLCFastFeatureCount) )
    2133               0 :         return m_bPreParsed;
    2134                 : 
    2135               0 :     else if( EQUAL(pszCap,OLCFastSpatialFilter) )
    2136               0 :         return FALSE;
    2137                 : 
    2138               0 :     else if( EQUAL(pszCap,OLCFastGetExtent) )
    2139               0 :         return m_bPreParsed;
    2140                 : 
    2141                 :     else 
    2142               0 :         return FALSE;
    2143                 : }

Generated by: LTP GCOV extension version 1.5