/**********************************************************************

 *

 * Name:     mitab.h

 * Project:  MapInfo TAB Read/Write library

 * Language: C++

 * Purpose:  Header file containing public definitions for the library.

 * Author:   Daniel Morissette, dmorissette@dmsolutions.ca

 *

 **********************************************************************

 * Copyright (c) 1999-2005, Daniel Morissette

 * Copyright (c) 2014, Even Rouault <even.rouault at spatialys.com>

 *

 * SPDX-License-Identifier: MIT

 **********************************************************************/

#ifndef MITAB_H_INCLUDED_

#define MITAB_H_INCLUDED_

#include "mitab_priv.h"

#include "ogr_feature.h"

#include "ogr_featurestyle.h"

#include "ogrsf_frmts.h"

#include <set>

/*---------------------------------------------------------------------

 * Current version of the MITAB library... always useful!

 *--------------------------------------------------------------------*/

#define MITAB_VERSION "2.0.0-dev (2008-10)"

#define MITAB_VERSION_INT 2000000 /* version x.y.z -> xxxyyyzzz */

#ifndef ROUND_INT

#define ROUND_INT(dX) static_cast<int>((dX) < 0.0 ? (dX) - 0.5 : (dX) + 0.5)

#endif

#define MITAB_AREA(x1, y1, x2, y2)                                             \

    ((static_cast<double>(x2) - (x1)) * (static_cast<double>(y2) - (y1)))

class TABFeature;

/*---------------------------------------------------------------------

 * Codes for the GetFileClass() in the IMapInfoFile-derived  classes

 *--------------------------------------------------------------------*/

typedef enum

{

    TABFC_IMapInfoFile = 0,

    TABFC_TABFile,

    TABFC_TABView,

    TABFC_TABSeamless,

    TABFC_MIFFile

} TABFileClass;

/*---------------------------------------------------------------------

 *                      class IMapInfoFile

 *

 * Virtual base class for the TABFile and MIFFile classes.

 *

 * This is the definition of the public interface methods that should

 * be available for any type of MapInfo dataset.

 *--------------------------------------------------------------------*/

class IMapInfoFile CPL_NON_FINAL : public OGRLayer

{

    CPL_DISALLOW_COPY_ASSIGN(IMapInfoFile)

  protected:

    GDALDataset *m_poDS = nullptr;

    GIntBig m_nCurFeatureId;

    TABFeature *m_poCurFeature;

    GBool m_bBoundsSet;

    char *m_pszCharset;

    bool m_bStrictLaundering = true;

    std::set<CPLString> m_oSetFields{};

    TABFeature *CreateTABFeature(OGRFeature *poFeature);

  public:

    IMapInfoFile(GDALDataset *poDS);

    ~IMapInfoFile() override;

    virtual TABFileClass GetFileClass()

    {

        return TABFC_IMapInfoFile;

    }

    virtual int Open(const char *pszFname, const char *pszAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr);

    virtual int Open(const char *pszFname, TABAccess eAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) = 0;

    virtual int Close() = 0;

    virtual int

    SetQuickSpatialIndexMode(CPL_UNUSED GBool bQuickSpatialIndexMode = TRUE)

    {

        return -1;

    }

    virtual const char *GetTableName() = 0;

    ///////////////

    // Static method to detect file type, create an object to read that

    // file and open it.

    static IMapInfoFile *SmartOpen(GDALDataset *poDS, const char *pszFname,

                                   GBool bUpdate = FALSE,

                                   GBool bTestOpenNoError = FALSE);

    ///////////////

    //  OGR methods for read support

    void ResetReading() override = 0;

    GIntBig GetFeatureCount(int bForce) override = 0;

    OGRFeature *GetNextFeature() override;

    OGRFeature *GetFeature(GIntBig nFeatureId) override;

    OGRErr ICreateFeature(OGRFeature *poFeature) override;

    int TestCapability(const char *pszCap) const override = 0;

    OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,

