ogr_feature.h

Go to the documentation of this file.

/******************************************************************************
 *
 * Project:  OpenGIS Simple Features Reference Implementation
 * Purpose:  Class for representing a whole feature, and layer schemas.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 1999,  Les Technologies SoftMap Inc.
 * Copyright (c) 2008-2013, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#ifndef OGR_FEATURE_H_INCLUDED
#define OGR_FEATURE_H_INCLUDED
 
#include "cpl_atomic_ops.h"
#include "gdal_fwd.h"
#include "ogr_featurestyle.h"
#include "ogr_geometry.h"
#include "ogr_geomcoordinateprecision.h"
 
#include <cstddef>
 
#include <exception>
#include <memory>
#include <string>
#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#include <string_view>
#endif
#include <vector>
 
class OGRStyleTable;
 
/************************************************************************/
/*                             OGRFieldDefn                             */
/************************************************************************/
 
class CPL_DLL OGRFieldDefn
{
  private:
    char *pszName;
    char *pszAlternativeName;
    OGRFieldType eType;
    OGRJustification eJustify;
    int nWidth;  // Zero is variable.
    int nPrecision;
    char *pszDefault;
 
    int bIgnore;
    OGRFieldSubType eSubType;
 
    int bNullable;
    int bUnique;
 
    // Used by drivers (GPKG) to track generated fields
    bool m_bGenerated = false;
 
    std::string m_osDomainName{};  // field domain name. Might be empty
 
    std::string m_osComment{};  // field comment. Might be empty
 
    int m_nTZFlag = OGR_TZFLAG_UNKNOWN;
    bool m_bSealed = false;
 
  public:
    OGRFieldDefn(const char *, OGRFieldType);
    explicit OGRFieldDefn(const OGRFieldDefn *);
    ~OGRFieldDefn();
 
    // Copy constructor
    OGRFieldDefn(const OGRFieldDefn &oOther);
 
    // Copy assignment operator
    OGRFieldDefn &operator=(const OGRFieldDefn &oOther);
 
    void SetName(const char *);
 
    const char *GetNameRef() const
    {
        return pszName;
    }
 
    void SetAlternativeName(const char *);
 
    const char *GetAlternativeNameRef() const
    {
        return pszAlternativeName;
    }
 
    OGRFieldType GetType() const
    {
        return eType;
    }
 
    void SetType(OGRFieldType eTypeIn);
    static const char *GetFieldTypeName(OGRFieldType);
    static OGRFieldType GetFieldTypeByName(const char *);
 
    OGRFieldSubType GetSubType() const
    {
        return eSubType;
    }
 
    void SetSubType(OGRFieldSubType eSubTypeIn);
    static const char *GetFieldSubTypeName(OGRFieldSubType);
    static OGRFieldSubType GetFieldSubTypeByName(const char *);
 
    OGRJustification GetJustify() const
    {
        return eJustify;
    }
 
    void SetJustify(OGRJustification eJustifyIn)
    {
        eJustify = eJustifyIn;
    }
 
    int GetWidth() const
    {
        return nWidth;
    }
 
    void SetWidth(int nWidthIn);
 
    int GetPrecision() const
    {
        return nPrecision;
    }
 
    void SetPrecision(int nPrecisionIn);
 
    int GetTZFlag() const
    {
        return m_nTZFlag;
    }
 
    void SetTZFlag(int nTZFlag);
 
    void Set(const char *, OGRFieldType, int = 0, int = 0,
             OGRJustification = OJUndefined);
 
    void SetDefault(const char *);
    const char *GetDefault() const;
    int IsDefaultDriverSpecific() const;
 
    int IsIgnored() const
    {
        return bIgnore;
    }
 
    void SetIgnored(int bIgnoreIn)
    {
        bIgnore = bIgnoreIn;
    }
 
    int IsNullable() const
    {
        return bNullable;
    }
 
    void SetNullable(int bNullableIn);
 
    int IsUnique() const
    {
        return bUnique;
    }
 
    bool IsGenerated() const
    {
        return m_bGenerated;
    }
 
    void SetGenerated(bool bGeneratedIn)
    {
        m_bGenerated = bGeneratedIn;
    }
 
    void SetUnique(int bUniqueIn);
 
    const std::string &GetDomainName() const
    {
        return m_osDomainName;
    }
 
    void SetDomainName(const std::string &osDomainName);
 
    const std::string &GetComment() const
    {
        return m_osComment;
    }
 
    void SetComment(const std::string &osComment);
 
    int IsSame(const OGRFieldDefn *) const;
 
    static inline OGRFieldDefnH ToHandle(OGRFieldDefn *poFieldDefn)
    {
        return reinterpret_cast<OGRFieldDefnH>(poFieldDefn);
    }
 
    static inline OGRFieldDefn *FromHandle(OGRFieldDefnH hFieldDefn)
    {
        return reinterpret_cast<OGRFieldDefn *>(hFieldDefn);
    }
 
    void Seal();
 
    void Unseal();
 
    struct CPL_DLL TemporaryUnsealer
    {
      private:
        OGRFieldDefn *m_poFieldDefn = nullptr;
        CPL_DISALLOW_COPY_ASSIGN(TemporaryUnsealer)
      public:
        explicit TemporaryUnsealer(OGRFieldDefn *poFieldDefn)
            : m_poFieldDefn(poFieldDefn)
        {
            m_poFieldDefn->Unseal();
        }
 
        TemporaryUnsealer(TemporaryUnsealer &&) = default;
        TemporaryUnsealer &operator=(TemporaryUnsealer &&) = default;
 
        ~TemporaryUnsealer()
        {
            m_poFieldDefn->Seal();
        }
 
        OGRFieldDefn *operator->()
        {
            return m_poFieldDefn;
        }
    };
 
    TemporaryUnsealer GetTemporaryUnsealer();
};
 
#ifdef GDAL_COMPILATION
inline OGRFieldDefn::TemporaryUnsealer whileUnsealing(OGRFieldDefn *object)
{
    return object->GetTemporaryUnsealer();
}
#endif
 
