Line data    Source code

       1             : /******************************************************************************
       2             :  * Project:  OGR_SCHEMA open options handling
       3             :  * Purpose:  Class for representing a layer schema override.
       4             :  * Author:   Alessandro Pasotti, elpaso@itopen.it
       5             :  *
       6             :  ******************************************************************************
       7             :  * Copyright (c) 2024, Alessandro Pasotti <elpaso at itopen dot it>
       8             :  *
       9             :  * SPDX-License-Identifier: MIT
      10             :  ****************************************************************************/
      11             : 
      12             : #ifndef OGR_SCHEMA_OVERRIDE_H_INCLUDED
      13             : #define OGR_SCHEMA_OVERRIDE_H_INCLUDED
      14             : 
      15             : //! @cond Doxygen_Suppress
      16             : 
      17             : #include <string>
      18             : #include <map>
      19             : #include <optional>
      20             : #include <ogr_api.h>
      21             : #include <ogr_feature.h>
      22             : #include <cpl_vsi.h>
      23             : #include <cpl_json.h>
      24             : 
      25             : /** Class that holds the schema override options for a single field */
      26             : class CPL_DLL OGRFieldDefnOverride
      27             : {
      28             :   public:
      29         125 :     OGRFieldDefnOverride()
      30         125 :         : m_osName(), m_eType(), m_eSubType(), m_nWidth(), m_nPrecision()
      31             :     {
      32         125 :     }
      33             : 
      34           4 :     void SetFieldName(const std::string &osName)
      35             :     {
      36           4 :         m_osName = osName;
      37           4 :     }
      38             : 
      39          36 :     void SetFieldType(OGRFieldType eType)
      40             :     {
      41          36 :         m_eType = eType;
      42          36 :     }
      43             : 
      44          19 :     void SetFieldSubType(OGRFieldSubType eSubType)
      45             :     {
      46          19 :         m_eSubType = eSubType;
      47          19 :     }
      48             : 
      49           5 :     void SetFieldWidth(int nWidth)
      50             :     {
      51           5 :         m_nWidth = nWidth;
      52           5 :     }
      53             : 
      54           5 :     void SetFieldPrecision(int nPrecision)
      55             :     {
      56           5 :         m_nPrecision = nPrecision;
      57           5 :     }
      58             : 
      59          51 :     std::optional<std::string> GetFieldName() const
      60             :     {
      61          51 :         return m_osName;
      62             :     }
      63             : 
      64          70 :     std::optional<OGRFieldType> GetFieldType() const
      65             :     {
      66          70 :         return m_eType;
      67             :     }
      68             : 
      69          80 :     std::optional<OGRFieldSubType> GetFieldSubType() const
      70             :     {
      71          80 :         return m_eSubType;
      72             :     }
      73             : 
      74          52 :     std::optional<int> GetFieldWidth() const
      75             :     {
      76          52 :         return m_nWidth;
      77             :     }
      78             : 
      79          52 :     std::optional<int> GetFieldPrecision() const
      80             :     {
      81          52 :         return m_nPrecision;
      82             :     }
      83             : 
      84             :     // Considered valid if it carries any change information, otherwise it's considered a no-op
      85             :     bool IsValid() const;
      86             : 
      87             :   private:
      88             :     std::optional<std::string> m_osName;
      89             :     std::optional<OGRFieldType> m_eType;
      90             :     std::optional<OGRFieldSubType> m_eSubType;
      91             :     std::optional<int> m_nWidth;
      92             :     std::optional<int> m_nPrecision;
      93             : };
      94             : 
      95             : /** Class that holds the schema override options for a single layer */
      96             : class CPL_DLL OGRLayerSchemaOverride
      97             : {
      98             :   public:
      99         101 :     OGRLayerSchemaOverride() : m_osLayerName(), m_moFieldOverrides()
     100             :     {
     101         101 :     }
     102             : 
     103          53 :     void SetLayerName(const std::string &osLayerName)
     104             :     {
     105          53 :         m_osLayerName = osLayerName;
     106          53 :     }
     107             : 
     108          60 :     void AddFieldOverride(const std::string &osFieldName,
     109             :                           const OGRFieldDefnOverride &oFieldOverride)
     110             :     {
     111          60 :         m_moFieldOverrides[osFieldName] = oFieldOverride;
     112          60 :     }
     113             : 
     114             :     const std::string &GetLayerName() const
     115             :     {
     116             :         return m_osLayerName;
     117             :     }
     118             : 
     119          42 :     const std::map<std::string, OGRFieldDefnOverride> &GetFieldOverrides() const
     120             :     {
     121          42 :         return m_moFieldOverrides;
     122             :     }
     123             : 
     124          48 :     bool IsFullOverride() const
     125             :     {
     126          48 :         return m_bIsFullOverride;
     127             :     }
     128             : 
     129          53 :     void SetFullOverride(bool bIsFullOverride)
     130             :     {
     131          53 :         m_bIsFullOverride = bIsFullOverride;
     132          53 :     }
     133             : 
     134             :     bool IsValid() const;
     135             : 
     136             :   private:
     137             :     std::string m_osLayerName;
     138             :     std::map<std::string, OGRFieldDefnOverride> m_moFieldOverrides;
     139             :     bool m_bIsFullOverride = false;
     140             : };
     141             : 
     142             : /** Class that holds the schema override options for a datasource */
     143             : class CPL_DLL OGRSchemaOverride
     144             : {
     145             :   public:
     146          51 :     OGRSchemaOverride() : m_moLayerOverrides()
     147             :     {
     148          51 :     }
     149             : 
     150          48 :     void AddLayerOverride(const std::string &osLayerName,
     151             :                           const OGRLayerSchemaOverride &oLayerOverride)
     152             :     {
     153          48 :         m_moLayerOverrides[osLayerName] = oLayerOverride;
     154          48 :     }
     155             : 
     156             :     bool LoadFromJSON(const std::string &osJSON);
     157             : 
     158             :     const std::map<std::string, OGRLayerSchemaOverride> &
     159          46 :     GetLayerOverrides() const
     160             :     {
     161          46 :         return m_moLayerOverrides;
     162             :     }
     163             : 
     164             :     bool IsValid() const;
     165             : 
     166             :   private:
     167             :     std::map<std::string, OGRLayerSchemaOverride> m_moLayerOverrides;
     168             : };
     169             : 
     170             : //! @endcond
     171             : 
     172             : #endif /* ndef OGR_FEATURE_H_INCLUDED */