                      bool bForce) override = 0;

    GDALDataset *GetDataset() override

    {

        return m_poDS;

    }

    ///////////////

    // Read access specific stuff

    //

    virtual GIntBig GetNextFeatureId(GIntBig nPrevId) = 0;

    virtual TABFeature *GetFeatureRef(GIntBig nFeatureId) = 0;

    const OGRFeatureDefn *GetLayerDefn() const override = 0;

    virtual TABFieldType GetNativeFieldType(int nFieldId) = 0;

    virtual int GetBounds(double &dXMin, double &dYMin, double &dXMax,

                          double &dYMax, GBool bForce = TRUE) = 0;

    const OGRSpatialReference *GetSpatialRef() const override = 0;

    virtual int GetFeatureCountByType(int &numPoints, int &numLines,

                                      int &numRegions, int &numTexts,

                                      GBool bForce = TRUE) = 0;

    virtual GBool IsFieldIndexed(int nFieldId) = 0;

    virtual GBool IsFieldUnique(int nFieldId) = 0;

    ///////////////

    // Write access specific stuff

    //

    GBool IsBoundsSet()

    {

        return m_bBoundsSet;

    }

    virtual int SetBounds(double dXMin, double dYMin, double dXMax,

                          double dYMax) = 0;

    virtual int

    SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,

                   TABFieldType *paeMapInfoNativeFieldTypes = nullptr) = 0;

    virtual int AddFieldNative(const char *pszName, TABFieldType eMapInfoType,

                               int nWidth = 0, int nPrecision = 0,

                               GBool bIndexed = FALSE, GBool bUnique = FALSE,

                               int bApproxOK = TRUE) = 0;

    virtual OGRErr CreateField(const OGRFieldDefn *poField,

                               int bApproxOK = TRUE) override;

    virtual int SetSpatialRef(OGRSpatialReference *poSpatialRef) = 0;

    virtual OGRErr CreateFeature(TABFeature *poFeature) = 0;

    virtual int SetFieldIndexed(int nFieldId) = 0;

    virtual int SetCharset(const char *charset);

    virtual const char *GetCharset() const;

    static const char *CharsetToEncoding(const char *);

    static const char *EncodingToCharset(const char *);

    void SetEncoding(const char *);

    const char *GetEncoding() const;

    virtual void SetStrictLaundering(bool);

    int TestUtf8Capability() const;

    CPLString NormalizeFieldName(const char *pszName) const;

    ///////////////

    // semi-private.

    virtual int GetProjInfo(TABProjInfo *poPI) = 0;

    virtual int SetProjInfo(TABProjInfo *poPI) = 0;

    virtual int SetMIFCoordSys(const char *pszMIFCoordSys) = 0;

    static int GetTABType(const OGRFieldDefn *poField, TABFieldType *peTABType,

                          int *pnWidth, int *pnPrecision);

#ifdef DEBUG

    virtual void Dump(FILE *fpOut = nullptr) = 0;

#endif

};

/*---------------------------------------------------------------------

 *                      class TABFile

 *

 * The main class for TAB datasets.  External programs should use this

 * class to open a TAB dataset and read/write features from/to it.

 *

 *--------------------------------------------------------------------*/

class TABFile final : public IMapInfoFile

{

    CPL_DISALLOW_COPY_ASSIGN(TABFile)

  private:

    char *m_pszFname;

    TABAccess m_eAccessMode;

    char **m_papszTABFile;

    int m_nVersion;

    int *m_panIndexNo;

    TABTableType m_eTableType;  // NATIVE (.DAT) or DBF

    TABDATFile *m_poDATFile;  // Attributes file

    TABMAPFile *m_poMAPFile;  // Object Geometry file

    TABINDFile *m_poINDFile;  // Attributes index file

    OGRFeatureDefn *m_poDefn;

    mutable OGRSpatialReference *m_poSpatialRef;

    int bUseSpatialTraversal;

    int m_nLastFeatureId;

    GIntBig *m_panMatchingFIDs;

    int m_iMatchingFID;

    int m_bNeedTABRewrite;

    int m_bLastOpWasRead;

    int m_bLastOpWasWrite;

    ///////////////

    // Private Read access specific stuff

    //

    int ParseTABFileFirstPass(GBool bTestOpenNoError);

    int ParseTABFileFields();

    ///////////////

    // Private Write access specific stuff

    //

    int WriteTABFile();

  public:

    explicit TABFile(GDALDataset *poDS);

    ~TABFile() override;

    TABFileClass GetFileClass() override

    {

        return TABFC_TABFile;

    }

