vs_queue.h

Go to the documentation of this file.

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