TypeConfig.h

Go to the documentation of this file.

#ifndef OSMSCOUT_TYPECONFIG_H
#define OSMSCOUT_TYPECONFIG_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2009  Tim Teulings
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/
 
#include <list>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <array>
 
#include <osmscout/lib/CoreImportExport.h>
 
#include <osmscout/ObjectRef.h>
#include <osmscout/OSMScoutTypes.h>
#include <osmscout/Tag.h>
#include <osmscout/TypeFeature.h>
 
#include <osmscout/util/TagErrorReporter.h>
#include <osmscout/util/Number.h>
 
#include <osmscout/io/FileScanner.h>
#include <osmscout/io/FileWriter.h>
 
#include <osmscout/system/Assert.h>
 
#include <osmscout/system/Compiler.h>
 
namespace osmscout {

  static const TypeId typeIgnore      = 0;
 
  class TypeInfo;
 
  using TypeInfoRef = std::shared_ptr<TypeInfo>;
 

  class OSMSCOUT_API TypeInfo CLASS_FINAL
  {
  public:
    static const uint8_t typeNode     = 1u << 0u; 
    static const uint8_t typeWay      = 1u << 1u; 
    static const uint8_t typeArea     = 1u << 2u; 
    static const uint8_t typeRelation = 1u << 3u; 
 
    enum class SpecialType : uint8_t {
      none         = 0,
      multipolygon = 1,
      routeMaster  = 2,
      route        = 3
    };
 
  public:
    struct TypeCondition
    {
      unsigned char    types;     
      TagConditionRef  condition; 
    };
 
  private:
    TypeId                                      nodeId=0;                      
    TypeId                                      wayId=0;                       
    TypeId                                      areaId=0;                      
    TypeId                                      routeId=0;                     
    std::string                                 name;                          
    size_t                                      index=0;                       
 
    bool                                        internal=false;                
 
    std::list<TypeCondition>                    conditions;                    
    std::unordered_map<std::string,size_t>      nameToFeatureMap;
    std::vector<FeatureInstance>                features;                      
    size_t                                      featureMaskBytes=0;            
    size_t                                      specialFeatureMaskBytes=0;     
    size_t                                      valueBufferSize=0;             
 
    bool                                        canBeNode=false;               
    bool                                        canBeWay=false;                
    bool                                        canBeArea=false;               
    bool                                        canBeRelation=false;           
    bool                                        isPath=false;                  
    bool                                        canRouteFoot=false;            
    bool                                        canRouteBicycle=false;         
    bool                                        canRouteCar=false;             
    bool                                        indexAsAddress=false;          
    bool                                        indexAsLocation=false;         
    bool                                        indexAsRegion=false;           
    bool                                        indexAsPOI=false;              
    bool                                        optimizeLowZoom=false;         
    SpecialType                                 specialType=SpecialType::none; 
    bool                                        pinWay=false;                  
    bool                                        mergeAreas=false;              
    bool                                        ignoreSeaLand=false;           
    bool                                        ignore=false;                  
    uint8_t                                     lanes=1;                       
    uint8_t                                     onewayLanes=1;                 
 
    std::unordered_set<std::string>             groups;                        
    std::unordered_map<std::string,std::string> descriptions;                  
 
  public:
    explicit TypeInfo(const std::string& name);
    ~TypeInfo() = default;

    TypeInfo(const TypeInfo& other) = delete;
    TypeInfo(TypeInfo&& other) = delete;
 
    TypeInfo& operator=(const TypeInfo& other) = delete;
    TypeInfo& operator=(const TypeInfo&& other) = delete;

    TypeInfo& SetNodeId(TypeId id);

    TypeInfo& SetWayId(TypeId id);

    TypeInfo& SetAreaId(TypeId id);

    TypeInfo& SetRouteId(TypeId id);

    TypeInfo& SetIndex(size_t index);

    TypeInfo& SetInternal();

    TypeInfo& SetType(const std::string& name);
 
    TypeInfo& AddCondition(unsigned char types,
                           const TagConditionRef& condition);

    TypeInfo& AddFeature(const FeatureRef& feature);

    TypeInfo& AddGroup(const std::string& groupName);
 
    TypeInfo& AddDescription(const std::string& languageCode,
                             const std::string& description);
 
