vs_stack.h

Go to the documentation of this file.

#ifndef _VS_STACK_H
#define _VS_STACK_H
 
#include <functional>
#include <stack>
#include <initializer_list>
#include <iterator>
 
#include "versioned.h"
#include "revision.h"
#include "strategy.h"
 
namespace vs
{
 
    template<typename _Key>
    class vs_stack_strategy;
 
    template<typename _Key, typename _Strategy = vs_stack_strategy<_Key>>
    class vs_stack
    {
 
    static_assert(vs::IsMergeStrategy<_Strategy, std::stack<_Key>>, 
        "Provided invalid strategy class in template");
 
    public:
    /* public typedefs */
 
    typedef Versioned<std::stack<_Key>,_Strategy> _Versioned;
    typedef std::stack<_Key>::size_type size_type;
 
    private:
 
    _Versioned _v_s;
 
    public:
 
    /* ------------------ Constructors ----------------------*/
    explicit
    vs_stack()
    : _v_s(std::stack<_Key>()) { }
 
    vs_stack(std::initializer_list<_Key> __l)
    : _v_s(std::stack<_Key>()) 
    {
        _v_s.Set(_v_s.Get(),
        [&](std::stack<_Key>& _stack){
            for (auto& i: __l){
                _stack.push(i);
            }
            return true;
        });
    }
 
    vs_stack(const vs_stack& __vs_stack)
    : _v_s(__vs_stack._v_s.Get()) { }
 
    //*  @brief %stack move constructor
 
    //*  @brief  Builds a %stack from a range.
 
    /* ------------------ Accessors ----------------------*/
 
    const _Key&
    top() const
    { return _v_s.Get().top(); }
 
    size_type
    size() const noexcept
    { return _v_s.Get().size(); }
 
    /* ------------------ Operators ----------------------*/
 
    void
    push(const _Key& __x)
    {
        _v_s.Set(_v_s.Get(), [&](std::stack<_Key>& _stack){ _stack.push(__x); return true; });
    }
 
    void
    pop()
    {
        if (_v_s.Get().size() > 0)
            _v_s.Set(_v_s.Get(), [](std::stack<_Key>& _stack){ _stack.pop(); return true; });
    }
    // = (copy)
    // = {}
    };
 
    template<typename _Key>
    class vs_stack_strategy
    {
    public:
 
    void
    merge(std::stack<_Key>& dst, std::stack<_Key>& src)
    {
        while (src.size() > 0)
        {
            dst.push(src.top());
            src.pop();
        }
    }
 
    void
    merge_same_element(std::stack<_Key>& dst, _Key& dstk, _Key& srck)
    {
        dst.push(srck);
    }
 
    };
 
    template<typename _Key>
    std::ostream& operator << (std::ostream& os, vs_stack<_Key> const& value) {
        vs_stack<_Key> temp = value;
        std::stack<_Key> reversedStack;
 
        while (temp.size() != 0) {
            reversedStack.push(temp.top());
            temp.pop();
        }
 
        std::ostringstream o;
        o << "{ ";
        while (reversedStack.size() != 0) {
            o << reversedStack.top();
            reversedStack.pop();
            if (reversedStack.size() != 0) {
                o << ", ";
            }
        }
        o << " }";
 
        os << o.str();
        return os;
    }
}
 
#endif