FMTlist.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 FMTlist_H_INCLUDED
#define FMTlist_H_INCLUDED
 
#include <boost/unordered_map.hpp>
#include <functional>
#include <vector>
#include <utility>
 
#include "FMTmask.hpp"
#include "FMTmaskfilter.hpp"
#include <boost/serialization/version.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/hash_collections_save_imp.hpp>
#include <boost/serialization/hash_collections_load_imp.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/unordered_map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
#include "FMTexceptionhandler.hpp"
#include "FMTobject.hpp"
#include <iterator>
#include <memory>
#include "FMTyieldhandler.hpp"
#include "FMTtheme.hpp"
 
 
namespace Core
{
    // DocString: FMTlist
    template<typename T>
    class FMTlist: public FMTobject
    {
    public:
        // DocString: FMTlist::operator+=
        Core::FMTlist<T>& operator+= (const Core::FMTlist<T>& OtherList)
        {
            try {
                if (!this->canshrink()||!OtherList.canshrink())
                    {
                    _exhandler->raise(Exception::FMTexc::FMTinvalid_action, "Cant append list together",
                        "FMTlist::operator::+=", __LINE__, __FILE__);
                    }
                for (const std::pair<FMTmask, T>& Object : OtherList.data)
                    {
                    push_back(Object.first, Object.second);
                    }
            }catch (...) {
                _exhandler->raisefromcatch("", "FMTlist::operator::+=", __LINE__, __FILE__);
 
            }
            return *this;
        }
 
