GISFile.hpp

Go to the documentation of this file.

#pragma once
#include <filesystem>
#include <array>
#include <fishnet/Option.hpp>
#include <utility>
#include <fishnet/ObjectConcepts.hpp>
#include <fishnet/PathHelper.h>
 
namespace fishnet{
 
enum class GISFileType{
    SHAPEFILE,GEOTIFF,GEOPACKAGE,VECTOR
};
 
[[maybe_unused]] static std::array<GISFileType,4> SUPPORTED_VECTOR_FORMATS{GISFileType::SHAPEFILE,GISFileType::GEOPACKAGE};
[[maybe_unused]] static std::array<GISFileType,4> SUPPORTED_RASTER_FORMATS{GISFileType::GEOTIFF};
 
static fishnet::Option<GISFileType> getGISFileType(const std::filesystem::path & path) {
    const auto & ext = path.extension().string();
    if(ext == ".shp" )
        return GISFileType::SHAPEFILE;
    else if (ext  == ".tif" || ext  == ".tiff") {
        return GISFileType::GEOTIFF;
    }
    else if (ext == ".gpkg") {
        return GISFileType::GEOPACKAGE;
    }
    return std::nullopt;
}
 
static const char * getExtension(GISFileType type) {
    switch(type) {
        case GISFileType::SHAPEFILE:
            return ".shp";
        case GISFileType::GEOTIFF:
            return ".tif";
        case GISFileType::GEOPACKAGE:
            return ".gpkg";
        default:
            throw std::invalid_argument("Unsupported GISFileType");
    }
}
 
class AbstractGISFile {
protected:
    std::filesystem::path pathToFile;
 
    void supportsOrThrow(const std::filesystem::path & path) const {
        if(not supports(path)){
            throw std::invalid_argument("File type not supported: "+ path.string());
        }
    }
 
private:
    explicit AbstractGISFile(std::filesystem::path pathToFile):pathToFile(std::move(pathToFile)){}
 
    explicit AbstractGISFile(const std::string& pathName):pathToFile(pathName){}
 
    friend class AbstractVectorFile;
    friend class AbstractRasterFile;
public:
    [[nodiscard]] const std::filesystem::path & getPath() const noexcept {
        return pathToFile;
    }
 
    operator bool ()const noexcept {
        return this->exists();
    }
 
    [[nodiscard]] bool exists() const noexcept {
        return std::filesystem::exists(this->pathToFile);
    }
 
    [[nodiscard]] bool supports(const std::filesystem::path & path) const noexcept{
        auto type = getGISFileType(path);
        return type && type.value() == this->type();
    }
 
    void changeFilename(const std::string & filename) noexcept {
        this->pathToFile = util::PathHelper::changeFilename(this->pathToFile, filename);
    }
 
    void appendToFilename(const std::string & suffix) noexcept {
        changeFilename(this->pathToFile.stem().string() + suffix);
    }
 
    constexpr virtual GISFileType type() const noexcept = 0;
 
    virtual bool remove() const noexcept = 0;
 
    virtual ~AbstractGISFile() = default;
};
 
class AbstractVectorFile: public AbstractGISFile {
public:
    AbstractVectorFile(const std::filesystem::path & pathToFile): AbstractGISFile(pathToFile){}
    AbstractVectorFile(const std::string& pathName): AbstractGISFile(pathName){}
    virtual ~AbstractVectorFile() = default;
 
    constexpr GISFileType type() const noexcept override {
        return GISFileType::VECTOR;
    }
 
    bool remove() const noexcept override {
        return std::filesystem::remove(this->pathToFile);
    }
 
    AbstractVectorFile & move(const std::filesystem::path & newPath) {
        std::filesystem::rename(this->pathToFile, newPath);
        this->pathToFile = newPath;
        return *this;
    }
 
    AbstractVectorFile copy(const std::filesystem::path & newPath) const {
        std::filesystem::copy(this->pathToFile, newPath);
        return AbstractVectorFile(newPath);
    }
 
    std::string toString() const noexcept {
        return "VectorFile(" + this->pathToFile.string() + ")";
    }
};
 
 
class AbstractRasterFile: public AbstractGISFile {
public:
    explicit AbstractRasterFile(const std::filesystem::path & pathToFile): AbstractGISFile(pathToFile){}
    explicit AbstractRasterFile(const std::string& pathName): AbstractGISFile(pathName){}
    virtual ~AbstractRasterFile() = default;
};
 
template<typename File>
concept GISFile = std::derived_from<File,AbstractGISFile> && fishnet::util::HasToString<File> && requires (const File & constF, File & file, std::filesystem::path p){
    {file.move(p)}-> std::same_as<File &>;
    {constF.copy(p)} -> std::same_as<File>;
    {File(p)};
};
 
template<typename File>
concept VectorGISFile = GISFile<File> && std::derived_from<File,AbstractVectorFile>;
 
static_assert(VectorGISFile<AbstractVectorFile>, "AbstractVectorFile should be a VectorGISFile");
 
template<typename File>
concept RasterGISFile = GISFile<File> && std::derived_from<File,AbstractRasterFile>;
}