/************************************************************************/
/*                           OGRGeomFieldDefn                           */
/************************************************************************/
 
class CPL_DLL OGRGeomFieldDefn
{
  protected:
    char *pszName = nullptr;
    OGRwkbGeometryType eGeomType =
        wkbUnknown; /* all values possible except wkbNone */
    mutable OGRSpatialReferenceRefCountedPtr poSRS = nullptr;
 
    int bIgnore = false;
    mutable int bNullable = true;
    bool m_bSealed = false;
    OGRGeomCoordinatePrecision m_oCoordPrecision{};
 
    void Initialize(const char *, OGRwkbGeometryType);
 
  public:
    OGRGeomFieldDefn(const char *pszNameIn, OGRwkbGeometryType eGeomTypeIn);
    explicit OGRGeomFieldDefn(const OGRGeomFieldDefn *);
    virtual ~OGRGeomFieldDefn();
 
    // Copy constructor
    OGRGeomFieldDefn(const OGRGeomFieldDefn &oOther);
 
    // Move constructor
    OGRGeomFieldDefn(OGRGeomFieldDefn &&oOther);
 
    // Copy assignment operator
    OGRGeomFieldDefn &operator=(const OGRGeomFieldDefn &oOther);
 
    // Move assignment operator
    OGRGeomFieldDefn &operator=(OGRGeomFieldDefn &&oOther);
 
    void SetName(const char *);
 
    const char *GetNameRef() const
    {
        return pszName;
    }
 
    OGRwkbGeometryType GetType() const
    {
        return eGeomType;
    }
 
    void SetType(OGRwkbGeometryType eTypeIn);
 
    virtual const OGRSpatialReference *GetSpatialRef() const;
    void SetSpatialRef(const OGRSpatialReference *poSRSIn);
    void SetSpatialRef(OGRSpatialReferenceRefCountedPtr poSRSIn);
 
    int IsIgnored() const
    {
        return bIgnore;
    }
 
    void SetIgnored(int bIgnoreIn)
    {
        bIgnore = bIgnoreIn;
    }
 
    int IsNullable() const
    {
        return bNullable;
    }
 
    void SetNullable(int bNullableIn);
 
    const OGRGeomCoordinatePrecision &GetCoordinatePrecision() const
    {
        return m_oCoordPrecision;
    }
 
    void SetCoordinatePrecision(const OGRGeomCoordinatePrecision &prec);
 
    int IsSame(const OGRGeomFieldDefn *) const;
 
    static inline OGRGeomFieldDefnH ToHandle(OGRGeomFieldDefn *poGeomFieldDefn)
    {
        return reinterpret_cast<OGRGeomFieldDefnH>(poGeomFieldDefn);
    }
 
    static inline OGRGeomFieldDefn *FromHandle(OGRGeomFieldDefnH hGeomFieldDefn)
    {
        return reinterpret_cast<OGRGeomFieldDefn *>(hGeomFieldDefn);
    }
 
    void Seal();
 
    void Unseal();
 
    struct CPL_DLL TemporaryUnsealer
    {
      private:
        OGRGeomFieldDefn *m_poFieldDefn = nullptr;
        CPL_DISALLOW_COPY_ASSIGN(TemporaryUnsealer)
      public:
        explicit TemporaryUnsealer(OGRGeomFieldDefn *poFieldDefn)
            : m_poFieldDefn(poFieldDefn)
        {
            m_poFieldDefn->Unseal();
        }
 
        TemporaryUnsealer(TemporaryUnsealer &&) = default;
        TemporaryUnsealer &operator=(TemporaryUnsealer &&) = default;
 
        ~TemporaryUnsealer()
        {
            m_poFieldDefn->Seal();
        }
 
        OGRGeomFieldDefn *operator->()
        {
            return m_poFieldDefn;
        }
    };
 
    TemporaryUnsealer GetTemporaryUnsealer();
 
  private:
    OGRSpatialReferenceRefCountedPtr &GetRefCountedSRS() const
    {
        GetSpatialRef();
        return poSRS;
    }
};
 
#ifdef GDAL_COMPILATION
inline OGRGeomFieldDefn::TemporaryUnsealer
whileUnsealing(OGRGeomFieldDefn *object)
{
    return object->GetTemporaryUnsealer();
}
#endif
 
/************************************************************************/
/*                            OGRFeatureDefn                            */
/************************************************************************/
 
class CPL_DLL OGRFeatureDefn
{
  protected:
    volatile int nRefCount = 0;
 
    mutable std::vector<std::unique_ptr<OGRFieldDefn>> apoFieldDefn{};
    mutable std::vector<std::unique_ptr<OGRGeomFieldDefn>> apoGeomFieldDefn{};
 
    char *pszFeatureClassName = nullptr;
 
    bool bIgnoreStyle = false;
 
    friend class TemporaryUnsealer;
    bool m_bSealed = false;
    int m_nTemporaryUnsealCount = 0;
 
  public:
    explicit OGRFeatureDefn(const char *pszName = nullptr);
    virtual ~OGRFeatureDefn();
 
    void SetName(const char *pszName);
    virtual const char *GetName() const;
 
