FMTtheme.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 FMTtheme_H_INCLUDED
#define FMTtheme_H_INCLUDED
 
#include <boost/dynamic_bitset_fwd.hpp>
#include <boost/serialization/serialization.hpp>
#include <string>
#include <vector>
#include <map>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/string.hpp>
#include "FMTexceptionhandler.hpp"
#include "FMTobject.hpp"
#include <unordered_map>
 
#if defined FMTWITHR
    #include <Rcpp.h>
#endif 
 
namespace Parser
{
    class FMTlandscapeparser;
}
 
 
 
 
namespace Core
{
class FMTmask;
class FMTmaskfilter;
// DocString: FMTtheme
class FMTEXPORT FMTtheme : public FMTobject
    {
    friend class FMTmask;
    friend class Parser::FMTlandscapeparser;
    protected:
        // DocString: FMTtheme::id
        size_t id;
        // DocString: FMTtheme::start
        size_t start;
    private:
        // DocString: FMTtheme::serialize
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            try{
                ar & boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTobject>(*this));
                ar & BOOST_SERIALIZATION_NVP(id);
                ar & BOOST_SERIALIZATION_NVP(start);
                ar & BOOST_SERIALIZATION_NVP(attributes);
                ar & BOOST_SERIALIZATION_NVP(attributenames);
                ar & BOOST_SERIALIZATION_NVP(aggregates);
                ar & BOOST_SERIALIZATION_NVP(aggregatenames);
                ar & BOOST_SERIALIZATION_NVP(indexes);
                ar & BOOST_SERIALIZATION_NVP(name);
                buildattributelocations();
            }catch (...)
                {
                _exhandler->printexceptions("", "FMTtheme::serialize", __LINE__, __FILE__);
                }
        }
        // DocString: FMTtheme::attributes
        std::vector<std::string>attributes;
        // DocString: FMTtheme::attributenames
        std::vector<std::string>attributenames;
        // DocString: FMTtheme::aggregates
        std::vector<std::string>aggregates;
        // DocString: FMTtheme::aggregates
        std::vector<std::vector<std::string>>aggregatenames;
        // DocString: FMTtheme::indexes
        std::vector<std::map<std::string, double>>indexes;
        // DocString: FMTtheme::attribute_locations
        std::unordered_map<std::string, std::vector<size_t>>attribute_locations;
        // DocString: FMTtheme::lookiterator
        typedef typename std::unordered_map<std::string, std::vector<size_t>>::const_iterator lookiterator;
        // DocString: FMTtheme::name
        std::string name;
        // DocString: FMTtheme::strtobits
        boost::dynamic_bitset<> strtobits(const std::string& value) const;
        // DocString: FMTtheme::bitstostr
        std::string bitstostr(const boost::dynamic_bitset<>& bits) const;
        // DocString: FMTtheme::getattribute
        lookiterator getattribute(const std::string& value, bool raiseifnotfound = false) const;
        // DocString: FMTtheme::buildattributelocations
        void buildattributelocations();
        // DocString: FMTtheme::fillupaggregates
        void fillupaggregates(std::vector<int>& themeids, std::vector<std::string>& locattributes, std::vector<std::string>& locaggregates) const;
        // DocString: FMTtheme::push_aggregate
        void push_aggregate(const std::string& aggregatename);
        // DocString: FMTtheme::push_aggregate
        void push_aggregate_value(const std::string& aggregatename, const std::string& value);
    public:
        // DocString: FMTtheme()
        FMTtheme() = default;
        // DocString: ~FMTtheme()
        ~FMTtheme() = default;
        // DocString: FMTtheme(const std::vector<std::string>&,const std::vector<std::string>&,const std::vector<std::vector<std::string>>,const std::vector<std::map<std::string, double>>&,const size_t&, const size_t&, const std::string&)
        FMTtheme(const std::vector<std::string>& lattributes,
            const std::vector<std::string>& lattributenames,
            const std::vector<std::string>& laggregates,
            const std::vector<std::vector<std::string>>& laggregatenames,
            const std::vector<std::map<std::string, double>>& lindexes,
            const size_t& lid, const size_t& lstart, const std::string& lname);
        // DocString: FMTtheme(const std::vector<std::string>&,const std::vector<std::string>&,const std::vector<std::vector<std::string>>,const size_t&, const size_t&, const std::string&)
        FMTtheme(const std::vector<std::string>& lattributes,
            const std::vector<std::string>& lattributenames,
            const std::vector<std::string>& laggregates,
            const std::vector<std::vector<std::string>>& laggregatenames,
            const size_t& lid, const size_t& lstart, const std::string& lname);
        // DocString: FMTtheme(const std::vector<std::string>& lattributes,const size_t&,const size_t&,const std::string&)
        FMTtheme(const std::vector<std::string>& lattributes,
            const size_t& lid, const size_t& lstart, const std::string& lname);
        // DocString: FMTtheme(const FMTtheme&)
        FMTtheme(const FMTtheme& rhs);
        // DocString: FMTtheme::operator=
        FMTtheme& operator = (const FMTtheme& rhs);
        // DocString: FMTtheme::isattribute
        inline bool isattribute(const std::string& value) const
            {
            return (getattribute(value) != attribute_locations.end());
            }
        // DocString: FMTtheme::isaggregate
        inline bool isaggregate(const std::string& value) const
            {
            return (std::find(aggregates.begin(),aggregates.end(),value)!= aggregates.end());
            }
        // DocString: FMTtheme::isindex
        bool isindex(const std::string& attribute, const std::string& value) const;
        // DocString: FMTtheme::isindex
        bool isindex(const std::string& value) const;
        // DocString: FMTtheme::useindex
        bool useindex() const;
        // DocString: FMTtheme::getindex
        double getindex(const std::string& attribute,const std::string& value) const;
        // DocString: FMTtheme::inaggregate
        bool inaggregate(const std::string& value,const std::string& aggregate);
        // DocString: FMTtheme::isvalid
        bool isvalid(const std::string& value) const;
        // DocString: FMTtheme::operator==
        bool operator == (const FMTtheme& rhs) const;
        // DocString: FMTtheme::size
        inline size_t size() const
            {
            return attributes.size();
            }
        // DocString: FMTtheme::getstart
        inline const size_t& getstart() const
            {
            return start;
            }
        // DocString: FMTtheme::getid
        inline const size_t& getid() const
            {
            return id;
            }
        // DocString: FMTtheme::getname
        inline std::string getname() const
            {
            return name;
            }
        // DocString: FMTtheme::empty
        inline bool empty() const
            {
            return attributes.empty();
            }
        // DocString: FMTtheme::getattributes
        std::vector<std::string>getattributes(const std::string& value, bool aggregate_source = false) const;
        // DocString: FMTtheme::getbaseattributes
        inline const std::vector<std::string>& getbaseattributes() const
            {
            return attributes;
            }
        // DocString: FMTtheme::getattributenames
        const std::vector<std::string>& getattributenames() const
            {
            return attributenames;
            }
        // DocString: FMTtheme::presolve
        FMTtheme presolve(FMTmaskfilter& maskfilter, size_t& newid, size_t& newstart) const;
        // DocString: FMTtheme::updatefrommask
        std::string updatefrommask(const Core::FMTmask& globalmask);
        // DocString: FMTtheme::operator std::string
        operator std::string() const;
    #if defined FMTWITHR
            // DocString:  FMTtheme::getaggregatesdataframe
            Rcpp::DataFrame getaggregatesasdataframe() const;
            // DocString:  FMTtheme::getattributesasdataframe
            Rcpp::DataFrame getattributesasdataframe() const;
    #endif
            // DocString: FMTtheme::validate
        static bool validate(const std::vector<Core::FMTtheme>& themes,
                std::string& mask, std::string otherinformation = std::string());
        // DocString: FMTobject::theme
        static bool checkmask(const std::vector<Core::FMTtheme>& themes,
            const std::vector<std::string>& values, std::string& mask,
            const std::string& otherinformation);
        // DocString: FMTobject::getaggregates
        std::vector<std::string>getaggregates() const;
    };
 
    // DocString: FMTthemecomparator
    class FMTthemecomparator
    {
        // DocString: FMTthemecomparator::base_theme
        FMTtheme base_theme;
        // DocString: FMTthemecomparator::comparedwithpresolved
        bool comparedwithpresolved;
    public:
        // DocString: FMTthemecomparator(const FMTtheme&,const bool&)
        FMTthemecomparator(const FMTtheme& lbase_theme,const bool& lcomparedwithpresolved=false);
        // DocString: FMTthemecomparatorr::operator()(const FMTtheme&)
        bool operator()(const FMTtheme& theme) const;
 
    };
 
 
 
}
 
BOOST_CLASS_EXPORT_KEY(Core::FMTtheme)
 
#endif // FMTtheme_H_INCLUDED