    virtual int Open(const char *pszFname, const char *pszAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override

    {

        return IMapInfoFile::Open(pszFname, pszAccess, bTestOpenNoError,

                                  pszCharset);

    }

    virtual int Open(const char *pszFname, TABAccess eAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override

    {

        return Open(pszFname, eAccess, bTestOpenNoError, 512, pszCharset);

    }

    int Open(const char *pszFname, TABAccess eAccess, GBool bTestOpenNoError,

             int nBlockSizeForCreate, const char *pszCharset);

    int Close() override;

    virtual int

    SetQuickSpatialIndexMode(GBool bQuickSpatialIndexMode = TRUE) override;

    const char *GetTableName() override

    {

        return m_poDefn ? m_poDefn->GetName() : "";

    }

    void ResetReading() override;

    int TestCapability(const char *pszCap) const override;

    GIntBig GetFeatureCount(int bForce) override;

    OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,

                      bool bForce) override;

    /* Implement OGRLayer's SetFeature() for random write, only with TABFile */

    OGRErr ISetFeature(OGRFeature *) override;

    OGRErr DeleteFeature(GIntBig nFeatureId) override;

    OGRErr DeleteField(int iField) override;

    OGRErr ReorderFields(int *panMap) override;

    virtual OGRErr AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,

                                  int nFlags) override;

    OGRErr SyncToDisk() override;

    CPLErr SetMetadataItem(const char *pszName, const char *pszValue,

                           const char *pszDomain = "") override;

    ///////////////

    // Read access specific stuff

    //

    int GetNextFeatureId_Spatial(int nPrevId);

    GIntBig GetNextFeatureId(GIntBig nPrevId) override;

    TABFeature *GetFeatureRef(GIntBig nFeatureId) override;

    const OGRFeatureDefn *GetLayerDefn() const override;

    TABFieldType GetNativeFieldType(int nFieldId) override;

    virtual int GetBounds(double &dXMin, double &dYMin, double &dXMax,

                          double &dYMax, GBool bForce = TRUE) override;

    const OGRSpatialReference *GetSpatialRef() const override;

    virtual int GetFeatureCountByType(int &numPoints, int &numLines,

                                      int &numRegions, int &numTexts,

                                      GBool bForce = TRUE) override;

    GBool IsFieldIndexed(int nFieldId) override;

    GBool IsFieldUnique(int /*nFieldId*/) override

    {

        return FALSE;

    }

    int GetVersion()

    {

        return m_nVersion;

    }

    ///////////////

    // Write access specific stuff

    //

    virtual int SetBounds(double dXMin, double dYMin, double dXMax,

                          double dYMax) override;

    virtual int

    SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,

                   TABFieldType *paeMapInfoNativeFieldTypes = nullptr) override;

    virtual int AddFieldNative(const char *pszName, TABFieldType eMapInfoType,

                               int nWidth = 0, int nPrecision = 0,

                               GBool bIndexed = FALSE, GBool bUnique = FALSE,

                               int bApproxOK = TRUE) override;

    int SetSpatialRef(OGRSpatialReference *poSpatialRef) override;

    OGRErr CreateFeature(TABFeature *poFeature) override;

    int SetFieldIndexed(int nFieldId) override;

    ///////////////

    // semi-private.

    int GetProjInfo(TABProjInfo *poPI) override

    {

        return m_poMAPFile->GetHeaderBlock()->GetProjInfo(poPI);

    }

    int SetProjInfo(TABProjInfo *poPI) override;

    int SetMIFCoordSys(const char *pszMIFCoordSys) override;

    int GetFieldIndexNumber(int nFieldId);

    TABINDFile *GetINDFileRef();

    TABMAPFile *GetMAPFileRef()

    {

        return m_poMAPFile;

    }

    int WriteFeature(TABFeature *poFeature);

    int SetCharset(const char *pszCharset) override;

    void SetStrictLaundering(bool bStrictLaundering) override;

#ifdef DEBUG

    void Dump(FILE *fpOut = nullptr) override;

#endif

};

/*---------------------------------------------------------------------

 *                      class TABView

 *

 * TABView is used to handle special type of .TAB files that are

 * composed of a number of .TAB datasets linked through some indexed

 * fields.

 *

 * NOTE: The current implementation supports only TABViews composed

 *       of 2 TABFiles linked through an indexed field of integer type.

 *       It is unclear if any other type of views could exist anyways.

 *--------------------------------------------------------------------*/