    virtual int GetFieldCount() const;
    virtual OGRFieldDefn *GetFieldDefn(int i);
    virtual const OGRFieldDefn *GetFieldDefn(int i) const;
    virtual int GetFieldIndex(const char *) const;
    int GetFieldIndexCaseSensitive(const char *) const;
 
 
    template <class OwnerT, class ChildT> struct CPL_DLL Fields
    {
      private:
        OwnerT m_poFDefn;
 
      public:
        inline explicit Fields(OwnerT poFDefn) : m_poFDefn(poFDefn)
        {
        }
 
        struct CPL_DLL Iterator
        {
          private:
            OwnerT m_poFDefn;
            const int m_nFieldCount;
            int m_nIdx;
            ChildT m_curValue{};
 
          public:
            inline Iterator(OwnerT poFDefn, int nIdx)
                : m_poFDefn(poFDefn), m_nFieldCount(poFDefn->GetFieldCount()),
                  m_nIdx(nIdx)
            {
                if (m_nIdx < m_nFieldCount)
                    m_curValue = m_poFDefn->GetFieldDefn(m_nIdx);
            }
 
            inline const ChildT &operator*() const
            {
                return m_curValue;
            }
 
            inline ChildT &operator*()
            {
                return m_curValue;
            }
 
            inline Iterator &operator++()
            {
                m_nIdx++;
                if (m_nIdx < m_nFieldCount)
                    m_curValue = m_poFDefn->GetFieldDefn(m_nIdx);
                else
                    m_curValue = nullptr;
                return *this;
            }
 
            inline bool operator!=(const Iterator &it) const
            {
                return m_nIdx != it.m_nIdx;
            }
        };
 
        inline Iterator begin() const
        {
            return Iterator(m_poFDefn, 0);
        }
 
        inline Iterator end() const
        {
            return Iterator(m_poFDefn, m_poFDefn->GetFieldCount());
        }
 
        inline size_t size() const
        {
            return static_cast<std::size_t>(m_poFDefn->GetFieldCount());
        }
 
        inline ChildT operator[](size_t i)
        {
            return m_poFDefn->GetFieldDefn(static_cast<int>(i));
        }
    };
 
 
    using NonConstFields = Fields<OGRFeatureDefn *, OGRFieldDefn *>;
 
    inline NonConstFields GetFields()
    {
        return NonConstFields(this);
    }
 
    using ConstFields = Fields<const OGRFeatureDefn *, const OGRFieldDefn *>;
 
    inline ConstFields GetFields() const
    {
        return ConstFields(this);
    }
 
    // That method should only be called if there's a guarantee that
    // GetFieldCount() has been called before
    int GetFieldCountUnsafe() const
    {
        return static_cast<int>(apoFieldDefn.size());
    }
 
    // Those methods don't check i is n range.
    OGRFieldDefn *GetFieldDefnUnsafe(int i)
    {
        if (apoFieldDefn.empty())
            GetFieldDefn(i);
        return apoFieldDefn[static_cast<std::size_t>(i)].get();
    }
 
    const OGRFieldDefn *GetFieldDefnUnsafe(int i) const
    {
        if (apoFieldDefn.empty())
            GetFieldDefn(i);
        return apoFieldDefn[static_cast<std::size_t>(i)].get();
    }
 
 
    virtual void AddFieldDefn(const OGRFieldDefn *);
    virtual OGRErr DeleteFieldDefn(int iField);
 
    virtual std::unique_ptr<OGRFieldDefn> StealFieldDefn(int iField);
 
    virtual void AddFieldDefn(std::unique_ptr<OGRFieldDefn> &&poFieldDefn);
 
    virtual OGRErr ReorderFieldDefns(const int *panMap);
 
    virtual std::unique_ptr<OGRGeomFieldDefn> StealGeomFieldDefn(int iField);
 
    virtual int GetGeomFieldCount() const;
    virtual OGRGeomFieldDefn *GetGeomFieldDefn(int i);
    virtual const OGRGeomFieldDefn *GetGeomFieldDefn(int i) const;
    virtual int GetGeomFieldIndex(const char *) const;
 
 
    template <class OwnerT, class ChildT> struct CPL_DLL GeomFields
    {
      private:
        OwnerT m_poFDefn;
 
      public:
        inline explicit GeomFields(OwnerT poFDefn) : m_poFDefn(poFDefn)
        {
        }
 
        struct CPL_DLL Iterator
        {
          private:
            OwnerT m_poFDefn;
            int m_nIdx;
 
          public:
            inline Iterator(OwnerT poFDefn, int nIdx)
                : m_poFDefn(poFDefn), m_nIdx(nIdx)
            {
            }
 
            inline ChildT operator*() const
            {
                return m_poFDefn->GetGeomFieldDefn(m_nIdx);
            }
 
            inline Iterator &operator++()
            {
                m_nIdx++;
                return *this;
            }
 
            inline bool operator!=(const Iterator &it) const
            {
                return m_nIdx != it.m_nIdx;
            }
        };
 
        inline Iterator begin()
        {
            return Iterator(m_poFDefn, 0);
        }
 
        inline Iterator end()
        {
            return Iterator(m_poFDefn, m_poFDefn->GetGeomFieldCount());
        }
 
        inline size_t size() const
        {
            return static_cast<std::size_t>(m_poFDefn->GetGeomFieldCount());
        }
 
        inline ChildT operator[](size_t i) const
        {
            return m_poFDefn->GetGeomFieldDefn(static_cast<int>(i));
        }
    };
 
 
    using NonConstGeomFields = GeomFields<OGRFeatureDefn *, OGRGeomFieldDefn *>;
 
    inline NonConstGeomFields GetGeomFields()
    {
        return NonConstGeomFields(this);
    }
 
    using ConstGeomFields =
        GeomFields<const OGRFeatureDefn *, const OGRGeomFieldDefn *>;
 
    inline ConstGeomFields GetGeomFields() const
    {
        return ConstGeomFields(this);
    }
 
    virtual void AddGeomFieldDefn(const OGRGeomFieldDefn *);
    virtual void AddGeomFieldDefn(std::unique_ptr<OGRGeomFieldDefn> &&);
    virtual OGRErr DeleteGeomFieldDefn(int iGeomField);
 
    virtual OGRwkbGeometryType GetGeomType() const;
    virtual void SetGeomType(OGRwkbGeometryType);
 
    virtual OGRFeatureDefn *Clone() const;
 
#ifdef DEPRECATE_OGRFEATUREDEFN_REF_COUNTING
    int Reference()
        CPL_WARN_DEPRECATED("Use OGRFeatureDefnRefCountedPtr instead")
    {
        return CPLAtomicInc(&nRefCount);
    }
 
    int Dereference()
        CPL_WARN_DEPRECATED("Use OGRFeatureDefnRefCountedPtr instead")
    {
        return CPLAtomicDec(&nRefCount);
    }
 
    int GetReferenceCount() const
        CPL_WARN_DEPRECATED("Use OGRFeatureDefnRefCountedPtr instead")
    {
        return nRefCount;
    }
 