    bool HasFeatures() const
    {
      return !features.empty();
    }

    bool HasFeature(const std::string& featureName) const;

    bool GetFeature(const std::string& name,
                    size_t& index) const;

    const FeatureInstance& GetFeature(size_t idx) const
    {
      return features[idx];
    }

    const std::vector<FeatureInstance>& GetFeatures() const
    {
      return features;
    }

    size_t GetFeatureCount() const
    {
      return features.size();
    }

    size_t GetFeatureMaskBytes() const
    {
      return featureMaskBytes;
    }

    size_t GetSpecialFeatureMaskBytes() const
    {
      return specialFeatureMaskBytes;
    }

    size_t GetFeatureValueBufferSize() const
    {
      return valueBufferSize;
    }

    TypeId GetNodeId() const
    {
      return nodeId;
    }

    TypeId GetWayId() const
    {
      return wayId;
    }

    TypeId GetAreaId() const
    {
      return areaId;
    }

    TypeId GetRouteId() const
    {
      return routeId;
    }

    size_t GetIndex() const
    {
      return index;
    }

    bool IsInternal() const
    {
      return internal;
    }

    std::string GetName() const
    {
      return name;
    }

    bool HasConditions() const
    {
      return !conditions.empty();
    }

    const std::list<TypeCondition>& GetConditions() const
    {
      return conditions;
    }

    TypeInfo& CanBeNode(bool canBeNode)
    {
      this->canBeNode=canBeNode;
 
      return *this;
    }
 
    bool CanBeNode() const
    {
      return canBeNode;
    }

    TypeInfo& CanBeWay(bool canBeWay)
    {
      this->canBeWay=canBeWay;
 
      return *this;
    }
 
    bool CanBeWay() const
    {
      return canBeWay;
    }

    TypeInfo& CanBeArea(bool canBeArea)
    {
      this->canBeArea=canBeArea;
 
      return *this;
    }
 
    bool CanBeArea() const
    {
      return canBeArea;
    }

    TypeInfo& CanBeRelation(bool canBeRelation)
    {
      this->canBeRelation=canBeRelation;
 
      return *this;
    }
 
    bool CanBeRelation() const
    {
      return canBeRelation;
    }

    TypeInfo& SetIsPath(bool isPath)
    {
      this->isPath=isPath;
 
      return *this;
    }
 
    bool IsPath() const
    {
      return isPath;
    }

    TypeInfo& CanRouteFoot(bool canBeRoute)
    {
      this->canRouteFoot=canBeRoute;
 
      return *this;
    }
 
    TypeInfo& CanRouteBicycle(bool canBeRoute)
    {
      this->canRouteBicycle=canBeRoute;
 
      return *this;
    }

    TypeInfo& CanRouteCar(bool canBeRoute)
    {
      this->canRouteCar=canBeRoute;
 
      return *this;
    }
 
    bool CanRoute() const
    {
      return canRouteFoot || canRouteBicycle || canRouteCar;
    }

    bool CanRoute(Vehicle vehicle) const
    {
      switch (vehicle)
      {
      case vehicleFoot:
        return canRouteFoot;
      case vehicleBicycle:
        return canRouteBicycle;
      case vehicleCar:
        return canRouteCar;
      }
 
      return false;
    }
 
    bool CanRouteFoot() const
    {
      return canRouteFoot;
    }
 
    bool CanRouteBicycle() const
    {
      return canRouteBicycle;
    }
 
    bool CanRouteCar() const
    {
      return canRouteCar;
    }
 
    uint8_t GetDefaultAccess() const;

    TypeInfo& SetIndexAsAddress(bool indexAsAddress)
    {
      this->indexAsAddress=indexAsAddress;
 
      return *this;
    }
 
    bool GetIndexAsAddress() const
    {
      return indexAsAddress;
    }

    TypeInfo& SetIndexAsLocation(bool indexAsLocation)
    {
      this->indexAsLocation=indexAsLocation;
 
      return *this;
    }
 
    bool GetIndexAsLocation() const
    {
      return indexAsLocation;
    }

    TypeInfo& SetIndexAsRegion(bool indexAsRegion)
    {
      this->indexAsRegion=indexAsRegion;
 
      return *this;
    }
 
