FMTmask.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 FMTMASK_H_INCLUDED
#define FMTMASK_H_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 "FMTexception.hpp"
#include <vector>
#include <string>
 
 
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);
        }
 
    }
}
#if (BOOST_VERSION / 100 % 1000) < 71
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
    {
    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_NVP(data);
        ar & BOOST_SERIALIZATION_NVP(name);
        }
        // DocString: FMTmask::subset
        boost::dynamic_bitset<> subset(const FMTtheme& theme) const;
        // DocString: FMTmask::setsubset
        void setsubset(const FMTtheme& theme,const boost::dynamic_bitset<>& subset);
        // DocString: FMTmask::name
        std::string name;
        // DocString: FMTmask::data
        boost::dynamic_bitset<> data;
    public:
        // 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<>&)
        FMTmask(const boost::dynamic_bitset<>& bits);
        // DocString: FMTmask::operator bool
        explicit operator bool() const;
        // DocString: FMTmask(const std::string&,const boost::dynamic_bitset<>&)
        FMTmask(const std::string& mask,const boost::dynamic_bitset<>& 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::getsubsetcount
        size_t getsubsetcount(const FMTtheme& theme) const;
        // DocString: FMTmask::set
        void set(const std::vector<FMTtheme>& themes,const std::string& value);
        // DocString: FMTmask::set
        void set(const FMTtheme& theme, const std::string& value);
        // DocString: FMTmask::getstaticthemes
        std::vector<FMTtheme>getstaticthemes(const std::vector<FMTtheme>& themes) const;
        // DocString: FMTmask::getselectedthemes
        std::vector<FMTtheme> getselectedthemes(const  std::vector<FMTtheme>& themes) const;
        // DocString: FMTmask::isnotthemessubset
        bool isnotthemessubset(const FMTmask& rhs, const  std::vector<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<> &bits);
        // DocString: FMTmask::binarizedappend
        template <class typetobinarize>
        void binarizedappend(const typetobinarize& element)
        {
            size_t  location = data.size();
            data.resize(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)
                {
                    data[location] = ((value & (1 << i)));
                    ++location;
                }
            }
        }
        // DocString: FMTmask::getunion
        FMTmask getunion(const FMTmask& rhs) const;
        // DocString: FMTmask::getintersect
        FMTmask getintersect(const FMTmask& rhs) const;
        // DocString: FMTmask::getbitsetintersect
        boost::dynamic_bitset<> 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<>& 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<>>()(data);
            }
        // DocString: FMTmask::getbitsstring
        std::string getbitsstring() const;
        // DocString: FMTmask::operator std::string
        inline operator std::string() const
            {
            return name;
            }
        // DocString: FMTmask::issubsetof
        inline bool issubsetof(const boost::dynamic_bitset<>& rhs) const
            {
            return data.is_subset_of(rhs);
            }
        // DocString: FMTmask::issubsetof
        inline bool issubsetof(const FMTmask& rhs) const
            {
            return data.is_subset_of(rhs.data);
            }
        // DocString: FMTmask::getbitsetreference
        inline const boost::dynamic_bitset<>& getbitsetreference() const
            {
            return data;
            }
        // DocString: FMTmask::getstringreference
        inline const std::string& getstringreference() const
        {
            return name;
        }
        // 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::postsolve
        FMTmask postsolve(const FMTmaskfilter& filter, const std::vector<FMTtheme>&basethemes) const;
    };
 
 
template<> inline void FMTmask::binarizedappend<std::string>(const std::string& element)
    {
        size_t  location = data.size();
        data.resize(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)
            {
                data[location] = ((value & (1 << i)));
                ++location;
            }
        }
    }
 
template<> inline void FMTmask::binarizedappend<double>(const double& element)
{
    size_t  location = data.size();
    const int corrected = static_cast<int>(element*(1 / FMT_DBL_TOLERANCE));
    data.resize(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)
        {
            data[location] = ((value & (1 << i)));
            ++location;
        }
    }
}
 
// DocString: FMTmaskcomparator
class FMTmaskcomparator
    {
    // DocString: FMTmaskcomparator::base_mask
    FMTmask base_mask;
    public:
        // DocString: FMTmaskcomparator:(const FMTmask&)
        FMTmaskcomparator(const FMTmask& lbase_mask);
        // DocString: FMTmaskcomparator::operator()(const FMTaction&)
        bool operator()(const FMTmask& mask) const;
 
    };
 
}
 
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_H_INCLUDED