FMTMask.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 FMTMASK_Hm_included
#define FMTMASK_Hm_included
 
#ifndef BOOST_DYNAMIC_BITSET_DONT_USE_FRIENDS
#define BOOST_DYNAMIC_BITSET_DONT_USE_FRIENDS
#endif
 
#include <boost/dynamic_bitset.hpp>
#include <boost/unordered_map.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/functional/hash.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/split_free.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/string.hpp>
#include <boost/functional/hash.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/dynamic_bitset/serialization.hpp>
#include "FMTException.h"
#include <vector>
#include <string>
 
 
 
 
#if (BOOST_VERSION / 100 % 1000) < 71
namespace boost {
    namespace serialization {
 
        template <typename Ar, typename Block, typename Alloc>
        void save(Ar& ar, dynamic_bitset<Block, Alloc> const& bs, unsigned) {
            size_t num_bits = bs.size();
            std::vector<Block> blocks(bs.num_blocks());
            to_block_range(bs, blocks.begin());
 
            ar& BOOST_SERIALIZATION_NVP(num_bits);
            ar& BOOST_SERIALIZATION_NVP(blocks);
        }
 
        template <typename Ar, typename Block, typename Alloc>
        void load(Ar& ar, dynamic_bitset<Block, Alloc>& bs, unsigned) {
            size_t num_bits;
            std::vector<Block> blocks;
            ar& BOOST_SERIALIZATION_NVP(num_bits);
            ar& BOOST_SERIALIZATION_NVP(blocks);
 
            bs.resize(num_bits);
            from_block_range(blocks.begin(), blocks.end(), bs);
            bs.resize(num_bits);
        }
 
        template <typename Ar, typename Block, typename Alloc>
        void serialize(Ar& ar, dynamic_bitset<Block, Alloc>& bs, unsigned version) {
            split_free(ar, bs, version);
        }
 
    }
}
namespace boost {
    template <typename Block, typename Alloc>
    std::size_t hash_value(const boost::dynamic_bitset<Block, Alloc>& bs)
    {
    std::size_t hash = hash_value(bs.m_num_bits);
    boost::hash_combine(hash, bs.m_bits); 
    return hash;
    }
}
#endif
 
namespace Core
{
 
class FMTTheme;
class FMTMaskFilter;
// DocString: FMTMask
class FMTEXPORT FMTMask
    {
 
    public:
        // DocString: FMTMask::(FMTMask&& rhs)
        FMTMask(FMTMask&& rhs) noexcept;
        // DocString: FMTMask::operator=(FMTMask&& rhs)
        FMTMask& operator=(FMTMask&& rhs) noexcept;
        // DocString: swap()
        void swap(FMTMask& rhs);
        // DocString: FMTMask()
        FMTMask();
        // DocString: FMTMask(const FMTMask&)
        FMTMask(const FMTMask& rhs);
        // DocString: ~FMTMask()
        virtual ~FMTMask()=default;
        // DocString: FMTMask(const boost::dynamic_bitset<uint8_t>&)
        FMTMask(const boost::dynamic_bitset<uint8_t>& bits);
        // DocString: FMTMask::operator bool
        explicit operator bool() const;
        // DocString: FMTMask(const std::string&,const boost::dynamic_bitset<uint8_t>&)
        FMTMask(const std::string& mask,const boost::dynamic_bitset<uint8_t>& bits);
        // DocString: FMTMask(const std::string&,const std::vector<FMTTheme>&)
        FMTMask(const std::string& mask,const std::vector<FMTTheme>& themes);
        // DocString: FMTMask(const std::vector<std::string>&,const std::vector<FMTTheme>&)
        FMTMask(const std::vector<std::string>& values,const std::vector<FMTTheme>& themes);
        // DocString: FMTMask(const std::vector<FMTTheme>&,const std::vector<FMTTheme>&)
        FMTMask(const std::vector<FMTTheme>& themes);
        // DocString: FMTMask::clear
        void clear();
        // DocString: FMTMask::size
        size_t size() const;
        // DocString: FMTMask::count
        size_t count() const;
        // DocString: FMTMask::get
        std::string get(const std::vector<FMTTheme>& themes) const;
        // DocString: FMTMask::get
        std::string get(const FMTTheme& theme) const;
        // DocString: FMTMask::getAttribute
        const std::string& getAttribute(const FMTTheme& p_theme) const;
        // DocString: FMTMask::getSubsetCount
        size_t getSubsetCount(const FMTTheme& theme) const;
        // DocString: FMTMask::set
        void set(const std::vector<FMTTheme>& themes,const std::string& value);
        // DocString: FMTMask::setExclusiveBits
        void setExclusiveBits(const FMTMask& p_mask,const FMTTheme& p_theme);
        // DocString: FMTMask::getNonFullBlocks
        std::vector<size_t>getNonFullBlocks() const;
        // DocString: FMTMask::isSubsetOf
        bool isSubsetOf(const FMTMask& p_mask,const std::vector<size_t>& p_subset) const;
        // DocString: FMTMask::set
        void set(const FMTTheme& theme, const std::string& value);
        // DocString: FMTMask::getStaticThemes
        std::vector<const Core::FMTTheme*>getStaticThemes(const std::vector<const Core::FMTTheme*>& themes) const;
        // DocString: FMTMask::getSelectedThemes
        std::vector<const Core::FMTTheme*> getSelectedThemes(const  std::vector<Core::FMTTheme>& themes) const;
        // DocString: FMTMask::isNotThemesSubset
        bool isNotThemesSubset(const FMTMask& rhs, const  std::vector<const Core::FMTTheme*>& themes) const;
        // DocString: FMTMask::isNotThemesSubset
        bool isNotThemesSubset(const FMTMask& rhs, const  std::vector<Core::FMTTheme>& themes) const;
        // DocString: FMTMask::removeAggregates
        FMTMask removeAggregates(const std::vector<FMTTheme>& themes,bool questionmarkonly=false) const;
        // DocString: FMTMask::empty
        bool empty() const;
        // DocString: FMTMask::update
        void update(const std::vector<FMTTheme>& themes);
        // DocString: FMTMask::decompose
        std::vector<FMTMask>decompose(const FMTTheme &theme) const;
        // DocString: FMTMask::append
        void append(const boost::dynamic_bitset<uint8_t> &bits);
 