class TABView final : public IMapInfoFile

{

    CPL_DISALLOW_COPY_ASSIGN(TABView)

  private:

    char *m_pszFname;

    TABAccess m_eAccessMode;

    char **m_papszTABFile;

    char *m_pszVersion;

    char **m_papszTABFnames;

    TABFile **m_papoTABFiles;

    int m_numTABFiles;

    int m_nMainTableIndex;  // The main table is the one that also

                            // contains the geometries

    char **m_papszFieldNames;

    char **m_papszWhereClause;

    TABRelation *m_poRelation;

    GBool m_bRelFieldsCreated;

    ///////////////

    // Private Read access specific stuff

    //

    int ParseTABFile(const char *pszDatasetPath,

                     GBool bTestOpenNoError = FALSE);

    int OpenForRead(const char *pszFname, GBool bTestOpenNoError = FALSE);

    ///////////////

    // Private Write access specific stuff

    //

    int OpenForWrite(const char *pszFname);

    int WriteTABFile();

  public:

    explicit TABView(GDALDataset *poDS);

    ~TABView() override;

    TABFileClass GetFileClass() override

    {

        return TABFC_TABView;

    }

    virtual int Open(const char *pszFname, const char *pszAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override

    {

        return IMapInfoFile::Open(pszFname, pszAccess, bTestOpenNoError,

                                  pszCharset);

    }

    virtual int Open(const char *pszFname, TABAccess eAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override;

    int Close() override;

    virtual int

    SetQuickSpatialIndexMode(GBool bQuickSpatialIndexMode = TRUE) override;

    const char *GetTableName() override

    {

        return m_poRelation ? m_poRelation->GetFeatureDefn()->GetName() : "";

    }

    void ResetReading() override;

    int TestCapability(const char *pszCap) const override;

    GIntBig GetFeatureCount(int bForce) override;

    OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,

                      bool bForce) override;

    ///////////////

    // Read access specific stuff

    //

    GIntBig GetNextFeatureId(GIntBig nPrevId) override;

    TABFeature *GetFeatureRef(GIntBig nFeatureId) override;

    const OGRFeatureDefn *GetLayerDefn() const override;

    TABFieldType GetNativeFieldType(int nFieldId) override;

    virtual int GetBounds(double &dXMin, double &dYMin, double &dXMax,

                          double &dYMax, GBool bForce = TRUE) override;

    const OGRSpatialReference *GetSpatialRef() const override;

    virtual int GetFeatureCountByType(int &numPoints, int &numLines,

                                      int &numRegions, int &numTexts,

                                      GBool bForce = TRUE) override;

    GBool IsFieldIndexed(int nFieldId) override;

    GBool IsFieldUnique(int nFieldId) override;

    ///////////////

    // Write access specific stuff

    //

    virtual int SetBounds(double dXMin, double dYMin, double dXMax,

                          double dYMax) override;

    virtual int

    SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,

                   TABFieldType *paeMapInfoNativeFieldTypes = nullptr) override;

    virtual int AddFieldNative(const char *pszName, TABFieldType eMapInfoType,

                               int nWidth = 0, int nPrecision = 0,

                               GBool bIndexed = FALSE, GBool bUnique = FALSE,

                               int bApproxOK = TRUE) override;

    int SetSpatialRef(OGRSpatialReference *poSpatialRef) override;

    OGRErr CreateFeature(TABFeature *poFeature) override;

    int SetFieldIndexed(int nFieldId) override;

    ///////////////

    // semi-private.

    int GetProjInfo(TABProjInfo *poPI) override

    {

        return m_nMainTableIndex != -1

                   ? m_papoTABFiles[m_nMainTableIndex]->GetProjInfo(poPI)

                   : -1;

    }

    int SetProjInfo(TABProjInfo *poPI) override

    {

        return m_nMainTableIndex != -1

                   ? m_papoTABFiles[m_nMainTableIndex]->SetProjInfo(poPI)

                   : -1;

    }

    int SetMIFCoordSys(const char * /*pszMIFCoordSys*/) override

    {

        return -1;

    }

    int SetCharset(const char *pszCharset) override;

#ifdef DEBUG

    void Dump(FILE *fpOut = nullptr) override;

#endif

};

