FMTparser.hpp

Go to the documentation of this file.

/*
Copyright (c) 2019 Gouvernement du Québec
 
SPDX-License-Identifier: LiLiQ-R-1.1
License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
*/
 
#ifndef FMTparser_H_INCLUDED
#define FMTparser_H_INCLUDED
 
#include <boost/regex.hpp>
#include <iterator>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <queue>
#include "FMTutility.hpp"
#include <array>
#include <ctime>
 
 
#include <boost/thread/recursive_mutex.hpp>
 
 
 
#include "FMTobject.hpp"
#if defined FMTWITHGDAL
    class OGRSpatialReference;
    class GDALDataset;
    class OGRLayer;
    class GDALRasterBand;
    class GDALDriver;
    class OGRSpatialReference;
    class OGRCoordinateTransformation;
#endif
 
 
 
namespace Core {
    class FMTtheme;
    class FMTaction;
    class FMTyields;
    class FMTspec;
    class FMTconstants;
    template<typename T>
    class FMTbounds;
}
 
namespace Spatial
{
    template<typename T>
    class FMTlayer;
}
 
 
namespace Parser
{
// DocString: FMTparser
class FMTEXPORT FMTparser: public Core::FMTobject
    {
    private:
        // DocString: FMTparser::rxvectortheme
        const static boost::regex rxvectortheme;
        // DocString: FMTparser::rxnumber
        const static boost::regex rxnumber;
        // DocString: FMTparser::rxremovecomment
        const static boost::regex rxremovecomment;
        // DocString: FMTparser::rxvalid
        const static boost::regex rxvalid;
        // DocString: FMTparser::rxinclude
        const static boost::regex rxinclude;
        // DocString: FMTparser::rxfor
        const static boost::regex rxfor;
        // DocString: FMTparser::rxend
        const static boost::regex rxend;
        // DocString: FMTparser::primary_sections
        static std::map<Core::FMTsection, std::string>primary_sections;
        // DocString: FMTparser::_incomment
        bool _incomment;
        // DocString: FMTparser::_forvalues
        std::queue<std::string>_forvalues;
        // DocString: FMTparser::_included
        std::queue<std::string>_included;
        // DocString: FMTparser::GDALinitialization;
        static bool GDALinitialization;
        // DocString: FMTparser::safeGetline
        std::istream& safeGetline(std::istream& is, std::string& t) const;
        #ifdef FMTWITHGDAL
        // DocString: FMTparser::GDALinitialization
        static void initializeGDAL();
        #endif
    protected:
        // DocString: FMTparser::mtx
        mutable boost::recursive_mutex mtx;
        // DocString: FMTparser::FMTsection
        mutable Core::FMTsection _section;
        // DocString: FMTparser::rxayld
        const static boost::regex rxayld;
        // DocString: FMTparser::rxaage
        const static boost::regex rxaage;
        // DocString: FMTparser::rxayldage
        const static boost::regex rxayldage;
        // DocString: FMTparser::rxbounds
        const static boost::regex rxbounds;
        // DocString: FMTparser::rxoperators
        const static boost::regex rxoperators;
        // DocString: FMTparser::rxprimary
        const static boost::regex rxprimary;
        // DocString: FMTparser::_constreplacement
        mutable int _constreplacement;
        // DocString: FMTparser::_line
        mutable int _line;
        // DocString: FMTparser::_comment
        std::string _comment;
        // DocString: FMTparser::_location
        mutable std::string _location;
        // DocString: FMTparser::mostrecentfile
        mutable std::time_t mostrecentfile;
        // DocString: FMTparser::setsection
        void setsection(const Core::FMTsection& section) const;
        #ifdef FMTWITHGDAL
            // DocString: FMTparser::getallGDALdrivernames
            std::vector<GDALDriver*> getallGDALdrivers(const char* spatialtype,bool testcreation=true) const;
            // DocString: FMTparser::getGDALextensions
            std::vector<std::vector<std::string>>getGDALextensions(const char* spatialtype,bool testcreation = true) const;
            // DocString: FMTparser::setcategories
            void setcategories(GDALRasterBand* band, const std::vector<std::string>& categories) const;
            // DocString: FMTareaparser::getprojtransform
            OGRCoordinateTransformation* getprojtransform(OGRLayer* baselayer,bool fittoforel =true) const;
            // DocString: FMTareaparser::gettransformmemlayercopy
            GDALDataset* gettransformmemlayercopy(OGRLayer* baselayer,const OGRSpatialReference* newreference, const std::string& fieldname) const;
            // DocString: FMTparser::getFORELspatialref
            std::unique_ptr<OGRSpatialReference> getFORELspatialref() const;
            // DocString: FMTparser::createdataset
            template<typename T>
            GDALDataset* createdataset(const std::string& location, const Spatial::FMTlayer<T>& layer, const int datatypeid,std::string format = "GTiff") const;
            // DocString: FMTparser::getdataset
            GDALDataset* getdataset(const std::string& location) const;
            // DocString: FMTparser::getvectordataset
            GDALDataset* getvectordataset(const std::string& location) const;
            // DocString: FMTparser::getlayer
            OGRLayer* getlayer(GDALDataset* dataset,int id) const;
            // DocString: FMTparser::getband
            GDALRasterBand* getband(GDALDataset* dataset,int bandid=1) const;
            // DocString: FMTparser::createband
            GDALRasterBand* createband(GDALDataset* dataset,const std::vector<std::string>& categories,int bandid=1) const;
            // DocString: FMTparser::getcat
            std::vector<std::string> getcat(GDALDataset* dataset,int bandid=1) const;
            // DocString: FMTparser::getoverview
            GDALRasterBand* getoverview(GDALRasterBand* band,int view=1) const;
            // DocString: FMTparser::getWSfields
            void getWSfields(OGRLayer* layer, std::map<int,int>& themes,int& age,int& area,int& lock, std::string agefield="", std::string areafield="", std::string lockfield="") const;
            // DocString: FMTparser::createvectormemoryds
            GDALDataset* createvectormemoryds() const;
            #endif
        // DocString: FMTparser::getbaseoperators
        std::array<std::string, 5>getbaseoperators() const;
        // DocString: FMTparser::sameas
        std::vector<std::string> sameas(const std::string& allset) const;
        // DocString: FMTparser::getprimary
        std::map<Core::FMTsection, std::string> getprimary(const std::string& primarylocation);
        // DocString: FMTparser::isyld
        bool isyld(const Core::FMTyields& ylds,const std::string& value, Core::FMTsection section) const;
        // DocString: FMTparser::isact
        bool isact(Core::FMTsection section,const std::vector<Core::FMTaction>& actions, std::string action) const;
        // DocString: FMTparser::setspecs
        std::string setspecs(Core::FMTsection section, Core::FMTkwor key,const Core::FMTyields& ylds,const Core::FMTconstants& constants, std::vector<Core::FMTspec>& specs, const std::string& line);
        // DocString: FMTparser::setspec
        std::string setspec(Core::FMTsection section, Core::FMTkwor key,const Core::FMTyields& ylds,const Core::FMTconstants& constants, Core::FMTspec& spec, const std::string& line);
        // DocString: FMTparser::from_extension
        Core::FMTsection from_extension(const std::string& ext) const;
        // DocString: FMTparser::readcsv
        std::vector<std::vector<std::string>>readcsv(const std::string& location,const char& separator);
    public:
        // DocString: FMTparser::rxseparator
        const static boost::regex rxseparator;
        // DocString: FMTparser()
        FMTparser();
        // DocString: FMTparser(const FMTparser&)
        FMTparser(const FMTparser& rhs);
        // DocString: FMTparser::operator=
        FMTparser& operator = (const FMTparser& rhs);
        // DocString: ~FMTparser()
        virtual ~FMTparser()=default;
        // DocString: FMTparser::getmostrecentfiletime
        std::time_t getmostrecentfiletime() const;
        // DocString: FMTparser::setheader
        void setheader(const std::string& header);
        // DocString: FMTparser::tryopening
        bool tryopening(const std::ifstream& stream, const std::string& location) const;
        // DocString: FMTparser::tryopening
        bool tryopening(std::ofstream& stream, const std::string& location) const;
        // DocString: FMTparser::isvalidfile
        bool isvalidfile(const std::string& location) const;
        // DocString: FMTparser::isvalid
        bool isvalid(const std::string& line) const;
        // DocString: FMTparser::regexloop
        std::vector<std::string>regexloop(const boost::regex& cutregex, std::string& str) const;
        // DocString: FMTparser::spliter
        std::vector<std::string>spliter(std::string strmask,const boost::regex& xspliter) const;
        // DocString: FMTparser::clearcomments
        void clearcomments(std::string& line);
        // DocString: FMTparser::upper
        std::string upper(const std::string& lowercases) const;
        // DocString: FMTparser::getcleanline
        std::string getcleanline(std::ifstream& stream);
        // DocString: FMTparser::tryinclude
        std::queue<std::string> tryinclude(const std::string& line, const std::vector<Core::FMTtheme>& themes, const Core::FMTconstants& cons);
        // DocString: FMTparser::returninclude
        std::string returninclude(const std::string& line, const std::vector<Core::FMTtheme>& themes, const Core::FMTconstants& cons);
        // DocString: FMTparser::getforloops
        bool getforloops(std::string& line, const std::vector<Core::FMTtheme>& themes, const Core::FMTconstants& cons, std::vector<std::string>& allvalues, std::string& target);
        // DocString: FMTparser::getcleanlinewfor
        std::string getcleanlinewfor(std::ifstream& stream,const std::vector<Core::FMTtheme>& themes,const Core::FMTconstants& cons);
        // DocString: FMTparser::isnum
        bool isnum(std::string value) const;
        // DocString: FMTparser::isnum
        bool isnum(const std::string& value,const Core::FMTconstants& constant,bool throwerror= true) const;
        // DocString: FMTparser::getnum
        template<typename T>
        T getnum(const std::string& value, const Core::FMTconstants& constant, int period = 0) const;
        // DocString: FMTparser::getnum
        template<typename T>
        T getnum(const std::string& value,bool omitnumtest=false) const;
        // DocString: FMTparser::tryfillnumber
        template<typename T>
        bool tryfillnumber(T& number, const std::string& value, const Core::FMTconstants& constant, int period = 0) const;
        // DocString: FMTparser::bounds
        template<typename T>
        Core::FMTbounds<T>bounds(const Core::FMTconstants& constants, const std::string& value, const std::string& ope, Core::FMTsection section) const;
        #ifdef FMTWITHGDAL
        // DocString: FMTparser::getWSfields
        GDALDataset* createOGRdataset(std::string location = std::string(),std::string gdaldrivername = "CSV") const;
        // DocString: FMTparser::createlayer()
        OGRLayer* createlayer(GDALDataset* dataset,
            const std::string& name, std::vector<std::string> creationoptions = std::vector<std::string>()) const;
        // DocString: FMTparser::getGDALvectordrivernames
        std::vector<std::string>getGDALvectordrivernames(bool testcreation = true) const;
        // DocString: FMTparser::getGDALrasterdrivernames
        std::vector<std::string>getGDALrasterdrivernames(bool testcreation = true) const;
        // DocString: FMTparser::getGDALvectordriverextensions
        std::vector<std::vector<std::string>>getGDALvectordriverextensions(bool testcreation = true) const;
        // DocString: FMTparser::getGDALrasterdriverextensions
        std::vector<std::vector<std::string>>getGDALrasterdriverextensions(bool testcreation = true) const;
        #endif
    };
 
}
 
#endif