    void Release()
        CPL_WARN_DEPRECATED("Use OGRFeatureDefnRefCountedPtr instead");
#else
    int Reference()
    {
        return CPLAtomicInc(&nRefCount);
    }
 
    int Dereference()
#if defined(GDAL_COMPILATION) && !defined(DOXYGEN_XML)
        CPL_WARN_DEPRECATED("Use Release() instead")
#endif
    {
        return CPLAtomicDec(&nRefCount);
    }
 
    int GetReferenceCount() const
    {
        return nRefCount;
    }
 
    void Release();
#endif
 
    virtual int IsGeometryIgnored() const;
    virtual void SetGeometryIgnored(int bIgnore);
 
    virtual bool IsStyleIgnored() const
    {
        return bIgnoreStyle;
    }
 
    virtual void SetStyleIgnored(bool bIgnore)
    {
        bIgnoreStyle = bIgnore;
    }
 
    virtual int IsSame(const OGRFeatureDefn *poOtherFeatureDefn) const;
 
    void ReserveSpaceForFields(int nFieldCountIn);
 
    std::vector<int> ComputeMapForSetFrom(const OGRFeatureDefn *poSrcFDefn,
                                          bool bForgiving = true) const;
 
    static OGRFeatureDefn *CreateFeatureDefn(const char *pszName = nullptr);
    static void DestroyFeatureDefn(OGRFeatureDefn *);
 
    static inline OGRFeatureDefnH ToHandle(OGRFeatureDefn *poFeatureDefn)
    {
        return reinterpret_cast<OGRFeatureDefnH>(poFeatureDefn);
    }
 
    static inline OGRFeatureDefn *FromHandle(OGRFeatureDefnH hFeatureDefn)
    {
        return reinterpret_cast<OGRFeatureDefn *>(hFeatureDefn);
    }
 
    void Seal(bool bSealFields);
 
    void Unseal(bool bUnsealFields);
 
    struct CPL_DLL TemporaryUnsealer
    {
      private:
        OGRFeatureDefn *m_poFeatureDefn = nullptr;
        bool m_bSealFields = false;
        CPL_DISALLOW_COPY_ASSIGN(TemporaryUnsealer)
      public:
        explicit TemporaryUnsealer(OGRFeatureDefn *poFeatureDefn,
                                   bool bSealFields);
 
        TemporaryUnsealer(TemporaryUnsealer &&) = default;
        TemporaryUnsealer &operator=(TemporaryUnsealer &&) = default;
 
        ~TemporaryUnsealer();
 
        OGRFeatureDefn *operator->()
        {
            return m_poFeatureDefn;
        }
    };
 
    TemporaryUnsealer GetTemporaryUnsealer(bool bSealFields = true);
 
  private:
    CPL_DISALLOW_COPY_ASSIGN(OGRFeatureDefn)
};
 
#include "ogr_refcountedptr.h"
 
template <>
struct OGRRefCountedPtr<OGRFeatureDefn>
    : public OGRRefCountedPtrBase<OGRFeatureDefn>
{
    inline explicit OGRRefCountedPtr(OGRFeatureDefn *poFDefn = nullptr,
                                     bool add_ref = true)
        : OGRRefCountedPtrBase<OGRFeatureDefn>(poFDefn, add_ref)
    {
    }
 
    inline explicit OGRRefCountedPtr(std::nullptr_t)
    {
    }
 
    inline static OGRRefCountedPtr makeInstance(const char *pszName)
    {
        // Initial ref_count of OGRFeatureDefn is 0, so do add a ref
        return OGRRefCountedPtr(new OGRFeatureDefn(pszName),
                                /* add_ref = */ true);
    }
};
 
using OGRFeatureDefnRefCountedPtr = OGRRefCountedPtr<OGRFeatureDefn>;
 
#ifdef GDAL_COMPILATION
inline OGRFeatureDefn::TemporaryUnsealer whileUnsealing(OGRFeatureDefn *object,
                                                        bool bSealFields = true)
{
    return object->GetTemporaryUnsealer(bSealFields);
}
 
inline OGRFeatureDefn::TemporaryUnsealer
whileUnsealing(OGRFeatureDefnRefCountedPtr &object, bool bSealFields = true)
{
    return object->GetTemporaryUnsealer(bSealFields);
}
 
#endif
 
/************************************************************************/
/*                              OGRFeature                              */
/************************************************************************/
 
class CPL_DLL OGRFeature
{
  private:
    GIntBig nFID;
    const OGRFeatureDefn *poDefn;
    OGRGeometry **papoGeometries;
    OGRField *pauFields;
    char *m_pszNativeData;
    char *m_pszNativeMediaType;
 
    bool SetFieldInternal(int i, const OGRField *puValue);
 
  protected:
    mutable char *m_pszStyleString;
    mutable OGRStyleTable *m_poStyleTable;
    mutable char *m_pszTmpFieldValue;
 
    bool CopySelfTo(OGRFeature *poNew) const;
 
  public:
    explicit OGRFeature(const OGRFeatureDefn *);
    virtual ~OGRFeature();
 
    class CPL_DLL FieldValue
    {
        friend class OGRFeature;
        struct Private;
        std::unique_ptr<Private> m_poPrivate;
 
        FieldValue(OGRFeature *poFeature, int iFieldIndex);
        FieldValue(const OGRFeature *poFeature, int iFieldIndex);
        FieldValue(const FieldValue &oOther) = delete;
        FieldValue &Assign(const FieldValue &oOther);
 
      public:
        ~FieldValue();
 
        FieldValue &operator=(FieldValue &&oOther);
 
        FieldValue &operator=(const FieldValue &oOther);
        FieldValue &operator=(int nVal);
        FieldValue &operator=(GIntBig nVal);
        FieldValue &operator=(double dfVal);
        FieldValue &operator=(const char *pszVal);
        FieldValue &operator=(const std::string &osVal);
        FieldValue &operator=(const std::vector<int> &oArray);
        FieldValue &operator=(const std::vector<GIntBig> &oArray);
        FieldValue &operator=(const std::vector<double> &oArray);
        FieldValue &operator=(const std::vector<std::string> &oArray);
        FieldValue &operator=(CSLConstList papszValues);
        void SetNull();
        void clear();
 