/*---------------------------------------------------------------------

 *                      class TABSeamless

 *

 * TABSeamless is used to handle seamless .TAB files that are

 * composed of a main .TAB file in which each feature is the MBR of

 * a base table.

 *

 * TABSeamless are supported for read access only.

 *--------------------------------------------------------------------*/

class TABSeamless final : public IMapInfoFile

{

    CPL_DISALLOW_COPY_ASSIGN(TABSeamless)

  private:

    char *m_pszFname;

    char *m_pszPath;

    TABAccess m_eAccessMode;

    OGRFeatureDefn *m_poFeatureDefnRef;

    TABFile *m_poIndexTable;

    int m_nTableNameField;

    int m_nCurBaseTableId;

    TABFile *m_poCurBaseTable;

    GBool m_bEOF;

    ///////////////

    // Private Read access specific stuff

    //

    int OpenForRead(const char *pszFname, GBool bTestOpenNoError = FALSE);

    int OpenBaseTable(TABFeature *poIndexFeature,

                      GBool bTestOpenNoError = FALSE);

    int OpenBaseTable(int nTableId, GBool bTestOpenNoError = FALSE);

    int OpenNextBaseTable(GBool bTestOpenNoError = FALSE);

    static GIntBig EncodeFeatureId(int nTableId, int nBaseFeatureId);

    static int ExtractBaseTableId(GIntBig nEncodedFeatureId);

    static int ExtractBaseFeatureId(GIntBig nEncodedFeatureId);

  public:

    explicit TABSeamless(GDALDataset *poDS);

    ~TABSeamless() override;

    TABFileClass GetFileClass() override

    {

        return TABFC_TABSeamless;

    }

    virtual int Open(const char *pszFname, const char *pszAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override

    {

        return IMapInfoFile::Open(pszFname, pszAccess, bTestOpenNoError,

                                  pszCharset);

    }

    virtual int Open(const char *pszFname, TABAccess eAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override;

    int Close() override;

    const char *GetTableName() override

    {

        return m_poFeatureDefnRef ? m_poFeatureDefnRef->GetName() : "";

    }

    virtual OGRErr ISetSpatialFilter(int iGeomField,

                                     const OGRGeometry *poGeom) override;

    void ResetReading() override;

    int TestCapability(const char *pszCap) const override;

    GIntBig GetFeatureCount(int bForce) override;

    OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,

                      bool bForce) override;

    ///////////////

    // Read access specific stuff

    //

    GIntBig GetNextFeatureId(GIntBig nPrevId) override;

    TABFeature *GetFeatureRef(GIntBig nFeatureId) override;

    const OGRFeatureDefn *GetLayerDefn() const override;

    TABFieldType GetNativeFieldType(int nFieldId) override;

    virtual int GetBounds(double &dXMin, double &dYMin, double &dXMax,

                          double &dYMax, GBool bForce = TRUE) override;

    const OGRSpatialReference *GetSpatialRef() const override;

    virtual int GetFeatureCountByType(int &numPoints, int &numLines,

                                      int &numRegions, int &numTexts,

                                      GBool bForce = TRUE) override;

    GBool IsFieldIndexed(int nFieldId) override;

    GBool IsFieldUnique(int nFieldId) override;

    ///////////////

    // Write access specific stuff

    //

    virtual int SetBounds(CPL_UNUSED double dXMin, CPL_UNUSED double dYMin,

                          CPL_UNUSED double dXMax,

                          CPL_UNUSED double dYMax) override

    {

        return -1;

    }

    virtual int SetFeatureDefn(

        CPL_UNUSED OGRFeatureDefn *poFeatureDefn,

        CPL_UNUSED TABFieldType *paeMapInfoNativeFieldTypes = nullptr) override

    {

        return -1;

    }

    virtual int AddFieldNative(CPL_UNUSED const char *pszName,

                               CPL_UNUSED TABFieldType eMapInfoType,

                               CPL_UNUSED int nWidth = 0,

                               CPL_UNUSED int nPrecision = 0,

                               CPL_UNUSED GBool bIndexed = FALSE,

                               CPL_UNUSED GBool bUnique = FALSE,

                               CPL_UNUSED int bApproxOK = TRUE) override

    {

        return -1;

    }

    virtual int

    SetSpatialRef(CPL_UNUSED OGRSpatialReference *poSpatialRef) override

    {

        return -1;

    }

    OGRErr CreateFeature(CPL_UNUSED TABFeature *poFeature) override

    {

        return OGRERR_UNSUPPORTED_OPERATION;

    }

    int SetFieldIndexed(CPL_UNUSED int nFieldId) override

    {

        return -1;

    }

    ///////////////

    // semi-private.

    int GetProjInfo(TABProjInfo *poPI) override

    {

        return m_poIndexTable ? m_poIndexTable->GetProjInfo(poPI) : -1;

    }

    int SetProjInfo(CPL_UNUSED TABProjInfo *poPI) override

    {

        return -1;

    }

    int SetMIFCoordSys(const char * /*pszMIFCoordSys*/) override

    {

        return -1;

    }

#ifdef DEBUG

    void Dump(FILE *fpOut = nullptr) override;

#endif

};

/*---------------------------------------------------------------------

 *                      class MIFFile

 *

 * The main class for (MID/MIF) datasets.  External programs should use this

 * class to open a (MID/MIF) dataset and read/write features from/to it.

 *

 *--------------------------------------------------------------------*/

class MIFFile final : public IMapInfoFile

{

