vs Namespace Reference

Classes
class	vs_queue_strategy
	simpliest determenistic merge strategy. More...
class	vs_queue
	A versioned mimic of a stl::queue, suitable for multithread. More...
class	vs_set_strategy
	simpliest determenistic merge strategy. More...
class	vs_set
	A versioned mimic of a stl::set, suitable for multithread. More...
class	vs_stack_strategy
	simpliest determenistic merge strategy. More...
class	vs_stack
	A versioned mimic of a stl::stack, suitable for multithread. More...
class	thread
	std::thread wrapper with additional logic for managing Revisions More...
class	vs_tree_strategy
	simpliest determenistic merge strategy. More...
struct	_vs_tree_node
	Manages all balancing logic and correlating allocations;. More...
struct	_vs_tree_iterator
class	_vs_tree
	serves as stl-like interface from node to vs_tree; handles allocations in construction and destruction. More...
class	vs_tree
	A versioned AVL-tree with deep copy constructor in internal classes. More...

Functions
template<typename _Key >
std::ostream &	operator<< (std::ostream &os, vs_queue< _Key > const &value)
template<typename _Key >
std::ostream &	operator<< (std::ostream &os, vs_stack< _Key > const &value)
template<typename _Key , typename _Comp >
std::ostream &	operator<< (std::ostream &os, vs_tree< _Key, _Comp > const &value)

Variables
template<typename T , typename Container >
concept	IsMergeStrategy
	Concept for compile-time type checking passed user strategies. More...

Function Documentation

operator<<() [1/3]

template<typename _Key >

std::ostream& vs::operator<<	(	std::ostream &	os,
		vs_queue< _Key > const &	value
	)

Definition at line 169 of file vs_queue.h.

                                                                          {
        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;
    }

operator<<() [2/3]

template<typename _Key >

std::ostream& vs::operator<<	(	std::ostream &	os,
		vs_stack< _Key > const &	value
	)

Definition at line 159 of file vs_stack.h.

                                                                          {
        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;
    }

operator<<() [3/3]

template<typename _Key , typename _Comp >

std::ostream& vs::operator<<	(	std::ostream &	os,
		vs_tree< _Key, _Comp > const &	value
	)

Definition at line 609 of file vs_tree.h.

                                                                               {
        vs_tree<_Key,_Comp> temp = value;
 
        std::ostringstream o;
        o << "{ ";
        for (auto& i: temp) {
            o << i << ", ";
        }
        o << " }";
 
        os << o.str();
        return os;
    }

Variable Documentation

IsMergeStrategy

template<typename T , typename Container >

concept vs::IsMergeStrategy

Initial value:

= requires(T t, Container& src, Container& dst,
            Container& dstc, Container::value_type& src_elem, Container::value_type& dst_elem)
    {
        
        
        t.merge(dst, src);
 
        
        t.merge_same_element(dstc, dst_elem, src_elem);
 
    }

Concept for compile-time type checking passed user strategies.

Definition at line 12 of file strategy.h.