        void Unset()
        {
            clear();
        }
 
        void SetDateTime(int nYear, int nMonth, int nDay, int nHour = 0,
                         int nMinute = 0, float fSecond = 0.f, int nTZFlag = 0);
 
        int GetIndex() const;
        const OGRFieldDefn *GetDefn() const;
 
        const char *GetName() const
        {
            return GetDefn()->GetNameRef();
        }
 
        OGRFieldType GetType() const
        {
            return GetDefn()->GetType();
        }
 
        OGRFieldSubType GetSubType() const
        {
            return GetDefn()->GetSubType();
        }
 
        // cppcheck-suppress functionStatic
        bool empty() const
        {
            return IsUnset();
        }
 
        // cppcheck-suppress functionStatic
        bool IsUnset() const;
 
        // cppcheck-suppress functionStatic
        bool IsNull() const;
 
        const OGRField *GetRawValue() const;
 
        // cppcheck-suppress functionStatic
        int GetInteger() const
        {
            return GetRawValue()->Integer;
        }
 
        // cppcheck-suppress functionStatic
        GIntBig GetInteger64() const
        {
            return GetRawValue()->Integer64;
        }
 
        // cppcheck-suppress functionStatic
        double GetDouble() const
        {
            return GetRawValue()->Real;
        }
 
        // cppcheck-suppress functionStatic
        const char *GetString() const
        {
            return GetRawValue()->String;
        }
 
        bool GetDateTime(int *pnYear, int *pnMonth, int *pnDay, int *pnHour,
                         int *pnMinute, float *pfSecond, int *pnTZFlag) const;
 
        operator int() const
        {
            return GetAsInteger();
        }
 
        operator GIntBig() const
        {
            return GetAsInteger64();
        }
 
        operator double() const
        {
            return GetAsDouble();
        }
 
        operator const char *() const
        {
            return GetAsString();
        }
 
        operator const std::vector<int> &() const
        {
            return GetAsIntegerList();
        }
 
        operator const std::vector<GIntBig> &() const
        {
            return GetAsInteger64List();
        }
 
        operator const std::vector<double> &() const
        {
            return GetAsDoubleList();
        }
 
        operator const std::vector<std::string> &() const
        {
            return GetAsStringList();
        }
 
        operator CSLConstList() const;
 
        int GetAsInteger() const;
        GIntBig GetAsInteger64() const;
        double GetAsDouble() const;
        const char *GetAsString() const;
        const std::vector<int> &GetAsIntegerList() const;
        const std::vector<GIntBig> &GetAsInteger64List() const;
        const std::vector<double> &GetAsDoubleList() const;
        const std::vector<std::string> &GetAsStringList() const;
    };
 
    class CPL_DLL ConstFieldIterator
    {
        friend class OGRFeature;
        struct Private;
        std::unique_ptr<Private> m_poPrivate;
 
        ConstFieldIterator(const OGRFeature *poSelf, int nPos);
 
      public:
        ConstFieldIterator(
            ConstFieldIterator &&oOther) noexcept;  // declared but not defined.
        // Needed for gcc 5.4 at least
        ~ConstFieldIterator();
        const FieldValue &operator*() const;
        ConstFieldIterator &operator++();
        bool operator!=(const ConstFieldIterator &it) const;
    };
 
    ConstFieldIterator begin() const;
    ConstFieldIterator end() const;
 
    const FieldValue operator[](int iField) const;
    FieldValue operator[](int iField);
 
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"
#endif
 
    class FieldNotFoundException final : public std::exception
    {
    };
 
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
 
    const FieldValue operator[](const char *pszFieldName) const;
    FieldValue operator[](const char *pszFieldName);
 
    const OGRFeatureDefn *GetDefnRef() const
    {
        return poDefn;
    }
 
    void SetFDefnUnsafe(OGRFeatureDefn *poNewFDefn);
 
    OGRErr SetGeometryDirectly(OGRGeometry *);
    OGRErr SetGeometry(const OGRGeometry *);
    OGRErr SetGeometry(std::unique_ptr<OGRGeometry>);
    OGRGeometry *GetGeometryRef();
    const OGRGeometry *GetGeometryRef() const;
    OGRGeometry *StealGeometry() CPL_WARN_UNUSED_RESULT;
 
    int GetGeomFieldCount() const
    {
        return poDefn->GetGeomFieldCount();
    }
 
    const OGRGeomFieldDefn *GetGeomFieldDefnRef(int iField) const
    {
        return poDefn->GetGeomFieldDefn(iField);
    }
 
    int GetGeomFieldIndex(const char *pszName) const
    {
        return poDefn->GetGeomFieldIndex(pszName);
    }
 
    OGRGeometry *GetGeomFieldRef(int iField);
    const OGRGeometry *GetGeomFieldRef(int iField) const;
    OGRGeometry *StealGeometry(int iField);
    OGRGeometry *GetGeomFieldRef(const char *pszFName);
    const OGRGeometry *GetGeomFieldRef(const char *pszFName) const;
    OGRErr SetGeomFieldDirectly(int iField, OGRGeometry *);
    OGRErr SetGeomField(int iField, const OGRGeometry *);
    OGRErr SetGeomField(int iField, std::unique_ptr<OGRGeometry>);
 
    void Reset();
 
    OGRFeature *Clone() const CPL_WARN_UNUSED_RESULT;
    virtual OGRBoolean Equal(const OGRFeature *poFeature) const;
 
    int GetFieldCount() const
    {
        return poDefn->GetFieldCount();
    }
 
    const OGRFieldDefn *GetFieldDefnRef(int iField) const
    {
        return poDefn->GetFieldDefn(iField);
    }
 
    int GetFieldIndex(const char *pszName) const
    {
        return poDefn->GetFieldIndex(pszName);
    }
 