    CPL_DISALLOW_COPY_ASSIGN(MIFFile)

  private:

    char *m_pszFname;

    TABAccess m_eAccessMode;

    int m_nVersion; /* Dataset version: 300, 450, 600, 900, etc. */

    char *m_pszDelimiter;

    char *m_pszUnique;

    char *m_pszIndex;

    char *m_pszCoordSys;

    TABFieldType *m_paeFieldType;

    GBool *m_pabFieldIndexed;

    GBool *m_pabFieldUnique;

    double m_dfXMultiplier;

    double m_dfYMultiplier;

    double m_dfXDisplacement;

    double m_dfYDisplacement;

    /* these are the projection bounds, possibly much broader than extents */

    double m_dXMin;

    double m_dYMin;

    double m_dXMax;

    double m_dYMax;

    /* extents, as cached by MIFFile::PreParseFile() */

    int m_bExtentsSet;

    OGREnvelope m_sExtents{};

    int m_nPoints;

    int m_nLines;

    int m_nRegions;

    int m_nTexts;

    int m_nPreloadedId;        // preloaded mif line is for this feature id

    MIDDATAFile *m_poMIDFile;  // Mid file

    MIDDATAFile *m_poMIFFile;  // Mif File

    OGRFeatureDefn *m_poDefn;

    mutable OGRSpatialReference *m_poSpatialRef;

    int m_nFeatureCount;

    int m_nWriteFeatureId;

    int m_nAttribute;

    ///////////////

    // Private Read access specific stuff

    //

    int ReadFeatureDefn();

    int ParseMIFHeader(int *pbIsEmpty);

    void PreParseFile();

    int AddFields(const char *pszLine);

    int GotoFeature(int nFeatureId);

    ///////////////

    // Private Write access specific stuff

    //

    GBool m_bPreParsed;

    GBool m_bHeaderWrote;

    int WriteMIFHeader();

    void UpdateExtents(double dfX, double dfY);

  public:

    explicit MIFFile(GDALDataset *poDS);

    ~MIFFile() override;

    TABFileClass GetFileClass() override

    {

        return TABFC_MIFFile;

    }

    virtual int Open(const char *pszFname, const char *pszAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override

    {

        return IMapInfoFile::Open(pszFname, pszAccess, bTestOpenNoError,

                                  pszCharset);

    }

    virtual int Open(const char *pszFname, TABAccess eAccess,

                     GBool bTestOpenNoError = FALSE,

                     const char *pszCharset = nullptr) override;

    int Close() override;

    const char *GetTableName() override

    {

        return m_poDefn ? m_poDefn->GetName() : "";

    }

    int TestCapability(const char *pszCap) const override;

    GIntBig GetFeatureCount(int bForce) override;

    void ResetReading() override;

    OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,

                      bool bForce) override;

    ///////////////

    // Read access specific stuff

    //

    GIntBig GetNextFeatureId(GIntBig nPrevId) override;

    TABFeature *GetFeatureRef(GIntBig nFeatureId) override;

    const OGRFeatureDefn *GetLayerDefn() const override;