    bool GetIndexAsRegion() const
    {
      return indexAsRegion;
    }

    TypeInfo& SetIndexAsPOI(bool indexAsPOI)
    {
      this->indexAsPOI=indexAsPOI;
 
      return *this;
    }
 
    bool GetIndexAsPOI() const
    {
      return indexAsPOI;
    }

    TypeInfo& SetOptimizeLowZoom(bool optimize)
    {
      this->optimizeLowZoom=optimize;
 
      return *this;
    }
 
    bool GetOptimizeLowZoom() const
    {
      return optimizeLowZoom;
    }
 
    TypeInfo& SetSpecialType(SpecialType specialType) {
      this->specialType=specialType;
 
      return *this;
    }
 
    SpecialType GetSpecialType() const
    {
      return specialType;
    }

    TypeInfo& SetMultipolygon()
    {
      this->specialType=SpecialType::multipolygon;
 
      return *this;
    }

    TypeInfo& SetRouteMaster()
    {
      this->specialType=SpecialType::routeMaster;
 
      return *this;
    }

    TypeInfo& SetRoute()
    {
      this->specialType=SpecialType::route;
 
      return *this;
    }
 
    bool IsMultipolygon() const
    {
      return specialType==SpecialType::multipolygon;
    }
 
    bool IsRouteMaster() const
    {
      return specialType==SpecialType::routeMaster;
    }
 
    bool IsRoute() const
    {
      return specialType==SpecialType::route;
    }
 
    TypeInfo& SetPinWay(bool pinWay)
    {
      this->pinWay=pinWay;
 
      return *this;
    }
 
    bool GetPinWay() const
    {
      return pinWay;
    }

    TypeInfo& SetMergeAreas(bool mergeAreas)
    {
      this->mergeAreas=mergeAreas;
 
      return *this;
    }
 
    bool GetMergeAreas() const
    {
      return mergeAreas;
    }

    TypeInfo& SetIgnoreSeaLand(bool ignoreSeaLand)
    {
      this->ignoreSeaLand=ignoreSeaLand;
 
      return *this;
    }
 
    bool GetIgnoreSeaLand() const
    {
      return ignoreSeaLand;
    }

    TypeInfo& SetIgnore(bool ignore)
    {
      this->ignore=ignore;
 
      return *this;
    }
 
    bool GetIgnore() const
    {
      return ignore;
    }
 
    TypeInfo& SetLanes(uint8_t lanes)
    {
      this->lanes=lanes;
 
      return *this;
    }
 
    uint8_t GetLanes() const
    {
      return lanes;
    }
 
    TypeInfo& SetOnewayLanes(uint8_t lanes)
    {
      this->onewayLanes=lanes;
 
      return *this;
    }
 
    uint8_t GetOnewayLanes() const
    {
      return onewayLanes;
    }

    const std::unordered_set<std::string>& GetGroups() const
    {
      return groups;
    }
 
    bool IsInGroup(const std::string& groupName) const
    {
      return groups.find(groupName)!=groups.end();
    }
 
    const std::unordered_map<std::string,std::string>& GetDescriptions() const
    {
      return descriptions;
    };
 
    std::string GetDescription(const std::string& languageCode) const;
 
    static TypeInfoRef Read(FileScanner& scanner);
  };

  class OSMSCOUT_API FeatureValueBuffer CLASS_FINAL
  {
  private:
    TypeInfoRef type;
    uint8_t     *featureBits=nullptr;
    char        *featureValueBuffer=nullptr;
 
  private:
    void DeleteData();
    void AllocateBits();
    void AllocateValueBufferLazy();

    FeatureValue* GetValueAndAllocateBuffer(size_t idx)
    {
      AllocateValueBufferLazy();
      return static_cast<FeatureValue*>(static_cast<void*>(&featureValueBuffer[type->GetFeature(idx).GetOffset()]));
    }
 
  public:
    FeatureValueBuffer() = default;
    FeatureValueBuffer(const FeatureValueBuffer& other);
    FeatureValueBuffer(FeatureValueBuffer&& other) noexcept;
    ~FeatureValueBuffer();
 
    FeatureValueBuffer& operator=(const FeatureValueBuffer& other);
    FeatureValueBuffer& operator=(FeatureValueBuffer&& other) noexcept;

