/********************************************************************** * $Id: mitab_tabfile.cpp,v 1.59 2006/02/08 05:02:58 dmorissette Exp $ * * Name: mitab_tabfile.cpp * Project: MapInfo TAB Read/Write library * Language: C++ * Purpose: Implementation of the TABFile class, the main class of the lib. * To be used by external programs to handle reading/writing of * features from/to TAB datasets. * Author: Daniel Morissette, dmorissette@dmsolutions.ca * ********************************************************************** * Copyright (c) 1999-2003, Daniel Morissette * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. ********************************************************************** * * $Log: mitab_tabfile.cpp,v $ * Revision 1.59 2006/02/08 05:02:58 dmorissette * Fixed crash when attempting to write TABPolyline object with an invalid * geometry (GDAL bug 1059) * * Revision 1.58 2005/10/13 20:12:03 fwarmerdam * layers with just regions can't be set as type wkbPolygon because they may * have multipolygons (bug GDAL:958) * http://bugzilla.remotesensing.org/show_bug.cgi?id=958 * * Revision 1.57 2005/10/04 15:44:31 dmorissette * First round of support for Collection objects. Currently supports reading * from .TAB/.MAP and writing to .MIF. Still lacks symbol support and write * support. (Based in part on patch and docs from Jim Hope, bug 1126) * * Revision 1.56 2004/09/17 19:26:23 fwarmerdam * Several fixes in error/failure cases in TABFile::Open() care of * Stephen Cheesman of GeoSoft. * * Revision 1.55 2004/06/30 20:29:04 dmorissette * Fixed refs to old address danmo@videotron.ca * * Revision 1.54 2004/05/20 13:49:46 fwarmerdam * Removed special bailout for m_poMAPFile == NULL in TABFile::Close(). * It is important to cleanup other used memory. * * Revision 1.53 2003/01/18 20:22:39 daniel * Fixed leak of TABMAPObjHdr when writing NONE geometries in SetFeature() * * Revision 1.52 2002/09/23 13:15:35 warmerda * fixed memory leak in SetMIFCoordSys * * Revision 1.51 2002/09/23 13:06:21 warmerda * ensure pre-created m_poDefn is referenced properly * * Revision 1.50 2002/08/27 17:19:22 warmerda * auto-add FID column if there aren't any columns * * Revision 1.49 2002/03/26 01:48:40 daniel * Added Multipoint object type (V650) * * Revision 1.48 2001/11/19 15:08:50 daniel * Handle the case of TAB_GEOM_NONE with the new TABMAPObjHdr classes. * * Revision 1.47 2001/11/17 21:54:06 daniel * Made several changes in order to support writing objects in 16 bits * coordinate format. New TABMAPObjHdr-derived classes are used to hold * object info in mem until block is full. * * Revision 1.46 2001/09/19 21:39:31 warmerda * improved capabilities logic * * Revision 1.45 2001/09/14 19:14:43 warmerda * added attribute query support * * Revision 1.44 2001/09/14 03:23:55 warmerda * Substantial upgrade to support spatial queries using spatial indexes * * Revision 1.43 2001/03/15 03:57:51 daniel * Added implementation for new OGRLayer::GetExtent(), returning data MBR. * * Revision 1.42 2001/03/09 04:14:19 daniel * Fixed problem creating new files with mixed case extensions (e.g. ".Tab") * * Revision 1.41 2001/01/23 21:23:42 daniel * Added projection bounds lookup table, called from TABFile::SetProjInfo() * * Revision 1.40 2001/01/22 16:03:58 warmerda * expanded tabs * * Revision 1.39 2000/12/15 05:32:31 daniel * Handle table type LINKED the same way as table type NATIVE. * Make sure max char field width is 254 in AddFieldNative(). * * Revision 1.38 2000/10/18 03:53:16 daniel * GetBounds() now calculates bounds based on +/- 1e9 integer coordinates limit * * Revision 1.37 2000/09/20 18:32:02 daniel * Accept "FORMAT: DBF" in version 100 .tab headers * * Revision 1.36 2000/09/07 23:32:13 daniel * Added RecordDeletedFlag to TABFeature with get/set methods * * Revision 1.35 2000/07/04 01:50:02 warmerda * removed unprotected debugging printf. * * Revision 1.34 2000/06/28 00:31:05 warmerda * Try to set geometry type on OGRFeatureDefn by feature count * * Revision 1.33 2000/03/19 23:22:43 daniel * Fixed test on return value of SetSpatialRef() in SetMIFCoordSys() * * Revision 1.32 2000/02/28 17:11:14 daniel * Support indexed fields and new V450 object types * * Revision 1.31 2000/02/18 20:45:56 daniel * Validate field names on write * * Revision 1.30 2000/01/26 18:18:01 warmerda * fixed capabilities test * * Revision 1.29 2000/01/18 23:13:05 daniel * Added missing m_poDefn->Reference() * * Revision 1.28 2000/01/18 22:14:36 daniel * Fixed compile warnings * * Revision 1.27 2000/01/16 19:08:49 daniel * Added support for reading 'Table Type DBF' tables * * ... * * Revision 1.1 1999/07/12 04:18:25 daniel * Initial checkin * **********************************************************************/ #include "mitab.h" #include "mitab_utils.h" #include /* isspace() */ /*===================================================================== * class TABFile *====================================================================*/ /********************************************************************** * TABFile::TABFile() * * Constructor. **********************************************************************/ TABFile::TABFile() { m_eAccessMode = TABRead; m_pszFname = NULL; m_papszTABFile = NULL; m_nVersion = 300; m_pszCharset = NULL; m_eTableType = TABTableNative; m_poMAPFile = NULL; m_poDATFile = NULL; m_poINDFile = NULL; m_poDefn = NULL; m_poSpatialRef = NULL; m_poCurFeature = NULL; m_nCurFeatureId = 0; m_nLastFeatureId = 0; m_panIndexNo = NULL; bUseSpatialTraversal = FALSE; } /********************************************************************** * TABFile::~TABFile() * * Destructor. **********************************************************************/ TABFile::~TABFile() { Close(); } /************************************************************************/ /* GetFeatureCount() */ /************************************************************************/ int TABFile::GetFeatureCount (int bForce) { if( m_poFilterGeom != NULL || m_poAttrQuery != NULL ) return OGRLayer::GetFeatureCount( bForce ); else return m_nLastFeatureId; } /************************************************************************/ /* ResetReading() */ /************************************************************************/ void TABFile::ResetReading() { m_nCurFeatureId = 0; if( m_poMAPFile != NULL ) m_poMAPFile->ResetReading(); /* -------------------------------------------------------------------- */ /* Decide whether to operate in spatial traversal mode or not, */ /* and ensure the current spatial filter is applied to the map */ /* file object. */ /* -------------------------------------------------------------------- */ if( m_poMAPFile ) { bUseSpatialTraversal = FALSE; m_poMAPFile->ResetCoordFilter(); if( m_poFilterGeom != NULL ) { OGREnvelope sEnvelope; TABVertex sMin, sMax; TABMAPHeaderBlock *poHeader; poHeader = m_poMAPFile->GetHeaderBlock(); m_poFilterGeom->getEnvelope( &sEnvelope ); m_poMAPFile->GetCoordFilter( sMin, sMax ); if( sEnvelope.MinX > sMin.x || sEnvelope.MinY > sMin.y || sEnvelope.MaxX < sMax.x || sEnvelope.MaxY < sMax.y ) { bUseSpatialTraversal = TRUE; sMin.x = sEnvelope.MinX; sMin.y = sEnvelope.MinY; sMax.x = sEnvelope.MaxX; sMax.y = sEnvelope.MaxY; m_poMAPFile->SetCoordFilter( sMin, sMax ); } } } } /********************************************************************** * TABFile::Open() * * Open a .TAB dataset and the associated files, and initialize the * structures to be ready to read features from (or write to) it. * * Supported access modes are "r" (read-only) and "w" (create new dataset). * * Set bTestOpenNoError=TRUE to silently return -1 with no error message * if the file cannot be opened. This is intended to be used in the * context of a TestOpen() function. The default value is FALSE which * means that an error is reported if the file cannot be opened. * * Note that dataset extents will have to be set using SetBounds() before * any feature can be written to a newly created dataset. * * In read mode, a valid dataset must have at least a .TAB and a .DAT file. * The .MAP and .ID files are optional and if they do not exist then * all features will be returned with NONE geometry. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::Open(const char *pszFname, const char *pszAccess, GBool bTestOpenNoError /*=FALSE*/ ) { char *pszTmpFname = NULL; int nFnameLen = 0; CPLErrorReset(); if (m_poMAPFile) { CPLError(CE_Failure, CPLE_AssertionFailed, "Open() failed: object already contains an open file"); return -1; } /*----------------------------------------------------------------- * Validate access mode *----------------------------------------------------------------*/ if (EQUALN(pszAccess, "r", 1)) { m_eAccessMode = TABRead; pszAccess = "rb"; } else if (EQUALN(pszAccess, "w", 1)) { m_eAccessMode = TABWrite; pszAccess = "wb"; } else { if (!bTestOpenNoError) CPLError(CE_Failure, CPLE_FileIO, "Open() failed: access mode \"%s\" not supported", pszAccess); else CPLErrorReset(); return -1; } /*----------------------------------------------------------------- * Make sure filename has a .TAB extension... *----------------------------------------------------------------*/ m_pszFname = CPLStrdup(pszFname); nFnameLen = strlen(m_pszFname); if (nFnameLen > 4 && (strcmp(m_pszFname+nFnameLen-4, ".TAB")==0 || strcmp(m_pszFname+nFnameLen-4, ".MAP")==0 || strcmp(m_pszFname+nFnameLen-4, ".DAT")==0 ) ) strcpy(m_pszFname+nFnameLen-4, ".TAB"); else if (nFnameLen > 4 && (EQUAL(m_pszFname+nFnameLen-4, ".tab") || EQUAL(m_pszFname+nFnameLen-4, ".map") || EQUAL(m_pszFname+nFnameLen-4, ".dat") ) ) strcpy(m_pszFname+nFnameLen-4, ".tab"); else { if (!bTestOpenNoError) CPLError(CE_Failure, CPLE_FileIO, "Open() failed for %s: invalid filename extension", m_pszFname); else CPLErrorReset(); CPLFree(m_pszFname); return -1; } pszTmpFname = CPLStrdup(m_pszFname); #ifndef _WIN32 /*----------------------------------------------------------------- * On Unix, make sure extension uses the right cases * We do it even for write access because if a file with the same * extension already exists we want to overwrite it. *----------------------------------------------------------------*/ TABAdjustFilenameExtension(m_pszFname); #endif /*----------------------------------------------------------------- * Handle .TAB file... depends on access mode. *----------------------------------------------------------------*/ if (m_eAccessMode == TABRead) { /*------------------------------------------------------------- * Open .TAB file... since it's a small text file, we will just load * it as a stringlist in memory. *------------------------------------------------------------*/ m_papszTABFile = TAB_CSLLoad(m_pszFname); if (m_papszTABFile == NULL) { if (!bTestOpenNoError) { CPLError(CE_Failure, CPLE_FileIO, "Failed opening %s.", m_pszFname); } CPLFree(m_pszFname); m_pszFname = NULL; CSLDestroy(m_papszTABFile); m_papszTABFile = NULL; CPLFree( pszTmpFname ); return -1; } /*------------------------------------------------------------- * Do a first pass on the TAB header to establish the type of * dataset we have (NATIVE, DBF, etc.)... and also to know if * it is a supported type. *------------------------------------------------------------*/ if ( ParseTABFileFirstPass(bTestOpenNoError) != 0 ) { // No need to produce an error... it's already been done if // necessary... just cleanup and exit. CPLFree(m_pszFname); m_pszFname = NULL; CSLDestroy(m_papszTABFile); m_papszTABFile = NULL; CPLFree( pszTmpFname ); return -1; } } else { /*------------------------------------------------------------- * In Write access mode, the .TAB file will be written during the * Close() call... we will just set some defaults here. *------------------------------------------------------------*/ m_nVersion = 300; m_pszCharset = CPLStrdup("Neutral"); m_eTableType = TABTableNative; /*------------------------------------------------------------- * Do initial setup of feature definition. *------------------------------------------------------------*/ char *pszFeatureClassName = TABGetBasename(m_pszFname); m_poDefn = new OGRFeatureDefn(pszFeatureClassName); m_poDefn->Reference(); CPLFree(pszFeatureClassName); } /*----------------------------------------------------------------- * Open .DAT file (or .DBF) *----------------------------------------------------------------*/ if (nFnameLen > 4 && strcmp(pszTmpFname+nFnameLen-4, ".TAB")==0) { if (m_eTableType == TABTableDBF) strcpy(pszTmpFname+nFnameLen-4, ".DBF"); else // Default is NATIVE strcpy(pszTmpFname+nFnameLen-4, ".DAT"); } else { if (m_eTableType == TABTableDBF) strcpy(pszTmpFname+nFnameLen-4, ".dbf"); else // Default is NATIVE strcpy(pszTmpFname+nFnameLen-4, ".dat"); } #ifndef _WIN32 TABAdjustFilenameExtension(pszTmpFname); #endif m_poDATFile = new TABDATFile; if ( m_poDATFile->Open(pszTmpFname, pszAccess, m_eTableType) != 0) { // Open Failed... an error has already been reported, just return. CPLFree(pszTmpFname); Close(); if (bTestOpenNoError) CPLErrorReset(); return -1; } m_nLastFeatureId = m_poDATFile->GetNumRecords(); /*----------------------------------------------------------------- * Parse .TAB file field defs and build FeatureDefn (only in read access) *----------------------------------------------------------------*/ if (m_eAccessMode == TABRead && ParseTABFileFields() != 0) { // Failed... an error has already been reported, just return. CPLFree(pszTmpFname); Close(); if (bTestOpenNoError) CPLErrorReset(); return -1; } /*----------------------------------------------------------------- * Open .MAP (and .ID) file * Note that the .MAP and .ID files are optional. Failure to open them * is not an error... it simply means that all features will be returned * with NONE geometry. *----------------------------------------------------------------*/ if (nFnameLen > 4 && strcmp(pszTmpFname+nFnameLen-4, ".DAT")==0) strcpy(pszTmpFname+nFnameLen-4, ".MAP"); else strcpy(pszTmpFname+nFnameLen-4, ".map"); #ifndef _WIN32 TABAdjustFilenameExtension(pszTmpFname); #endif m_poMAPFile = new TABMAPFile; if (m_eAccessMode == TABRead) { /*------------------------------------------------------------- * Read access: .MAP/.ID are optional... try to open but return * no error if files do not exist. *------------------------------------------------------------*/ if (m_poMAPFile->Open(pszTmpFname, pszAccess, TRUE) < 0) { // File exists, but Open Failed... // we have to produce an error message if (!bTestOpenNoError) CPLError(CE_Failure, CPLE_FileIO, "Open() failed for %s", pszTmpFname); else CPLErrorReset(); CPLFree(pszTmpFname); Close(); return -1; } /*------------------------------------------------------------- * Set geometry type if the geometry objects are uniform. *------------------------------------------------------------*/ int numPoints=0, numRegions=0, numTexts=0, numLines=0; GetFeatureCountByType( numPoints, numLines, numRegions, numTexts); numPoints += numTexts; if( numPoints > 0 && numLines == 0 && numRegions == 0 ) m_poDefn->SetGeomType( wkbPoint ); else if( numPoints == 0 && numLines > 0 && numRegions == 0 ) m_poDefn->SetGeomType( wkbLineString ); else /* we leave it unknown indicating a mixture */; } else if (m_poMAPFile->Open(pszTmpFname, pszAccess) != 0) { // Open Failed for write... // an error has already been reported, just return. CPLFree(pszTmpFname); Close(); if (bTestOpenNoError) CPLErrorReset(); return -1; } CPLFree(pszTmpFname); pszTmpFname = NULL; /*----------------------------------------------------------------- * __TODO__ we could probably call GetSpatialRef() here to force * parsing the projection information... this would allow us to * assignSpatialReference() on the geometries that we return. *----------------------------------------------------------------*/ return 0; } /********************************************************************** * TABFile::ParseTABFileFirstPass() * * Do a first pass in the TAB header file to establish the table type, etc. * and store any useful information into class members. * * This private method should be used only during the Open() call. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::ParseTABFileFirstPass(GBool bTestOpenNoError) { int iLine, numLines, numFields = 0; char **papszTok=NULL; GBool bInsideTableDef = FALSE, bFoundTableFields=FALSE; if (m_eAccessMode != TABRead) { CPLError(CE_Failure, CPLE_NotSupported, "ParseTABFile() can be used only with Read access."); return -1; } numLines = CSLCount(m_papszTABFile); for(iLine=0; iLine2048 || iLine+numFields >= numLines) { if (!bTestOpenNoError) CPLError(CE_Failure, CPLE_FileIO, "Invalid number of fields (%s) at line %d in file %s", papszTok[1], iLine+1, m_pszFname); CSLDestroy(papszTok); return -1; } bInsideTableDef = FALSE; }/* end of fields section*/ else { // Simply Ignore unrecognized lines } } CSLDestroy(papszTok); if (m_pszCharset == NULL) m_pszCharset = CPLStrdup("Neutral"); if (numFields == 0) { if (!bTestOpenNoError) CPLError(CE_Failure, CPLE_NotSupported, "%s contains no table field definition. " "This type of .TAB file cannot be read by this library.", m_pszFname); return -1; } return 0; } /********************************************************************** * TABFile::ParseTABFileFields() * * Extract the field definition from the TAB header file, validate * with what we have in the previously opened .DAT or .DBF file, and * finally build the m_poDefn OGRFeatureDefn for this dataset. * * This private method should be used only during the Open() call and after * ParseTABFileFirstPass() has been called. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::ParseTABFileFields() { int iLine, numLines=0, numTok, nStatus; char **papszTok=NULL; OGRFieldDefn *poFieldDefn; if (m_eAccessMode != TABRead) { CPLError(CE_Failure, CPLE_NotSupported, "ParseTABFile() can be used only with Read access."); return -1; } char *pszFeatureClassName = TABGetBasename(m_pszFname); m_poDefn = new OGRFeatureDefn(pszFeatureClassName); CPLFree(pszFeatureClassName); // Ref count defaults to 0... set it to 1 m_poDefn->Reference(); /*------------------------------------------------------------- * Scan for fields. *------------------------------------------------------------*/ numLines = CSLCount(m_papszTABFile); for(iLine=0; iLine 2048 || iLine+numFields >= numLines) { CPLError(CE_Failure, CPLE_FileIO, "Invalid number of fields (%s) at line %d in file %s", pszStr+7, iLine+1, m_pszFname); CSLDestroy(papszTok); return -1; } // Alloc the array to keep track of indexed fields m_panIndexNo = (int *)CPLCalloc(numFields, sizeof(int)); iLine++; poFieldDefn = NULL; for(iField=0; iField= 3 && EQUAL(papszTok[1], "char")) { /*------------------------------------------------- * CHAR type *------------------------------------------------*/ nStatus = m_poDATFile->ValidateFieldInfoFromTAB(iField, papszTok[0], TABFChar, atoi(papszTok[2]), 0); poFieldDefn = new OGRFieldDefn(papszTok[0], OFTString); poFieldDefn->SetWidth(atoi(papszTok[2])); } else if (numTok >= 2 && EQUAL(papszTok[1], "integer")) { /*------------------------------------------------- * INTEGER type *------------------------------------------------*/ nStatus = m_poDATFile->ValidateFieldInfoFromTAB(iField, papszTok[0], TABFInteger, 0, 0); poFieldDefn = new OGRFieldDefn(papszTok[0], OFTInteger); } else if (numTok >= 2 && EQUAL(papszTok[1], "smallint")) { /*------------------------------------------------- * SMALLINT type *------------------------------------------------*/ nStatus = m_poDATFile->ValidateFieldInfoFromTAB(iField, papszTok[0], TABFSmallInt, 0, 0); poFieldDefn = new OGRFieldDefn(papszTok[0], OFTInteger); } else if (numTok >= 4 && EQUAL(papszTok[1], "decimal")) { /*------------------------------------------------- * DECIMAL type *------------------------------------------------*/ nStatus = m_poDATFile->ValidateFieldInfoFromTAB(iField, papszTok[0], TABFDecimal, atoi(papszTok[2]), atoi(papszTok[3])); poFieldDefn = new OGRFieldDefn(papszTok[0], OFTReal); poFieldDefn->SetWidth(atoi(papszTok[2])); poFieldDefn->SetPrecision(atoi(papszTok[3])); } else if (numTok >= 2 && EQUAL(papszTok[1], "float")) { /*------------------------------------------------- * FLOAT type *------------------------------------------------*/ nStatus = m_poDATFile->ValidateFieldInfoFromTAB(iField, papszTok[0], TABFFloat, 0, 0); poFieldDefn = new OGRFieldDefn(papszTok[0], OFTReal); } else if (numTok >= 2 && EQUAL(papszTok[1], "date")) { /*------------------------------------------------- * DATE type (returned as a string: "DD/MM/YYYY") *------------------------------------------------*/ nStatus = m_poDATFile->ValidateFieldInfoFromTAB(iField, papszTok[0], TABFDate, 0, 0); poFieldDefn = new OGRFieldDefn(papszTok[0], OFTString); poFieldDefn->SetWidth(10); } else if (numTok >= 2 && EQUAL(papszTok[1], "logical")) { /*------------------------------------------------- * LOGICAL type (value "T" or "F") *------------------------------------------------*/ nStatus = m_poDATFile->ValidateFieldInfoFromTAB(iField, papszTok[0], TABFLogical, 0, 0); poFieldDefn = new OGRFieldDefn(papszTok[0], OFTString); poFieldDefn->SetWidth(1); } else nStatus = -1; // Unrecognized field type or line corrupt if (nStatus != 0) { CPLError(CE_Failure, CPLE_FileIO, "Failed to parse field definition at line %d in file %s", iLine+1, m_pszFname); CSLDestroy(papszTok); return -1; } /*----------------------------------------------------- * Keep track of index number if present *----------------------------------------------------*/ if (numTok >= 4 && EQUAL(papszTok[numTok-2], "index")) { m_panIndexNo[iField] = atoi(papszTok[numTok-1]); } else { m_panIndexNo[iField] = 0; } /*----------------------------------------------------- * Add the FieldDefn to the FeatureDefn and continue with * the next one. *----------------------------------------------------*/ m_poDefn->AddFieldDefn(poFieldDefn); // AddFieldDenf() takes a copy, so we delete the original if (poFieldDefn) delete poFieldDefn; poFieldDefn = NULL; } /*--------------------------------------------------------- * OK, we're done... end the loop now. *--------------------------------------------------------*/ break; }/* end of fields section*/ else { // Simply Ignore unrecognized lines } } CSLDestroy(papszTok); if (m_poDefn->GetFieldCount() == 0) { CPLError(CE_Failure, CPLE_NotSupported, "%s contains no table field definition. " "This type of .TAB file cannot be read by this library.", m_pszFname); return -1; } return 0; } /********************************************************************** * TABFile::WriteTABFile() * * Generate the .TAB file using mainly the attribute fields definition. * * This private method should be used only during the Close() call with * write access mode. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::WriteTABFile() { FILE *fp; if (m_eAccessMode != TABWrite) { CPLError(CE_Failure, CPLE_NotSupported, "WriteTABFile() can be used only with Write access."); return -1; } if ( (fp = VSIFOpen(m_pszFname, "wt")) != NULL) { fprintf(fp, "!table\n"); fprintf(fp, "!version %d\n", m_nVersion); fprintf(fp, "!charset %s\n", m_pszCharset); fprintf(fp, "\n"); if (m_poDefn && m_poDefn->GetFieldCount() > 0) { int iField; OGRFieldDefn *poFieldDefn; const char *pszFieldType; fprintf(fp, "Definition Table\n"); fprintf(fp, " Type NATIVE Charset \"%s\"\n", m_pszCharset); fprintf(fp, " Fields %d\n", m_poDefn->GetFieldCount()); for(iField=0; iFieldGetFieldCount(); iField++) { poFieldDefn = m_poDefn->GetFieldDefn(iField); switch(GetNativeFieldType(iField)) { case TABFChar: pszFieldType = CPLSPrintf("Char (%d)", poFieldDefn->GetWidth()); break; case TABFDecimal: pszFieldType = CPLSPrintf("Decimal (%d,%d)", poFieldDefn->GetWidth(), poFieldDefn->GetPrecision()); break; case TABFInteger: pszFieldType = "Integer"; break; case TABFSmallInt: pszFieldType = "SmallInt"; break; case TABFFloat: pszFieldType = "Float"; break; case TABFLogical: pszFieldType = "Logical"; break; case TABFDate: pszFieldType = "Date"; break; default: // Unsupported field type!!! This should never happen. CPLError(CE_Failure, CPLE_AssertionFailed, "WriteTABFile(): Unsupported field type"); VSIFClose(fp); return -1; } if (GetFieldIndexNumber(iField) == 0) { fprintf(fp, " %s %s ;\n", poFieldDefn->GetNameRef(), pszFieldType ); } else { fprintf(fp, " %s %s Index %d ;\n", poFieldDefn->GetNameRef(), pszFieldType, GetFieldIndexNumber(iField) ); } } } else { fprintf(fp, "Definition Table\n"); fprintf(fp, " Type NATIVE Charset \"%s\"\n", m_pszCharset); fprintf(fp, " Fields 1\n"); fprintf(fp, " FID Integer ;\n" ); } VSIFClose(fp); } else { CPLError(CE_Failure, CPLE_FileIO, "Failed to create file `%s'", m_pszFname); return -1; } return 0; } /********************************************************************** * TABFile::Close() * * Close current file, and release all memory used. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::Close() { // Commit the latest changes to the file... // In Write access, it's time to write the .TAB file. if (m_eAccessMode == TABWrite && m_poMAPFile) { // First update file version number... int nMapObjVersion = m_poMAPFile->GetMinTABFileVersion(); m_nVersion = MAX(m_nVersion, nMapObjVersion); WriteTABFile(); } if (m_poMAPFile) { m_poMAPFile->Close(); delete m_poMAPFile; m_poMAPFile = NULL; } if (m_poDATFile) { m_poDATFile->Close(); delete m_poDATFile; m_poDATFile = NULL; } if (m_poINDFile) { m_poINDFile->Close(); delete m_poINDFile; m_poINDFile = NULL; } if (m_poCurFeature) { delete m_poCurFeature; m_poCurFeature = NULL; } /*----------------------------------------------------------------- * Note: we have to check the reference count before deleting * m_poSpatialRef and m_poDefn *----------------------------------------------------------------*/ if (m_poDefn ) { int nRefCount = m_poDefn->Dereference(); CPLAssert( nRefCount >= 0 ); if( nRefCount == 0 ) delete m_poDefn; m_poDefn = NULL; } if (m_poSpatialRef && m_poSpatialRef->Dereference() == 0) delete m_poSpatialRef; m_poSpatialRef = NULL; CSLDestroy(m_papszTABFile); m_papszTABFile = NULL; CPLFree(m_pszFname); m_pszFname = NULL; CPLFree(m_pszCharset); m_pszCharset = NULL; CPLFree(m_panIndexNo); m_panIndexNo = NULL; return 0; } /********************************************************************** * TABFile::GetNextFeatureId() * * Returns feature id that follows nPrevId, or -1 if it is the * last feature id. Pass nPrevId=-1 to fetch the first valid feature id. **********************************************************************/ int TABFile::GetNextFeatureId(int nPrevId) { if (m_eAccessMode != TABRead) { CPLError(CE_Failure, CPLE_NotSupported, "GetNextFeatureId() can be used only with Read access."); return -1; } /*----------------------------------------------------------------- * Are we using spatial rather than .ID based traversal? *----------------------------------------------------------------*/ if( bUseSpatialTraversal ) return m_poMAPFile->GetNextFeatureId( nPrevId ); /*----------------------------------------------------------------- * Establish what the next logical feature ID should be *----------------------------------------------------------------*/ int nFeatureId = -1; if (nPrevId <= 0 && m_nLastFeatureId > 0) nFeatureId = 1; // Feature Ids start at 1 else if (nPrevId > 0 && nPrevId < m_nLastFeatureId) nFeatureId = nPrevId + 1; else { // This was the last feature return OGRNullFID; } /*----------------------------------------------------------------- * Skip any feature with NONE geometry and a deleted attribute record *----------------------------------------------------------------*/ while(nFeatureId <= m_nLastFeatureId) { if ( m_poMAPFile->MoveToObjId(nFeatureId) != 0 || m_poDATFile->GetRecordBlock(nFeatureId) == NULL ) { CPLError(CE_Failure, CPLE_IllegalArg, "GetNextFeatureId() failed: unable to set read pointer " "to feature id %d", nFeatureId); return -1; } // __TODO__ Add a test here to check if object is deleted, // i.e. 0x40 set on object_id in object block if (m_poMAPFile->GetCurObjType() != TAB_GEOM_NONE || m_poDATFile->IsCurrentRecordDeleted() == FALSE) { // This feature contains at least a geometry or some attributes... // return its id. return nFeatureId; } nFeatureId++; } // If we reached this point, then we kept skipping deleted features // and stopped when EOF was reached. return -1; } /********************************************************************** * TABFile::GetNextFeatureId_Spatial() * * Returns feature id that follows nPrevId, or -1 if it is the * last feature id, but by traversing the spatial tree instead of the * direct object index. Generally speaking the feature id's will be * returned in an unordered fashion. **********************************************************************/ int TABFile::GetNextFeatureId_Spatial(int nPrevId) { if (m_eAccessMode != TABRead) { CPLError(CE_Failure, CPLE_NotSupported, "GetNextFeatureId_Spatial() can be used only with Read access."); return -1; } if( m_poMAPFile == NULL ) { CPLError(CE_Failure, CPLE_NotSupported, "GetNextFeatureId_Spatial() requires availability of .MAP file." ); return -1; } return m_poMAPFile->GetNextFeatureId( nPrevId ); } /********************************************************************** * TABFile::GetFeatureRef() * * Fill and return a TABFeature object for the specified feature id. * * The retruned pointer is a reference to an object owned and maintained * by this TABFile object. It should not be altered or freed by the * caller and its contents is guaranteed to be valid only until the next * call to GetFeatureRef() or Close(). * * Returns NULL if the specified feature id does not exist of if an * error happened. In any case, CPLError() will have been called to * report the reason of the failure. * * If an unsupported object type is encountered (likely from a newer version * of MapInfo) then a valid feature will be returned with a NONE geometry, * and a warning will be produced with code TAB_WarningFeatureTypeNotSupported * CPLGetLastErrorNo() should be used to detect that case. **********************************************************************/ TABFeature *TABFile::GetFeatureRef(int nFeatureId) { CPLErrorReset(); if (m_eAccessMode != TABRead) { CPLError(CE_Failure, CPLE_NotSupported, "GetFeatureRef() can be used only with Read access."); return NULL; } /*----------------------------------------------------------------- * Make sure file is opened and Validate feature id by positioning * the read pointers for the .MAP and .DAT files to this feature id. *----------------------------------------------------------------*/ if (m_poMAPFile == NULL) { CPLError(CE_Failure, CPLE_IllegalArg, "GetFeatureRef() failed: file is not opened!"); return NULL; } if (nFeatureId <= 0 || nFeatureId > m_nLastFeatureId || m_poMAPFile->MoveToObjId(nFeatureId) != 0 || m_poDATFile->GetRecordBlock(nFeatureId) == NULL ) { // CPLError(CE_Failure, CPLE_IllegalArg, // "GetFeatureRef() failed: invalid feature id %d", // nFeatureId); return NULL; } /*----------------------------------------------------------------- * Flush current feature object * __TODO__ try to reuse if it is already of the right type *----------------------------------------------------------------*/ if (m_poCurFeature) { delete m_poCurFeature; m_poCurFeature = NULL; } /*----------------------------------------------------------------- * Create new feature object of the right type *----------------------------------------------------------------*/ switch(m_poMAPFile->GetCurObjType()) { case TAB_GEOM_NONE: m_poCurFeature = new TABFeature(m_poDefn); break; case TAB_GEOM_SYMBOL_C: case TAB_GEOM_SYMBOL: m_poCurFeature = new TABPoint(m_poDefn); break; case TAB_GEOM_FONTSYMBOL_C: case TAB_GEOM_FONTSYMBOL: m_poCurFeature = new TABFontPoint(m_poDefn); break; case TAB_GEOM_CUSTOMSYMBOL_C: case TAB_GEOM_CUSTOMSYMBOL: m_poCurFeature = new TABCustomPoint(m_poDefn); break; case TAB_GEOM_LINE_C: case TAB_GEOM_LINE: case TAB_GEOM_PLINE_C: case TAB_GEOM_PLINE: case TAB_GEOM_MULTIPLINE_C: case TAB_GEOM_MULTIPLINE: case TAB_GEOM_V450_MULTIPLINE_C: case TAB_GEOM_V450_MULTIPLINE: m_poCurFeature = new TABPolyline(m_poDefn); break; case TAB_GEOM_ARC_C: case TAB_GEOM_ARC: m_poCurFeature = new TABArc(m_poDefn); break; case TAB_GEOM_REGION_C: case TAB_GEOM_REGION: case TAB_GEOM_V450_REGION_C: case TAB_GEOM_V450_REGION: m_poCurFeature = new TABRegion(m_poDefn); break; case TAB_GEOM_RECT_C: case TAB_GEOM_RECT: case TAB_GEOM_ROUNDRECT_C: case TAB_GEOM_ROUNDRECT: m_poCurFeature = new TABRectangle(m_poDefn); break; case TAB_GEOM_ELLIPSE_C: case TAB_GEOM_ELLIPSE: m_poCurFeature = new TABEllipse(m_poDefn); break; case TAB_GEOM_TEXT_C: case TAB_GEOM_TEXT: m_poCurFeature = new TABText(m_poDefn); break; case TAB_GEOM_MULTIPOINT_C: case TAB_GEOM_MULTIPOINT: m_poCurFeature = new TABMultiPoint(m_poDefn); break; case TAB_GEOM_COLLECTION_C: case TAB_GEOM_COLLECTION: m_poCurFeature = new TABCollection(m_poDefn); break; default: /*------------------------------------------------------------- * Unsupported feature type... we still return a valid feature * with NONE geometry after producing a Warning. * Callers can trap that case by checking CPLGetLastErrorNo() * against TAB_WarningFeatureTypeNotSupported *------------------------------------------------------------*/ // m_poCurFeature = new TABDebugFeature(m_poDefn); m_poCurFeature = new TABFeature(m_poDefn); CPLError(CE_Warning, TAB_WarningFeatureTypeNotSupported, "Unsupported object type %d (0x%2.2x). Feature will be " "returned with NONE geometry.", m_poMAPFile->GetCurObjType(), m_poMAPFile->GetCurObjType() ); } /*----------------------------------------------------------------- * Read fields from the .DAT file * GetRecordBlock() has already been called above... *----------------------------------------------------------------*/ if (m_poCurFeature->ReadRecordFromDATFile(m_poDATFile) != 0) { delete m_poCurFeature; m_poCurFeature = NULL; return NULL; } /*----------------------------------------------------------------- * Read geometry from the .MAP file * MoveToObjId() has already been called above... *----------------------------------------------------------------*/ TABMAPObjHdr *poObjHdr = TABMAPObjHdr::NewObj(m_poMAPFile->GetCurObjType(), m_poMAPFile->GetCurObjId()); // Note that poObjHdr==NULL is a valid case if geometry type is NONE if ((poObjHdr && poObjHdr->ReadObj(m_poMAPFile->GetCurObjBlock()) != 0) || m_poCurFeature->ReadGeometryFromMAPFile(m_poMAPFile, poObjHdr) != 0) { delete m_poCurFeature; m_poCurFeature = NULL; if (poObjHdr) delete poObjHdr; return NULL; } if (poObjHdr) // May be NULL if feature geometry type is NONE delete poObjHdr; m_nCurFeatureId = nFeatureId; m_poCurFeature->SetFID(m_nCurFeatureId); m_poCurFeature->SetRecordDeleted(m_poDATFile->IsCurrentRecordDeleted()); return m_poCurFeature; } /********************************************************************** * TABFile::SetFeature() * * Write a feature to this dataset. * * For now only sequential writes are supported (i.e. with nFeatureId=-1) * but eventually we should be able to do random access by specifying * a value through nFeatureId. * * Returns the new featureId (> 0) on success, or -1 if an * error happened in which case, CPLError() will have been called to * report the reason of the failure. **********************************************************************/ int TABFile::SetFeature(TABFeature *poFeature, int nFeatureId /*=-1*/) { if (m_eAccessMode != TABWrite) { CPLError(CE_Failure, CPLE_NotSupported, "SetFeature() can be used only with Write access."); return -1; } if (nFeatureId != -1) { CPLError(CE_Failure, CPLE_NotSupported, "SetFeature(): random access not implemented yet."); return -1; } /*----------------------------------------------------------------- * Make sure file is opened and establish new feature id. *----------------------------------------------------------------*/ if (m_poMAPFile == NULL) { CPLError(CE_Failure, CPLE_IllegalArg, "SetFeature() failed: file is not opened!"); return -1; } if (m_nLastFeatureId < 1) { /*------------------------------------------------------------- * OK, this is the first feature in the dataset... make sure the * .DAT schema has been initialized. *------------------------------------------------------------*/ if (m_poDefn == NULL) SetFeatureDefn(poFeature->GetDefnRef(), NULL); /*------------------------------------------------------------- * Special hack to write out at least one field if none are in * OGRFeatureDefn. *------------------------------------------------------------*/ if( m_poDATFile->GetNumFields() == 0 ) { CPLError(CE_Warning, CPLE_IllegalArg, "MapInfo tables must contain at least 1 column, adding dummy FID column."); m_poDATFile->AddField("FID", TABFInteger, 10, 0 ); } nFeatureId = m_nLastFeatureId = 1; } else { nFeatureId = ++ m_nLastFeatureId; } /*----------------------------------------------------------------- * Write fields to the .DAT file and update .IND if necessary *----------------------------------------------------------------*/ if (m_poDATFile == NULL || m_poDATFile->GetRecordBlock(nFeatureId) == NULL || poFeature->WriteRecordToDATFile(m_poDATFile, m_poINDFile, m_panIndexNo) != 0 ) { CPLError(CE_Failure, CPLE_FileIO, "Failed writing attributes for feature id %d in %s", nFeatureId, m_pszFname); return -1; } /*----------------------------------------------------------------- * Write geometry to the .MAP file * The call to PrepareNewObj() takes care of the .ID file. *----------------------------------------------------------------*/ TABMAPObjHdr *poObjHdr = TABMAPObjHdr::NewObj(poFeature->ValidateMapInfoType(m_poMAPFile), nFeatureId); TABMAPObjectBlock *poObjBlock = NULL; /*----------------------------------------------------------------- * ValidateMapInfoType() may have returned TAB_GEOM_NONE if feature * contained an invalid geometry for its class. Need to catch that * case and return the error. *----------------------------------------------------------------*/ if (poObjHdr->m_nType == TAB_GEOM_NONE && poFeature->GetFeatureClass() != TABFCNoGeomFeature ) { CPLError(CE_Failure, CPLE_FileIO, "Invalid geometry for feature id %d in %s", nFeatureId, m_pszFname); return -1; } if ( poObjHdr == NULL || m_poMAPFile == NULL || m_poMAPFile->PrepareNewObj(nFeatureId, poObjHdr->m_nType) != 0 || poFeature->WriteGeometryToMAPFile(m_poMAPFile, poObjHdr) != 0 ) { CPLError(CE_Failure, CPLE_FileIO, "Failed writing geometry for feature id %d in %s", nFeatureId, m_pszFname); return -1; } if (poObjHdr->m_nType == TAB_GEOM_NONE) { // NONE objects have no reference in the ObjectBlocks. Just flush it. delete poObjHdr; } else if ( (poObjBlock = m_poMAPFile->GetCurObjBlock()) == NULL || poObjBlock->AddObject(poObjHdr) != 0 ) { CPLError(CE_Failure, CPLE_FileIO, "Failed writing object header for feature id %d in %s", nFeatureId, m_pszFname); return -1; } return nFeatureId; } /********************************************************************** * TABFile::GetLayerDefn() * * Returns a reference to the OGRFeatureDefn that will be used to create * features in this dataset. * * Returns a reference to an object that is maintained by this TABFile * object (and thus should not be modified or freed by the caller) or * NULL if the OGRFeatureDefn has not been initialized yet (i.e. no file * opened yet) **********************************************************************/ OGRFeatureDefn *TABFile::GetLayerDefn() { return m_poDefn; } /********************************************************************** * TABFile::SetFeatureDefn() * * Pass a reference to the OGRFeatureDefn that will be used to create * features in this dataset. This function should be called after * creating a new dataset, but before writing the first feature. * All features that will be written to this dataset must share this same * OGRFeatureDefn. * * A reference to the OGRFeatureDefn will be kept and will be used to * build the .DAT file, etc. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::SetFeatureDefn(OGRFeatureDefn *poFeatureDefn, TABFieldType *paeMapInfoNativeFieldTypes /* =NULL */) { int iField, numFields; OGRFieldDefn *poFieldDefn; TABFieldType eMapInfoType = TABFUnknown; int nStatus = 0; if (m_eAccessMode != TABWrite) { CPLError(CE_Failure, CPLE_NotSupported, "SetFeatureDefn() can be used only with Write access."); return -1; } /*----------------------------------------------------------------- * Keep a reference to the OGRFeatureDefn... we'll have to take the * reference count into account when we are done with it. *----------------------------------------------------------------*/ if (m_poDefn && m_poDefn->Dereference() == 0) delete m_poDefn; m_poDefn = poFeatureDefn; m_poDefn->Reference(); /*----------------------------------------------------------------- * Pass field information to the .DAT file, after making sure that * it has been created and that it does not contain any field * definition yet. *----------------------------------------------------------------*/ if (m_poDATFile== NULL || m_poDATFile->GetNumFields() > 0 ) { CPLError(CE_Failure, CPLE_AssertionFailed, "SetFeatureDefn() can be called only once in a newly " "created dataset."); return -1; } numFields = poFeatureDefn->GetFieldCount(); for(iField=0; nStatus==0 && iField < numFields; iField++) { poFieldDefn = m_poDefn->GetFieldDefn(iField); /*------------------------------------------------------------- * Make sure field name is valid... check for special chars, etc. *------------------------------------------------------------*/ char *pszCleanName = TABCleanFieldName(poFieldDefn->GetNameRef()); if (!EQUAL(pszCleanName, poFieldDefn->GetNameRef())) poFieldDefn->SetName(pszCleanName); CPLFree(pszCleanName); pszCleanName = NULL; if (paeMapInfoNativeFieldTypes) { eMapInfoType = paeMapInfoNativeFieldTypes[iField]; } else { /*--------------------------------------------------------- * Map OGRFieldTypes to MapInfo native types *--------------------------------------------------------*/ switch(poFieldDefn->GetType()) { case OFTInteger: eMapInfoType = TABFInteger; break; case OFTReal: eMapInfoType = TABFFloat; break; case OFTString: default: eMapInfoType = TABFChar; } } nStatus = m_poDATFile->AddField(poFieldDefn->GetNameRef(), eMapInfoType, poFieldDefn->GetWidth(), poFieldDefn->GetPrecision()); } /*----------------------------------------------------------------- * Alloc the array to keep track of indexed fields (default=NOT indexed) *----------------------------------------------------------------*/ m_panIndexNo = (int *)CPLCalloc(numFields, sizeof(int)); return nStatus; } /********************************************************************** * TABFile::AddFieldNative() * * Create a new field using a native mapinfo data type... this is an * alternative to defining fields through the OGR interface. * This function should be called after creating a new dataset, but before * writing the first feature. * * This function will build/update the OGRFeatureDefn that will have to be * used when writing features to this dataset. * * A reference to the OGRFeatureDefn can be obtained using GetLayerDefn(). * * Note: The bUnique flag has no effect on TABFiles. See the TABView class. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::AddFieldNative(const char *pszName, TABFieldType eMapInfoType, int nWidth /*=0*/, int nPrecision /*=0*/, GBool bIndexed /*=FALSE*/, GBool /*bUnique=FALSE*/) { OGRFieldDefn *poFieldDefn; int nStatus = 0; char *pszCleanName = NULL; if (m_eAccessMode != TABWrite) { CPLError(CE_Failure, CPLE_NotSupported, "AddFieldNative() can be used only with Write access."); return -1; } /*----------------------------------------------------------------- * Check that call happens at the right time in dataset's life. *----------------------------------------------------------------*/ if (m_eAccessMode != TABWrite || m_nLastFeatureId > 0 || m_poDATFile == NULL) { CPLError(CE_Failure, CPLE_AssertionFailed, "AddFieldNative() must be called after opening a new " "dataset, but before writing the first feature to it."); return -1; } /*----------------------------------------------------------------- * Create new OGRFeatureDefn if not done yet... *----------------------------------------------------------------*/ if (m_poDefn== NULL) { char *pszFeatureClassName = TABGetBasename(m_pszFname); m_poDefn = new OGRFeatureDefn(pszFeatureClassName); CPLFree(pszFeatureClassName); // Ref count defaults to 0... set it to 1 m_poDefn->Reference(); } /*----------------------------------------------------------------- * Validate field width... must be <= 254 *----------------------------------------------------------------*/ if (nWidth > 254) { CPLError(CE_Warning, CPLE_IllegalArg, "Invalid size (%d) for field '%s'. " "Size must be 254 or less.", nWidth, pszName); nWidth=254; } /*----------------------------------------------------------------- * Map fields with width=0 (variable length in OGR) to a valid default *----------------------------------------------------------------*/ if (eMapInfoType == TABFDecimal && nWidth == 0) nWidth=20; else if (nWidth == 0) nWidth=254; /* char fields */ /*----------------------------------------------------------------- * Make sure field name is valid... check for special chars, etc. * (pszCleanName will have to be freed.) *----------------------------------------------------------------*/ pszCleanName = TABCleanFieldName(pszName); /*----------------------------------------------------------------- * Map MapInfo native types to OGR types *----------------------------------------------------------------*/ poFieldDefn = NULL; switch(eMapInfoType) { case TABFChar: /*------------------------------------------------- * CHAR type *------------------------------------------------*/ poFieldDefn = new OGRFieldDefn(pszCleanName, OFTString); poFieldDefn->SetWidth(nWidth); break; case TABFInteger: /*------------------------------------------------- * INTEGER type *------------------------------------------------*/ poFieldDefn = new OGRFieldDefn(pszCleanName, OFTInteger); break; case TABFSmallInt: /*------------------------------------------------- * SMALLINT type *------------------------------------------------*/ poFieldDefn = new OGRFieldDefn(pszCleanName, OFTInteger); break; case TABFDecimal: /*------------------------------------------------- * DECIMAL type *------------------------------------------------*/ poFieldDefn = new OGRFieldDefn(pszCleanName, OFTReal); poFieldDefn->SetWidth(nWidth); poFieldDefn->SetPrecision(nPrecision); break; case TABFFloat: /*------------------------------------------------- * FLOAT type *------------------------------------------------*/ poFieldDefn = new OGRFieldDefn(pszCleanName, OFTReal); break; case TABFDate: /*------------------------------------------------- * DATE type (returned as a string: "DD/MM/YYYY") *------------------------------------------------*/ poFieldDefn = new OGRFieldDefn(pszCleanName, OFTString); poFieldDefn->SetWidth(10); break; case TABFLogical: /*------------------------------------------------- * LOGICAL type (value "T" or "F") *------------------------------------------------*/ poFieldDefn = new OGRFieldDefn(pszCleanName, OFTString); poFieldDefn->SetWidth(1); break; default: CPLError(CE_Failure, CPLE_NotSupported, "Unsupported type for field %s", pszCleanName); CPLFree(pszCleanName); return -1; } /*----------------------------------------------------- * Add the FieldDefn to the FeatureDefn *----------------------------------------------------*/ m_poDefn->AddFieldDefn(poFieldDefn); delete poFieldDefn; /*----------------------------------------------------- * ... and pass field info to the .DAT file. *----------------------------------------------------*/ nStatus = m_poDATFile->AddField(pszCleanName, eMapInfoType, nWidth, nPrecision); /*----------------------------------------------------------------- * Extend the array to keep track of indexed fields (default=NOT indexed) *----------------------------------------------------------------*/ m_panIndexNo = (int *)CPLRealloc(m_panIndexNo, m_poDefn->GetFieldCount()*sizeof(int)); m_panIndexNo[m_poDefn->GetFieldCount()-1] = 0; /*----------------------------------------------------------------- * Index the field if requested *----------------------------------------------------------------*/ if (nStatus == 0 && bIndexed) nStatus = SetFieldIndexed(m_poDefn->GetFieldCount()-1); CPLFree(pszCleanName); return nStatus; } /********************************************************************** * TABFile::GetNativeFieldType() * * Returns the native MapInfo field type for the specified field. * * Returns TABFUnknown if file is not opened, or if specified field index is * invalid. * * Note that field ids are positive and start at 0. **********************************************************************/ TABFieldType TABFile::GetNativeFieldType(int nFieldId) { if (m_poDATFile) { return m_poDATFile->GetFieldType(nFieldId); } return TABFUnknown; } /********************************************************************** * TABFile::GetFieldIndexNumber() * * Returns the field's index number that was specified in the .TAB header * or 0 if the specified field is not indexed. * * Note that field ids are positive and start at 0 * and valid index ids are positive and start at 1. **********************************************************************/ int TABFile::GetFieldIndexNumber(int nFieldId) { if (m_panIndexNo == NULL || nFieldId < 0 || m_poDATFile== NULL || nFieldId >= m_poDATFile->GetNumFields()) return 0; // no index return m_panIndexNo[nFieldId]; } /************************************************************************ * TABFile::SetFieldIndexed() * * Request that a field be indexed. This will create the .IND file if * necessary, etc. * * Note that field ids are positive and start at 0. * * Returns 0 on success, -1 on error. ************************************************************************/ int TABFile::SetFieldIndexed( int nFieldId ) { /*----------------------------------------------------------------- * Make sure things are OK *----------------------------------------------------------------*/ if (m_pszFname == NULL || m_eAccessMode != TABWrite || m_poDefn == NULL) { CPLError(CE_Failure, CPLE_AssertionFailed, "SetFieldIndexed() must be called after opening a new " "dataset, but before writing the first feature to it."); return -1; } if (m_panIndexNo == NULL || nFieldId < 0 || m_poDATFile== NULL || nFieldId >= m_poDATFile->GetNumFields()) { CPLError(CE_Failure, CPLE_AssertionFailed, "Invalid field number in SetFieldIndexed()."); return -1; } /*----------------------------------------------------------------- * If field is already indexed then just return *----------------------------------------------------------------*/ if (m_panIndexNo[nFieldId] != 0) return 0; // Nothing to do /*----------------------------------------------------------------- * Create .IND file if it's not done yet. * * Note: We can pass the .TAB's filename directly and the * TABINDFile class will automagically adjust the extension. *----------------------------------------------------------------*/ if (m_poINDFile == NULL) { m_poINDFile = new TABINDFile; if ( m_poINDFile->Open(m_pszFname, "w", TRUE) != 0) { // File could not be opened... delete m_poINDFile; m_poINDFile = NULL; return -1; } } /*----------------------------------------------------------------- * Init new index. *----------------------------------------------------------------*/ int nNewIndexNo; OGRFieldDefn *poFieldDefn = m_poDefn->GetFieldDefn(nFieldId); if (poFieldDefn == NULL || (nNewIndexNo = m_poINDFile->CreateIndex(GetNativeFieldType(nFieldId), poFieldDefn->GetWidth()) ) < 1) { // Failed... an error has already been reported. return -1; } m_panIndexNo[nFieldId] = nNewIndexNo; return 0; } /************************************************************************ * TABFile::IsFieldIndexed() * * Returns TRUE if field is indexed, or FALSE otherwise. ************************************************************************/ GBool TABFile::IsFieldIndexed( int nFieldId ) { return (GetFieldIndexNumber(nFieldId) > 0 ? TRUE:FALSE); } /********************************************************************** * TABFile::GetINDFileRef() * * Opens the .IND file for this dataset and returns a reference to * the handle. * If the .IND file has already been opened then the same handle is * returned directly. * If the .IND file does not exist then the function silently returns NULL. * * Note that the returned TABINDFile handle is only a reference to an * object that is owned by this class. Callers can use it but cannot * destroy the object. The object will remain valid for as long as * the TABFile will remain open. **********************************************************************/ TABINDFile *TABFile::GetINDFileRef() { if (m_pszFname == NULL) return NULL; if (m_eAccessMode == TABRead && m_poINDFile == NULL) { /*------------------------------------------------------------- * File is not opened yet... do it now. * * Note: We can pass the .TAB's filename directly and the * TABINDFile class will automagically adjust the extension. *------------------------------------------------------------*/ m_poINDFile = new TABINDFile; if ( m_poINDFile->Open(m_pszFname, "r", TRUE) != 0) { // File could not be opened... probably does not exist delete m_poINDFile; m_poINDFile = NULL; } else if (m_panIndexNo && m_poDATFile) { /*--------------------------------------------------------- * Pass type information for each indexed field. *--------------------------------------------------------*/ for(int i=0; iGetNumFields(); i++) { if (m_panIndexNo[i] > 0) { m_poINDFile->SetIndexFieldType(m_panIndexNo[i], GetNativeFieldType(i)); } } } } return m_poINDFile; } /********************************************************************** * TABFile::SetBounds() * * Set projection coordinates bounds of the newly created dataset. * * This function must be called after creating a new dataset and before any * feature can be written to it. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::SetBounds(double dXMin, double dYMin, double dXMax, double dYMax) { if (m_eAccessMode != TABWrite) { CPLError(CE_Failure, CPLE_NotSupported, "SetBounds() can be used only with Write access."); return -1; } /*----------------------------------------------------------------- * Check that dataset has been created but no feature set yet. *----------------------------------------------------------------*/ if (m_poMAPFile && m_nLastFeatureId < 1) { m_poMAPFile->SetCoordsysBounds(dXMin, dYMin, dXMax, dYMax); m_bBoundsSet = TRUE; } else { CPLError(CE_Failure, CPLE_AssertionFailed, "SetBounds() can be called only after dataset has been " "created and before any feature is set."); return -1; } return 0; } /********************************************************************** * TABFile::GetBounds() * * Fetch projection coordinates bounds of a dataset. * * The bForce flag has no effect on TAB files since the bounds are * always in the header. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::GetBounds(double &dXMin, double &dYMin, double &dXMax, double &dYMax, GBool /*bForce = TRUE*/) { TABMAPHeaderBlock *poHeader; if (m_poMAPFile && (poHeader=m_poMAPFile->GetHeaderBlock()) != NULL) { /*------------------------------------------------------------- * Projection bounds correspond to the +/- 1e9 integer coord. limits *------------------------------------------------------------*/ double dX0, dX1, dY0, dY1; m_poMAPFile->Int2Coordsys(-1000000000, -1000000000, dX0, dY0); m_poMAPFile->Int2Coordsys(1000000000, 1000000000, dX1, dY1); /*------------------------------------------------------------- * ... and make sure that Min < Max *------------------------------------------------------------*/ dXMin = MIN(dX0, dX1); dXMax = MAX(dX0, dX1); dYMin = MIN(dY0, dY1); dYMax = MAX(dY0, dY1); } else { CPLError(CE_Failure, CPLE_AppDefined, "GetBounds() can be called only after dataset has been opened."); return -1; } return 0; } /********************************************************************** * TABFile::GetExtent() * * Fetch extent of the data currently stored in the dataset. * * The bForce flag has no effect on TAB files since that value is * always in the header. * * Returns OGRERR_NONE/OGRRERR_FAILURE. **********************************************************************/ OGRErr TABFile::GetExtent (OGREnvelope *psExtent, int bForce) { TABMAPHeaderBlock *poHeader; if (m_poMAPFile && (poHeader=m_poMAPFile->GetHeaderBlock()) != NULL) { double dX0, dX1, dY0, dY1; /*------------------------------------------------------------- * Fetch extent of the data from the .map header block * this value is different from the projection bounds. *------------------------------------------------------------*/ m_poMAPFile->Int2Coordsys(poHeader->m_nXMin, poHeader->m_nYMin, dX0, dY0); m_poMAPFile->Int2Coordsys(poHeader->m_nXMax, poHeader->m_nYMax, dX1, dY1); /*------------------------------------------------------------- * ... and make sure that Min < Max *------------------------------------------------------------*/ psExtent->MinX = MIN(dX0, dX1); psExtent->MaxX = MAX(dX0, dX1); psExtent->MinY = MIN(dY0, dY1); psExtent->MaxY = MAX(dY0, dY1); return OGRERR_NONE; } return OGRERR_FAILURE; } /********************************************************************** * TABFile::GetFeatureCountByType() * * Return number of features of each type. * * Note that the sum of the 4 returned values may be different from * the total number of features since features with NONE geometry * are not taken into account here. * * Note: the bForce flag has nmo effect on .TAB files since the info * is always in the header. * * Returns 0 on success, or silently returns -1 (with no error) if this * information is not available. **********************************************************************/ int TABFile::GetFeatureCountByType(int &numPoints, int &numLines, int &numRegions, int &numTexts, GBool /* bForce = TRUE*/ ) { TABMAPHeaderBlock *poHeader; if (m_poMAPFile && (poHeader=m_poMAPFile->GetHeaderBlock()) != NULL) { numPoints = poHeader->m_numPointObjects; numLines = poHeader->m_numLineObjects; numRegions = poHeader->m_numRegionObjects; numTexts = poHeader->m_numTextObjects; } else { numPoints = numLines = numRegions = numTexts = 0; return -1; } return 0; } /********************************************************************** * TABFile::SetMIFCoordSys() * * Set projection for a new file using a MIF coordsys string. * * This function must be called after creating a new dataset and before any * feature can be written to it. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::SetMIFCoordSys(const char *pszMIFCoordSys) { if (m_eAccessMode != TABWrite) { CPLError(CE_Failure, CPLE_NotSupported, "SetMIFCoordSys() can be used only with Write access."); return -1; } /*----------------------------------------------------------------- * Check that dataset has been created but no feature set yet. *----------------------------------------------------------------*/ if (m_poMAPFile && m_nLastFeatureId < 1) { OGRSpatialReference *poSpatialRef; poSpatialRef = MITABCoordSys2SpatialRef( pszMIFCoordSys ); if (poSpatialRef) { double dXMin, dYMin, dXMax, dYMax; if (SetSpatialRef(poSpatialRef) == 0) { if (MITABExtractCoordSysBounds(pszMIFCoordSys, dXMin, dYMin, dXMax, dYMax) == TRUE) { // If the coordsys string contains bounds, then use them if (SetBounds(dXMin, dYMin, dXMax, dYMax) != 0) { // Failed Setting Bounds... an error should have // been already reported. return -1; } } } else { // Failed setting poSpatialRef... and error should have // been reported. return -1; } // Release our handle on poSpatialRef if( poSpatialRef->Dereference() == 0 ) delete poSpatialRef; } } else { CPLError(CE_Failure, CPLE_AssertionFailed, "SetMIFCoordSys() can be called only after dataset has been " "created and before any feature is set."); return -1; } return 0; } /********************************************************************** * TABFile::SetProjInfo() * * Set projection for a new file using a TABProjInfo structure. * * This function must be called after creating a new dataset and before any * feature can be written to it. * * This call will also trigger a lookup of default bounds for the specified * projection (except nonearth), and reset the m_bBoundsValid flag. * * Returns 0 on success, -1 on error. **********************************************************************/ int TABFile::SetProjInfo(TABProjInfo *poPI) { if (m_eAccessMode != TABWrite) { CPLError(CE_Failure, CPLE_NotSupported, "SetProjInfo() can be used only with Write access."); return -1; } /*----------------------------------------------------------------- * Check that dataset has been created but no feature set yet. *----------------------------------------------------------------*/ if (m_poMAPFile && m_nLastFeatureId < 1) { if (m_poMAPFile->GetHeaderBlock()->SetProjInfo( poPI ) != 0) return -1; } else { CPLError(CE_Failure, CPLE_AssertionFailed, "SetProjInfo() can be called only after dataset has been " "created and before any feature is set."); return -1; } /*----------------------------------------------------------------- * Lookup default bounds and reset m_bBoundsSet flag *----------------------------------------------------------------*/ double dXMin, dYMin, dXMax, dYMax; m_bBoundsSet = FALSE; if (MITABLookupCoordSysBounds(poPI, dXMin, dYMin, dXMax, dYMax) == TRUE) { SetBounds(dXMin, dYMin, dXMax, dYMax); } return 0; } /************************************************************************/ /* TestCapability() */ /************************************************************************/ int TABFile::TestCapability( const char * pszCap ) { if( EQUAL(pszCap,OLCRandomRead) ) return TRUE; else if( EQUAL(pszCap,OLCSequentialWrite) ) return m_eAccessMode == TABWrite; else if( EQUAL(pszCap,OLCRandomWrite) ) return FALSE; else if( EQUAL(pszCap,OLCFastFeatureCount) ) return m_poFilterGeom == NULL && m_poAttrQuery == NULL; else if( EQUAL(pszCap,OLCFastSpatialFilter) ) return TRUE; else if( EQUAL(pszCap,OLCFastGetExtent) ) return TRUE; else if( EQUAL(pszCap,OLCCreateField) ) return TRUE; else return FALSE; } /********************************************************************** * TABFile::Dump() * * Dump block contents... available only in DEBUG mode. **********************************************************************/ #ifdef DEBUG void TABFile::Dump(FILE *fpOut /*=NULL*/) { if (fpOut == NULL) fpOut = stdout; fprintf(fpOut, "----- TABFile::Dump() -----\n"); if (m_poMAPFile == NULL) { fprintf(fpOut, "File is not opened.\n"); } else { fprintf(fpOut, "File is opened: %s\n", m_pszFname); fprintf(fpOut, "Associated TABLE file ...\n\n"); m_poDATFile->Dump(fpOut); fprintf(fpOut, "... end of TABLE file dump.\n\n"); if( GetSpatialRef() != NULL ) { char *pszWKT; GetSpatialRef()->exportToWkt( &pszWKT ); fprintf( fpOut, "SRS = %s\n", pszWKT ); OGRFree( pszWKT ); } fprintf(fpOut, "Associated .MAP file ...\n\n"); m_poMAPFile->Dump(fpOut); fprintf(fpOut, "... end of .MAP file dump.\n\n"); } fflush(fpOut); } #endif // DEBUG