vs_set.h

Go to the documentation of this file.

#ifndef _VS_SET_H
#define _VS_SET_H
 
#include <functional>
#include <set>
#include <initializer_list>
#include <iterator>
 
#include "versioned.h"
#include "revision.h"
#include "strategy.h"
 
namespace vs
{
 
    template<typename _Key, typename _Comp>
    class vs_set_strategy;
 
    template<typename _Key, typename _Comp = std::less<_Key>, 
        typename _Strategy = vs_set_strategy<_Key, _Comp>>
    class vs_set
    {
 
    static_assert(vs::IsMergeStrategy<_Strategy, std::set<_Key, _Comp>>, 
        "Provided invalid strategy class in template");
 
    public:
    /* public typedefs */
 
    typedef Versioned<std::set<_Key, _Comp>, _Strategy> _Versioned;
    typedef std::set<_Key, _Comp>::iterator iterator;
    typedef std::set<_Key, _Comp>::size_type size_type;
 
    private:
 
    _Versioned _v_s;
 
    public:
 
    /* ------------------ Constructors ----------------------*/
    explicit
    vs_set(const _Comp& __comp = _Comp())
    : _v_s(std::set<_Key, _Comp>(__comp)) { }
 
    vs_set(std::initializer_list<_Key> __l,
           const _Comp& __comp = _Comp())
    : _v_s(std::set<_Key, _Comp>(__l, __comp)) { }
 
    vs_set(const vs_set& __vs_set)
    : _v_s(__vs_set._v_s.Get()) { }
 
    //*  @brief %Set move constructor
 
    //*  @brief  Builds a %set from a range.
 
 
    /* ------------------ Accessors ----------------------*/
 
    iterator
    begin() const noexcept
    { return _v_s.Get().begin(); }
 
    iterator
    end() const noexcept
    { return _v_s.Get().end(); }
 
 
    size_type
    size() const noexcept
    { return _v_s.Get().size(); }
 
    bool
    contains(const _Key& __x)
    { 
        auto& _set = _v_s.Get();
        return _set.find(__x) != _set.end();
    }
 
    iterator
    find(const _Key& __x) const
    { return _v_s.Get().find(__x); }
 
    /* ------------------ Operators ----------------------*/
 
    /* XXX: add pair<iteraror as in stl> */
    /* XXX: move insert */
 
    bool
    insert(const _Key& __x)
    {
        return _v_s.Set(_v_s.Get(), [&](std::set<_Key, _Comp>& _set){return _set.insert(__x).second;});
    }
    // = (copy)
    // = {}
    };
 
    template<typename _Key, typename _Comp>
    class vs_set_strategy
    {
    public:
 
    void
    merge(std::set<_Key, _Comp>& dst, std::set<_Key, _Comp>& src)
    {
        for (auto& i: src)
        {
            auto found = dst.find(i);
            /* XXX: dirty const_cast, but it is not used as const anyway */
            if (found != dst.end())
                merge_same_element(dst, const_cast<_Key&>(*found), const_cast<_Key&>(i));
            else
                dst.insert(i);
        }
    }
 
    void
    merge_same_element(std::set<_Key, _Comp>& dst, _Key& dstk, _Key& srck)
    {
        /* do nothing, as insert would handle it */
    }
 
    };
}
 
#endif