    void Set(const FeatureValueBuffer& other);

    void CopyMissingValues(const FeatureValueBuffer& other);

    void ClearFeatureValues();
 
    void SetType(const TypeInfoRef& type);
 
    TypeInfoRef GetType() const
    {
      return type;
    }

    size_t GetFeatureCount() const
    {
      return type->GetFeatureCount();
    }

    FeatureInstance GetFeature(size_t idx) const
    {
      return type->GetFeature(idx);
    }

    bool HasFeature(size_t idx) const
    {
      size_t featureBit=type->GetFeature(idx).GetFeatureBit();
 
      return (featureBits[featureBit/8] & (1u << featureBit%8))!=0;
    }

    FeatureValue* GetValue(size_t idx) const
    {
      return featureValueBuffer==nullptr ? nullptr
                                         : static_cast<FeatureValue*>(static_cast<void*>(&featureValueBuffer[type->GetFeature(idx).GetOffset()]));
    }
 
    FeatureValue* AllocateValue(size_t idx);
    void FreeValue(size_t idx);
 
    void Parse(TagErrorReporter& errorReporter,
               const TagRegistry& tagRegistry,
               const ObjectOSMRef& object,
               const TagMap& tags);

    void Read(FileScanner& scanner);

    void Read(FileScanner& scanner,
              bool& specialFlag);

    void Read(FileScanner& scanner,
              bool& specialFlag1,
              bool& specialFlag2);

    void Read(FileScanner& scanner,
              bool& specialFlag1,
              bool& specialFlag2,
              bool& specialFlag3);

    void Write(FileWriter& writer) const;

    void Write(FileWriter& writer,
               bool specialFlag) const;

    void Write(FileWriter& writer,
               bool specialFlag1,
               bool specialFlag2) const;
 

    void Write(FileWriter& writer,
               bool specialFlag1,
               bool specialFlag2,
               bool specialFlag3) const;
 
    bool operator==(const FeatureValueBuffer& other) const;
    bool operator!=(const FeatureValueBuffer& other) const;

    template<std::size_t FlagCnt>
    void Read(FileScanner& scanner, std::array<bool,FlagCnt> &specialFlags)
    {
      for (size_t i=0; i<type->GetFeatureMaskBytes(); i++) {
        featureBits[i]=scanner.ReadUInt8();
      }
 
      if (!specialFlags.empty()) {
        static_assert(FlagCnt <= 8);
        uint8_t flagByte;
        if (BitsToBytes(type->GetFeatureCount()) == BitsToBytes(type->GetFeatureCount() + specialFlags.size())) {
          flagByte = featureBits[type->GetFeatureMaskBytes() - 1];
        } else {
          flagByte = scanner.ReadUInt8();
        }
        uint8_t mask=0x80;
        for (bool &specialFlag: specialFlags) {
          specialFlag = (flagByte & mask) != 0;
          mask = mask >> 1;
        }
      }
 
      for (const auto &feature : type->GetFeatures()) {
        size_t idx=feature.GetIndex();
 
        if (HasFeature(idx) &&
            feature.GetFeature()->HasValue()) {
          FeatureValue* value=feature.GetFeature()->AllocateValue(GetValueAndAllocateBuffer(idx));
 
          value->Read(scanner);
        }
      }
    }

    template<std::size_t FlagCnt>
    void Write(FileWriter& writer,
               const std::array<bool,FlagCnt> &specialFlags) const
    {
      static_assert(FlagCnt <= 8u);
      if (BitsToBytes(type->GetFeatureCount()) == BitsToBytes(type->GetFeatureCount() + specialFlags.size())) {
        uint8_t mask=0x80u;
        for (const bool &specialFlag: specialFlags) {
          if (specialFlag) {
            featureBits[type->GetFeatureMaskBytes() - 1u] |= mask;
          } else {
            featureBits[type->GetFeatureMaskBytes() - 1u] &= uint8_t(~mask);
          }
          mask = mask >> 1;
        }
 
        for (size_t i = 0; i < type->GetFeatureMaskBytes(); i++) {
          writer.Write(featureBits[i]);
        }
      } else {
        for (size_t i = 0; i < type->GetFeatureMaskBytes(); i++) {
          writer.Write(featureBits[i]);
        }
 
        uint8_t flagByte=0u;
        uint8_t mask=0x80u;
        for (const bool &specialFlag: specialFlags) {
          if (specialFlag) {
            flagByte |= mask;
          }
          mask = mask >> 1u;
        }
 
        writer.Write(flagByte);
      }
 
      for (const auto &feature : type->GetFeatures()) {
        size_t idx=feature.GetIndex();
 
        if (HasFeature(idx) &&
            feature.GetFeature()->HasValue()) {
          FeatureValue* value=GetValue(idx);
 
          value->Write(writer);
        }
      }
    }
 