    TABFieldType GetNativeFieldType(int nFieldId) override;

    virtual int GetBounds(double &dXMin, double &dYMin, double &dXMax,

                          double &dYMax, GBool bForce = TRUE) override;

    const OGRSpatialReference *GetSpatialRef() const override;

    virtual int GetFeatureCountByType(int &numPoints, int &numLines,

                                      int &numRegions, int &numTexts,

                                      GBool bForce = TRUE) override;

    GBool IsFieldIndexed(int nFieldId) override;

    GBool IsFieldUnique(int nFieldId) override;

    int GetVersion()

    {

        return m_nVersion;

    }

    ///////////////

    // Write access specific stuff

    //

    virtual int SetBounds(double dXMin, double dYMin, double dXMax,

                          double dYMax) override;

    virtual int

    SetFeatureDefn(OGRFeatureDefn *poFeatureDefn,

                   TABFieldType *paeMapInfoNativeFieldTypes = nullptr) override;

    virtual int AddFieldNative(const char *pszName, TABFieldType eMapInfoType,

                               int nWidth = 0, int nPrecision = 0,

                               GBool bIndexed = FALSE, GBool bUnique = FALSE,

                               int bApproxOK = TRUE) override;

    /* TODO */

    int SetSpatialRef(OGRSpatialReference *poSpatialRef) override;

    OGRErr CreateFeature(TABFeature *poFeature) override;

    int SetFieldIndexed(int nFieldId) override;

    ///////////////

    // semi-private.

    int GetProjInfo(TABProjInfo * /*poPI*/) override

    {

        return -1;

    }

    /*  { return m_poMAPFile->GetHeaderBlock()->GetProjInfo( poPI ); }*/

    int SetProjInfo(TABProjInfo * /*poPI*/) override

    {

        return -1;

    }

    /*  { return m_poMAPFile->GetHeaderBlock()->SetProjInfo( poPI ); }*/

    int SetMIFCoordSys(const char *pszMIFCoordSys) override;

    int SetCharset(const char *pszCharset) override;

    void SetStrictLaundering(bool bStrictLaundering) override;

#ifdef DEBUG

    void Dump(FILE * /*fpOut*/ = nullptr) override

    {

    }

#endif

};

/*---------------------------------------------------------------------

 * Define some error codes specific to this lib.

 *--------------------------------------------------------------------*/

#define TAB_WarningFeatureTypeNotSupported 501

#define TAB_WarningInvalidFieldName 502

#define TAB_WarningBoundsOverflow 503

/*---------------------------------------------------------------------

 * Codes for the feature classes

 *--------------------------------------------------------------------*/

typedef enum

{

    TABFCNoGeomFeature = 0,

    TABFCPoint = 1,

    TABFCFontPoint = 2,

    TABFCCustomPoint = 3,

    TABFCText = 4,

    TABFCPolyline = 5,

    TABFCArc = 6,

    TABFCRegion = 7,

    TABFCRectangle = 8,

    TABFCEllipse = 9,

    TABFCMultiPoint = 10,

    TABFCCollection = 11,

    TABFCDebugFeature

} TABFeatureClass;

/*---------------------------------------------------------------------

 * Definitions for text attributes

 *--------------------------------------------------------------------*/

typedef enum TABTextJust_t

{

    TABTJLeft = 0,  // Default: Left Justification

    TABTJCenter,

    TABTJRight

} TABTextJust;

typedef enum TABTextSpacing_t

{

    TABTSSingle = 0,  // Default: Single spacing

    TABTS1_5,         // 1.5

    TABTSDouble

} TABTextSpacing;

typedef enum TABTextLineType_t

{

    TABTLNoLine = 0,  // Default: No line

    TABTLSimple,

    TABTLArrow

} TABTextLineType;

typedef enum TABFontStyle_t  // Can be OR'ed

{                            // except box and halo are mutually exclusive

    TABFSNone = 0,

    TABFSBold = 0x0001,

    TABFSItalic = 0x0002,

    TABFSUnderline = 0x0004,

    TABFSStrikeout = 0x0008,

    TABFSOutline = 0x0010,

    TABFSShadow = 0x0020,

    TABFSInverse = 0x0040,

    TABFSBlink = 0x0080,

    TABFSBox = 0x0100,      // See note about box vs halo below.

    TABFSHalo = 0x0200,     // MIF uses 256, see MIF docs, App.A

    TABFSAllCaps = 0x0400,  // MIF uses 512

    TABFSExpanded = 0x0800  // MIF uses 1024

} TABFontStyle;

/* TABFontStyle enum notes:

 *

 * The enumeration values above correspond to the values found in a .MAP

 * file. However, they differ a little from what is found in a MIF file:

 * Values 0x01 to 0x80 are the same in .MIF and .MAP files.

 * Values 0x200 to 0x800 in .MAP are 0x100 to 0x400 in .MIF

 *

 * What about TABFSBox (0x100) ?

 * TABFSBox is stored just like the other styles in .MAP files but it is not

 * explicitly stored in a MIF file.

 * If a .MIF FONT() clause contains the optional BG color, then this implies

 * that either Halo or Box was set.  Thus if TABFSHalo (value 256 in MIF)

 * is not set in the style, then this implies that TABFSBox should be set.

 */

typedef enum TABCustSymbStyle_t  // Can be OR'ed

{

    TABCSNone = 0,          // Transparent BG, use default colors

    TABCSBGOpaque = 0x01,   // White pixels are opaque

    TABCSApplyColor = 0x02  // non-white pixels drawn using symbol color

} TABCustSymbStyle;

/*=====================================================================

  Base classes to be used to add supported drawing tools to each feature type

 =====================================================================*/

class ITABFeaturePen /* non final */

{

