FMTTheme.h

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_Hm_included
#define FMTtheme_Hm_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/vector.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/string.hpp>
#include "FMTExceptionHandler.h"
#include "FMTObject.h"
#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;
    public:
        // DocString: FMTTheme()
        FMTTheme();
        // 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>& p_attributes,
            const std::vector<std::string>& p_attributenames,
            const std::vector<std::string>& p_aggregates,
            const std::vector<std::vector<std::string>>& p_aggregatenames,
            const std::vector<std::map<std::string, double>>& p_indexes,
            const size_t& p_id, const size_t& p_start, const std::string& p_name);
        // 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>& p_attributes,
            const std::vector<std::string>& p_attributenames,
            const std::vector<std::string>& p_aggregates,
            const std::vector<std::vector<std::string>>& p_aggregatenames,
            const size_t& p_id, const size_t& p_start, const std::string& p_name);
        // DocString: FMTTheme(const std::vector<std::string>& lattributes,const size_t&,const size_t&,const std::string&)
        FMTTheme(const std::vector<std::string>& p_attributes,
            const size_t& p_id, const size_t& p_start, const std::string& p_name);
        // 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& p_value) const
        {
            if (!p_value.empty() && p_value.at(0) == '!')
            {
                return (_getAttribute(p_value.substr(1, p_value.size())) != m_attributem_locations.end());
            }else {
                return (_getAttribute(p_value) != m_attributem_locations.end());
                }
            
        }
        // DocString: FMTTheme::isAggregate
        inline bool isAggregate(const std::string& p_value) const
        {
            if (!p_value.empty() && p_value.at(0) == '!')
            {
                return (std::find(m_aggregates.begin(), m_aggregates.end(), p_value.substr(1, p_value.size())) != 
                                        m_aggregates.end());
            }else {
                return (std::find(m_aggregates.begin(), m_aggregates.end(), p_value) != m_aggregates.end());
            }
            
        }
        // DocString: FMTTheme::isIndex
        bool isIndex(const std::string& p_attribute, const std::string& p_value) const;
        // DocString: FMTTheme::isIndex
        bool isIndex(const std::string& p_value) const;
        // DocString: FMTTheme::useIndex
        bool useIndex() const;
        // DocString: FMTTheme::getIndex
        double getIndex(const std::string& p_attribute, const std::string& p_value) const;
        // DocString: FMTTheme::inAggregate
        bool inAggregate(const std::string& p_value, const std::string& p_aggregate);
        // DocString: FMTTheme::isValid
        bool isValid(const std::string& p_value) const;
        // DocString: FMTTheme::operator==
        bool operator == (const FMTTheme& p_rhs) const;
        // DocString: FMTTheme::size
        inline size_t size() const
        {
            return m_attributes.size();
        }
        // DocString: FMTTheme::getStart
        inline const size_t& getStart() const
        {
            return m_start;
        }
        // DocString: FMTTheme::getId
        inline const size_t& getId() const
        {
            return m_id;
        }
        // DocString: FMTTheme::getName
        inline std::string getName() const
        {
            return m_name;
        }
        // DocString: FMTTheme::empty
        inline bool empty() const
        {
            return m_attributes.empty();
        }
        // DocString: FMTTheme::getAttributes
        std::vector<std::string>getAttributes(const std::string& p_value, bool p_aggregate_source = false) const;
        // DocString: FMTTheme::getBaseAttributes
        inline const std::vector<std::string>& getBaseAttributes() const
        {
            return m_attributes;
        }
        // DocString: FMTTheme::getAttributeNames
        const std::vector<std::string>& getAttributeNames() const
        {
            return m_attributenames;
        }
        // DocString: FMTTheme::preSolve
        FMTTheme preSolve(FMTMaskFilter& p_maskfilter, size_t& p_newid, size_t& p_newstart) const;
        // DocString: FMTTheme::updateFromMask
        std::string updateFromMask(const Core::FMTMask& p_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>& p_themes,
            std::string& p_mask, std::string p_otherinformation = std::string());
        // DocString: FMTObject::theme
        static bool checkMask(const std::vector<Core::FMTTheme>& p_themes,
            const std::vector<std::string>& p_values, std::string& p_mask,
            const std::string& p_otherinformation);
        // DocString: FMTObject::getAggregates
        std::vector<std::string>getAggregates() const;
    protected:
        // DocString: FMTTheme::id
        size_t m_id;
        // DocString: FMTTheme::start
        size_t m_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(m_id);
                ar & BOOST_SERIALIZATION_NVP(m_start);
                ar & BOOST_SERIALIZATION_NVP(m_attributes);
                ar & BOOST_SERIALIZATION_NVP(m_attributenames);
                ar & BOOST_SERIALIZATION_NVP(m_aggregates);
                ar & BOOST_SERIALIZATION_NVP(m_aggregatenames);
                ar & BOOST_SERIALIZATION_NVP(m_indexes);
                ar & BOOST_SERIALIZATION_NVP(m_name);
                _buildAttributeLocations();
            }catch (...)
                {
                _exhandler->printExceptions("", "FMTTheme::serialize", __LINE__, __FILE__);
                }
        }
        // DocString: FMTTheme::attributes
        std::vector<std::string>m_attributes;
        // DocString: FMTTheme::attributenames
        std::vector<std::string>m_attributenames;
        // DocString: FMTTheme::aggregates
        std::vector<std::string>m_aggregates;
        // DocString: FMTTheme::aggregates
        std::vector<std::vector<std::string>>m_aggregatenames;
        // DocString: FMTTheme::indexes
        std::vector<std::map<std::string, double>>m_indexes;
        // DocString: FMTTheme::attributem_locations
        std::unordered_map<std::string, std::vector<size_t>>m_attributem_locations;
        // DocString: FMTTheme::lookiterator
        typedef typename std::unordered_map<std::string, std::vector<size_t>>::const_iterator lookiterator;
        // DocString: FMTTheme::name
        std::string m_name;
        // DocString: FMTTheme::_strToBits
         boost::dynamic_bitset<uint8_t> _strToBits(const std::string& p_value) const;
        // DocString: FMTTheme::_getCount
        size_t _getCount(const Core::FMTMask& p_mask) const;
        // DocString: FMTTheme::_getFlipCount
        size_t _getFlipCount(const Core::FMTMask& p_mask) const;
        // DocString: FMTTheme::_findFirstFlip
        size_t _findFirstFlip(const Core::FMTMask& p_mask) const;
        // DocString: FMTTheme::_findFirst
        size_t _findFirst(const Core::FMTMask& p_mask) const;
        // DocString: FMTTheme::_isEqual
        bool _isEqual(const Core::FMTMask& p_mask,
            const boost::dynamic_bitset<uint8_t>& p_bits) const;
        // DocString: FMTTheme::_isFlipEqual
        bool _isFlipEqual(const Core::FMTMask& p_mask,
            const boost::dynamic_bitset<uint8_t>& p_bits) const;
        // DocString: FMTTheme::_bitsToStr
        std::string _bitsToStr(const Core::FMTMask& p_mask) const;
        // DocString: FMTTheme::_getAttribute
        const std::string& _getAttribute(size_t p_attributeId) const;
        // DocString: FMTTheme::_getAttribute
        lookiterator _getAttribute(const std::string& p_value, bool p_raiseifnotfound = false) const;
        // DocString: FMTTheme::_buildAttributeLocations
        void _buildAttributeLocations();
        // DocString: FMTTheme::_fillupAggregates
        void _fillupAggregates(std::vector<int>& p_themeids, std::vector<std::string>& p_locattributes, std::vector<std::string>& p_locaggregates) const;
        // DocString: FMTTheme::_pushAggregate
        void _pushAggregate(const std::string& p_aggregatename);
        // DocString: FMTTheme::_pushAggregate
        void _pushAggregateValue(const std::string& p_aggregatename, const std::string& p_value);
    
    
    };
 
    // DocString: FMTThemeComparator
    class FMTThemeComparator
    {
    public:
        // DocString: FMTThemeComparator(const FMTTheme&,const bool&)
        FMTThemeComparator(const FMTTheme& p_lbase_theme,const bool& p_lcomparedwithpresolved=false);
        // DocString: FMTthemecomparatorr::operator()(const FMTTheme&)
        bool operator()(const FMTTheme& p_theme) const;
    private:
        // DocString: FMTThemeComparator::base_theme
        FMTTheme m_base_theme;
        // DocString: FMTThemeComparator::comparedwithpresolved
        bool m_comparedwithpresolved;
 
    };
 
 
 
}
 
BOOST_CLASS_EXPORT_KEY(Core::FMTTheme)
 
#endif // FMTtheme_Hm_included