    template<class T> const T* findValue() const
    {
      for (const auto& featureInstance :GetType()->GetFeatures()) {
        if (HasFeature(featureInstance.GetIndex())) {
          osmscout::FeatureRef feature=featureInstance.GetFeature();
          if (feature->HasValue()) {
            const osmscout::FeatureValue* value=GetValue(featureInstance.GetIndex());
            const auto *v=dynamic_cast<const T*>(value);
            if (v!=nullptr) {
              return v;
            }
          }
        }
      }
 
      return nullptr;
    }
  };
 
  using FeatureValueBufferRef = std::shared_ptr<FeatureValueBuffer>;
 
  // Forward declaration
  class TypeConfig;
 
  static const uint32_t FILE_FORMAT_VERSION=25;

  class OSMSCOUT_API TypeConfig CLASS_FINAL
  {
  public:
    static const char* FILE_TYPES_DAT;
    static const uint32_t MIN_FORMAT_VERSION = FILE_FORMAT_VERSION;
    static const uint32_t MAX_FORMAT_VERSION = FILE_FORMAT_VERSION;
 
  private:
    // Tags
    TagRegistry                                 tagRegistry;
 
    // Types
 
    std::vector<TypeInfoRef>                    types;
    std::vector<TypeInfoRef>                    nodeTypes;
    std::vector<TypeInfoRef>                    wayTypes;
    std::vector<TypeInfoRef>                    areaTypes;
    std::vector<TypeInfoRef>                    routeTypes;
 
    uint8_t                                     nodeTypeIdBytes=1;
    uint8_t                                     wayTypeIdBytes=1;
    uint8_t                                     areaTypeIdBits=1;
    uint8_t                                     areaTypeIdBytes=1;
    uint8_t                                     routeTypeIdBytes=1;
 
    std::unordered_map<std::string,TypeInfoRef> nameToTypeMap;
 
    // Features
 
    std::vector<FeatureRef>                     features;
 
    std::unordered_map<std::string,FeatureRef>  nameToFeatureMap;
 
    FeatureRef                                  featureName;
    FeatureRef                                  featureNameShort;
    FeatureRef                                  featureRef;
    FeatureRef                                  featureLocation;
    FeatureRef                                  featureAddress;
    FeatureRef                                  featurePostalCode;
    FeatureRef                                  featureWebsite;
    FeatureRef                                  featurePhone;
    FeatureRef                                  featureAccess;
    FeatureRef                                  featureAccessRestricted;
    FeatureRef                                  featureLayer;
    FeatureRef                                  featureWidth;
    FeatureRef                                  featureMaxSpeed;
    FeatureRef                                  featureGrade;
    FeatureRef                                  featureBridge;
    FeatureRef                                  featureTunnel;
    FeatureRef                                  featureEmbankment;
    FeatureRef                                  featureRoundabout;
    FeatureRef                                  featureLanes;
    FeatureRef                                  featureOpeningHours;
 
  public:
    // Internal use (only available during preprocessing)
    TagId                                       tagArea;
    TagId                                       tagNatural;
    TagId                                       tagDataPolygon;
    TagId                                       tagType;
    TagId                                       tagRestriction;
    TagId                                       tagJunction;
 
    TypeInfoRef                                 typeInfoIgnore;
    TypeInfoRef                                 typeInfoTileLand;         
    TypeInfoRef                                 typeInfoTileSea;          
    TypeInfoRef                                 typeInfoTileCoast;        
    TypeInfoRef                                 typeInfoTileUnknown;      
    TypeInfoRef                                 typeInfoCoastline;        
    TypeInfoRef                                 typeInfoOSMTileBorder;    
    TypeInfoRef                                 typeInfoOSMSubTileBorder; 
 