  protected:

    int m_nPenDefIndex;

    TABPenDef m_sPenDef;

  public:

    ITABFeaturePen();

    virtual ~ITABFeaturePen();

    int GetPenDefIndex() const

    {

        return m_nPenDefIndex;

    }

    TABPenDef *GetPenDefRef()

    {

        return &m_sPenDef;

    }

    const TABPenDef *GetPenDefRef() const

    {

        return &m_sPenDef;

    }

    GByte GetPenWidthPixel() const;

    double GetPenWidthPoint() const;

    int GetPenWidthMIF() const;

    GByte GetPenPattern() const

    {

        return m_sPenDef.nLinePattern;

    }

    GInt32 GetPenColor() const

    {

        return m_sPenDef.rgbColor;

    }

    void SetPenWidthPixel(GByte val);

    void SetPenWidthPoint(double val);

    void SetPenWidthMIF(int val);

    void SetPenPattern(GByte val)

    {

        m_sPenDef.nLinePattern = val;

    }

    void SetPenColor(GInt32 clr)

    {

        m_sPenDef.rgbColor = clr;

    }

    const char *GetPenStyleString() const;

    void SetPenFromStyleString(const char *pszStyleString);

    void DumpPenDef(FILE *fpOut = nullptr);

};

class ITABFeatureBrush /* non final */

{

  protected:

    int m_nBrushDefIndex;

    TABBrushDef m_sBrushDef;

  public:

    ITABFeatureBrush();

    virtual ~ITABFeatureBrush();

    int GetBrushDefIndex() const

    {

        return m_nBrushDefIndex;

    }

    TABBrushDef *GetBrushDefRef()

    {

        return &m_sBrushDef;

    }

    const TABBrushDef *GetBrushDefRef() const

    {

        return &m_sBrushDef;

    }

    GInt32 GetBrushFGColor() const

    {

        return m_sBrushDef.rgbFGColor;

    }

    GInt32 GetBrushBGColor() const

    {

        return m_sBrushDef.rgbBGColor;

    }

    GByte GetBrushPattern() const

    {

        return m_sBrushDef.nFillPattern;

    }

    GByte GetBrushTransparent() const

    {

        return m_sBrushDef.bTransparentFill;

    }

    void SetBrushFGColor(GInt32 clr)

    {

        m_sBrushDef.rgbFGColor = clr;

    }

    void SetBrushBGColor(GInt32 clr)

    {

        m_sBrushDef.rgbBGColor = clr;

    }

    void SetBrushPattern(GByte val)

    {

        m_sBrushDef.nFillPattern = val;

    }

    void SetBrushTransparent(GByte val)

    {

        m_sBrushDef.bTransparentFill = val;

    }

    const char *GetBrushStyleString() const;

    void SetBrushFromStyleString(const char *pszStyleString);

    void DumpBrushDef(FILE *fpOut = nullptr);

};