    int IsFieldSet(int iField) const;
 
    void UnsetField(int iField);
 
    bool IsFieldNull(int iField) const;
 
    void SetFieldNull(int iField);
 
    bool IsFieldSetAndNotNull(int iField) const;
 
    OGRField *GetRawFieldRef(int i)
    {
        return pauFields + i;
    }
 
    const OGRField *GetRawFieldRef(int i) const
    {
        return pauFields + i;
    }
 
    int GetFieldAsInteger(int i) const;
    GIntBig GetFieldAsInteger64(int i) const;
    double GetFieldAsDouble(int i) const;
    const char *GetFieldAsString(int i) const;
    const char *GetFieldAsISO8601DateTime(int i,
                                          CSLConstList papszOptions) const;
    const int *GetFieldAsIntegerList(int i, int *pnCount) const;
    const GIntBig *GetFieldAsInteger64List(int i, int *pnCount) const;
    const double *GetFieldAsDoubleList(int i, int *pnCount) const;
    char **GetFieldAsStringList(int i) const;
    GByte *GetFieldAsBinary(int i, int *pnCount) const;
    int GetFieldAsDateTime(int i, int *pnYear, int *pnMonth, int *pnDay,
                           int *pnHour, int *pnMinute, int *pnSecond,
                           int *pnTZFlag) const;
    int GetFieldAsDateTime(int i, int *pnYear, int *pnMonth, int *pnDay,
                           int *pnHour, int *pnMinute, float *pfSecond,
                           int *pnTZFlag) const;
    char *GetFieldAsSerializedJSon(int i) const;
 
    bool IsFieldSetUnsafe(int i) const
    {
        return !(pauFields[i].Set.nMarker1 == OGRUnsetMarker &&
                 pauFields[i].Set.nMarker2 == OGRUnsetMarker &&
                 pauFields[i].Set.nMarker3 == OGRUnsetMarker);
    }
 
    bool IsFieldNullUnsafe(int i) const
    {
        return (pauFields[i].Set.nMarker1 == OGRNullMarker &&
                pauFields[i].Set.nMarker2 == OGRNullMarker &&
                pauFields[i].Set.nMarker3 == OGRNullMarker);
    }
 
    bool IsFieldSetAndNotNullUnsafe(int i) const
    {
        return IsFieldSetUnsafe(i) && !IsFieldNullUnsafe(i);
    }
 
    // Those methods should only be called on a field that is of the type
    // consistent with the value, and that is set.
    int GetFieldAsIntegerUnsafe(int i) const
    {
        return pauFields[i].Integer;
    }
 
    GIntBig GetFieldAsInteger64Unsafe(int i) const
    {
        return pauFields[i].Integer64;
    }
 
    double GetFieldAsDoubleUnsafe(int i) const
    {
        return pauFields[i].Real;
    }
 
    const char *GetFieldAsStringUnsafe(int i) const
    {
        return pauFields[i].String;
    }
 
 
    int GetFieldAsInteger(const char *pszFName) const
    {
        return GetFieldAsInteger(GetFieldIndex(pszFName));
    }
 
    GIntBig GetFieldAsInteger64(const char *pszFName) const
    {
        return GetFieldAsInteger64(GetFieldIndex(pszFName));
    }
 
    double GetFieldAsDouble(const char *pszFName) const
    {
        return GetFieldAsDouble(GetFieldIndex(pszFName));
    }
 
    const char *GetFieldAsString(const char *pszFName) const
    {
        return GetFieldAsString(GetFieldIndex(pszFName));
    }
 
    const char *GetFieldAsISO8601DateTime(const char *pszFName,
                                          CSLConstList papszOptions) const
    {
        return GetFieldAsISO8601DateTime(GetFieldIndex(pszFName), papszOptions);
    }
 
    const int *GetFieldAsIntegerList(const char *pszFName, int *pnCount) const
    {
        return GetFieldAsIntegerList(GetFieldIndex(pszFName), pnCount);
    }
 
    const GIntBig *GetFieldAsInteger64List(const char *pszFName,
                                           int *pnCount) const
    {
        return GetFieldAsInteger64List(GetFieldIndex(pszFName), pnCount);
    }
 
    const double *GetFieldAsDoubleList(const char *pszFName, int *pnCount) const
    {
        return GetFieldAsDoubleList(GetFieldIndex(pszFName), pnCount);
    }
 
    char **GetFieldAsStringList(const char *pszFName) const
    {
        return GetFieldAsStringList(GetFieldIndex(pszFName));
    }
 
    void SetField(int i, int nValue);
    void SetField(int i, GIntBig nValue);
    void SetField(int i, double dfValue);
    void SetField(int i, const char *pszValue);
#if defined(DOXYGEN_SKIP) || __cplusplus >= 201703L ||                         \
    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
    void SetField(int i, std::string_view svValue);
 
    inline void SetField(int i, const std::string &osValue)
    {
        SetField(i, osValue.c_str());
    }
 
#endif
    void SetField(int i, int nCount, const int *panValues);
    void SetField(int i, int nCount, const GIntBig *panValues);
    void SetField(int i, int nCount, const double *padfValues);
    void SetField(int i, const char *const *papszValues);
    void SetField(int i, const OGRField *puValue);
    void SetField(int i, int nCount, const void *pabyBinary);
    void SetField(int i, int nYear, int nMonth, int nDay, int nHour = 0,
                  int nMinute = 0, float fSecond = 0.f, int nTZFlag = 0);
 
    // Those methods should only be called on a field that is of the type
    // consistent with the value, and in a unset state.
    void SetFieldSameTypeUnsafe(int i, int nValue)
    {
        pauFields[i].Integer = nValue;
        pauFields[i].Set.nMarker2 = 0;
        pauFields[i].Set.nMarker3 = 0;
    }
 
    void SetFieldSameTypeUnsafe(int i, GIntBig nValue)
    {
        pauFields[i].Integer64 = nValue;
    }
 
    void SetFieldSameTypeUnsafe(int i, double dfValue)
    {
        pauFields[i].Real = dfValue;
    }
 
