VectorLayer.hpp

Go to the documentation of this file.

#pragma once
#include <ranges>
#include <utility>
#include <vector>
#include <algorithm>
#include <expected>
 
#include <fishnet/IGeometry.hpp>
#include <fishnet/ObjectConcepts.hpp>
#include <fishnet/CollectionConcepts.hpp>
#include <fishnet/FunctionalConcepts.hpp>
#include <fishnet/Either.hpp>
 
#include "FieldType.hpp"
#include "Feature.hpp"
 
#include <gdal/ogr_spatialref.h>
 
 
namespace fishnet {
template<geometry::AnyGeometry G>
class VectorLayer{
private:
    OGRSpatialReference spatialRef;
    std::vector<Feature<G>> features;
 
    std::unordered_map<std::string,FieldDefinitionVariant> fields;
 
    using error_type = std::string; // error type for std::expected
 
    constexpr void remove(util::Predicate<Feature<G>> auto && predicate)noexcept {
        const auto removed = std::ranges::remove_if(this->features,predicate);
        this->features.erase(removed.begin(),removed.end());
    }
 
    template<geometry::AnyGeometry T>
    friend class VectorLayer; // allow other VectorLayers to access the private members
 
public: 
    using geometry_type = G;
    using feature_type = Feature<G>;
 
    VectorLayer() = default;
 
    explicit VectorLayer(OGRSpatialReference spatialReference):spatialRef(std::move(spatialReference)){}
 
    constexpr size_t size() const noexcept {
        return this->features.size();
    }
 
    constexpr bool isEmpty() const noexcept {
        return this->size() == 0;
    }
 
    constexpr util::view_of<G> auto getGeometries() const noexcept {
        return std::views::all(features) | std::views::transform([](const auto & feature){return feature.getGeometry();});
    }
 
    constexpr util::view_of<Feature<G>> auto getFeatures() const noexcept {
        return std::views::all(features);
    }
 
    constexpr util::view_of<Feature<G>> auto getFeatures()  noexcept {
        return std::views::all(features);
    }
 
    constexpr const OGRSpatialReference & getSpatialReference() const noexcept {
        return this->spatialRef;
    }
 
    constexpr void setSpatialReference(const OGRSpatialReference & spatialReference) noexcept {
        this->spatialRef = spatialReference;
    }
 
    constexpr void addGeometry(const G & g) noexcept {
        addFeature(Feature<G>(g));
    }
 
    constexpr void addGeometry(G && g) noexcept {
        addFeature(Feature<G>(std::move(g)));
    }
 
    constexpr void addAllGeometry(util::forward_range_of<G> auto && geometries) noexcept {
        for(auto && geometry:geometries){
            this->addGeometry(std::forward<G>(geometry));
        }
    }
 
    constexpr bool containsGeometry(const G & g) const noexcept {
        return std::ranges::find_if(this->features,[&g](const auto & feature){return feature.getGeometry() == g;}) != std::ranges::end(this->features);
    }
 
 
    constexpr void removeGeometry(const G & g) noexcept {
        remove( [&g](const auto & feature){return feature.getGeometry() == g;});
    }
 
    constexpr void addFeature(Feature<G> && feature) noexcept {
        features.push_back(std::forward<Feature<G>>(feature));
    }
 
    constexpr void addFeature(const Feature<G> & feature) noexcept {
        features.push_back(feature);
    }
 
    constexpr void addFeatures(util::forward_range_of<Feature<G>> auto && features) noexcept {
        for(auto && feature:features){
            this->addFeature(std::forward<Feature<G>>(feature));
        }
    }
 
    constexpr bool containsFeature(const Feature<G> & feature) noexcept {
        return std::ranges::contains(this->features, feature);
    }
 
    constexpr void removeFeature(const Feature<G> & feature) noexcept {
        remove([&feature](const auto & f){return f==feature;});
    }
 