  public:
    TypeConfig();
    ~TypeConfig();

    TagId GetTagId(const char* name) const
    {
      return tagRegistry.GetTagId(name);
    }
 
    TagId GetTagId(const std::string& name) const
    {
      return tagRegistry.GetTagId(name);
    }
 
    const TagRegistry& GetTagRegistry() const
    {
      return tagRegistry;
    }
 
    TagRegistry& GetTagRegistry()
    {
      return tagRegistry;
    }


    void RegisterSurfaceToGradeMapping(const std::string& surface,
                                              size_t grade)
    {
      tagRegistry.RegisterSurfaceToGradeMapping(surface,
                                                grade);
    }


    void RegisterMaxSpeedAlias(const std::string& alias,
                                      uint8_t maxSpeed)
    {
      tagRegistry.RegisterMaxSpeedAlias(alias,
                                        maxSpeed);
    }


    TypeInfoRef RegisterType(const TypeInfoRef& typeInfo);

    const std::vector<TypeInfoRef>& GetTypes() const
    {
      return types;
    }

    const std::vector<TypeInfoRef>& GetNodeTypes() const
    {
      return nodeTypes;
    }
 
    uint8_t GetNodeTypeIdBytes() const
    {
      return nodeTypeIdBytes;
    }

    const std::vector<TypeInfoRef>& GetWayTypes() const
    {
      return wayTypes;
    }
 
    uint8_t GetWayTypeIdBytes() const
    {
      return wayTypeIdBytes;
    }

    const std::vector<TypeInfoRef>& GetAreaTypes() const
    {
      return areaTypes;
    }
 
    uint8_t GetAreaTypeIdBits() const
    {
      return areaTypeIdBits;
    }
 
    uint8_t GetAreaTypeIdBytes() const
    {
      return areaTypeIdBytes;
    }

    const std::vector<TypeInfoRef>& GetRouteTypes() const
    {
      return routeTypes;
    }
 
    uint8_t GetRouteTypeIdBytes() const
    {
      return routeTypeIdBytes;
    }

    size_t GetTypeCount() const
    {
      return types.size();
    }

    TypeId GetMaxTypeId() const;

    TypeInfoRef GetTypeInfo(size_t index) const
    {
      assert(index<types.size());
 
      return types[index];
    }

    TypeInfoRef GetNodeTypeInfo(TypeId id) const
    {
      assert(id<=nodeTypes.size());
 
      if (id==typeIgnore) {
        return typeInfoIgnore;
      }
 
      return nodeTypes[id-1];
    }

    TypeInfoRef GetWayTypeInfo(TypeId id) const
    {
      assert(id<=wayTypes.size());
 
      if (id==typeIgnore) {
        return typeInfoIgnore;
      }
 
      return wayTypes[id-1];
    }

    TypeInfoRef GetAreaTypeInfo(TypeId id) const
    {
      assert(id<=areaTypes.size());
 
      if (id==typeIgnore) {
        return typeInfoIgnore;
      }
 
      return areaTypes[id-1];
    }

    TypeInfoRef GetRouteTypeInfo(TypeId id) const
    {
      assert(id<=routeTypes.size());
 
      if (id==typeIgnore) {
        return typeInfoIgnore;
      }
 
      return routeTypes[id-1];
    }

    TypeInfoRef GetTypeInfo(const std::string& name) const;

    TypeInfoRef GetNodeType(const TagMap& tagMap) const;

    bool GetWayAreaType(const TagMap& tagMap,
                        TypeInfoRef& wayType,
                        TypeInfoRef& areaType) const;

    TypeInfoRef GetRelationType(const TagMap& tagMap) const;

    void RegisterFeature(const FeatureRef& feature);

    FeatureRef GetFeature(const std::string& name) const;

    const std::vector<FeatureRef>& GetFeatures() const
    {
      return features;
    }


    bool LoadFromOSTFile(const std::string& filename);
    bool LoadFromDataFile(const std::string& directory);
    bool StoreToDataFile(const std::string& directory) const;
  };
 

  using TypeConfigRef = std::shared_ptr<TypeConfig>;

}
 
#endif