        // DocString: FMTMask::binarizedAppend
        template <class typetobinarize>
        void binarizedAppend(const typetobinarize& element)
        {
            size_t  location = m_data.size();
            m_data.resize(m_data.size() + (sizeof(typetobinarize) * 8));
            const char* charelements = reinterpret_cast<const char*>(&element);
            for (size_t charit = 0; charit < sizeof(typetobinarize); ++charit)
            {
                const char value = charelements[charit];
                for (int i = 7; i >= 0; --i)
                {
                    m_data[location] = ((value & (1 << i)));
                    ++location;
                }
            }
        }
        // DocString: FMTMask::unionWith
        void unionWith(const FMTMask& rhs);
        // DocString: FMTMask::getUnion
        FMTMask getUnion(const FMTMask& rhs) const;
        // DocString: FMTMask::getIntersect
        FMTMask getIntersect(const FMTMask& rhs) const;
        // DocString: FMTMask::setIntersect
        void setIntersect(const FMTMask& rhs);
        // DocString: FMTMask::getBitsetIntersect
        boost::dynamic_bitset<uint8_t> getBitsetIntersect(const FMTMask& rhs) const;
        // DocString: FMTMask::operator=
        FMTMask& operator = (const FMTMask& rhs);
        // DocString: FMTMask::operator!=
        bool operator != (const FMTMask& rhs) const;
        // DocString: FMTMask::operator==
        bool operator == (const FMTMask& rhs) const;
        // DocString: FMTMask::operator<
        bool operator < (const FMTMask& rhs) const;
        // DocString: FMTMask::resume
        FMTMask resume(const boost::dynamic_bitset<uint8_t>& rhs) const;
        // DocString: FMTMask::resume
        FMTMask resume(const std::vector<size_t>& indexes) const;
        // DocString: FMTMask::hash
        inline size_t hash() const
            {
            return boost::hash<boost::dynamic_bitset<uint8_t>>()(m_data);
            }
        // DocString: FMTMask::getBitsString
        std::string getBitsString() const;
        // DocString: FMTMask::operator std::string
        inline operator std::string() const
            {
            return m_name;
            }
        // DocString: FMTMask::isSubsetOf
        bool isSubsetOf(const FMTMask& p_rhs) const;
        // DocString: FMTMask::getBitsetReference
        inline const boost::dynamic_bitset<uint8_t>& getBitsetReference() const
            {
            return m_data;
            }
        // DocString: FMTMask::getStringReference
        inline const std::string& getStringReference() const
        {
            return m_name;
        }
        // DocString: FMTMask::reserve
        void reserve(size_t p_size);
        // DocString: FMTMask::refine
        FMTMask refine(const FMTMask& mask, const std::vector<FMTTheme>& themes) const;
        // DocString: FMTMask::getPostSolveMask
        FMTMask getPostSolveMask(const FMTMask& mask,const std::vector<FMTTheme>& themes) const;
        // DocString: FMTMask::preSolve
        FMTMask preSolve(const FMTMaskFilter& filter,const std::vector<FMTTheme>&presolvedthemes) const;
        // DocString: FMTMask::preSolveRef
        void preSolveRef(const FMTMaskFilter& p_filter, const std::vector<FMTTheme>& p_presolvedThemes,bool p_allowReallocation = true);
 