    void SetFieldSameTypeUnsafe(int i, char *pszValueTransferred)
    {
        pauFields[i].String = pszValueTransferred;
    }
 
 
    void SetField(const char *pszFName, int nValue)
    {
        SetField(GetFieldIndex(pszFName), nValue);
    }
 
    void SetField(const char *pszFName, GIntBig nValue)
    {
        SetField(GetFieldIndex(pszFName), nValue);
    }
 
    void SetField(const char *pszFName, double dfValue)
    {
        SetField(GetFieldIndex(pszFName), dfValue);
    }
 
    void SetField(const char *pszFName, const char *pszValue)
    {
        SetField(GetFieldIndex(pszFName), pszValue);
    }
 
    void SetField(const char *pszFName, int nCount, const int *panValues)
    {
        SetField(GetFieldIndex(pszFName), nCount, panValues);
    }
 
    void SetField(const char *pszFName, int nCount, const GIntBig *panValues)
    {
        SetField(GetFieldIndex(pszFName), nCount, panValues);
    }
 
    void SetField(const char *pszFName, int nCount, const double *padfValues)
    {
        SetField(GetFieldIndex(pszFName), nCount, padfValues);
    }
 
    void SetField(const char *pszFName, const char *const *papszValues)
    {
        SetField(GetFieldIndex(pszFName), papszValues);
    }
 
    void SetField(const char *pszFName, const OGRField *puValue)
    {
        SetField(GetFieldIndex(pszFName), puValue);
    }
 
    void SetField(const char *pszFName, int nYear, int nMonth, int nDay,
                  int nHour = 0, int nMinute = 0, float fSecond = 0.f,
                  int nTZFlag = 0)
    {
        SetField(GetFieldIndex(pszFName), nYear, nMonth, nDay, nHour, nMinute,
                 fSecond, nTZFlag);
    }
 
    GIntBig GetFID() const
    {
        return nFID;
    }
 
    virtual OGRErr SetFID(GIntBig nFIDIn);
 
    void DumpReadable(FILE *, CSLConstList papszOptions = nullptr) const;
    std::string DumpReadableAsString(CSLConstList papszOptions = nullptr) const;
 
    OGRErr SetFrom(const OGRFeature *, int bForgiving = TRUE);
    OGRErr SetFrom(const OGRFeature *, const int *panMap, int bForgiving = TRUE,
                   bool bUseISO8601ForDateTimeAsString = false);
    OGRErr SetFieldsFrom(const OGRFeature *, const int *panMap,
                         int bForgiving = TRUE,
                         bool bUseISO8601ForDateTimeAsString = false);
 
    OGRErr RemapFields(const OGRFeatureDefn *poNewDefn,
                       const int *panRemapSource);
    void AppendField();
    OGRErr RemapGeomFields(const OGRFeatureDefn *poNewDefn,
                           const int *panRemapSource);
 
    int Validate(int nValidateFlags, int bEmitError) const;
    void FillUnsetWithDefault(int bNotNullableOnly, CSLConstList papszOptions);
 
    bool SerializeToBinary(std::vector<GByte> &abyBuffer) const;
    bool DeserializeFromBinary(const GByte *pabyBuffer, size_t nSize);
 
    virtual const char *GetStyleString() const;
    virtual void SetStyleString(const char *);
    virtual void SetStyleStringDirectly(char *);
 
    virtual OGRStyleTable *GetStyleTable() const
    {
        return m_poStyleTable;
    } /* f.i.x.m.e: add a const qualifier for return type */
 
    virtual void SetStyleTable(OGRStyleTable *poStyleTable);
    virtual void SetStyleTableDirectly(OGRStyleTable *poStyleTable);
 
    const char *GetNativeData() const
    {
        return m_pszNativeData;
    }
 
    const char *GetNativeMediaType() const
    {
        return m_pszNativeMediaType;
    }
 
    void SetNativeData(const char *pszNativeData);
    void SetNativeMediaType(const char *pszNativeMediaType);
 
    static OGRFeature *CreateFeature(const OGRFeatureDefn *);
    static void DestroyFeature(OGRFeature *);
 
    static inline OGRFeatureH ToHandle(OGRFeature *poFeature)
    {
        return reinterpret_cast<OGRFeatureH>(poFeature);
    }
 
    static inline OGRFeature *FromHandle(OGRFeatureH hFeature)
    {
        return reinterpret_cast<OGRFeature *>(hFeature);
    }
 
  private:
    CPL_DISALLOW_COPY_ASSIGN(OGRFeature)
};
 
struct CPL_DLL OGRFeatureUniquePtrDeleter
{
    void operator()(OGRFeature *) const;
};
 
 
typedef std::unique_ptr<OGRFeature, OGRFeatureUniquePtrDeleter>
    OGRFeatureUniquePtr;
 
 
inline OGRFeature::ConstFieldIterator begin(const OGRFeature *poFeature)
{
    return poFeature->begin();
}
 
inline OGRFeature::ConstFieldIterator end(const OGRFeature *poFeature)
{
    return poFeature->end();
}
 
inline OGRFeature::ConstFieldIterator
begin(const OGRFeatureUniquePtr &poFeature)
{
    return poFeature->begin();
}
 
inline OGRFeature::ConstFieldIterator end(const OGRFeatureUniquePtr &poFeature)
{
    return poFeature->end();
}
 
 
/************************************************************************/
/*                            OGRFieldDomain                            */
/************************************************************************/
 
/* clang-format off */
/* clang-format on */
 
class CPL_DLL OGRFieldDomain
{
  protected:
    std::string m_osName;
    std::string m_osDescription;
    OGRFieldDomainType m_eDomainType;
    OGRFieldType m_eFieldType;
    OGRFieldSubType m_eFieldSubType;
    OGRFieldDomainSplitPolicy m_eSplitPolicy = OFDSP_DEFAULT_VALUE;
    OGRFieldDomainMergePolicy m_eMergePolicy = OFDMP_DEFAULT_VALUE;
 