        // DocString: FMTlist::swap
        void swap(Core::FMTlist<T>& rhs)
        {
            data.swap(rhs.data);
            filter.swap(rhs.filter);
            fastpass.swap(rhs.fastpass);
        }
        // DocString: FMTlist::getunion
        FMTmask getunion(const std::vector<FMTtheme>& themes) const
        {
            Core::FMTmask testedmask(std::string(this->begin()->first), themes);
            for (const auto& object : *this)
            {
                const Core::FMTmask specificiermask(std::string(object.first), themes);
                testedmask = testedmask.getunion(specificiermask);
            }
            return testedmask;
        }
        // DocString: FMTlist()
        FMTlist() :
            FMTobject(),
            data(),
            filter(),
            fastpass() {};
        // DocString: FMTlist(const FMTlist&)
        FMTlist(const FMTlist<T>& rhs) :
            FMTobject(rhs),
            data(),
            filter(rhs.filter),
            fastpass(rhs.fastpass)
        {
            copydata(rhs);
        }
        // DocString: FMTlist::operator=
        FMTlist& operator = (const FMTlist<T>& rhs)
        {
            if (this != &rhs)
            {
                FMTobject::operator=(rhs);
                copydata(rhs);
                filter = rhs.filter;
                fastpass = rhs.fastpass;
            }
            return *this;
        }
        // DocString: FMTlist::operator==
        bool operator == (const FMTlist<T>& rhs) const
        {
            return (data == rhs.data);
        }
        // DocString: ~FMTlist()
        ~FMTlist() = default;
        // DocString: FMTlist::empty
        bool empty() const
        {
            return data.empty();
        }
        // DocString: FMTlist::canshrink
        bool canshrink() const
        {
            return filter.empty();
        }
        // DocString: FMTlist::clearcache
        virtual void clearcache()
        {
            boost::unordered_map<FMTmask, std::vector<int>>().swap(fastpass);
        }
        // DocString: FMTlist::size
        size_t size() const
        {
            return data.size();
        }
        // DocString: FMTlist::findsets
        std::vector<const T*> findsets(const FMTmask& mask) const
        {
            const FMTmask newkey = filter.filter(mask);
            return findsetswithfiltered(newkey);
        }
        // DocString: FMTlist::findsetswithfiltered
        std::vector<const T*> findsetswithfiltered(const FMTmask& newkey) const
        {
            std::vector<const T*>allhits;
            boost::unordered_map<FMTmask, std::vector<int>>::const_iterator fast_it = fastpass.find(newkey);
            if (fast_it != fastpass.end())
            {
                allhits.reserve(fast_it->second.size());
                for (const int& location : fast_it->second)
                {
                    allhits.push_back(&data.at(location).second);
                }
            }
            else {
                fastpass[newkey] = std::vector<int>();
                int location = 0;
                for (const std::pair<FMTmask, T>& object : data)
                {
                    if (newkey.issubsetof(object.first))
                    {
                        fastpass[newkey].push_back(location);
                        allhits.push_back(&object.second);
                    }
                    ++location;
                }
                fastpass[newkey].shrink_to_fit();
            }
            return allhits;
        }
        // DocString: FMTlist::filtermask
        inline FMTmask filtermask(const FMTmask& basemask) const
        {
            return filter.filter(basemask);
        }
        // DocString: FMTlist::shrink
        void shrink()
        {
            try {
                fastpass.clear();
                std::vector<Core::FMTmask> filteredmasks;
                for (const std::pair<FMTmask, T>& object : data)
                {
                    filteredmasks.push_back(object.first);
                }
                if (filteredmasks.empty())
                {
                    _exhandler->raise(Exception::FMTexc::FMTinvalid_maskrange, "Empty mask", "FMTactionparser::shrink", __LINE__, __FILE__);
                }
                filter = Core::FMTmaskfilter(filteredmasks);
                for (std::pair<FMTmask, T>& object : data)
                {
                    object.first = filter.filter(object.first);
                }
                data.shrink_to_fit();
            }
            catch (...) {
 
                _exhandler->raisefromcatch("", "FMTlist::shrink", __LINE__, __FILE__);
 
            }
        }
        // DocString: FMTlist::unshrink
        void unshrink(const std::vector<FMTtheme>& themes)
        {
            fastpass.clear();
            filter = Core::FMTmaskfilter();
            for (std::pair<FMTmask, T>& object : data)
            {
                object.first = FMTmask(std::string(object.first), themes);
            }
        }
        // DocString: FMTlist::APIpush_back
        void APIpush_back(const FMTmask& mask, const T& value)
        {
            push_back(mask, value);
        }
        // DocString: FMTlist::push_back
        void push_back(const FMTmask& mask, const T& value)
        {
            data.emplace_back(mask, value);
        }
        // DocString: FMTlist::update
        virtual void update()
        {
            if (canshrink())
            {
                shrink();
            }
        }
        // DocString: FMTlist::push_back
        void push_back(const FMTlist<T>& rhs)
        {
            if (this->canshrink() && rhs.canshrink())
            {
                copydata(rhs);
                this->shrink();
            }
        }
        // DocString: FMTlist::push_front
        void push_front(const FMTmask& mask, const T& value)
        {
            insert(0, mask, value);
        }
        // DocString: FMTlist::pop_back
        void pop_back()
        {
            data.pop_back();
        }
        // DocString: FMTlist::erase
        void erase(const size_t& location)
        {
            data.erase(data.begin() + location);
        }
        // DocString: FMTlist::insert
        void insert(const size_t& location, const FMTmask& mask, const T& value)
        {
            data.insert(data.begin() + location, std::pair<FMTmask, T>(mask, value));
        }
        // DocString: FMTlist::value_type
        typedef typename std::vector<std::pair<FMTmask, T>>::value_type value_type;
        // DocString: FMTlist::iterator
        typedef typename std::vector<std::pair<FMTmask, T>>::iterator iterator;
        // DocString: FMTlist::const_iterator
        typedef typename std::vector<std::pair<FMTmask, T>>::const_iterator const_iterator;
        // DocString: FMTlist::begin
        iterator begin()
        {
            return data.begin();
        }
        // DocString: FMTlist::begin
        const_iterator begin() const
        {
            return data.begin();
        }
        // DocString: FMTlist::end
        iterator  end()
        {
            return data.end();
        }
        // DocString: FMTlist::end
        const_iterator end() const
        {
            return data.end();
        }
    protected:
        // DocString: FMTlist::compressmasks
        void compressmasks(std::vector<FMTtheme>& newthemes)
            {
            try {
                if (size()==1)
                {
                    return;
                }
                unshrink(newthemes);
                size_t thstart = 0;
                for (FMTtheme& theme : newthemes)
                {
                    std::vector<std::pair<FMTmask, T>>newvecdata;
                    std::list<std::pair<FMTmask, T>>newdata(data.begin(), data.end());
                    boost::dynamic_bitset<>selectedbits;
                    selectedbits.resize(data.begin()->first.size(), true);
                    for (size_t loc = thstart;loc < (theme.size()+ thstart);++loc)
                        {
                        selectedbits[loc] = false;
                        }
                    while (!newdata.empty())
                        {
                        typename std::list<std::pair<FMTmask, T>>::iterator baseit = newdata.begin();
                        typename std::list<std::pair<FMTmask, T>>::iterator datait = newdata.begin();
                        ++datait;
                        std::vector<typename std::list<std::pair<FMTmask, T>>::iterator>toremove;
                        Core::FMTmask basemask(baseit->first);
                        const boost::dynamic_bitset<> selecinter = selectedbits & baseit->first.getbitsetreference();
                        boost::dynamic_bitset<> reverselect(selecinter);
                        for (size_t loc = thstart; loc < (theme.size() + thstart); ++loc)
                            {
                            reverselect[loc] = true;
                            }
                        /*Core::FMTmask testmask(baseit->first);
                        testmask.set(theme, "?");*/
                        while (datait!=newdata.end())
                            {
                            /*Core::FMTmask datamask(datait->first);
                            datamask.set(theme, "?");*/
                            const boost::dynamic_bitset<>&dataref = datait->first.getbitsetreference();
                            if (dataref.is_subset_of(reverselect))
                            {
                                const boost::dynamic_bitset<> datainter = selectedbits & dataref;
                                if (datainter == selecinter &&
                                    baseit->second == datait->second)
                                {
                                    basemask = basemask.getunion(datait->first);
                                    toremove.push_back(datait);
                                }
                            }
                            ++datait;
                            }
                        std::pair<FMTmask, T>newelement(basemask,baseit->second);
                        newdata.erase(newdata.begin());
                        for (typename std::list<std::pair<FMTmask, T>>::iterator remove : toremove)
                            {
                            newdata.erase(remove);
                            }
                        if(!toremove.empty())//aggregation done set new aggregate and refresh mask
                            {
                            std::string newmask;
                            for (const FMTtheme& subtheme : newthemes)
                                {
                                if (subtheme==theme)
                                    {
                                    newmask +=theme.updatefrommask(basemask) + " ";
                                }else {
                                    newmask += basemask.get(subtheme) + " ";
                                    }
                                }
                            newmask.pop_back();
                            newelement.first = Core::FMTmask(newmask, newthemes);
                            }
                        newvecdata.push_back(newelement);
                        }
                    thstart += theme.size();
                    data.swap(newvecdata);
                }
                shrink();
            }catch (...)
                    {
                _exhandler->raisefromcatch("", "compressmasks", __LINE__, __FILE__);
                }
            }
        // DocString: FMTlist::presolvelist
        void presolvelist(const FMTmaskfilter& filter,
            const std::vector<FMTtheme>& originalthemes,
            const std::vector<FMTtheme>& newthemes)
            {
            try {
                if (!canshrink())
                {
                    unshrink(originalthemes);
                }
                const std::vector<FMTtheme>maskthemes = filter.getselectedthemes(originalthemes);
                std::vector<std::pair<FMTmask, T>>newdata;
                for (const std::pair<FMTmask, T>& object : data)
                {
                    if (filter.canpresolve(object.first,maskthemes))
                    {
                        FMTmask mskkey = object.first;
                        if (!filter.emptyflipped())
                        {
                            mskkey = mskkey.presolve(filter, newthemes);
                        }
                        pushtodata(newdata, mskkey, object.second);
                    }
                }
                data.swap(newdata);
                FMTlist::update();
                data.shrink_to_fit();
            }catch (...)
                {
                _exhandler->raisefromcatch("","FMTlist::presolvelist", __LINE__, __FILE__);
                }
            }
        void copydata(const Core::FMTlist<T>& rhs)
            {
            data = rhs.data;
            }
    private:
        // DocString: FMTlist::save
        friend class boost::serialization::access;
        template<class Archive>
        void save(Archive& ar, const unsigned int version) const
        {
            try {
                ar& boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTobject>(*this));
                ar& BOOST_SERIALIZATION_NVP(data);
                ar& BOOST_SERIALIZATION_NVP(filter);
                std::vector<std::pair<FMTmask, std::vector<int>>>vecfastpass(fastpass.begin(), fastpass.end());
                ar& BOOST_SERIALIZATION_NVP(vecfastpass);
            }
            catch (...)
            {
                _exhandler->printexceptions("", "FMTlist::save", __LINE__, __FILE__);
            }
        }
        // DocString: FMTlist::load
        template<class Archive>
        void load(Archive& ar, const unsigned int version)
        {
            ar& BOOST_SERIALIZATION_NVP(data);
            ar& BOOST_SERIALIZATION_NVP(filter);
            std::vector<std::pair<FMTmask, std::vector<int>>>vecfastpass;
            ar& BOOST_SERIALIZATION_NVP(vecfastpass);
            for (const std::pair<FMTmask, std::vector<int>>& values : vecfastpass)
            {
                fastpass[values.first] = values.second;
            }
        }
        BOOST_SERIALIZATION_SPLIT_MEMBER()
            // DocString: FMTlist::data
            std::vector<std::pair<FMTmask, T>>data;
        // DocString: FMTlist::filter
        FMTmaskfilter filter;
        // DocString: FMTlist::fastpass
        mutable boost::unordered_map<FMTmask, std::vector<int>>fastpass;
        // DocString: FMTlist::pushtodata
        void pushtodata(std::vector<std::pair<FMTmask, T>>& datavector,
            const FMTmask& mask, const T& maskdata) const
        {
            datavector.push_back(std::pair<FMTmask, T>(mask, maskdata));
        }
 
    };
 
    template<> inline void FMTlist<std::unique_ptr<Core::FMTyieldhandler>>::compressmasks(std::vector<FMTtheme>& newthemes)
    {
 
    }
    
 
    template<> inline void FMTlist<std::unique_ptr<Core::FMTyieldhandler>>::insert(const size_t& location, const FMTmask& mask, const std::unique_ptr<Core::FMTyieldhandler>& value)
    {
        std::pair<Core::FMTmask, std::unique_ptr<Core::FMTyieldhandler>> newobject = std::make_pair(mask, std::move(value->clone()));
        data.insert(data.begin() + location, std::move(newobject));
    }
 
    template<> inline void FMTlist<std::unique_ptr<Core::FMTyieldhandler>>::pushtodata(std::vector<std::pair<FMTmask, std::unique_ptr<Core::FMTyieldhandler>>>& datavector,
        const FMTmask& mask, const std::unique_ptr<Core::FMTyieldhandler>& maskdata) const
    {
        std::pair<Core::FMTmask, std::unique_ptr<Core::FMTyieldhandler>> newobject = std::make_pair(mask, std::move(maskdata->clone()));
        datavector.push_back(std::move(newobject));
    }
 
    template<> inline void FMTlist<std::unique_ptr<Core::FMTyieldhandler>>::push_back(const FMTmask& mask, const std::unique_ptr<Core::FMTyieldhandler>& value)
    {
        pushtodata(data, mask, value);
    }
 
    template<> inline void FMTlist<std::unique_ptr<Core::FMTyieldhandler>>::copydata(const FMTlist<std::unique_ptr<Core::FMTyieldhandler>>& rhs)
    {
        data.clear();
        data.reserve(rhs.data.size());
        for (const std::pair<Core::FMTmask, std::unique_ptr<Core::FMTyieldhandler>>& object : rhs.data)
        {
            pushtodata(data, object.first, object.second);
        }
    }
 
 
}
 
 
#endif