        // DocString: FMTMask::canPreSolve
        bool canPreSolve(const FMTMaskFilter& p_filter, const std::vector<FMTTheme>& p_presolvedThemes) const;
        // DocString: FMTMask::postSolve
        FMTMask postSolve(const FMTMaskFilter& filter, const std::vector<FMTTheme>&basethemes) const;
    private:
        friend class FMTTheme;
        // DocString: FMTMask::serialize
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar& boost::serialization::make_nvp("data", m_data);
            ar& boost::serialization::make_nvp("name", m_name);
        }
        // DocString: FMTMask::_subset
        boost::dynamic_bitset<uint8_t> _subset(const FMTTheme& theme) const;
        // DocString: FMTMask::operator []
        bool operator [](int i) const;
        // DocString: FMTMask::_anyIntersect
        bool _anyIntersect(const FMTMask& p_MASK, const FMTTheme& p_THEME) const;
        // DocString: FMTMask::_countTheme
        size_t _countTheme(const FMTTheme& p_Theme) const;
        // DocString: FMTMask::_getPresolveMas
        boost::dynamic_bitset<uint8_t> _getPreSolveMask(const FMTMaskFilter& p_filter,
                                const std::vector<FMTTheme>& p_presolvedThemes) const;
        // DocString: FMTMask::_setSubset
        void _setSubset(const FMTTheme& theme, const boost::dynamic_bitset<uint8_t>& subset);
        // DocString: FMTMask::m_name
        std::string m_name;
        // DocString: FMTMask::m_data
        boost::dynamic_bitset<uint8_t> m_data;
    };
 
 
template<> inline void FMTMask::binarizedAppend<std::string>(const std::string& element)
    {
        size_t  location = m_data.size();
        m_data.resize(m_data.size() + (element.size() * 8));
        const char* charelements = element.c_str();
        for (size_t charit = 0; charit < element.size(); ++charit)
        {
            const char value = charelements[charit];
            for (int i = 7; i >= 0; --i)
            {
                m_data[location] = ((value & (1 << i)));
                ++location;
            }
        }
    }
 
template<> inline void FMTMask::binarizedAppend<double>(const double& element)
{
    size_t  location = m_data.size();
    const int corrected = static_cast<int>(element*(1 / FMT_DBL_TOLERANCE));
    m_data.resize(m_data.size() + (sizeof(int) * 8));
    const char* charelements = reinterpret_cast<const char*>(&corrected);
    for (size_t charit = 0; charit < sizeof(int); ++charit)
    {
        const char value = charelements[charit];
        for (int i = 7; i >= 0; --i)
        {
            m_data[location] = ((value & (1 << i)));
            ++location;
        }
    }
}
 
// DocString: FMTMaskComparator
class FMTMaskComparator
    {
    public:
        // DocString: FMTMaskComparator:(const FMTMask&)
        FMTMaskComparator(const FMTMask& lbase_mask);
        // DocString: FMTMaskComparator::operator()(const FMTAction&)
        bool operator()(const FMTMask& mask) const;
 
    private:
    // DocString: FMTMaskComparator::m_baseMask
    FMTMask m_baseMask;
    };
 
}
 
namespace boost {
  template <>
  struct hash<Core::FMTMask>
  {
    std::size_t operator()(const Core::FMTMask& mask) const
    {
      return (mask.hash());
    }
  };
 
}
 
BOOST_CLASS_EXPORT_KEY(Core::FMTMask)
 
#endif // FMTMASK_Hm_included