    OGRFieldDomain(const std::string &osName, const std::string &osDescription,
                   OGRFieldDomainType eDomainType, OGRFieldType eFieldType,
                   OGRFieldSubType eFieldSubType);
  public:
    virtual ~OGRFieldDomain();
 
    virtual OGRFieldDomain *Clone() const = 0;
 
    const std::string &GetName() const
    {
        return m_osName;
    }
 
    const std::string &GetDescription() const
    {
        return m_osDescription;
    }
 
    OGRFieldDomainType GetDomainType() const
    {
        return m_eDomainType;
    }
 
    OGRFieldType GetFieldType() const
    {
        return m_eFieldType;
    }
 
    OGRFieldSubType GetFieldSubType() const
    {
        return m_eFieldSubType;
    }
 
    static inline OGRFieldDomainH ToHandle(OGRFieldDomain *poFieldDomain)
    {
        return reinterpret_cast<OGRFieldDomainH>(poFieldDomain);
    }
 
    static inline OGRFieldDomain *FromHandle(OGRFieldDomainH hFieldDomain)
    {
        return reinterpret_cast<OGRFieldDomain *>(hFieldDomain);
    }
 
    OGRFieldDomainSplitPolicy GetSplitPolicy() const
    {
        return m_eSplitPolicy;
    }
 
    void SetSplitPolicy(OGRFieldDomainSplitPolicy policy)
    {
        m_eSplitPolicy = policy;
    }
 
    OGRFieldDomainMergePolicy GetMergePolicy() const
    {
        return m_eMergePolicy;
    }
 
    void SetMergePolicy(OGRFieldDomainMergePolicy policy)
    {
        m_eMergePolicy = policy;
    }
};
 
class CPL_DLL OGRCodedFieldDomain final : public OGRFieldDomain
{
  private:
    std::vector<OGRCodedValue> m_asValues{};
 
    OGRCodedFieldDomain(const OGRCodedFieldDomain &) = delete;
    OGRCodedFieldDomain &operator=(const OGRCodedFieldDomain &) = delete;
 
  public:
    OGRCodedFieldDomain(const std::string &osName,
                        const std::string &osDescription,
                        OGRFieldType eFieldType, OGRFieldSubType eFieldSubType,
                        std::vector<OGRCodedValue> &&asValues);
 
    ~OGRCodedFieldDomain() override;
 
    OGRCodedFieldDomain *Clone() const override;
 
    const OGRCodedValue *GetEnumeration() const
    {
        return m_asValues.data();
    }
};
 
class CPL_DLL OGRRangeFieldDomain final : public OGRFieldDomain
{
  private:
    OGRField m_sMin;
    OGRField m_sMax;
    bool m_bMinIsInclusive;
    bool m_bMaxIsInclusive;
 
    OGRRangeFieldDomain(const OGRRangeFieldDomain &) = delete;
    OGRRangeFieldDomain &operator=(const OGRRangeFieldDomain &) = delete;
 
  public:
    OGRRangeFieldDomain(const std::string &osName,
                        const std::string &osDescription,
                        OGRFieldType eFieldType, OGRFieldSubType eFieldSubType,
                        const OGRField &sMin, bool bMinIsInclusive,
                        const OGRField &sMax, bool bMaxIsInclusive);
 
    OGRRangeFieldDomain *Clone() const override;
 
    const OGRField &GetMin(bool &bIsInclusiveOut) const
    {
        bIsInclusiveOut = m_bMinIsInclusive;
        return m_sMin;
    }
 
    const OGRField &GetMax(bool &bIsInclusiveOut) const
    {
        bIsInclusiveOut = m_bMaxIsInclusive;
        return m_sMax;
    }
};
 
class CPL_DLL OGRGlobFieldDomain final : public OGRFieldDomain
{
  private:
    std::string m_osGlob;
 
    OGRGlobFieldDomain(const OGRGlobFieldDomain &) = delete;
    OGRGlobFieldDomain &operator=(const OGRGlobFieldDomain &) = delete;
 
  public:
    OGRGlobFieldDomain(const std::string &osName,
                       const std::string &osDescription,
                       OGRFieldType eFieldType, OGRFieldSubType eFieldSubType,
                       const std::string &osBlob);
 
    OGRGlobFieldDomain *Clone() const override;
 
    const std::string &GetGlob() const
    {
        return m_osGlob;
    }
};
 
/************************************************************************/
/*                           OGRFeatureQuery                            */
/************************************************************************/
 
class OGRLayer;
class swq_expr_node;
class swq_custom_func_registrar;
struct swq_evaluation_context;
 
class CPL_DLL OGRFeatureQuery
{
  private:
    const OGRFeatureDefn *poTargetDefn;
    void *pSWQExpr;
    swq_evaluation_context *m_psContext = nullptr;
 
    char **FieldCollector(void *, char **);
 
    static GIntBig *EvaluateAgainstIndices(const swq_expr_node *, OGRLayer *,
                                           GIntBig &nFIDCount);
 
    static int CanUseIndex(const swq_expr_node *, OGRLayer *);
 
    OGRErr Compile(const OGRLayer *, const OGRFeatureDefn *, const char *,
                   int bCheck,
                   swq_custom_func_registrar *poCustomFuncRegistrar);
 
    CPL_DISALLOW_COPY_ASSIGN(OGRFeatureQuery)
 
  public:
    OGRFeatureQuery();
    ~OGRFeatureQuery();
 
    OGRErr Compile(const OGRLayer *, const char *, int bCheck = TRUE,
                   swq_custom_func_registrar *poCustomFuncRegistrar = nullptr);
    OGRErr Compile(const OGRFeatureDefn *, const char *, int bCheck = TRUE,
                   swq_custom_func_registrar *poCustomFuncRegistrar = nullptr);
    int Evaluate(OGRFeature *);
 
    GIntBig *EvaluateAgainstIndices(OGRLayer *, OGRErr *);
 
    int CanUseIndex(OGRLayer *);
 
    char **GetUsedFields();
 
    void *GetSWQExpr()
    {
        return pSWQExpr;
    }
};
 
 
#endif /* ndef OGR_FEATURE_H_INCLUDED */