    template<FieldValueType T>
    [[nodiscard]] constexpr fishnet::Either<FieldDefinition<T>,error_type> addField(const std::string & fieldName, const std::optional<int> & fieldID = std::nullopt) noexcept {
        if(fieldName.length() > 10){
            return std::unexpected("Field name \""+ fieldName+"\" must not exceed a length of 10 characters");
        }
        if(this->fields.contains(fieldName))
            return std::unexpected("Field \"" + fieldName + "\" already exists");
        
        FieldDefinition<T> field = fieldID.transform([&fieldName](int id) { return FieldDefinition<T>(fieldName, id); }).value_or(FieldDefinition<T>(fieldName));
        this->fields.emplace(fieldName, field);
        return field;
    }
 
    constexpr fishnet::Either<FieldDefinition<int>,error_type> addIntegerField(const std::string & fieldName, const std::optional<int> & fieldID = std::nullopt) noexcept {
        return addField<int>(fieldName,fieldID);
    }
 
    constexpr fishnet::Either<FieldDefinition<double>,error_type> addDoubleField(const std::string & fieldName, const std::optional<int> & fieldID = std::nullopt) noexcept {
        return addField<double>(fieldName,fieldID);
    }
 
    constexpr fishnet::Either<FieldDefinition<std::string>,error_type> addTextField(const std::string & fieldName, const std::optional<int> & fieldID = std::nullopt) noexcept {
        return addField<std::string>(fieldName,fieldID);
    }
 
    constexpr fishnet::Either<FieldDefinition<size_t>,error_type> addSizeField(const std::string & fieldName, const std::optional<int> & fieldID = std::nullopt) noexcept {
        return addField<size_t>(fieldName,fieldID);
    }
 
    constexpr bool hasField(const std::string & fieldName) const noexcept {
        return this->fields.contains(fieldName);
    }
 
    constexpr void removeField(const std::string & fieldName) noexcept {
        this->fields.erase(fieldName);
    }
 
    constexpr void clearFields() noexcept {
        fields.clear();
    }
 
    template<geometry::AnyGeometry T>
    constexpr void copyFields(VectorLayer<T> & other) const noexcept {
        for(auto [fieldName,fieldVariant]:fields){
            other.fields.try_emplace(fieldName,fieldVariant);
        }
    }
 
    template<FieldValueType T>
    constexpr fishnet::Either<FieldDefinition<T>,error_type> getField(const std::string & fieldName) const noexcept {
        fishnet::Either<FieldDefinition<T>,error_type> optFieldDef = std::unexpected(std::string("Field \"" + fieldName + "\" does not exist"));
        if(not fields.contains(fieldName)) {
            return optFieldDef;
        }
        // test whether the FieldVariant with name == fieldName has the correct value_type
        std::visit([&optFieldDef](auto && fieldVariant){
            using U = typename  std::decay_t<decltype(fieldVariant)>::value_type;
            if constexpr(std::same_as<T,U>){
                optFieldDef = fieldVariant;
            }
        },fields.at(fieldName));
        return optFieldDef;
    }
 
    constexpr fishnet::Either<FieldDefinition<double>,error_type> getDoubleField(const std::string  & fieldName) const noexcept {
        return getField<double>(fieldName);
    }
 
    constexpr fishnet::Either<FieldDefinition<int>,error_type> getIntegerField(const std::string  & fieldName) const noexcept {
        return getField<int>(fieldName);
    }
 
    constexpr fishnet::Either<FieldDefinition<size_t>,error_type> getSizeField(const std::string & fieldName) const noexcept  {
        return getField<size_t>(fieldName);
    }
 
    constexpr fishnet::Either<FieldDefinition<std::string>,error_type> getTextField(const std::string  & fieldName) const noexcept {
        return getField<std::string>(fieldName);
    }
 
    constexpr const std::unordered_map<std::string,FieldDefinitionVariant> & getFieldsMap() const noexcept {
        return this->fields;
    }
};
}