www.pudn.com > mitab-1.5.1.zip > mitab_datfile.cpp
/**********************************************************************
* $Id: mitab_datfile.cpp,v 1.17 2004/06/30 20:29:03 dmorissette Exp $
*
* Name: mitab_datfile.cpp
* Project: MapInfo TAB Read/Write library
* Language: C++
* Purpose: Implementation of the TABIDFile class used to handle
* reading/writing of the .DAT file
* Author: Daniel Morissette, dmorissette@dmsolutions.ca
*
**********************************************************************
* Copyright (c) 1999-2001, 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_datfile.cpp,v $
* Revision 1.17 2004/06/30 20:29:03 dmorissette
* Fixed refs to old address danmo@videotron.ca
*
* Revision 1.16 2001/05/01 12:32:03 daniel
* Get rid of leading spaces in WriteDateField().
*
* Revision 1.15 2000/04/27 15:42:03 daniel
* Map variable field length (width=0) coming from OGR to acceptable default
*
* Revision 1.14 2000/02/28 16:52:52 daniel
* Added support for writing indexes, removed validation on field name in
* NATIVE tables, and remove trailing spaces in DBF char field values
*
* Revision 1.13 2000/01/28 07:31:49 daniel
* Validate char field width (must be <= 254 chars)
*
* Revision 1.12 2000/01/16 19:08:48 daniel
* Added support for reading 'Table Type DBF' tables
*
* Revision 1.11 2000/01/15 22:30:43 daniel
* Switch to MIT/X-Consortium OpenSource license
*
* Revision 1.10 1999/12/20 18:59:20 daniel
* Dates again... now returned as "YYYYMMDD"
*
* Revision 1.9 1999/12/16 17:11:45 daniel
* Date fields: return as "YYYY/MM/DD", and accept 3 diff. formats as input
*
* Revision 1.8 1999/12/14 03:58:29 daniel
* Fixed date read/write (bytes were reversed)
*
* Revision 1.7 1999/11/09 07:34:35 daniel
* Return default values when deleted attribute records are encountered
*
* Revision 1.6 1999/10/19 06:09:25 daniel
* Removed obsolete GetFieldDef() method
*
* Revision 1.5 1999/10/01 03:56:28 daniel
* Avoid multiple InitWriteHeader() calls (caused a leak) and added a fix
* in WriteCharField() to prevent reading bytes past end of string buffer
*
* Revision 1.4 1999/10/01 02:02:36 warmerda
* Added assertions to try and track TABRawBinBlock leak.
*
* Revision 1.3 1999/09/26 14:59:36 daniel
* Implemented write support
*
* Revision 1.2 1999/09/20 18:43:20 daniel
* Use binary access to open file.
*
* Revision 1.1 1999/07/12 04:18:23 daniel
* Initial checkin
*
**********************************************************************/
#include "mitab.h"
/*=====================================================================
* class TABDATFile
*
* Note that the .DAT files are .DBF files with some exceptions:
*
* All fields in the DBF header are defined as 'C' type (strings),
* even for binary integers. So we have to look in the associated .TAB
* file to find the real field definition.
*
* Even though binary integers are defined as 'C' type, they are stored
* in binary form inside a 4 bytes string field.
*====================================================================*/
/**********************************************************************
* TABDATFile::TABDATFile()
*
* Constructor.
**********************************************************************/
TABDATFile::TABDATFile()
{
m_fp = NULL;
m_pszFname = NULL;
m_eTableType = TABTableNative;
m_poHeaderBlock = NULL;
m_poRecordBlock = NULL;
m_pasFieldDef = NULL;
m_numFields = -1;
m_numRecords = -1;
m_nFirstRecordPtr = 0;
m_nBlockSize = 0;
m_nRecordSize = -1;
m_nCurRecordId = -1;
m_bCurRecordDeletedFlag = FALSE;
m_bWriteHeaderInitialized = FALSE;
}
/**********************************************************************
* TABDATFile::~TABDATFile()
*
* Destructor.
**********************************************************************/
TABDATFile::~TABDATFile()
{
Close();
}
/**********************************************************************
* TABDATFile::Open()
*
* Open a .DAT file, and initialize the structures to be ready to read
* records from it.
*
* We currently support NATIVE and DBF tables for reading, and only
* NATIVE tables for writing.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::Open(const char *pszFname, const char *pszAccess,
TABTableType eTableType /*=TABNativeTable*/)
{
int i;
if (m_fp)
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed: object already contains an open file");
return -1;
}
/*-----------------------------------------------------------------
* Validate access mode and make sure we use binary access.
*----------------------------------------------------------------*/
if (EQUALN(pszAccess, "r", 1) && (eTableType==TABTableNative ||
eTableType==TABTableDBF) )
{
m_eAccessMode = TABRead;
pszAccess = "rb";
}
else if (EQUALN(pszAccess, "w", 1) && eTableType==TABTableNative)
{
m_eAccessMode = TABWrite;
pszAccess = "wb";
}
else
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed: access mode \"%s\" not supported", pszAccess);
return -1;
}
/*-----------------------------------------------------------------
* Open file for reading
*----------------------------------------------------------------*/
m_pszFname = CPLStrdup(pszFname);
m_fp = VSIFOpen(m_pszFname, pszAccess);
m_eTableType = eTableType;
if (m_fp == NULL)
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed for %s", m_pszFname);
CPLFree(m_pszFname);
m_pszFname = NULL;
return -1;
}
if (m_eAccessMode == TABRead)
{
/*------------------------------------------------------------
* READ ACCESS:
* Read .DAT file header (record size, num records, etc...)
* m_poHeaderBlock will be reused later to read field definition
*-----------------------------------------------------------*/
m_poHeaderBlock = new TABRawBinBlock(m_eAccessMode, TRUE);
m_poHeaderBlock->ReadFromFile(m_fp, 0, 32);
m_poHeaderBlock->ReadByte(); // Table type ??? 0x03
m_poHeaderBlock->ReadByte(); // Last update year
m_poHeaderBlock->ReadByte(); // Last update month
m_poHeaderBlock->ReadByte(); // Last update day
m_numRecords = m_poHeaderBlock->ReadInt32();
m_nFirstRecordPtr = m_poHeaderBlock->ReadInt16();
m_nRecordSize = m_poHeaderBlock->ReadInt16();
m_numFields = m_nFirstRecordPtr/32 - 1;
/*-------------------------------------------------------------
* Read the field definitions
* First 32 bytes field definition starts at byte 32 in file
*------------------------------------------------------------*/
m_pasFieldDef = (TABDATFieldDef*)CPLCalloc(m_numFields,
sizeof(TABDATFieldDef));
for(i=0; iGotoByteInFile((i+1)*32);
m_poHeaderBlock->ReadBytes(11, (GByte*)m_pasFieldDef[i].szName);
m_pasFieldDef[i].szName[10] = '\0';
m_pasFieldDef[i].cType = (char)m_poHeaderBlock->ReadByte();
m_poHeaderBlock->ReadInt32(); // Skip Bytes 12-15
m_pasFieldDef[i].byLength = m_poHeaderBlock->ReadByte();
m_pasFieldDef[i].byDecimals = m_poHeaderBlock->ReadByte();
m_pasFieldDef[i].eTABType = TABFUnknown;
}
/*-------------------------------------------------------------
* Establish a good record block size to use based on record size, and
* then create m_poRecordBlock
* Record block size has to be a multiple of record size.
*------------------------------------------------------------*/
m_nBlockSize = ((1024/m_nRecordSize)+1)*m_nRecordSize;
m_nBlockSize = MIN(m_nBlockSize, (m_numRecords*m_nRecordSize));
CPLAssert( m_poRecordBlock == NULL );
m_poRecordBlock = new TABRawBinBlock(m_eAccessMode, FALSE);
m_poRecordBlock->InitNewBlock(m_fp, m_nBlockSize);
m_poRecordBlock->SetFirstBlockPtr(m_nFirstRecordPtr);
}
else
{
/*------------------------------------------------------------
* WRITE ACCESS:
* Set acceptable defaults for all class members.
* The real header initialization will be done when the first
* record is written
*-----------------------------------------------------------*/
m_poHeaderBlock = NULL;
m_numRecords = 0;
m_nFirstRecordPtr = 0;
m_nRecordSize = 0;
m_numFields = 0;
m_pasFieldDef = NULL;
m_bWriteHeaderInitialized = FALSE;
}
return 0;
}
/**********************************************************************
* TABDATFile::Close()
*
* Close current file, and release all memory used.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::Close()
{
if (m_fp == NULL)
return 0;
/*----------------------------------------------------------------
* Write access: Update the header with number of records, etc.
* and add a CTRL-Z char at the end of the file.
*---------------------------------------------------------------*/
if (m_eAccessMode == TABWrite)
{
WriteHeader();
char cEOF = 26;
if (VSIFSeek(m_fp, 0L, SEEK_END) == 0)
VSIFWrite(&cEOF, 1, 1, m_fp);
}
// Delete all structures
if (m_poHeaderBlock)
{
delete m_poHeaderBlock;
m_poHeaderBlock = NULL;
}
if (m_poRecordBlock)
{
delete m_poRecordBlock;
m_poRecordBlock = NULL;
}
// Close file
VSIFClose(m_fp);
m_fp = NULL;
CPLFree(m_pszFname);
m_pszFname = NULL;
CPLFree(m_pasFieldDef);
m_pasFieldDef = NULL;
m_numFields = -1;
m_numRecords = -1;
m_nFirstRecordPtr = 0;
m_nBlockSize = 0;
m_nRecordSize = -1;
m_nCurRecordId = -1;
m_bWriteHeaderInitialized = FALSE;
return 0;
}
/**********************************************************************
* TABDATFile::InitWriteHeader()
*
* Init the header members to be ready to write the header and data records
* to a newly created data file.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::InitWriteHeader()
{
int i;
if (m_eAccessMode != TABWrite || m_bWriteHeaderInitialized)
return 0;
/*------------------------------------------------------------
* Compute values for Record size, header size, etc.
*-----------------------------------------------------------*/
m_nFirstRecordPtr = (m_numFields+1)*32 + 1;
m_nRecordSize = 1;
for(i=0; iInitNewBlock(m_fp, m_nBlockSize);
m_poRecordBlock->SetFirstBlockPtr(m_nFirstRecordPtr);
/*-------------------------------------------------------------
* Make sure this init. will be performed only once
*------------------------------------------------------------*/
m_bWriteHeaderInitialized = TRUE;
return 0;
}
/**********************************************************************
* TABDATFile::WriteHeader()
*
* Init the header members to be ready to write the header and data records
* to a newly created data file.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::WriteHeader()
{
int i;
if (m_eAccessMode != TABWrite)
{
CPLError(CE_Failure, CPLE_NotSupported,
"WriteHeader() can be used only with Write access.");
return -1;
}
if (!m_bWriteHeaderInitialized)
InitWriteHeader();
/*------------------------------------------------------------
* Create a single block that will be used to generate the whole header.
*-----------------------------------------------------------*/
if (m_poHeaderBlock == NULL)
m_poHeaderBlock = new TABRawBinBlock(m_eAccessMode, TRUE);
m_poHeaderBlock->InitNewBlock(m_fp, m_nFirstRecordPtr, 0);
/*------------------------------------------------------------
* First 32 bytes: main header block
*-----------------------------------------------------------*/
m_poHeaderBlock->WriteByte(0x03); // Table type ??? 0x03
// __TODO__ Write the correct update date value
m_poHeaderBlock->WriteByte(99); // Last update year
m_poHeaderBlock->WriteByte(9); // Last update month
m_poHeaderBlock->WriteByte(9); // Last update day
m_poHeaderBlock->WriteInt32(m_numRecords);
m_poHeaderBlock->WriteInt16(m_nFirstRecordPtr);
m_poHeaderBlock->WriteInt16(m_nRecordSize);
m_poHeaderBlock->WriteZeros(20); // Pad rest with zeros
/*-------------------------------------------------------------
* Field definitions follow. Each field def is 32 bytes.
*------------------------------------------------------------*/
for(i=0; iWriteBytes(11, (GByte*)m_pasFieldDef[i].szName);
m_poHeaderBlock->WriteByte(m_pasFieldDef[i].cType);
m_poHeaderBlock->WriteInt32(0); // Skip Bytes 12-15
m_poHeaderBlock->WriteByte(m_pasFieldDef[i].byLength);
m_poHeaderBlock->WriteByte(m_pasFieldDef[i].byDecimals);
m_poHeaderBlock->WriteZeros(14); // Pad rest with zeros
}
/*-------------------------------------------------------------
* Header ends with a 0x0d character.
*------------------------------------------------------------*/
m_poHeaderBlock->WriteByte(0x0d);
/*-------------------------------------------------------------
* Write the block to the file and return.
*------------------------------------------------------------*/
return m_poHeaderBlock->CommitToFile();
}
/**********************************************************************
* TABDATFile::GetNumFields()
*
* Return the number of fields in this table.
*
* Returns a value >= 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::GetNumFields()
{
return m_numFields;
}
/**********************************************************************
* TABDATFile::GetNumRecords()
*
* Return the number of records in this table.
*
* Returns a value >= 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::GetNumRecords()
{
return m_numRecords;
}
/**********************************************************************
* TABDATFile::GetRecordBlock()
*
* Return a TABRawBinBlock reference positioned at the beginning of the
* specified record and ready to read (or write) field values from/to it.
* In read access, the returned block is guaranteed to contain at least one
* full record of data, and in write access, it is at least big enough to
* hold one full record.
*
* Note that record ids are positive and start at 1.
*
* In Write access, CommitRecordToFile() MUST be called after the
* data items have been written to the record, otherwise the record
* will never make it to the file.
*
* Returns a reference to the TABRawBinBlock on success or NULL on error.
* The returned pointer is a reference to a block object owned by this
* TABDATFile object and should not be freed by the caller.
**********************************************************************/
TABRawBinBlock *TABDATFile::GetRecordBlock(int nRecordId)
{
m_bCurRecordDeletedFlag = FALSE;
if (m_eAccessMode == TABRead)
{
/*-------------------------------------------------------------
* READ ACCESS
*------------------------------------------------------------*/
int nFileOffset;
nFileOffset = m_nFirstRecordPtr+(nRecordId-1)*m_nRecordSize;
/*-------------------------------------------------------------
* Move record block pointer to the right location
*------------------------------------------------------------*/
if ( m_poRecordBlock == NULL ||
nRecordId < 1 || nRecordId > m_numRecords ||
m_poRecordBlock->GotoByteInFile(nFileOffset) != 0 )
{
CPLError(CE_Failure, CPLE_FileIO,
"Failed reading .DAT record block for record #%d in %s",
nRecordId, m_pszFname);
return NULL;
}
/*-------------------------------------------------------------
* The first char of the record is a ' ' for an active record, or
* '*' for a deleted one.
* In the case of a deleted record, we simply return default
* values for each attribute... this is what MapInfo seems to do
* when it takes a .TAB with deleted records and exports it to .MIF
*------------------------------------------------------------*/
if (m_poRecordBlock->ReadByte() != ' ')
{
m_bCurRecordDeletedFlag = TRUE;
}
}
else if (m_eAccessMode == TABWrite && nRecordId > 0)
{
/*-------------------------------------------------------------
* WRITE ACCESS
*------------------------------------------------------------*/
int nFileOffset;
/*-------------------------------------------------------------
* Before writing the first record, we must generate the file
* header. We will also initialize class members such as record
* size, etc. and will create m_poRecordBlock.
*------------------------------------------------------------*/
if (!m_bWriteHeaderInitialized)
{
WriteHeader();
}
m_numRecords = MAX(nRecordId, m_numRecords);
nFileOffset = m_nFirstRecordPtr+(nRecordId-1)*m_nRecordSize;
m_poRecordBlock->InitNewBlock(m_fp, m_nRecordSize, nFileOffset);
/*-------------------------------------------------------------
* The first char of the record is the active/deleted flag.
* Automatically set it to ' ' (active).
*------------------------------------------------------------*/
m_poRecordBlock->WriteByte(' ');
}
m_nCurRecordId = nRecordId;
return m_poRecordBlock;
}
/**********************************************************************
* TABDATFile::CommitRecordToFile()
*
* Commit the data record previously initialized with GetRecordBlock()
* to the file. This function must be called after writing the data
* values to a record otherwise the record will never make it to the
* file.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABDATFile::CommitRecordToFile()
{
if (m_eAccessMode != TABWrite || m_poRecordBlock == NULL)
return -1;
return m_poRecordBlock->CommitToFile();
}
/**********************************************************************
* TABDATFile::ValidateFieldInfoFromTAB()
*
* Check that the value read from the .TAB file by the caller are
* consistent with what is found in the .DAT header.
*
* Note that field ids are positive and start at 0.
*
* We have to use this function when opening a file for reading since
* the .DAT file does not contain the full field types information...
* a .DAT file is actually a .DBF file in which the .DBF types are
* handled in a special way... type 'C' fields are used to store binary
* values for most MapInfo types.
*
* For TABTableDBF, we actually have no validation to do since all types
* are stored as strings internally, so we'll just convert from string.
*
* Returns a value >= 0 if OK, -1 on error.
**********************************************************************/
int TABDATFile::ValidateFieldInfoFromTAB(int iField, const char *pszName,
TABFieldType eType,
int nWidth, int nPrecision)
{
int i = iField; // Just to make things shorter
CPLAssert(m_pasFieldDef);
if (m_pasFieldDef == NULL || iField < 0 || iField >= m_numFields)
{
CPLError(CE_Failure, CPLE_FileIO,
"Invalid field %d (%s) in .TAB header. %s contains only %d fields.",
iField+1, pszName, m_pszFname, m_pasFieldDef? m_numFields:0);
return -1;
}
/*-----------------------------------------------------------------
* We used to check that the .TAB field name matched the .DAT
* name stored internally, but apparently some tools that rename table
* field names only update the .TAB file and not the .DAT, so we won't
* do that name validation any more... we'll just check the type.
*
* With TABTableNative, we have to validate the field sizes as well
* because .DAT files use char fields to store binary values.
* With TABTableDBF, no need to validate field type since all
* fields are stored as strings internally.
*----------------------------------------------------------------*/
if ((m_eTableType == TABTableNative &&
((eType == TABFChar && (m_pasFieldDef[i].cType != 'C' ||
m_pasFieldDef[i].byLength != nWidth )) ||
(eType == TABFDecimal && (m_pasFieldDef[i].cType != 'N' ||
m_pasFieldDef[i].byLength != nWidth||
m_pasFieldDef[i].byDecimals!=nPrecision)) ||
(eType == TABFInteger && (m_pasFieldDef[i].cType != 'C' ||
m_pasFieldDef[i].byLength != 4 )) ||
(eType == TABFSmallInt && (m_pasFieldDef[i].cType != 'C' ||
m_pasFieldDef[i].byLength != 2 )) ||
(eType == TABFFloat && (m_pasFieldDef[i].cType != 'C' ||
m_pasFieldDef[i].byLength != 8 )) ||
(eType == TABFDate && (m_pasFieldDef[i].cType != 'C' ||
m_pasFieldDef[i].byLength != 4 )) ||
(eType == TABFLogical && (m_pasFieldDef[i].cType != 'L' ||
m_pasFieldDef[i].byLength != 1 )) ) ))
{
CPLError(CE_Failure, CPLE_FileIO,
"Definition of field %d (%s) from .TAB file does not match "
"what is found in %s (name=%s, type=%c, width=%d, prec=%d)",
iField+1, pszName, m_pszFname,
m_pasFieldDef[i].szName, m_pasFieldDef[i].cType,
m_pasFieldDef[i].byLength, m_pasFieldDef[i].byDecimals);
return -1;
}
m_pasFieldDef[i].eTABType = eType;
return 0;
}
/**********************************************************************
* TABDATFile::AddField()
*
* Create a new field (column) in a newly created table. This function
* must be called after the file has been opened, but before writing the
* first record.
*
* Returns the new field index (a value >= 0) if OK, -1 on error.
**********************************************************************/
int TABDATFile::AddField(const char *pszName, TABFieldType eType,
int nWidth, int nPrecision /*=0*/)
{
if (m_eAccessMode != TABWrite || m_bWriteHeaderInitialized ||
m_eTableType != TABTableNative)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Addition of new table fields is not supported after the "
"first data item has been written.");
return -1;
}
/*-----------------------------------------------------------------
* Validate field width... must be <= 254
*----------------------------------------------------------------*/
if (nWidth > 254)
{
CPLError(CE_Failure, CPLE_IllegalArg,
"Invalid size (%d) for field '%s'. "
"Size must be 254 or less.", nWidth, pszName);
return -1;
}
/*-----------------------------------------------------------------
* Map fields with width=0 (variable length in OGR) to a valid default
*----------------------------------------------------------------*/
if (eType == TABFDecimal && nWidth == 0)
nWidth=20;
else if (nWidth == 0)
nWidth=254; /* char fields */
if (m_numFields < 0)
m_numFields = 0;
m_numFields++;
m_pasFieldDef = (TABDATFieldDef*)CPLRealloc(m_pasFieldDef,
m_numFields*sizeof(TABDATFieldDef));
strncpy(m_pasFieldDef[m_numFields-1].szName, pszName, 10);
m_pasFieldDef[m_numFields-1].szName[10] = '\0';
m_pasFieldDef[m_numFields-1].eTABType = eType;
m_pasFieldDef[m_numFields-1].byLength = (GByte)nWidth;
m_pasFieldDef[m_numFields-1].byDecimals = (GByte)nPrecision;
switch(eType)
{
case TABFChar:
m_pasFieldDef[m_numFields-1].cType = 'C';
break;
case TABFDecimal:
m_pasFieldDef[m_numFields-1].cType = 'N';
break;
case TABFInteger:
m_pasFieldDef[m_numFields-1].cType = 'C';
m_pasFieldDef[m_numFields-1].byLength = 4;
break;
case TABFSmallInt:
m_pasFieldDef[m_numFields-1].cType = 'C';
m_pasFieldDef[m_numFields-1].byLength = 2;
break;
case TABFFloat:
m_pasFieldDef[m_numFields-1].cType = 'C';
m_pasFieldDef[m_numFields-1].byLength = 8;
break;
case TABFDate:
m_pasFieldDef[m_numFields-1].cType = 'C';
m_pasFieldDef[m_numFields-1].byLength = 4;
break;
case TABFLogical:
m_pasFieldDef[m_numFields-1].cType = 'L';
m_pasFieldDef[m_numFields-1].byLength = 1;
break;
default:
CPLError(CE_Failure, CPLE_NotSupported,
"Unsupported field type for field `%s'", pszName);
return -1;
}
return 0;
}
/**********************************************************************
* TABDATFile::GetFieldType()
*
* Returns the native field type for field # nFieldId as previously set
* by ValidateFieldInfoFromTAB().
*
* Note that field ids are positive and start at 0.
**********************************************************************/
TABFieldType TABDATFile::GetFieldType(int nFieldId)
{
if (m_pasFieldDef == NULL || nFieldId < 0 || nFieldId >= m_numFields)
return TABFUnknown;
return m_pasFieldDef[nFieldId].eTABType;
}
/**********************************************************************
* TABDATFile::GetFieldWidth()
*
* Returns the width for field # nFieldId as previously read from the
* .DAT header.
*
* Note that field ids are positive and start at 0.
**********************************************************************/
int TABDATFile::GetFieldWidth(int nFieldId)
{
if (m_pasFieldDef == NULL || nFieldId < 0 || nFieldId >= m_numFields)
return 0;
return m_pasFieldDef[nFieldId].byLength;
}
/**********************************************************************
* TABDATFile::GetFieldPrecision()
*
* Returns the precision for field # nFieldId as previously read from the
* .DAT header.
*
* Note that field ids are positive and start at 0.
**********************************************************************/
int TABDATFile::GetFieldPrecision(int nFieldId)
{
if (m_pasFieldDef == NULL || nFieldId < 0 || nFieldId >= m_numFields)
return 0;
return m_pasFieldDef[nFieldId].byDecimals;
}
/**********************************************************************
* TABDATFile::ReadCharField()
*
* Read the character field value at the current position in the data
* block.
*
* Use GetRecordBlock() to position the data block to the beginning of
* a record before attempting to read values.
*
* nWidth is the field length, as defined in the .DAT header.
*
* Returns a reference to an internal buffer that will be valid only until
* the next field is read, or "" if the operation failed, in which case
* CPLError() will have been called.
**********************************************************************/
const char *TABDATFile::ReadCharField(int nWidth)
{
// We know that character strings are limited to 254 chars in MapInfo
static char szBuf[256];
// If current record has been deleted, then return an acceptable
// default value.
if (m_bCurRecordDeletedFlag)
return "";
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't read field value: file is not opened.");
return "";
}
if (nWidth < 1 || nWidth > 255)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Illegal width for a char field: %d", nWidth);
return "";
}
if (m_poRecordBlock->ReadBytes(nWidth, (GByte*)szBuf) != 0)
return "";
szBuf[nWidth] = '\0';
// NATIVE tables are padded with '\0' chars, but DBF tables are padded
// with spaces... get rid of the trailing spaces.
if (m_eTableType == TABTableDBF)
{
int nLen = strlen(szBuf)-1;
while(nLen>=0 && szBuf[nLen] == ' ')
szBuf[nLen--] = '\0';
}
return szBuf;
}
/**********************************************************************
* TABDATFile::ReadIntegerField()
*
* Read the integer field value at the current position in the data
* block.
*
* Note: nWidth is used only with TABTableDBF types.
*
* CPLError() will have been called if something fails.
**********************************************************************/
GInt32 TABDATFile::ReadIntegerField(int nWidth)
{
// If current record has been deleted, then return an acceptable
// default value.
if (m_bCurRecordDeletedFlag)
return 0;
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't read field value: file is not opened.");
return 0;
}
if (m_eTableType == TABTableDBF)
return atoi(ReadCharField(nWidth));
return m_poRecordBlock->ReadInt32();
}
/**********************************************************************
* TABDATFile::ReadSmallIntField()
*
* Read the smallint field value at the current position in the data
* block.
*
* Note: nWidth is used only with TABTableDBF types.
*
* CPLError() will have been called if something fails.
**********************************************************************/
GInt16 TABDATFile::ReadSmallIntField(int nWidth)
{
// If current record has been deleted, then return an acceptable
// default value.
if (m_bCurRecordDeletedFlag)
return 0;
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't read field value: file is not opened.");
return 0;
}
if (m_eTableType == TABTableDBF)
return atoi(ReadCharField(nWidth));
return m_poRecordBlock->ReadInt16();
}
/**********************************************************************
* TABDATFile::ReadFloatField()
*
* Read the float field value at the current position in the data
* block.
*
* Note: nWidth is used only with TABTableDBF types.
*
* CPLError() will have been called if something fails.
**********************************************************************/
double TABDATFile::ReadFloatField(int nWidth)
{
// If current record has been deleted, then return an acceptable
// default value.
if (m_bCurRecordDeletedFlag)
return 0.0;
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't read field value: file is not opened.");
return 0.0;
}
if (m_eTableType == TABTableDBF)
return atof(ReadCharField(nWidth));
return m_poRecordBlock->ReadDouble();
}
/**********************************************************************
* TABDATFile::ReadLogicalField()
*
* Read the logical field value at the current position in the data
* block.
*
* The file contains either 0 or 1, and we return a string with
* "F" (false) or "T" (true)
*
* Note: nWidth is used only with TABTableDBF types.
*
* CPLError() will have been called if something fails.
**********************************************************************/
const char *TABDATFile::ReadLogicalField(int nWidth)
{
GByte bValue;
// If current record has been deleted, then return an acceptable
// default value.
if (m_bCurRecordDeletedFlag)
return "F";
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't read field value: file is not opened.");
return "";
}
if (m_eTableType == TABTableDBF)
{
const char *pszVal = ReadCharField(nWidth);
bValue = (pszVal && strchr("1YyTt", pszVal[0]) != NULL);
}
else
{
// In Native tables, we are guaranteed it is 1 byte with 0/1 value
bValue = m_poRecordBlock->ReadByte();
}
return bValue? "T":"F";
}
/**********************************************************************
* TABDATFile::ReadDateField()
*
* Read the logical field value at the current position in the data
* block.
*
* A date field is a 4 bytes binary value in which the first byte is
* the day, followed by 1 byte for the month, and 2 bytes for the year.
*
* We return an 8 chars string in the format "YYYYMMDD"
*
* Note: nWidth is used only with TABTableDBF types.
*
* Returns a reference to an internal buffer that will be valid only until
* the next field is read, or "" if the operation failed, in which case
* CPLError() will have been called.
**********************************************************************/
const char *TABDATFile::ReadDateField(int nWidth)
{
int nDay, nMonth, nYear;
static char szBuf[20];
// If current record has been deleted, then return an acceptable
// default value.
if (m_bCurRecordDeletedFlag)
return "";
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't read field value: file is not opened.");
return "";
}
// With .DBF files, there is nothing to do... the value should already
// be stored in YYYYMMDD format according to DBF specs.
if (m_eTableType == TABTableDBF)
return ReadCharField(nWidth);
nYear = m_poRecordBlock->ReadInt16();
nMonth = m_poRecordBlock->ReadByte();
nDay = m_poRecordBlock->ReadByte();
if (CPLGetLastErrorNo() != 0 || (nYear==0 && nMonth==0 && nDay==0))
return "";
sprintf(szBuf, "%4.4d%2.2d%2.2d", nYear, nMonth, nDay);
return szBuf;
}
/**********************************************************************
* TABDATFile::ReadDecimalField()
*
* Read the decimal field value at the current position in the data
* block.
*
* A decimal field is a floating point value with a fixed number of digits
* stored as a character string.
*
* nWidth is the field length, as defined in the .DAT header.
*
* We return the value as a binary double.
*
* CPLError() will have been called if something fails.
**********************************************************************/
double TABDATFile::ReadDecimalField(int nWidth)
{
const char *pszVal;
// If current record has been deleted, then return an acceptable
// default value.
if (m_bCurRecordDeletedFlag)
return 0.0;
pszVal = ReadCharField(nWidth);
return atof(pszVal);
}
/**********************************************************************
* TABDATFile::WriteCharField()
*
* Write the character field value at the current position in the data
* block.
*
* Use GetRecordBlock() to position the data block to the beginning of
* a record before attempting to write values.
*
* nWidth is the field length, as defined in the .DAT header.
*
* Returns 0 on success, or -1 if the operation failed, in which case
* CPLError() will have been called.
**********************************************************************/
int TABDATFile::WriteCharField(const char *pszStr, int nWidth,
TABINDFile *poINDFile, int nIndexNo)
{
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't write field value: GetRecordBlock() has not been called.");
return -1;
}
if (nWidth < 1 || nWidth > 255)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Illegal width for a char field: %d", nWidth);
return -1;
}
//
// Write the buffer after making sure that we don't try to read
// past the end of the source buffer. The rest of the field will
// be padded with zeros if source string is shorter than specified
// field width.
//
int nLen = strlen(pszStr);
nLen = MIN(nLen, nWidth);
if ((nLen>0 && m_poRecordBlock->WriteBytes(nLen, (GByte*)pszStr) != 0) ||
(nWidth-nLen > 0 && m_poRecordBlock->WriteZeros(nWidth-nLen)!=0) )
return -1;
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, pszStr);
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return 0;
}
/**********************************************************************
* TABDATFile::WriteIntegerField()
*
* Write the integer field value at the current position in the data
* block.
*
* CPLError() will have been called if something fails.
**********************************************************************/
int TABDATFile::WriteIntegerField(GInt32 nValue,
TABINDFile *poINDFile, int nIndexNo)
{
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't write field value: GetRecordBlock() has not been called.");
return -1;
}
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, nValue);
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return m_poRecordBlock->WriteInt32(nValue);
}
/**********************************************************************
* TABDATFile::WriteSmallIntField()
*
* Write the smallint field value at the current position in the data
* block.
*
* CPLError() will have been called if something fails.
**********************************************************************/
int TABDATFile::WriteSmallIntField(GInt16 nValue,
TABINDFile *poINDFile, int nIndexNo)
{
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't write field value: GetRecordBlock() has not been called.");
return -1;
}
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, nValue);
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return m_poRecordBlock->WriteInt16(nValue);
}
/**********************************************************************
* TABDATFile::WriteFloatField()
*
* Write the float field value at the current position in the data
* block.
*
* CPLError() will have been called if something fails.
**********************************************************************/
int TABDATFile::WriteFloatField(double dValue,
TABINDFile *poINDFile, int nIndexNo)
{
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't write field value: GetRecordBlock() has not been called.");
return -1;
}
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, dValue);
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return m_poRecordBlock->WriteDouble(dValue);
}
/**********************************************************************
* TABDATFile::WriteLogicalField()
*
* Write the logical field value at the current position in the data
* block.
*
* The value written to the file is either 0 or 1, but this function
* takes as input a string with "F" (false) or "T" (true)
*
* CPLError() will have been called if something fails.
**********************************************************************/
int TABDATFile::WriteLogicalField(const char *pszValue,
TABINDFile *poINDFile, int nIndexNo)
{
GByte bValue;
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't write field value: GetRecordBlock() has not been called.");
return -1;
}
if (EQUALN(pszValue, "T", 1))
bValue = 1;
else
bValue = 0;
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, (int)bValue);
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return m_poRecordBlock->WriteByte(bValue);
}
/**********************************************************************
* TABDATFile::WriteDateField()
*
* Write the date field value at the current position in the data
* block.
*
* A date field is a 4 bytes binary value in which the first byte is
* the day, followed by 1 byte for the month, and 2 bytes for the year.
*
* The expected input is a 10 chars string in the format "YYYY/MM/DD"
* or "DD/MM/YYYY" or "YYYYMMDD"
*
* Returns 0 on success, or -1 if the operation failed, in which case
* CPLError() will have been called.
**********************************************************************/
int TABDATFile::WriteDateField(const char *pszValue,
TABINDFile *poINDFile, int nIndexNo)
{
int nDay, nMonth, nYear;
char **papszTok = NULL;
if (m_poRecordBlock == NULL)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"Can't write field value: GetRecordBlock() has not been called.");
return -1;
}
/*-----------------------------------------------------------------
* Get rid of leading spaces.
*----------------------------------------------------------------*/
while ( *pszValue == ' ' ) { pszValue++; }
/*-----------------------------------------------------------------
* Try to automagically detect date format, one of:
* "YYYY/MM/DD", "DD/MM/YYYY", or "YYYYMMDD"
*----------------------------------------------------------------*/
if (strlen(pszValue) == 8)
{
/*-------------------------------------------------------------
* "YYYYMMDD"
*------------------------------------------------------------*/
char szBuf[9];
strcpy(szBuf, pszValue);
nDay = atoi(szBuf+6);
szBuf[6] = '\0';
nMonth = atoi(szBuf+4);
szBuf[4] = '\0';
nYear = atoi(szBuf);
}
else if (strlen(pszValue) == 10 &&
(papszTok = CSLTokenizeStringComplex(pszValue, "/",
FALSE, FALSE)) != NULL &&
CSLCount(papszTok) == 3 &&
(strlen(papszTok[0]) == 4 || strlen(papszTok[2]) == 4) )
{
/*-------------------------------------------------------------
* Either "YYYY/MM/DD" or "DD/MM/YYYY"
*------------------------------------------------------------*/
if (strlen(papszTok[0]) == 4)
{
nYear = atoi(papszTok[0]);
nMonth = atoi(papszTok[1]);
nDay = atoi(papszTok[2]);
}
else
{
nYear = atoi(papszTok[2]);
nMonth = atoi(papszTok[1]);
nDay = atoi(papszTok[0]);
}
}
else if (strlen(pszValue) == 0)
{
nYear = nMonth = nDay = 0;
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid date field value `%s'. Date field values must "
"be in the format `YYYY/MM/DD', `MM/DD/YYYY' or `YYYYMMDD'",
pszValue);
CSLDestroy(papszTok);
return -1;
}
CSLDestroy(papszTok);
m_poRecordBlock->WriteInt16(nYear);
m_poRecordBlock->WriteByte(nMonth);
m_poRecordBlock->WriteByte(nDay);
if (CPLGetLastErrorNo() != 0)
return -1;
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, (nYear*0x10000 +
nMonth * 0x100 + nDay));
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return 0;
}
/**********************************************************************
* TABDATFile::WriteDecimalField()
*
* Write the decimal field value at the current position in the data
* block.
*
* A decimal field is a floating point value with a fixed number of digits
* stored as a character string.
*
* nWidth is the field length, as defined in the .DAT header.
*
* CPLError() will have been called if something fails.
**********************************************************************/
int TABDATFile::WriteDecimalField(double dValue, int nWidth, int nPrec,
TABINDFile *poINDFile, int nIndexNo)
{
const char *pszVal;
pszVal = CPLSPrintf("%*.*f", nWidth, nPrec, dValue);
if ((int)strlen(pszVal) > nWidth)
pszVal += strlen(pszVal) - nWidth;
// Update Index
if (poINDFile && nIndexNo > 0)
{
GByte *pKey = poINDFile->BuildKey(nIndexNo, dValue);
if (poINDFile->AddEntry(nIndexNo, pKey, m_nCurRecordId) != 0)
return -1;
}
return m_poRecordBlock->WriteBytes(nWidth, (GByte*)pszVal);
}
/**********************************************************************
* TABDATFile::Dump()
*
* Dump block contents... available only in DEBUG mode.
**********************************************************************/
#ifdef DEBUG
void TABDATFile::Dump(FILE *fpOut /*=NULL*/)
{
if (fpOut == NULL)
fpOut = stdout;
fprintf(fpOut, "----- TABDATFile::Dump() -----\n");
if (m_fp == NULL)
{
fprintf(fpOut, "File is not opened.\n");
}
else
{
fprintf(fpOut, "File is opened: %s\n", m_pszFname);
fprintf(fpOut, "m_numFields = %d\n", m_numFields);
fprintf(fpOut, "m_numRecords = %d\n", m_numRecords);
}
fflush(fpOut);
}
#endif // DEBUG