version 1.22.0

source tree changed
detached PIConsole and PIScreen* in "pip_console" library

lib/main/containers/picontainers.cpp

@@ -0,0 +1,174 @@
+/*
+	PIP - Platform Independent Primitives
+	Generic containers
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+/** \class PIVector
+ * \brief Dynamic array of any type
+ * \details This class used to store dynamic array of any
+ * type of data. In memory data stored linear. You can insert
+ * item in any place of remove some items from any place.
+ * For quick add elements this is stream operator <<.
+
+ * \fn PIVector::PIVector();
+ * Contructs an empty vector
+
+ * \fn PIVector::PIVector(ullong size, const Type & value = Type());
+ * \brief Contructs vector with size "size" filled elements "value"
+ * \details Example: \snippet picontainers.cpp PIVector::PIVector
+
+ * \fn const Type & PIVector::at(ullong index) const;
+ * \brief Read-only access to element by index "index"
+ * \details Example: \snippet picontainers.cpp PIVector::at_c
+ * \sa \a operator[]
+
+ * \fn Type & PIVector::at(ullong index);
+ * \brief Full access to element by index "index"
+ * \details Example: \snippet picontainers.cpp PIVector::at
+ * \sa \a operator[]
+
+ * \fn const Type * PIVector::data(ullong index = 0) const;
+ * \brief Read-only pointer to element by index "index"
+ * \details Example: \snippet picontainers.cpp PIVector::data_c
+
+ * \fn Type * PIVector::data(ullong index = 0);
+ * \brief Pointer to element by index "index"
+ * \details Example: \snippet picontainers.cpp PIVector::data
+
+ * \fn ullong PIVector::size() const;
+ * \brief Elements count
+
+ * \fn int PIVector::size_s() const;
+ * \brief Elements count
+
+ * \fn bool PIVector::isEmpty() const;
+ * \brief Return \c "true" if vector is empty, i.e. size = 0
+
+ * \fn bool PIVector::has(const Type & t) const;
+
+ * \fn bool PIVector::contains(const Type & v) const;
+ * \brief Return \c "true" if vector has at least one element equal "t"
+
+ * \fn int PIVector::etries(const Type & t) const;
+ * \brief Return how many times element "t" appears in vector
+
+ * \fn static int PIVector::compare_func(const Type * t0, const Type * t1);
+ * \brief Standard compare function for type "Type". Return  0 if t0 = t1,  -1 if t0 < t1  and  1 if t0 > t1.
+
+ * \fn void PIVector::resize(ullong size, const Type & new_type = Type());
+ * \brief Resize vector to size "size"
+ * \details Elements removed from end of vector if new size < old size, or added new elements = "new_type" if new size > old size.\n
+ * Example: \snippet picontainers.cpp PIVector::resize
+ * \sa \a size(), \a clear()
+
+ * \fn PIVector<T> & PIVector::enlarge(ullong size);
+ * \brief Increase vector size with "size" elements
+
+ * \fn void PIVector::clear();
+ * \brief Clear vector. Equivalent to call <tt>"resize(0)"</tt>
+
+ * \fn PIVector<T> & PIVector::sort(CompareFunc compare = compare_func);
+ * \brief Sort vector using quick sort algorithm and standard compare function
+ * \details Example: \snippet picontainers.cpp PIVector::sort_0 
+ * With custom compare function: \snippet picontainers.cpp PIVector::sort_1
+
+ * \fn PIVector<T> & PIVector::fill(const Type & t);
+ * \brief Fill vector with elements "t" leave size is unchanged and return reference to vector
+ * \details Example: \snippet picontainers.cpp PIVector::fill
+
+ * \fn Type & PIVector::back();
+ * \brief Last element of the vector
+
+ * \fn const Type & PIVector::back() const;
+ * \brief Last element of the vector
+
+ * \fn Type & PIVector::front();
+ * \brief First element of the vector
+
+ * \fn const Type & PIVector::front() const;
+ * \brief First element of the vector
+
+ * \fn PIVector<T> & PIVector::push_back(const Type & t);
+ * \brief Add new element "t" at the end of vector and return reference to vector
+
+ * \fn PIVector<T> & PIVector::push_front(const Type & t);
+ * \brief Add new element "t" at the beginning of vector and return reference to vector
+
+ * \fn PIVector<T> & PIVector::pop_back();
+ * \brief Remove one element from the end of vector and return reference to vector
+
+ * \fn PIVector<T> & PIVector::pop_front();
+ * \brief Remove one element from the beginning of vector and return reference to vector
+
+ * \fn Type PIVector::take_back();
+ * \brief Remove one element from the end of vector and return it
+
+ * \fn Type PIVector::take_front();
+ * \brief Remove one element from the beginning of vector and return it
+
+ * \fn PIVector<T> & PIVector::remove(uint index);
+ * \brief Remove one element by index "index" and return reference to vector
+ * \details Example: \snippet picontainers.cpp PIVector::remove_0
+ * \sa \a removeOne(), \a removeAll()
+
+ * \fn PIVector<T> & PIVector::remove(uint index, uint count);
+ * \brief Remove "count" elements by first index "index" and return reference to vector
+ * \details Example: \snippet picontainers.cpp PIVector::remove_1
+ * \sa \a removeOne(), \a removeAll()
+
+ * \fn PIVector<T> & PIVector::removeOne(const Type & v);
+ * \brief Remove no more than one element equal "v" and return reference to vector
+ * \details Example: \snippet picontainers.cpp PIVector::removeOne
+ * \sa \a remove(), \a removeAll()
+
+ * \fn PIVector<T> & PIVector::removeAll(const Type & v);
+ * \brief Remove all elements equal "v" and return reference to vector
+ * \details Example: \snippet picontainers.cpp PIVector::removeAll
+ * \sa \a remove(), \a removeOne()
+
+ * \fn PIVector<T> & PIVector::insert(uint pos, const Type & t);
+ * \brief Insert element "t" after index "pos" and return reference to vector
+ * \details Example: \snippet picontainers.cpp PIVector::insert_0
+
+ * \fn PIVector<T> & PIVector::insert(uint pos, const PIVector<T> & t);
+ * \brief Insert other vector "t" after index "pos" and return reference to vector
+ * \details Example: \snippet picontainers.cpp PIVector::insert_1
+
+ * \fn Type & PIVector::operator [](uint index);
+ * \brief Full access to element by index "index"
+ * \details Example: \snippet picontainers.cpp PIVector::()
+ * \sa \a at()
+
+ * \fn const Type & PIVector::operator [](uint index) const;
+ * \brief Read-only access to element by index "index"
+ * \details Example: \snippet picontainers.cpp PIVector::()_c
+ * \sa \a at()
+
+ * \fn PIVector<T> & PIVector::operator <<(const Type & t);
+ * \brief Add new element "t" at the end of vector and return reference to vector
+
+ * \fn PIVector<T> & PIVector::operator <<(const PIVector<T> & t);
+ * \brief Add vector "t" at the end of vector and return reference to vector
+
+ * \fn bool PIVector::operator ==(const PIVector<T> & t);
+ * \brief Compare with vector "t"
+
+ * \fn bool PIVector::operator !=(const PIVector<T> & t);
+ * \brief Compare with vector "t"
+
+ * */

lib/main/containers/picontainers.h

@@ -0,0 +1,239 @@
+/*! \file picontainers.h
+ * \brief Base for generic containers
+ * 
+ * This file declare all containers and useful macros
+ * to use them
+*/
+/*
+	PIP - Platform Independent Primitives
+	Base for generic containers
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PICONTAINERS_H
+#define PICONTAINERS_H
+
+#include "picout.h"
+#include "piintrospection_containers.h"
+#ifdef PIP_DEBUG
+#  ifdef NDEBUG
+#    undef NDEBUG
+#  endif
+#  include <cassert>
+#endif
+#ifndef assert
+#  define assert(x)
+#endif
+#ifdef MAC_OS
+#  include <stdlib.h>
+#else
+#  include <malloc.h>
+#endif
+#include <string.h>
+#include <new>
+#ifndef PIP_MEMALIGN_BYTES
+#  define PIP_MEMALIGN_BYTES (sizeof(void*)*4)
+#endif
+#ifdef WINDOWS
+#  ifdef CC_GCC
+#    define amalloc(s) __mingw_aligned_malloc(s, PIP_MEMALIGN_BYTES)
+#    define afree(p) __mingw_aligned_free(p)
+#  else
+#    ifdef CC_VC
+#      define amalloc(s) _aligned_malloc(s, PIP_MEMALIGN_BYTES)
+#      define afree(p) _aligned_free(p)
+#    endif
+#  endif
+#else
+#  define amalloc(s) aligned_alloc(PIP_MEMALIGN_BYTES, s)
+#  define afree(p) free(p)
+#endif
+
+
+#ifdef DOXYGEN
+
+/*!\brief Macro for iterate any container
+ * \details Use this macros instead of standard "for"
+ * to get read/write access to each element of container.
+ * Pass direction is direct \n
+ * Example: \snippet picontainers.cpp foreach
+ */
+#  define piForeach(i,c)
+
+/*!\brief Macro for iterate any container only for read
+ * \details Use this macros instead of standard "for"
+ * to get read access to each element of container.
+ * Pass direction is direct \n
+ * Example: \snippet picontainers.cpp foreachC
+ */
+#  define piForeachC(i,c)
+
+/*!\brief Macro for iterate any container with reverse direction
+ * \details Use this macros instead of standard "for"
+ * to get read/write access to each element of container.
+ * Pass direction is reverse \n
+ * Example: \snippet picontainers.cpp foreachR
+ */
+#  define piForeachR(i,c)
+
+/*!\brief Macro for iterate any container only for read with reverse direction
+ * \details Use this macros instead of standard "for"
+ * to get read access to each element of container.
+ * Pass direction is reverse \n
+ * Example: \snippet picontainers.cpp foreachCR
+ */
+#  define piForeachCR(i,c)
+
+/*!\brief Macro for break from any piForeach* loop
+ * \details \warning C++ ordinary "break" doesn`t work inside piForeach*
+ * loops! Always use "piBreak" instead!
+ */
+#  define piBreak
+
+#else
+
+#  define piBreak {_for._end = true; break;}
+
+#  define piForTimes(c) for(int _i##c = 0; _i##c < c; ++_i##c)
+
+#ifdef CC_GCC
+
+template<typename Type>
+class _PIForeach {
+public:
+	_PIForeach(Type & t): _t(t), _break(false), _end(false) {_it = _t.begin();}
+	typename Type::value_type _var;
+	typename Type::iterator _it;
+	Type & _t;
+	bool _break, _end;
+	inline bool isEnd() {return _it == _t.end();}
+	inline void operator ++() {if (_end) _it = _t.end(); else _it++; _break = false;}
+};
+
+template<typename Type>
+class _PIForeachR {
+public:
+	_PIForeachR(Type & t): _t(t), _break(false), _end(false) {_rit = _t.rbegin();}
+	typename Type::value_type _var;
+	typename Type::reverse_iterator _rit;
+	Type & _t;
+	bool _break, _end;
+	inline bool isEnd() {return _rit == _t.rend();}
+	inline void operator ++() {if (_end) _rit = _t.rend(); else _rit++; _break = false;}
+};
+
+template<typename Type>
+class _PIForeachC {
+public:
+	_PIForeachC(const Type & t): _t(t), _break(false), _end(false) {_it = _t.begin();}
+	typename Type::value_type _var;
+	typename Type::const_iterator _it;
+	const Type & _t;
+	bool _break, _end;
+	inline bool isEnd() {return _it == _t.end();}
+	inline void operator ++() {if (_end) _it = _t.end(); else _it++; _break = false;}
+};
+
+template<typename Type>
+class _PIForeachCR {
+public:
+	_PIForeachCR(const Type & t): _t(t), _break(false), _end(false) {_rit = _t.rbegin();}
+	typename Type::value_type _var;
+	typename Type::const_reverse_iterator _rit;
+	const Type & _t;
+	bool _break, _end;
+	inline bool isEnd() {return _rit == _t.rend();}
+	inline void operator ++() {if (_end) _rit = _t.rend(); else _rit++; _break = false;}
+};
+
+#define piForeach(i,c) for(_PIForeach<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(i(*_for._it); !_for._break; _for._break = true)
+#define piForeachR(i,c) for(_PIForeachR<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(i(*_for._rit); !_for._break; _for._break = true)
+#define piForeachA(i,c) for(_PIForeach<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(typeof(_for._var) & i(*_for._it); !_for._break; _for._break = true)
+#define piForeachAR(i,c) for(_PIForeachR<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(typeof(_for._var) & i(*_for._rit); !_for._break; _for._break = true)
+#define piForeachC(i,c) for(_PIForeachC<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(const i(*_for._it); !_for._break; _for._break = true)
+#define piForeachCR(i,c) for(_PIForeachCR<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(const i(*_for._rit); !_for._break; _for._break = true)
+#define piForeachCA(i,c) for(_PIForeachC<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(const typeof(_for._var) & i(*_for._it); !_for._break; _for._break = true)
+#define piForeachCAR(i,c) for(_PIForeachCR<typeof(c)> _for(c); !_for.isEnd(); ++_for) \
+							for(const typeof(_for._var) & i(*_for._rit); !_for._break; _for._break = true)
+
+#define piForeachRA piForeachAR
+#define piForeachAC piForeachCA
+#define piForeachCRA piForeachCAR
+#define piForeachARC piForeachCAR
+#define piForeachACR piForeachCAR
+#define piForeachRCA piForeachCAR
+#define piForeachRAC piForeachCAR
+
+#else
+
+class _PIForeachBase {public: mutable bool _break, _end; };
+
+template<typename Type>
+class _PIForeach: public _PIForeachBase {
+public:
+	_PIForeach(Type & t, bool i = false): _t(t), _inv(i) {_break = _end = false; if (_inv) _rit = _t.rbegin(); else _it = _t.begin();}
+	mutable typename Type::value_type _var;
+	mutable typename Type::iterator _it;
+	mutable typename Type::reverse_iterator _rit;
+	Type & _t;
+	bool _inv;
+	bool isEnd() {if (_inv) return _rit == _t.rend(); else return _it == _t.end();}
+	void operator ++() {if (_inv) {if (_end) _rit = _t.rend(); else _rit++;} else {if (_end) _it = _t.end(); else _it++;} _break = false;}
+};
+
+template<typename Type>
+class _PIForeachC: public _PIForeachBase {
+public:
+	_PIForeachC(const Type & t, bool i = false): _t(t), _inv(i) {_break = _end = false; if (_inv) _rit = _t.rbegin(); else _it = _t.begin();}
+	mutable typename Type::value_type _var;
+	mutable typename Type::const_iterator _it;
+	mutable typename Type::const_reverse_iterator _rit;
+	const Type & _t;
+	bool _inv;
+	bool isEnd() {if (_inv) return _rit == _t.rend(); else return _it == _t.end();}
+	void operator ++() {if (_inv) {if (_end) _rit = _t.rend(); else _rit++;} else {if (_end) _it = _t.end(); else _it++;} _break = false;}
+};
+
+template <typename T> inline _PIForeach<T> _PIForeachNew(T & t, bool i = false) {return _PIForeach<T>(t, i);}
+template <typename T> inline _PIForeach<T> * _PIForeachCast(_PIForeachBase & c, T & ) {return static_cast<_PIForeach<T> * >(&c);}
+
+template <typename T> inline _PIForeachC<T> _PIForeachNewC(const T & t, bool i = false) {return _PIForeachC<T>(t, i);}
+template <typename T> inline _PIForeachC<T> * _PIForeachCastC(_PIForeachBase & c, const T & ) {return static_cast<_PIForeachC<T> * >(&c);}
+
+#define piForeach(i,c) for(_PIForeachBase & _for = _PIForeachNew(c); !_PIForeachCast(_for, c)->isEnd(); ++(*_PIForeachCast(_for, c))) \
+							for(i = *(_PIForeachCast(_for, c)->_it); !_for._break; _for._break = true)
+#define piForeachR(i,c) for(_PIForeachBase & _for = _PIForeachNew(c, true); !_PIForeachCast(_for, c)->isEnd(); ++(*_PIForeachCast(_for, c))) \
+							for(i = *(_PIForeachCast(_for, c)->_rit); !_for._break; _for._break = true)
+#define piForeachC(i,c) for(_PIForeachBase & _for = _PIForeachNewC(c); !_PIForeachCastC(_for, c)->isEnd(); ++(*_PIForeachCastC(_for, c))) \
+							for(const i = *(_PIForeachCastC(_for, c)->_it); !_for._break; _for._break = true)
+#define piForeachCR(i,c) for(_PIForeachBase & _for = _PIForeachNewC(c, false); !_PIForeachCastC(_for, c)->isEnd(); ++(*_PIForeachCastC(_for, c))) \
+							for(const i = *(_PIForeachCastC(_for, c)->_rit); !_for._break; _for._break = true)
+
+#endif
+
+#define piForeachRC piForeachCR
+
+#endif // DOXYGEN
+
+
+#endif // PICONTAINERS_H

lib/main/containers/picontainersmodule.h

@@ -0,0 +1,31 @@
+/*
+	PIP - Platform Independent Primitives
+	Module includes
+	Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PICONTAINERSMODULE_H
+#define PICONTAINERSMODULE_H
+
+#include "pivector.h"
+#include "pideque.h"
+#include "pimap.h"
+#include "piqueue.h"
+#include "piset.h"
+#include "pistack.h"
+#include "pivector2d.h"
+
+#endif // PICONTAINERSMODULE_H

lib/main/containers/pideque.h

@@ -0,0 +1,542 @@
+/*! \file pideque.h
+ * \brief Dynamic array of any type
+ *
+ * This file declares PIDeque
+*/
+/*
+	PIP - Platform Independent Primitives
+	Dynamic array of any type
+	Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PIDEQUE_H
+#define PIDEQUE_H
+
+#include "picontainers.h"
+
+
+template <typename T>
+class PIDeque {
+public:
+	inline PIDeque(): pid_data(0), pid_size(0), pid_rsize(0), pid_start(0) {
+		//piCout << "PIDeque";
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+	}
+	inline PIDeque(const PIDeque<T> & other): pid_data(0), pid_size(0), pid_rsize(0), pid_start(0) {
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+		alloc(other.pid_size, true);
+		newT(pid_data + pid_start, other.pid_data + other.pid_start, pid_size);
+	}
+	inline PIDeque(const T * data, size_t size): pid_data(0), pid_size(0), pid_rsize(0), pid_start(0) {
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+		alloc(size, true);
+		newT(pid_data + pid_start, data, pid_size);
+	}
+	inline PIDeque(size_t pid_size, const T & f = T()): pid_data(0), pid_size(0), pid_rsize(0), pid_start(0) {
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+		resize(pid_size, f);
+	}
+	inline virtual ~PIDeque() {
+		//piCout << "~PIDeque";
+		PIINTROSPECTION_CONTAINER_DELETE(T)
+		PIINTROSPECTION_CONTAINER_FREE(T, (pid_rsize))
+		deleteT(pid_data + pid_start, pid_size);
+		dealloc();
+		_reset();
+	}
+
+	inline PIDeque<T> & operator =(const PIDeque<T> & other) {
+		if (this == &other) return *this;
+		deleteT(pid_data + pid_start, pid_size);
+		alloc(other.pid_size, true);
+		newT(pid_data + pid_start, other.pid_data + other.pid_start, pid_size);
+		return *this;
+	}
+
+	typedef T value_type;
+
+	class iterator {
+		friend class PIDeque<T>;
+	private:
+		inline iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		PIDeque<T> * parent;
+		size_t pos;
+	public:
+		inline iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const iterator & it) const {return (pos != it.pos);}
+	};
+
+	class const_iterator {
+		friend class PIDeque<T>;
+	private:
+		inline const_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		const PIDeque<T> * parent;
+		size_t pos;
+	public:
+		inline const_iterator(): parent(0), pos(0) {}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
+	};
+
+	class reverse_iterator {
+		friend class PIDeque<T>;
+	private:
+		inline reverse_iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		PIDeque<T> * parent;
+		size_t pos;
+	public:
+		inline reverse_iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
+	};
+
+	class const_reverse_iterator {
+		friend class PIDeque<T>;
+	private:
+		inline const_reverse_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
+		const PIDeque<T> * parent;
+		size_t pos;
+	public:
+		inline const_reverse_iterator(): parent(0), pos(0) {}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
+	};
+
+	inline iterator begin() {return iterator(this, 0);}
+	inline iterator end() {return iterator(this, pid_size);}
+	inline const_iterator begin() const {return const_iterator(this, 0);}
+	inline const_iterator end() const {return const_iterator(this, pid_size);}
+	inline reverse_iterator rbegin() {return reverse_iterator(this, pid_size - 1);}
+	inline reverse_iterator rend() {return reverse_iterator(this, -1);}
+	inline const_reverse_iterator rbegin() const {return const_reverse_iterator(this, pid_size - 1);}
+	inline const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
+
+	inline size_t size() const {return pid_size;}
+	inline ssize_t size_s() const {return pid_size;}
+	inline size_t length() const {return pid_size;}
+	inline size_t capacity() const {return pid_rsize;}
+	inline size_t _start() const {return pid_start;}
+	inline bool isEmpty() const {return (pid_size == 0);}
+
+	inline T & operator [](size_t index) {return pid_data[pid_start + index];}
+	inline T & at(size_t index) {return pid_data[pid_start + index];}
+	inline const T & operator [](size_t index) const {return pid_data[pid_start + index];}
+	inline const T & at(size_t index) const {return pid_data[pid_start + index];}
+	inline T & back() {return pid_data[pid_start + pid_size - 1];}
+	inline const T & back() const {return pid_data[pid_start + pid_size - 1];}
+	inline T & front() {return pid_data[pid_start];}
+	inline const T & front() const {return pid_data[pid_start];}
+	inline bool operator ==(const PIDeque<T> & t) const {
+		if (pid_size != t.pid_size) return false;
+		for (size_t i = 0; i < pid_size; ++i)
+			if (t[i] != (*this)[i])
+				return false;
+		return true;
+	}
+	inline bool operator !=(const PIDeque<T> & t) const {return !(*this == t);}
+	inline bool contains(const T & v) const {
+		for (size_t i = pid_start; i < pid_start + pid_size; ++i)
+			if (v == pid_data[i])
+				return true;
+		return false;
+	}
+	inline int etries(const T & v) const {
+		int ec = 0;
+		for (size_t i = pid_start; i < pid_start + pid_size; ++i)
+			if (v == pid_data[i]) ++ec;
+		return ec;
+	}
+	inline ssize_t indexOf(const T & v) const {
+		for (ssize_t i = pid_start; i < pid_start + (ssize_t)pid_size; ++i)
+			if (v == pid_data[i])
+				return i - pid_start;
+		return -1;
+	}
+	inline ssize_t lastIndexOf(const T & v) const {
+		for (ssize_t i = pid_start + (ssize_t)pid_size - 1; i >= pid_start; --i)
+			if (v == pid_data[i])
+				return i - pid_start;
+		return -1;
+	}
+
+	inline T * data(size_t index = 0) {return &(pid_data[pid_start + index]);}
+	inline const T * data(size_t index = 0) const {return &(pid_data[pid_start + index]);}
+
+	inline PIDeque<T> & clear() {resize(0); return *this;}
+	inline PIDeque<T> & fill(const T & f = T()) {
+		deleteT(pid_data + pid_start, pid_size);
+		PIINTROSPECTION_CONTAINER_USED(T, pid_size)
+		for (size_t i = pid_start; i < pid_start + pid_size; ++i)
+			elementNew(pid_data + i, f);
+		return *this;
+	}
+	inline PIDeque<T> & assign(const T & f = T()) {return fill(f);}
+	inline PIDeque<T> & assign(size_t new_size, const T & f) {
+		resize(new_size);
+		return fill(f);
+	}
+
+	inline PIDeque<T> & resize(size_t new_size, const T & f = T()) {
+		if (new_size < pid_size) {
+			deleteT(&(pid_data[new_size + pid_start]), pid_size - new_size);
+			pid_size = new_size;
+		}
+		if (new_size > pid_size) {
+			size_t os = pid_size;
+			alloc(new_size, true);
+			PIINTROSPECTION_CONTAINER_USED(T, (new_size-os))
+			for (size_t i = os + pid_start; i < new_size + pid_start; ++i) elementNew(pid_data + i, f);
+		}
+		return *this;
+	}
+	inline PIDeque<T> & _resizeRaw(size_t new_size) {
+		piCout << "Error, \"resizeRaw()\" only allowed for simple type declared with __PIDEQUE_SIMPLE_TYPE__ macro!";
+		assert(0);
+		return *this;
+	}
+
+	inline PIDeque<T> & reserve(size_t new_size) {
+		if (new_size <= pid_rsize) return *this;
+		size_t os = pid_size;
+		alloc(new_size, true);
+		pid_size = os;
+		return *this;
+	}
+
+	inline PIDeque<T> & insert(size_t index, const T & v = T()) {
+		bool dir = pid_rsize <= 2 ? true : (index >= pid_rsize / 2 ? true : false);
+		if (dir) {
+			alloc(pid_size + 1, true);
+			if (index < pid_size - 1) {
+				size_t os = pid_size - index - 1;
+				memmove((void*)(&(pid_data[index + pid_start + 1])), (const void*)(&(pid_data[index + pid_start])), os * sizeof(T));
+			}
+		} else {
+			alloc(pid_size + 1, false, -1);
+			if (index > 0)
+				memmove((void*)(&(pid_data[pid_start])), (const void*)(&(pid_data[pid_start + 1])), index * sizeof(T));
+		}
+		PIINTROSPECTION_CONTAINER_USED(T, 1)
+		elementNew(pid_data + pid_start + index, v);
+		return *this;
+	}
+	inline PIDeque<T> & insert(size_t index, const PIDeque<T> & other) {
+		if (other.isEmpty()) return *this;
+		assert(&other != this);
+		bool dir = pid_rsize <= 2 ? true : (index >= pid_rsize / 2 ? true : false);
+		if (dir) {
+			ssize_t os = pid_size - index;
+			alloc(pid_size + other.pid_size, true);
+			if (os > 0)
+				memmove((void*)(&(pid_data[index + pid_start + other.pid_size])), (const void*)(&(pid_data[index + pid_start])), os * sizeof(T));
+		} else {
+			alloc(pid_size + other.pid_size, false, -other.pid_size);
+			if (index > 0)
+				memmove((void*)(&(pid_data[pid_start])), (const void*)(&(pid_data[pid_start + other.pid_size])), index * sizeof(T));
+		}
+		newT(pid_data + pid_start + index, other.pid_data + other.pid_start, other.pid_size);
+		return *this;
+	}
+
+	inline PIDeque<T> & remove(size_t index, size_t count = 1) {
+		if (count == 0) return *this;
+		if (index + count >= pid_size) {
+			resize(index);
+			return *this;
+		}
+		size_t os = pid_size - index - count;
+		deleteT(&(pid_data[index + pid_start]), count);
+		if (os <= index) {
+			if (os > 0) memmove((void*)(&(pid_data[index + pid_start])), (const void*)(&(pid_data[index + pid_start + count])), os * sizeof(T));
+		} else {
+			if (index > 0) memmove((void*)(&(pid_data[pid_start + count])), (const void*)(&(pid_data[pid_start])), index * sizeof(T));
+			pid_start += count;
+		}
+		pid_size -= count;
+		return *this;
+	}
+
+	inline void swap(PIDeque<T> & other) {
+		piSwap<T*>(pid_data, other.pid_data);
+		piSwap<size_t>(pid_size, other.pid_size);
+		piSwap<size_t>(pid_rsize, other.pid_rsize);
+		piSwap<ssize_t>(pid_start, other.pid_start);
+	}
+
+	typedef int (*CompareFunc)(const T * , const T * );
+	static int compare_func(const T * t0, const T * t1) {return (*t0) < (*t1) ? -1 : ((*t0) == (*t1) ? 0 : 1);}
+	inline PIDeque<T> & sort(CompareFunc compare = compare_func) {
+		piqsort(pid_data + pid_start, pid_size, sizeof(T), (int(*)(const void * , const void * ))compare);
+		return *this;
+	}
+
+	inline PIDeque<T> & enlarge(llong pid_size) {
+		llong ns = size_s() + pid_size;
+		if (ns <= 0) clear();
+		else resize(size_t(ns));
+		return *this;
+	}
+
+	inline PIDeque<T> & removeOne(const T & v) {
+		for (size_t i = 0; i < pid_size; ++i)
+			if (pid_data[i + pid_start] == v) {
+				remove(i);
+				return *this;
+			}
+		return *this;
+	}
+	inline PIDeque<T> & removeAll(const T & v) {
+		for (ssize_t i = 0; i < ssize_t(pid_size); ++i)
+			if (pid_data[i + pid_start] == v) {
+				remove(i);
+				--i;
+			}
+		return *this;
+	}
+
+	inline PIDeque<T> & push_back(const T & v) {
+		alloc(pid_size + 1, true);
+		PIINTROSPECTION_CONTAINER_USED(T, 1);
+		elementNew(pid_data + pid_start + pid_size - 1, v);
+		return *this;
+	}
+	inline PIDeque<T> & append(const T & v) {return push_back(v);}
+	inline PIDeque<T> & append(const PIDeque<T> & t) {
+		assert(&t != this);
+		size_t ps = pid_size;
+		alloc(pid_size + t.pid_size, true);
+		newT(pid_data + ps + pid_start, t.pid_data + t.pid_start, t.pid_size);
+		return *this;
+	}
+	inline PIDeque<T> & operator <<(const T & v) {return push_back(v);}
+	inline PIDeque<T> & operator <<(const PIDeque<T> & t) {return append(t);}
+
+	inline PIDeque<T> & push_front(const T & v) {insert(0, v); return *this;}
+	inline PIDeque<T> & prepend(const T & v) {return push_front(v);}
+
+	inline PIDeque<T> & pop_back() {if (pid_size == 0) return *this; resize(pid_size - 1); return *this;}
+	inline PIDeque<T> & pop_front() {if (pid_size == 0) return *this; remove(0); return *this;}
+
+	inline T take_back() {T t(back()); pop_back(); return t;}
+	inline T take_front() {T t(front()); pop_front(); return t;}
+
+	template <typename ST>
+	PIDeque<ST> toType() const {
+		PIDeque<ST> ret(pid_size);
+		for (uint i = 0; i < pid_size; ++i)
+			ret[i] = ST(pid_data[i + pid_start]);
+		return ret;
+	}
+
+#ifdef PIP_CXX11_SUPPORT
+	const PIDeque<T> & forEach(std::function<void(const T &)> f) const {
+		for (uint i = 0; i < pid_size; ++i)
+			f(pid_data[i + pid_start]);
+		return *this;
+	}
+	PIDeque<T> copyForEach(std::function<T(const T &)> f) const {
+		PIDeque<T> ret; ret.reserve(pid_size);
+		for (uint i = 0; i < pid_size; ++i)
+			ret << f(pid_data[i + pid_start]);
+		return ret;
+	}
+	PIDeque<T> & forEachInplace(std::function<T(const T &)> f) {
+		for (uint i = 0; i < pid_size; ++i)
+			pid_data[i + pid_start] = f(pid_data[i + pid_start]);
+		return *this;
+	}
+	template <typename ST>
+	PIDeque<ST> toType(std::function<ST(const T &)> f) const {
+		PIDeque<ST> ret; ret.reserve(pid_size);
+		for (uint i = 0; i < pid_size; ++i)
+			ret << f(pid_data[i + pid_start]);
+		return ret;
+	}
+#endif
+
+private:
+	inline void _reset() {pid_size = pid_rsize = pid_start = 0; pid_data = 0;}
+	inline size_t asize(ssize_t s) {
+		if (s <= 0) return 0;
+		if (pid_rsize + pid_rsize >= size_t(s) && pid_rsize < size_t(s))
+			return pid_rsize + pid_rsize;
+		ssize_t t = 0, s_ = s - 1;
+		while (s_ >> t)
+			++t;
+		return (1 << t);
+	}
+	inline void newT(T * dst, const T * src, size_t s) {
+		PIINTROSPECTION_CONTAINER_USED(T, s)
+		for (size_t i = 0; i < s; ++i)
+			elementNew(dst + i, src[i]);
+	}
+	inline void deleteT(T * d, size_t sz) {
+		PIINTROSPECTION_CONTAINER_UNUSED(T, sz)
+		if ((uchar*)d != 0) {
+			for (size_t i = 0; i < sz; ++i)
+				elementDelete(d[i]);
+		}
+	}
+	inline void elementNew(T * to, const T & from) {new(to)T(from);}
+	inline void elementDelete(T & from) {from.~T();}
+	inline void dealloc() {
+		if ((uchar*)pid_data != 0) free((uchar*)pid_data);
+		pid_data = 0;
+	}
+	inline void checkMove(bool direction) {
+		if (pid_size >= 4) {
+			if (pid_size < pid_rsize / 6) {
+				if (pid_start < ssize_t(pid_size + pid_size) || pid_start > (ssize_t(pid_rsize) - ssize_t(pid_size) - ssize_t(pid_size))) {
+					ssize_t ns = (pid_rsize - pid_size) / 2;
+					if (pid_start != ns) {
+						memmove((void*)(pid_data + ns), (const void*)(pid_data + pid_start), pid_size * sizeof(T));
+						pid_start = ns;
+					}
+				}
+			}
+		} else {
+			ssize_t ns = (pid_rsize - pid_size) / 2;
+			if (pid_start != ns) {
+				memmove((void*)(pid_data + ns), (const void*)(pid_data + pid_start), pid_size * sizeof(T));
+				pid_start = ns;
+			}
+		}
+	}
+	inline void alloc(size_t new_size, bool direction, ssize_t start_offset = 0) { // direction == true -> alloc forward
+		if (direction) {
+			if (pid_start + new_size <= pid_rsize) {
+				pid_size = new_size;
+				checkMove(direction);
+				return;
+			}
+			pid_size = new_size;
+			size_t as = asize(pid_start + new_size);
+			if (as != pid_rsize) {
+				PIINTROSPECTION_CONTAINER_ALLOC(T, (as-pid_rsize))
+				T * p_d = (T*)(realloc((void*)(pid_data), as*sizeof(T)));
+				assert(p_d);
+				pid_data = p_d;
+				pid_rsize = as;
+			}
+		} else {
+			size_t as;
+			if (pid_start + start_offset < 0)
+				as = asize(pid_rsize - start_offset);
+			else as = pid_rsize;
+
+			if (as > pid_rsize) {
+				T * td = (T*)(malloc(as * sizeof(T)));
+				ssize_t ns = pid_start + as - pid_rsize;
+				PIINTROSPECTION_CONTAINER_ALLOC(T, (as-pid_rsize))
+				if (pid_rsize > 0 && pid_data != 0) {
+					memcpy((void*)(td + ns), (const void*)(pid_data + pid_start), pid_size * sizeof(T));
+					dealloc();
+				}
+				pid_data = td;
+				pid_rsize = as;
+				pid_start = ns;
+			}
+			pid_start += start_offset;
+			pid_size = new_size;
+			checkMove(direction);
+		}
+	}
+
+	T * pid_data;
+	size_t pid_size, pid_rsize;
+	ssize_t pid_start;
+};
+
+#define __PIDEQUE_SIMPLE_TYPE__(T) \
+	template<> inline void PIDeque<T>::newT(T * dst, const T * src, size_t s) {PIINTROSPECTION_CONTAINER_USED(T, s); memcpy((void*)(dst), (const void*)(src), s * sizeof(T));} \
+	template<> inline void PIDeque<T>::deleteT(T *, size_t sz) {PIINTROSPECTION_CONTAINER_UNUSED(T, sz);} \
+	template<> inline void PIDeque<T>::elementNew(T * to, const T & from) {(*to) = from;} \
+	template<> inline void PIDeque<T>::elementDelete(T &) {;} \
+	template<> inline PIDeque<T> & PIDeque<T>::_resizeRaw(size_t new_size) { \
+		if (new_size > pid_size) { \
+			PIINTROSPECTION_CONTAINER_USED(T, (new_size-pid_size)); \
+		} \
+		if (new_size < pid_size) { \
+			PIINTROSPECTION_CONTAINER_UNUSED(T, (pid_size-new_size)); \
+		} \
+		alloc(new_size, true); \
+		return *this; \
+	} \
+	template<> inline PIDeque<T> & PIDeque<T>::clear() {PIINTROSPECTION_CONTAINER_UNUSED(T, pid_size); pid_size = 0; return *this;} \
+	template<> inline PIDeque<T> & PIDeque<T>::assign(size_t new_size, const T & f) {_resizeRaw(new_size); return fill(f);}
+
+
+__PIDEQUE_SIMPLE_TYPE__(bool)
+__PIDEQUE_SIMPLE_TYPE__(char)
+__PIDEQUE_SIMPLE_TYPE__(uchar)
+__PIDEQUE_SIMPLE_TYPE__(short)
+__PIDEQUE_SIMPLE_TYPE__(ushort)
+__PIDEQUE_SIMPLE_TYPE__(int)
+__PIDEQUE_SIMPLE_TYPE__(uint)
+__PIDEQUE_SIMPLE_TYPE__(long)
+__PIDEQUE_SIMPLE_TYPE__(ulong)
+__PIDEQUE_SIMPLE_TYPE__(llong)
+__PIDEQUE_SIMPLE_TYPE__(ullong)
+__PIDEQUE_SIMPLE_TYPE__(float)
+__PIDEQUE_SIMPLE_TYPE__(double)
+__PIDEQUE_SIMPLE_TYPE__(ldouble)
+
+
+#ifdef PIP_STD_IOSTREAM
+template<typename T>
+inline std::ostream & operator <<(std::ostream & s, const PIDeque<T> & v) {s << "{"; for (size_t i = 0; i < v.size(); ++i) {s << v[i]; if (i < v.size() - 1) s << ", ";} s << "}"; return s;}
+#endif
+
+template<typename T>
+inline PICout operator <<(PICout s, const PIDeque<T> & v) {
+	s.space();
+	s.setControl(0, true);
+	s << "{";
+	for (size_t i = 0; i < v.size(); ++i) {
+		s << v[i];
+		if (i < v.size() - 1)
+			s << ", ";
+	}
+	s << "}";
+	s.restoreControl();
+	return s;
+}
+
+
+#endif // PIDEQUE_H

lib/main/containers/pimap.h

@@ -0,0 +1,346 @@
+/*! \file pimap.h
+ * \brief Associative array with custom types of key and value
+ * 
+ * This file declares PIMap
+*/
+/*
+	PIP - Platform Independent Primitives
+	Associative array with custom types of key and value
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PIMAP_H
+#define PIMAP_H
+
+#include "pivector.h"
+#include "pideque.h"
+#include "pipair.h"
+#  define __PICONTAINERS_SIMPLE_TYPE__(T) \
+__PIDEQUE_SIMPLE_TYPE__(T)\
+__PIVECTOR_SIMPLE_TYPE__(T)
+
+
+template<class T>
+void piQuickSort(T * a, ssize_t N) {
+	if (N < 1) return;
+	if (N < 46) {
+		T tmp;
+		ssize_t i,j;
+		for(i=1; i<=N; i++) {
+			tmp = a[i];
+			j = i-1;
+			while(tmp<a[j] && j>=0) {
+				a[j+1] = a[j];
+				j = j-1;
+			}
+			a[j+1] = tmp;
+		}
+	} else {
+		ssize_t i = 0, j = N;
+		T & p(a[N >> 1]);
+		do {
+			while (a[i] < p) i++;
+			while (a[j] > p) j--;
+			if (i <= j) {
+				if (i != j) {
+					//piCout << "swap" << i << j << a[i] << a[j];
+					piSwapBinary<T>(a[i], a[j]);
+				}
+				i++; j--;
+			}
+		} while (i <= j);
+		if (j > 0) piQuickSort(a, j);
+		if (N > i) piQuickSort(a + i, N - i);
+	}
+}
+
+template <typename Key, typename T>
+class PIMap {
+	template <typename Key1, typename T1> friend PIByteArray & operator >>(PIByteArray & s, PIMap<Key1, T1> & v);
+	template <typename Key1, typename T1> friend PIByteArray & operator <<(PIByteArray & s, const PIMap<Key1, T1> & v);
+public:
+	PIMap() {;}
+	PIMap(const PIMap<Key, T> & other) {*this = other;}
+	virtual ~PIMap() {;}
+
+	PIMap<Key, T> & operator =(const PIMap<Key, T> & other) {
+		if (this == &other) return *this;
+		clear();
+		pim_content = other.pim_content;
+		pim_index = other.pim_index;
+		return *this;
+	}
+
+	typedef T mapped_type;
+	typedef Key key_type;
+	typedef PIPair<Key, T> value_type;
+	
+	class iterator {
+		friend class PIMap<Key, T>;
+	private:
+		iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
+		const PIMap<Key, T> * parent;
+		ssize_t pos;
+	public:
+		iterator(): parent(0), pos(0) {}
+		const Key & key() const {return const_cast<PIMap<Key, T> * >(parent)->_key(pos);}
+		T & value() {return const_cast<PIMap<Key, T> * >(parent)->_value(pos);}
+		void operator ++() {++pos;}
+		void operator ++(int) {++pos;}
+		void operator --() {--pos;}
+		void operator --(int) {--pos;}
+		bool operator ==(const iterator & it) const {return (pos == it.pos);}
+		bool operator !=(const iterator & it) const {return (pos != it.pos);}
+	};
+	
+	class reverse_iterator {
+		friend class PIMap<Key, T>;
+	private:
+		reverse_iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
+		const PIMap<Key, T> * parent;
+		ssize_t pos;
+	public:
+		reverse_iterator(): parent(0), pos(0) {}
+		const Key & key() const {return const_cast<PIMap<Key, T> * >(parent)->_key(pos);}
+		T & value() const {return const_cast<PIMap<Key, T> * >(parent)->_value(pos);}
+		void operator ++() {--pos;}
+		void operator ++(int) {--pos;}
+		void operator --() {++pos;}
+		void operator --(int) {++pos;}
+		bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
+		bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
+	};
+	
+	class const_iterator {
+		friend class PIMap<Key, T>;
+	private:
+		const_iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
+		const PIMap<Key, T> * parent;
+		ssize_t pos;
+	public:
+		const_iterator(): parent(0), pos(0) {}
+		const value_type operator *() const {return parent->_pair(pos);}
+		const value_type* operator ->() const {cval = parent->_pair(pos); return &cval;}
+		const Key & key() const {return const_cast<PIMap<Key, T> * >(parent)->_key(pos);}
+		const T & value() const {return const_cast<PIMap<Key, T> * >(parent)->_value(pos);}
+		void operator ++() {++pos;}
+		void operator ++(int) {++pos;}
+		void operator --() {--pos;}
+		void operator --(int) {--pos;}
+		bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
+		bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
+		mutable value_type cval;
+	};
+	
+	class const_reverse_iterator {
+		friend class PIMap<Key, T>;
+	private:
+		const_reverse_iterator(const PIMap<Key, T> * v, ssize_t p): parent(v), pos(p) {}
+		const PIMap<Key, T> * parent;
+		ssize_t pos;
+	public:
+		const_reverse_iterator(): parent(0), pos(0) {}
+		const value_type operator *() const {return parent->_pair(pos);}
+		const value_type* operator ->() const {cval = parent->_pair(pos); return &cval;}
+		void operator ++() {--pos;}
+		void operator ++(int) {--pos;}
+		void operator --() {++pos;}
+		void operator --(int) {++pos;}
+		bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
+		bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
+		mutable value_type cval;
+	};
+
+ 	iterator begin() {return iterator(this, 0);}
+ 	iterator end() {return iterator(this, size());}
+	const_iterator begin() const {return const_iterator(this, 0);}
+	const_iterator end() const {return const_iterator(this, size());}
+	const_iterator constBegin() const {return const_iterator(this, 0);}
+	const_iterator constEnd() const {return const_iterator(this, size());}
+ 	reverse_iterator rbegin() {return reverse_iterator(this, size() - 1);}
+ 	reverse_iterator rend() {return reverse_iterator(this, -1);}
+	const_reverse_iterator rbegin() const {return const_reverse_iterator(this, size() - 1);}
+	const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
+	const_reverse_iterator constRbegin() const {return const_reverse_iterator(this, size() - 1);}
+	const_reverse_iterator constRend() const {return const_reverse_iterator(this, -1);}
+
+	size_t size() const {return pim_content.size();}
+	int size_s() const {return pim_content.size_s();}
+	size_t length() const {return pim_content.size();}
+	bool isEmpty() const {return (pim_content.size() == 0);}
+	
+	T & operator [](const Key & key) {
+		bool f(false);
+		ssize_t i = _find(key, f);
+		if (f) return pim_content[pim_index[i].index];
+		pim_content.push_back(T());
+		pim_index.insert(i, MapIndex(key, pim_content.size() - 1));
+		return pim_content.back();
+	}
+	const T operator [](const Key & key) const {bool f(false); ssize_t i = _find(key, f); if (f) return pim_content[pim_index[i].index]; return T();}
+	T & at(const Key & key) {return (*this)[key];}
+	const T at(const Key & key) const {return (*this)[key];}
+	
+	PIMap<Key, T> & operator <<(const PIMap<Key, T> & other) {
+		assert(&other != this);
+		if (other.isEmpty()) return *this;
+		if (other.size() == 1) {insert(other.pim_index[0].key, other.pim_content[0]); return *this;}
+		if (other.size() == 2) {insert(other.pim_index[0].key, other.pim_content[0]); insert(other.pim_index[1].key, other.pim_content[1]); return *this;}
+		for (int i = 0; i < other.pim_index.size_s(); ++i)
+			insert(other.pim_index[i].key, other.pim_content[other.pim_index[i].index]);
+		return *this;
+	}
+
+	bool operator ==(const PIMap<Key, T> & t) const {return (pim_content == t.pim_content && pim_index == t.pim_index);}
+	bool operator !=(const PIMap<Key, T> & t) const {return (pim_content != t.pim_content || pim_index != t.pim_index);}
+	bool contains(const Key & key) const {bool f(false); _find(key, f); return f;}
+
+	PIMap<Key, T> & reserve(size_t new_size) {pim_content.reserve(new_size); pim_index.reserve(new_size); return *this;}
+
+	PIMap<Key, T> & removeOne(const Key & key) {bool f(false); ssize_t i = _find(key, f); if (f) _remove(i); return *this;}
+	PIMap<Key, T> & remove(const Key & key) {return removeOne(key);}
+	PIMap<Key, T> & erase(const Key & key) {return removeOne(key);}
+	PIMap<Key, T> & clear() {pim_content.clear(); pim_index.clear(); return *this;}
+	
+	void swap(PIMap<Key, T> & other) {
+		piSwapBinary<PIVector<T> >(pim_content, other.pim_content);
+		piSwapBinary<PIDeque<MapIndex> >(pim_index, other.pim_index);
+	}
+
+	PIMap<Key, T> & insert(const Key & key, const T & value) {
+		bool f(false);
+		ssize_t i = _find(key, f);
+		//piCout << "insert key=" << key << "found=" << f << "index=" << i << "value=" << value;
+		if (f) {
+			pim_content[pim_index[i].index] = value;
+		} else {
+			pim_content.push_back(value);
+			pim_index.insert(i, MapIndex(key, pim_content.size() - 1));
+		}
+		return *this;
+	}
+	const T value(const Key & key, const T & default_ = T()) const {bool f(false); ssize_t i = _find(key, f); if (!f) return default_; return pim_content[pim_index[i].index];}
+	PIVector<T> values() const {return pim_content;}
+	Key key(const T & value_, const Key & default_ = Key()) const {for (int i = 0; i < pim_index.size_s(); ++i) if (pim_content[pim_index[i].index] == value_) return pim_index[i].key; return default_;}
+	PIVector<Key> keys() const {
+		PIVector<Key> ret;
+		for (int i = 0; i < pim_index.size_s(); ++i)
+			ret << pim_index[i].key;
+		return ret;
+	}
+	
+	void dump() {
+		piCout << "PIMap" << size() << "entries" << PICoutManipulators::NewLine << "content:";
+		for (size_t i = 0; i < pim_content.size(); ++i)
+			piCout << PICoutManipulators::Tab << i << ":" << pim_content[i];
+		piCout << "index:";
+		for (size_t i = 0; i < pim_index.size(); ++i)
+			piCout << PICoutManipulators::Tab << i << ":" << pim_index[i].key << "->" << pim_index[i].index;
+	}
+	
+protected:
+	struct MapIndex {
+		MapIndex(Key k = Key(), size_t i = 0): key(k), index(i) {;}
+		Key key;
+		size_t index;
+		bool operator ==(const MapIndex & s) const {return key == s.key;}
+		bool operator !=(const MapIndex & s) const {return key != s.key;}
+		bool operator <(const MapIndex & s) const {return key < s.key;}
+		bool operator >(const MapIndex & s) const {return key > s.key;}
+	};
+	template <typename Key1, typename T1> friend PIByteArray & operator >>(PIByteArray & s, PIDeque<typename PIMap<Key1, T1>::MapIndex> & v);
+	template <typename Key1, typename T1> friend PIByteArray & operator <<(PIByteArray & s, const PIDeque<typename PIMap<Key1, T1>::MapIndex> & v);
+
+	ssize_t binarySearch(ssize_t first, ssize_t last, const Key & key, bool & found) const {
+		ssize_t mid;
+		while (first <= last) {
+			mid = (first + last) / 2;
+			if (key > pim_index[mid].key) first = mid + 1;
+			else if (key < pim_index[mid].key) last = mid - 1;
+			else {found = true; return mid;}
+		}
+		found = false;
+		return first;
+	}
+	void _sort() {piQuickSort<MapIndex>(pim_index.data(), pim_index.size_s() - 1);}
+	ssize_t _find(const Key & k, bool & found) const {
+		if (pim_index.isEmpty()) {
+			found = false;
+			return 0;
+		}
+		return binarySearch(0, pim_index.size_s() - 1, k, found);
+	}
+	void _remove(ssize_t index) {
+		//if (index >= pim_index.size()) return;
+		size_t ci = pim_index[index].index, bi = pim_index.size() - 1;
+		pim_index.remove(index);
+		for (size_t i = 0; i < pim_index.size(); ++i)
+			if (pim_index[i].index == bi) {
+				pim_index[i].index = ci;
+				break;
+			}
+		piSwapBinary<T>(pim_content[ci], pim_content.back());
+		pim_content.resize(pim_index.size());
+	}
+	const value_type _pair(ssize_t index) const {
+		if (index < 0 || index >= pim_index.size_s())
+			return value_type();
+		//piCout << "_pair" << index << pim_index[index].index;
+		return value_type(pim_index[index].key, pim_content[pim_index[index].index]);
+	}
+	Key & _key(ssize_t index) {return pim_index[index].key;}
+	T & _value(ssize_t index) {return pim_content[pim_index[index].index];}
+	
+	PIVector<T> pim_content;
+	PIDeque<MapIndex> pim_index;
+};
+
+
+#ifdef PIP_STD_IOSTREAM
+template<typename Key, typename Type>
+inline std::ostream & operator <<(std::ostream & s, const PIMap<Key, Type> & v) {
+	s << "{";
+	bool first = true;
+	for (typename PIMap<Key, Type>::const_iterator i = v.begin(); i != v.end(); ++i) {
+		if (!first)
+			s << ", ";
+		first = false;
+		s << i->first << ": " << i->second;
+	}
+	s << "}";
+	return s;
+}
+#endif
+
+template<typename Key, typename Type>
+inline PICout operator <<(PICout s, const PIMap<Key, Type> & v) {
+	s.space();
+	s.setControl(0, true);
+	s << "{";
+	bool first = true;
+	for (typename PIMap<Key, Type>::const_iterator i = v.begin(); i != v.end(); ++i) {
+		if (!first)
+			s << ", ";
+		first = false;
+		s << i->first << ": " << i->second;
+	}
+	s << "}";
+	s.restoreControl();
+	return s;
+}
+
+
+#endif // PIMAP_H

lib/main/containers/pipair.h

@@ -0,0 +1,55 @@
+/*! \file pipair.h
+ * \brief pair
+ *
+ * This file declare PIPair
+*/
+/*
+	PIP - Platform Independent Primitives
+	pair
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PIPAIR_H
+#define PIPAIR_H
+
+#include "pibase.h"
+
+class PICout;
+
+template<typename Type0, typename Type1>
+class PIP_EXPORT PIPair {
+public:
+	PIPair() {first = Type0(); second = Type1();}
+	PIPair(const Type0 & value0, const Type1 & value1) {first = value0; second = value1;}
+	Type0 first;
+	Type1 second;
+};
+template<typename Type0, typename Type1>
+inline bool operator <(const PIPair<Type0, Type1> & value0, const PIPair<Type0, Type1> & value1) {return value0.first < value1.first;}
+template<typename Type0, typename Type1>
+inline bool operator ==(const PIPair<Type0, Type1> & value0, const PIPair<Type0, Type1> & value1) {return (value0.first == value1.first) && (value0.second == value1.second);}
+template<typename Type0, typename Type1>
+inline bool operator !=(const PIPair<Type0, Type1> & value0, const PIPair<Type0, Type1> & value1) {return (value0.first != value1.first) || (value0.second != value1.second);}
+
+#ifdef PIP_STD_IOSTREAM
+template<typename Type0, typename Type1>
+inline std::ostream & operator <<(std::ostream & s, const PIPair<Type0, Type1> & v) {s << "(" << v.first << ", " << v.second << ")"; return s;}
+#endif
+
+template<typename Type0, typename Type1>
+inline PICout operator <<(PICout s, const PIPair<Type0, Type1> & v) {s.space(); s.setControl(0, true); s << "(" << v.first << ", " << v.second << ")"; s.restoreControl(); return s;}
+
+#endif // PIPAIR_H

lib/main/containers/piqueue.h

@@ -0,0 +1,49 @@
+/*! \file pideque.h
+ * \brief Queue container
+ * 
+ * This file declare PIQueue
+*/
+/*
+	PIP - Platform Independent Primitives
+	Queue container
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PIQUEUE_H
+#define PIQUEUE_H
+
+#include "pideque.h"
+#include "pivector.h"
+
+
+template<typename T>
+class PIP_EXPORT PIQueue: public PIDeque<T> {
+public:
+	PIQueue() {}
+	virtual ~PIQueue() {}
+	PIDeque<T> & enqueue(const T & v) {PIDeque<T>::push_front(v); return *this;}
+	T dequeue() {return PIDeque<T>::take_back();}
+	T & head() {return PIDeque<T>::back();}
+	const T & head() const {return PIDeque<T>::back();}
+	PIVector<T> toVector() {
+		PIVector<T> v(PIDeque<T>::size());
+		for (uint i = 0; i < PIDeque<T>::size(); ++i)
+			v[i] = PIDeque<T>::at(i);
+		return v;
+	}
+};
+
+#endif // PIQUEUE_H

lib/main/containers/piset.h

@@ -0,0 +1,161 @@
+/*! \file piset.h
+ * \brief Set container
+ * 
+ * This file declare PISet
+*/
+/*
+	PIP - Platform Independent Primitives
+	Set container
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PISET_H
+#define PISET_H
+
+#include "pimap.h"
+
+/*! \brief Set of any type
+ * \details This class used to store collection of unique elements
+ * of any type. You can only add values to set with \a operator<< or
+ * with function \a insert(). You can discover if value already in
+ * set with \a operator[] or with function \a find(). These function
+ * has logarithmic complexity.
+ */
+template <typename T>
+class PIP_EXPORT PISet: public PIMap<T, uchar> {
+	typedef PIMap<T, uchar> _CSet;
+public:
+	
+	//! Contructs an empty set
+	PISet() {}
+
+	virtual ~PISet() {;}
+
+	//! Contructs set with one element "value"
+	PISet(const T & value) {_CSet::insert(value, 0);}
+	
+	//! Contructs set with elements "v0" and "v1"
+	PISet(const T & v0, const T & v1) {_CSet::insert(v0, 0); _CSet::insert(v1, 0);}
+	
+	//! Contructs set with elements "v0", "v1" and "v2"
+	PISet(const T & v0, const T & v1, const T & v2) {_CSet::insert(v0, 0); _CSet::insert(v1, 0); _CSet::insert(v2, 0);}
+	
+	//! Contructs set with elements "v0", "v1", "v2" and "v3"
+	PISet(const T & v0, const T & v1, const T & v2, const T & v3) {_CSet::insert(v0, 0); _CSet::insert(v1, 0); _CSet::insert(v2, 0); _CSet::insert(v3, 0);}
+
+	//! Contructs set from vector of elements
+	PISet(const PIVector<T> & values) {
+		if (values.isEmpty()) return;
+		for (int i = 0; i < values.size_s(); ++i) {
+			_CSet::insert(values[i], 0);
+		}
+	}
+
+	//! Contructs set from deque of elements
+	PISet(const PIDeque<T> & values) {
+		if (values.isEmpty()) return;
+		for (int i = 0; i < values.size_s(); ++i) {
+			_CSet::insert(values[i], 0);
+		}
+	}
+
+	typedef T key_type;
+	
+	PISet<T> & operator <<(const T & t) {_CSet::insert(t, 0); return *this;}
+	PISet<T> & operator <<(const PISet<T> & other) {(*(_CSet*)this) << *((_CSet*)&other); return *this;}
+	
+	//! Returns if element "t" exists in this set
+	bool operator [](const T & t) const {return _CSet::contains(t);}
+	
+	//! Returns if element "t" exists in this set
+	PISet<T> & remove(const T & t) {_CSet::remove(t); return *this;}
+
+	//! Unite set with "v"
+	PISet<T> & unite(const PISet<T> & v) {
+		for (typename PIMap<T, uchar>::const_iterator i = v.begin(); i != v.end(); ++i)
+			_CSet::insert(i->first, 0);
+		return *this;
+	}
+
+	//! Subtract set with "v"
+	PISet<T> & subtract(const PISet<T> & v) {
+		for (typename PIMap<T, uchar>::const_iterator i = v.begin(); i != v.end(); ++i)
+			_CSet::remove(i->first);
+		return *this;
+	}
+
+	//! Intersect set with "v"
+	PISet<T> & intersect(const PISet<T> & v) {
+		for (typename _CSet::iterator i = _CSet::begin(); i != _CSet::end(); ++i)
+			if (!v.contains(i.key())) {
+				_CSet::remove(i.key());
+				--i;
+			}
+		return *this;
+	}
+
+	//! Unite set with "v"
+	PISet<T> & operator +=(const PISet<T> & v) {return unite(v);}
+
+	//! Unite set with "v"
+	PISet<T> & operator |=(const PISet<T> & v) {return unite(v);}
+
+	//! Subtract set with "v"
+	PISet<T> & operator -=(const PISet<T> & v) {return subtract(v);}
+
+	//! Intersect set with "v"
+	PISet<T> & operator &=(const PISet<T> & v) {return intersect(v);}
+
+	//! Returns content of set as PIVector
+	PIVector<T> toVector() const {PIVector<T> ret; for (typename _CSet::const_iterator i = _CSet::begin(); i != _CSet::end(); ++i) ret << (*i).first; return ret;}
+
+	//! Returns content of set as PIDeque
+	PIDeque<T> toDeque() const {PIDeque<T> ret; for (typename _CSet::const_iterator i = _CSet::begin(); i != _CSet::end(); ++i) ret << (*i).first; return ret;}
+
+};
+
+
+//! \relatesalso PISet \brief Returns unite of two sets
+template <typename T> PISet<T> operator +(const PISet<T> & v0, const PISet<T> & v1) {PISet<T> ret(v0); ret.unite(v1); return ret;}
+
+//! \relatesalso PISet \brief Returns subtraction of two sets
+template <typename T> PISet<T> operator -(const PISet<T> & v0, const PISet<T> & v1) {PISet<T> ret(v0); ret.subtract(v1); return ret;}
+
+//! \relatesalso PISet \brief Returns unite of two sets
+template <typename T> PISet<T> operator |(const PISet<T> & v0, const PISet<T> & v1) {PISet<T> ret(v0); ret.unite(v1); return ret;}
+
+//! \relatesalso PISet \brief Returns intersetion of two sets
+template <typename T> PISet<T> operator &(const PISet<T> & v0, const PISet<T> & v1) {PISet<T> ret(v0); ret.intersect(v1); return ret;}
+
+
+template<typename Type>
+inline PICout operator <<(PICout s, const PISet<Type> & v) {
+	s.space();
+	s.setControl(0, true);
+	s << "{";
+	bool first = true;
+	for (typename PIMap<Type, uchar>::const_iterator i = v.begin(); i != v.end(); ++i) {
+		if (!first)
+			s << ", ";
+		first = false;
+		s << i->first;
+	}
+	s << "}";
+	s.restoreControl();
+	return s;
+}
+
+#endif // PISET_H

lib/main/containers/pistack.h

@@ -0,0 +1,42 @@
+/*! \file pistack.h
+ * \brief Stack container
+ * 
+ * This file declare PIStack
+*/
+/*
+	PIP - Platform Independent Primitives
+	Stack container
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PISTACK_H
+#define PISTACK_H
+
+#include "pivector.h"
+
+template<typename T>
+class PIP_EXPORT PIStack: public PIVector<T> {
+public:
+	PIStack() {;}
+	virtual ~PIStack() {;}
+	PIVector<T> & push(const T & v) {PIVector<T>::push_back(v); return *this;}
+	T pop() {return PIVector<T>::take_back();}
+	T & top() {return PIVector<T>::back();}
+	const T & top() const {return PIVector<T>::back();}
+	PIVector<T> toVector() {PIVector<T> v(PIVector<T>::size()); for (uint i = 0; i < PIVector<T>::size(); ++i) v[i] = PIVector<T>::at(i); return v;}
+};
+
+#endif // PISTACK_H

lib/main/containers/pivector.h

@@ -0,0 +1,491 @@
+/*! \file pivector.h
+ * \brief Dynamic array of any type
+ *
+ * This file declares PIVector
+*/
+/*
+	PIP - Platform Independent Primitives
+	Dynamic array of any type
+	Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PIVECTOR_H
+#define PIVECTOR_H
+
+#include "picontainers.h"
+
+
+template <typename T>
+class PIVector {
+public:
+	inline PIVector(): piv_data(0), piv_size(0), piv_rsize(0) {
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+	}
+	inline PIVector(const T * data, size_t size): piv_data(0), piv_size(0), piv_rsize(0) {
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+		alloc(size);
+		newT(piv_data, data, piv_size);
+	}
+	inline PIVector(const PIVector<T> & other): piv_data(0), piv_size(0), piv_rsize(0) {
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+		alloc(other.piv_size);
+		newT(piv_data, other.piv_data, piv_size);
+	}
+	inline PIVector(size_t piv_size, const T & f = T()): piv_data(0), piv_size(0), piv_rsize(0) {
+		PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
+		resize(piv_size, f);
+	}
+	inline virtual ~PIVector() {
+		PIINTROSPECTION_CONTAINER_DELETE(T)
+		PIINTROSPECTION_CONTAINER_FREE(T, (piv_rsize))
+		deleteT(piv_data, piv_size);
+		dealloc();
+		_reset();
+	}
+
+	inline PIVector<T> & operator =(const PIVector<T> & other) {
+		if (this == &other) return *this;
+		clear();
+		deleteT(piv_data, piv_size);
+		alloc(other.piv_size);
+		newT(piv_data, other.piv_data, piv_size);
+		return *this;
+	}
+
+	typedef T value_type;
+
+	class iterator {
+		friend class PIVector<T>;
+	private:
+		inline iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		PIVector<T> * parent;
+		size_t pos;
+	public:
+		inline iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const iterator & it) const {return (pos != it.pos);}
+	};
+
+	class const_iterator {
+		friend class PIVector<T>;
+	private:
+		inline const_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		const PIVector<T> * parent;
+		size_t pos;
+	public:
+		inline const_iterator(): parent(0), pos(0) {}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {++pos;}
+		inline void operator ++(int) {++pos;}
+		inline void operator --() {--pos;}
+		inline void operator --(int) {--pos;}
+		inline bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
+	};
+
+	class reverse_iterator {
+		friend class PIVector<T>;
+	private:
+		inline reverse_iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		PIVector<T> * parent;
+		size_t pos;
+	public:
+		inline reverse_iterator(): parent(0), pos(0) {}
+		inline T & operator *() {return (*parent)[pos];}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
+	};
+
+	class const_reverse_iterator {
+		friend class PIVector<T>;
+	private:
+		inline const_reverse_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
+		const PIVector<T> * parent;
+		size_t pos;
+	public:
+		inline const_reverse_iterator(): parent(0), pos(0) {}
+		inline const T & operator *() const {return (*parent)[pos];}
+		inline void operator ++() {--pos;}
+		inline void operator ++(int) {--pos;}
+		inline void operator --() {++pos;}
+		inline void operator --(int) {++pos;}
+		inline bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
+		inline bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
+	};
+
+	inline iterator begin() {return iterator(this, 0);}
+	inline iterator end() {return iterator(this, piv_size);}
+	inline const_iterator begin() const {return const_iterator(this, 0);}
+	inline const_iterator end() const {return const_iterator(this, piv_size);}
+	inline reverse_iterator rbegin() {return reverse_iterator(this, piv_size - 1);}
+	inline reverse_iterator rend() {return reverse_iterator(this, -1);}
+	inline const_reverse_iterator rbegin() const {return const_reverse_iterator(this, piv_size - 1);}
+	inline const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
+
+	inline size_t size() const {return piv_size;}
+	inline ssize_t size_s() const {return piv_size;}
+	inline size_t length() const {return piv_size;}
+	inline size_t capacity() const {return piv_rsize;}
+	inline bool isEmpty() const {return (piv_size == 0);}
+
+	inline T & operator [](size_t index) {return piv_data[index];}
+	inline T & at(size_t index) {return piv_data[index];}
+	inline const T & operator [](size_t index) const {return piv_data[index];}
+	inline const T & at(size_t index) const {return piv_data[index];}
+	inline T & back() {return piv_data[piv_size - 1];}
+	inline const T & back() const {return piv_data[piv_size - 1];}
+	inline T & front() {return piv_data[0];}
+	inline const T & front() const {return piv_data[0];}
+	inline bool operator ==(const PIVector<T> & t) const {
+		if (piv_size != t.piv_size)
+			return false;
+		for (size_t i = 0; i < piv_size; ++i)
+			if (t[i] != piv_data[i])
+				return false;
+		return true;
+	}
+	inline bool operator !=(const PIVector<T> & t) const {return !(*this == t);}
+	inline bool contains(const T & v) const {
+		for (size_t i = 0; i < piv_size; ++i)
+			if (v == piv_data[i])
+				return true;
+		return false;
+	}
+	inline int etries(const T & v) const {
+		int ec = 0;
+		for (size_t i = 0; i < piv_size; ++i)
+			if (v == piv_data[i]) ++ec;
+		return ec;
+	}
+	inline ssize_t indexOf(const T & v) const {
+		for (size_t i = 0; i < piv_size; ++i)
+			if (v == piv_data[i])
+				return i;
+		return -1;
+	}
+	inline ssize_t lastIndexOf(const T & v) const {
+		for (ssize_t i = piv_size - 1; i >= 0; --i)
+			if (v == piv_data[i])
+				return i;
+		return -1;
+	}
+
+	inline T * data(size_t index = 0) {return &(piv_data[index]);}
+	inline const T * data(size_t index = 0) const {return &(piv_data[index]);}
+
+	inline PIVector<T> & clear() {resize(0); return *this;}
+	inline PIVector<T> & fill(const T & f = T()) {
+		deleteT(piv_data, piv_size);
+		PIINTROSPECTION_CONTAINER_USED(T, piv_size)
+		for (size_t i = 0; i < piv_size; ++i)
+			elementNew(piv_data + i, f);
+		return *this;
+	}
+	inline PIVector<T> & assign(const T & f = T()) {return fill(f);}
+	inline PIVector<T> & assign(size_t new_size, const T & f) {
+		resize(new_size);
+		return fill(f);
+	}
+
+	inline PIVector<T> & resize(size_t new_size, const T & f = T()) {
+		if (new_size < piv_size) {
+			T * de = &(piv_data[new_size]);
+			deleteT(de, piv_size - new_size);
+			piv_size = new_size;
+		}
+		if (new_size > piv_size) {
+			size_t os = piv_size;
+			alloc(new_size);
+			PIINTROSPECTION_CONTAINER_USED(T, (new_size-os))
+			for (size_t i = os; i < new_size; ++i)
+				elementNew(piv_data + i, f);
+		}
+		return *this;
+	}
+	inline PIVector<T> & _resizeRaw(size_t new_size) {
+		piCout << "Error, \"resizeRaw()\" only allowed for simple type declared with __PIVECTOR_SIMPLE_TYPE__ macro!";
+		assert(0);
+		return *this;
+	}
+	inline void _copyRaw(T * dst, const T * src, size_t size) {
+		newT(dst, src, size);
+	}
+
+	inline PIVector<T> & reserve(size_t new_size) {
+		if (new_size <= piv_rsize) return *this;
+		size_t os = piv_size;
+		alloc(new_size);
+		piv_size = os;
+		return *this;
+	}
+
+	inline PIVector<T> & insert(size_t index, const T & v = T()) {
+		alloc(piv_size + 1);
+		if (index < piv_size - 1) {
+			size_t os = piv_size - index - 1;
+			memmove((void*)(&(piv_data[index + 1])), (const void*)(&(piv_data[index])), os * sizeof(T));
+		}
+		PIINTROSPECTION_CONTAINER_USED(T, 1)
+		elementNew(piv_data + index, v);
+		return *this;
+	}
+	inline PIVector<T> & insert(size_t index, const PIVector<T> & other) {
+		if (other.isEmpty()) return *this;
+		assert(&other != this);
+		ssize_t os = piv_size - index;
+		alloc(piv_size + other.piv_size);
+		if (os > 0)
+			memmove((void*)(&(piv_data[index + other.piv_size])), (const void*)(&(piv_data[index])), os * sizeof(T));
+		newT(piv_data + index, other.piv_data, other.piv_size);
+		return *this;
+	}
+
+	inline PIVector<T> & remove(size_t index, size_t count = 1) {
+		if (count == 0) return *this;
+		if (index + count >= piv_size) {
+			resize(index);
+			return *this;
+		}
+		size_t os = piv_size - index - count;
+		deleteT(&(piv_data[index]), count);
+		memmove((void*)(&(piv_data[index])), (const void*)(&(piv_data[index + count])), os * sizeof(T));
+		piv_size -= count;
+		return *this;
+	}
+
+	inline void swap(PIVector<T> & other) {
+		piSwap<T*>(piv_data, other.piv_data);
+		piSwap<size_t>(piv_size, other.piv_size);
+		piSwap<size_t>(piv_rsize, other.piv_rsize);
+	}
+
+	typedef int (*CompareFunc)(const T * , const T * );
+	static int compare_func(const T * t0, const T * t1) {return (*t0) < (*t1) ? -1 : ((*t0) == (*t1) ? 0 : 1);}
+	inline PIVector<T> & sort(CompareFunc compare = compare_func) {
+		piqsort(piv_data, piv_size, sizeof(T), (int(*)(const void * , const void * ))compare);
+		return *this;
+	}
+
+	inline PIVector<T> & enlarge(llong piv_size) {
+		llong ns = size_s() + piv_size;
+		if (ns <= 0) clear();
+		else resize(size_t(ns));
+		return *this;
+	}
+
+	inline PIVector<T> & removeOne(const T & v) {
+		for (size_t i = 0; i < piv_size; ++i)
+			if (piv_data[i] == v) {
+				remove(i);
+				return *this;
+			}
+		return *this;
+	}
+	inline PIVector<T> & removeAll(const T & v) {
+		for (ssize_t i = 0; i < ssize_t(piv_size); ++i)
+			if (piv_data[i] == v) {
+				remove(i);
+				--i;
+			}
+		return *this;
+	}
+
+	inline PIVector<T> & push_back(const T & v) {
+		alloc(piv_size + 1);
+		PIINTROSPECTION_CONTAINER_USED(T, 1);
+		elementNew(piv_data + piv_size - 1, v);
+		return *this;
+	}
+	inline PIVector<T> & append(const T & v) {return push_back(v);}
+	inline PIVector<T> & append(const PIVector<T> & other) {
+		assert(&other != this);
+		size_t ps = piv_size;
+		alloc(piv_size + other.piv_size);
+		newT(piv_data + ps, other.piv_data, other.piv_size);
+		return *this;
+	}
+	inline PIVector<T> & operator <<(const T & v) {return push_back(v);}
+	inline PIVector<T> & operator <<(const PIVector<T> & other) {return append(other);}
+
+	inline PIVector<T> & push_front(const T & v) {insert(0, v); return *this;}
+	inline PIVector<T> & prepend(const T & v) {return push_front(v);}
+
+	inline PIVector<T> & pop_back() {
+		if (piv_size == 0)
+			return *this;
+		resize(piv_size - 1);
+		return *this;
+	}
+	inline PIVector<T> & pop_front() {
+		if (piv_size == 0)
+			return *this;
+		remove(0);
+		return *this;
+	}
+
+	inline T take_back() {T t(back()); pop_back(); return t;}
+	inline T take_front() {T t(front()); pop_front(); return t;}
+
+	template <typename ST>
+	PIVector<ST> toType() const {
+		PIVector<ST> ret(piv_size);
+		for (uint i = 0; i < piv_size; ++i)
+			ret[i] = ST(piv_data[i]);
+		return ret;
+	}
+
+#ifdef PIP_CXX11_SUPPORT
+	const PIVector<T> & forEach(std::function<void(const T &)> f) const {
+		for (uint i = 0; i < piv_size; ++i)
+			f(piv_data[i]);
+		return *this;
+	}
+	PIVector<T> copyForEach(std::function<T(const T &)> f) const {
+		PIVector<T> ret; ret.reserve(piv_size);
+		for (uint i = 0; i < piv_size; ++i)
+			ret << f(piv_data[i]);
+		return ret;
+	}
+	PIVector<T> & forEachInplace(std::function<T(const T &)> f) {
+		for (uint i = 0; i < piv_size; ++i)
+			piv_data[i] = f(piv_data[i]);
+		return *this;
+	}
+	template <typename ST>
+	PIVector<ST> toType(std::function<ST(const T &)> f) const {
+		PIVector<ST> ret; ret.reserve(piv_size);
+		for (uint i = 0; i < piv_size; ++i)
+			ret << f(piv_data[i]);
+		return ret;
+	}
+#endif
+
+private:
+	inline void _reset() {piv_size = piv_rsize = 0; piv_data = 0;}
+	inline size_t asize(size_t s) {
+		if (s == 0) return 0;
+		if (piv_rsize + piv_rsize >= s && piv_rsize < s)
+			return piv_rsize + piv_rsize;
+		ssize_t t = 0, s_ = s - 1;
+		while (s_ >> t) ++t;
+		return (1 << t);
+	}
+	inline void newT(T * dst, const T * src, size_t s) {
+		PIINTROSPECTION_CONTAINER_USED(T, s)
+		for (size_t i = 0; i < s; ++i)
+			elementNew(dst + i, src[i]);
+	}
+	inline void deleteT(T * d, size_t sz) {
+		PIINTROSPECTION_CONTAINER_UNUSED(T, sz)
+		if ((uchar*)d != 0) {
+			for (size_t i = 0; i < sz; ++i)
+				elementDelete(d[i]);
+		}
+	}
+	inline void elementNew(T * to, const T & from) {new(to)T(from);}
+	inline void elementDelete(T & from) {from.~T();}
+	inline void dealloc() {
+		if ((uchar*)piv_data != 0) free((uchar*)piv_data);
+		piv_data = 0;
+	}
+	inline void alloc(size_t new_size) {
+		if (new_size <= piv_rsize) {
+			piv_size = new_size;
+			return;
+		}
+		piv_size = new_size;
+		size_t as = asize(new_size);
+		if (as == piv_rsize) return;
+		PIINTROSPECTION_CONTAINER_ALLOC(T, (as-piv_rsize))
+		T * p_d = (T*)(realloc((void*)(piv_data), as*sizeof(T)));
+		assert(p_d);
+		piv_data = p_d;
+		piv_rsize = as;
+	}
+
+	T * piv_data;
+	size_t piv_size, piv_rsize;
+};
+
+
+#define __PIVECTOR_SIMPLE_TYPE__(T) \
+	template<> inline void PIVector<T>::newT(T * dst, const T * src, size_t s) {PIINTROSPECTION_CONTAINER_USED(T, s); memcpy((void*)(dst), (const void*)(src), s * sizeof(T));} \
+	template<> inline void PIVector<T>::deleteT(T *, size_t sz) {PIINTROSPECTION_CONTAINER_UNUSED(T, sz);} \
+	template<> inline void PIVector<T>::elementNew(T * to, const T & from) {(*to) = from;} \
+	template<> inline void PIVector<T>::elementDelete(T &) {;} \
+	template<> inline PIVector<T> & PIVector<T>::_resizeRaw(size_t new_size) { \
+		if (new_size > piv_size) { \
+			PIINTROSPECTION_CONTAINER_USED(T, (new_size-piv_size)); \
+		} \
+		if (new_size < piv_size) { \
+			PIINTROSPECTION_CONTAINER_UNUSED(T, (piv_size-new_size)); \
+		} \
+		alloc(new_size); \
+		return *this; \
+	} \
+	template<> inline PIVector<T> & PIVector<T>::clear() {PIINTROSPECTION_CONTAINER_UNUSED(T, piv_size); piv_size = 0; return *this;} \
+	template<> inline PIVector<T> & PIVector<T>::assign(size_t new_size, const T & f) {_resizeRaw(new_size); return fill(f);}
+
+
+__PIVECTOR_SIMPLE_TYPE__(bool)
+__PIVECTOR_SIMPLE_TYPE__(char)
+__PIVECTOR_SIMPLE_TYPE__(uchar)
+__PIVECTOR_SIMPLE_TYPE__(short)
+__PIVECTOR_SIMPLE_TYPE__(ushort)
+__PIVECTOR_SIMPLE_TYPE__(int)
+__PIVECTOR_SIMPLE_TYPE__(uint)
+__PIVECTOR_SIMPLE_TYPE__(long)
+__PIVECTOR_SIMPLE_TYPE__(ulong)
+__PIVECTOR_SIMPLE_TYPE__(llong)
+__PIVECTOR_SIMPLE_TYPE__(ullong)
+__PIVECTOR_SIMPLE_TYPE__(float)
+__PIVECTOR_SIMPLE_TYPE__(double)
+__PIVECTOR_SIMPLE_TYPE__(ldouble)
+
+
+#ifdef PIP_STD_IOSTREAM
+template<typename T>
+inline std::ostream & operator <<(std::ostream & s, const PIVector<T> & v) {s << "{"; for (size_t i = 0; i < v.size(); ++i) {s << v[i]; if (i < v.size() - 1) s << ", ";} s << "}"; return s;}
+#endif
+
+template<typename T>
+inline PICout operator <<(PICout s, const PIVector<T> & v) {
+	s.space();
+	s.setControl(0, true);
+	s << "{";
+	for (size_t i = 0; i < v.size(); ++i) {
+		s << v[i];
+		if (i < v.size() - 1)
+			s << ", ";
+	}
+	s << "}";
+	s.restoreControl();
+	return s;
+}
+
+
+#endif // PIVECTOR_H

lib/main/containers/pivector2d.h

@@ -0,0 +1,307 @@
+/*! \file pivecto2d.h
+ * \brief 2D wrapper around PIVector
+ *
+ * This file declares PIVector
+*/
+/*
+	PIP - Platform Independent Primitives
+	2D wrapper around PIVector
+	Andrey Bychkov work.a.b@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PIVECTOR2D_H
+#define PIVECTOR2D_H
+
+#include "pivector.h"
+
+/*! \brief 2D array,
+ * \details This class used to store 2D array of any type elements as plain vector.
+ * You can read/write any element via operators [][], first dimension - row, second - column.
+ * The first dimension is Row, and you can operate with Row as PIVector<T>: modify any element, assign to another Row and etc.
+ * You can't add values to array, but you can modify any elements or create another PIVector2D.
+ * PIVector2D has constructors from PIVector<T> and PIVector<PIVector<T> >
+ */
+
+template <typename T>
+class PIVector2D {
+public:
+	inline PIVector2D() {rows_ = cols_ = 0;}
+	inline PIVector2D(size_t rows, size_t cols, const T & f = T()) {
+		rows_ = rows;
+		cols_ = cols;
+		mat.resize(rows*cols, f);
+	}
+	inline PIVector2D(size_t rows, size_t cols, const PIVector<T> & v) {
+		mat = v;
+		rows_ = rows;
+		cols_ = cols;
+		mat.resize(rows*cols);
+	}
+	inline PIVector2D(const PIVector<PIVector<T> > & v) {
+		rows_ = v.size();
+		if (rows_) {
+			cols_ = v[0].size();
+			for (size_t i = 0; i < rows_; i++) {
+				mat.append(v[i]);
+			}
+			mat.resize(rows_*cols_);
+		}
+		if (mat.isEmpty()) rows_ = cols_ = 0;
+	}
+
+	inline size_t rows() const {return rows_;}
+	inline size_t cols() const {return cols_;}
+	inline size_t size() const {return mat.size();}
+	inline ssize_t size_s() const {return mat.size_s();}
+	inline size_t length() const {return mat.length();}
+	inline size_t capacity() const {return mat.capacity();}
+	inline bool isEmpty() const {return mat.isEmpty();}
+
+	class Row {
+		friend class PIVector2D<T>;
+	private:
+		inline Row(PIVector2D<T> * p, size_t row) : p_(&(p->mat)) {st_ = p->cols_ * row; sz_ = p->cols_;}
+		PIVector<T> * p_;
+		size_t st_, sz_;
+	public:
+		inline size_t size() const {return sz_;}
+		inline T & operator [](size_t index) {return (*p_)[st_ + index];}
+		inline const T & operator [](size_t index) const {return (*p_)[st_ + index];}
+		inline T * data(size_t index = 0) {return p_->data(st_ + index);}
+		inline const T * data(size_t index = 0) const {return p_->data(st_ + index);}
+		inline Row & operator =(const Row & other) {
+			if (p_ == other.p_ && st_ == other.st_) return *this;
+			size_t sz = piMin<size_t>(sz_, other.sz_);
+			p_->_copyRaw(p_->data(st_), other.data(), sz);
+			return *this;
+		}
+		inline Row & operator =(const PIVector<T> & other) {
+			size_t sz = piMin<size_t>(sz, other.size());
+			p_->_copyRaw(p_->data(st_), other.data(), sz);
+			return *this;
+		}
+		inline PIVector<T> toVector() const {return PIVector<T>(p_->data(st_), sz_);}
+	};
+
+	class Col {
+		friend class PIVector2D<T>;
+	private:
+		inline Col(PIVector2D<T> * p, size_t row) : p_(&(p->mat)) {step_ = p->cols_; row_ = row; sz_ = p->rows_;}
+		PIVector<T> * p_;
+		size_t step_, row_, sz_;
+	public:
+		inline size_t size() const {return sz_;}
+		inline T & operator [](size_t index) {return (*p_)[index * step_ + row_];}
+		inline const T & operator [](size_t index) const {return (*p_)[index * step_ + row_];}
+		inline T * data(size_t index = 0) {return p_->data(index * step_ + row_);}
+		inline const T * data(size_t index = 0) const {return p_->data(index * step_ + row_);}
+		inline Col & operator =(const Col & other) {
+			if (p_ == other.p_ && row_ == other.row_) return *this;
+			size_t sz = piMin<size_t>(sz_, other.sz_);
+			for (int i=0; i<sz; ++i) (*p_)[i * step_ + row_] = other[i];
+			return *this;
+		}
+		inline Row & operator =(const PIVector<T> & other) {
+			size_t sz = piMin<size_t>(sz_, other.size());
+			for (int i=0; i<sz; ++i) (*p_)[i * step_ + row_] = other[i];
+			return *this;
+		}
+		inline PIVector<T> toVector() const {
+			PIVector<T> ret;
+			ret.reserve(sz_);
+			for (size_t i=0; i<sz_; i++) ret << (*p_)[i * step_ + row_];
+			return ret;
+		}
+	};
+
+	class RowConst {
+		friend class PIVector2D<T>;
+	private:
+		inline RowConst(const PIVector2D<T> * p, size_t row) : p_(&(p->mat)) {st_ = p->cols_ * row; sz_ = p->cols_;}
+		const PIVector<T> * p_;
+		size_t st_, sz_;
+	public:
+		inline size_t size() const {return sz_;}
+		inline const T & operator [](size_t index) const {return (*p_)[st_ + index];}
+		inline const T * data(size_t index = 0) const {return p_->data(st_ + index);}
+		inline PIVector<T> toVector() const {return PIVector<T>(p_->data(st_), sz_);}
+	};
+
+	class ColConst {
+		friend class PIVector2D<T>;
+	private:
+		inline ColConst(const PIVector2D<T> * p, size_t row) : p_(&(p->mat)) {step_ = p->cols_; row_ = row; sz_ = p->rows_;}
+		const PIVector<T> * p_;
+		size_t step_, row_, sz_;
+	public:
+		inline size_t size() const {return p_->rows_;}
+		inline const T & operator [](size_t index) const {return (*p_)[index * step_ + row_];}
+		inline const T * data(size_t index = 0) const {return p_->data(index * step_ + row_);}
+		inline PIVector<T> toVector() const {
+			PIVector<T> ret;
+			ret.reserve(sz_);
+			for (int i=0; i<size(); i++) ret << (*p_)[i * step_ + row_];
+			return ret;
+		}
+	};
+
+	inline T & element(size_t row, size_t col) {return mat[row * cols_ + col];}
+	inline const T & element(size_t row, size_t col) const {return mat[row * cols_ + col];}
+	inline Row operator[](size_t index) {return Row(this, index);}
+	inline RowConst operator[](size_t index) const {return RowConst(this, index);}
+	inline T * data(size_t index = 0) {return mat.data(index);}
+	inline const T * data(size_t index = 0) const {return mat.data(index);}
+
+	inline Row row(size_t index) {return Row(this, index);}
+	inline RowConst row(size_t index) const {return RowConst(this, index);}
+	inline Col col(size_t index) {return Col(this, index);}
+	inline ColConst col(size_t index) const {return ColConst(this, index);}
+	inline PIVector2D<T> & setRow(size_t row, const Row & other) {
+		size_t sz = piMin<size_t>(cols_, other.sz_);
+		mat._copyRaw(mat.data(cols_ * row), other.data(), sz);
+		return *this;
+	}
+	inline PIVector2D<T> & setRow(size_t row, const RowConst & other) {
+		size_t sz = piMin<size_t>(cols_, other.sz_);
+		mat._copyRaw(mat.data(cols_ * row), other.data(), sz);
+		return *this;
+	}
+	inline PIVector2D<T> & setRow(size_t row, const PIVector<T> & other) {
+		size_t sz = piMin<size_t>(cols_, other.size());
+		mat._copyRaw(mat.data(cols_ * row), other.data(), sz);
+		return *this;
+	}
+	inline PIVector2D<T> & addRow(const Row & other) {
+		if (cols_ == 0) cols_ = other.sz_;
+		size_t sz = piMin<size_t>(cols_, other.sz_);
+		size_t ps = mat.size();
+		mat.resize(mat.size() + cols_);
+		mat._copyRaw(mat.data(ps), other.data(), sz);
+		rows_++;
+		return *this;
+	}
+	inline PIVector2D<T> & addRow(const RowConst & other) {
+		if (cols_ == 0) cols_ = other.sz_;
+		size_t sz = piMin<size_t>(cols_, other.sz_);
+		size_t ps = mat.size();
+		mat.resize(mat.size() + cols_);
+		mat._copyRaw(mat.data(ps), other.data(), sz);
+		rows_++;
+		return *this;
+	}
+	inline PIVector2D<T> & addRow(const PIVector<T> & other) {
+		if (cols_ == 0) cols_ = other.size();
+		size_t sz = piMin<size_t>(cols_, other.size());
+		size_t ps = mat.size();
+		mat.resize(mat.size() + cols_);
+		mat._copyRaw(mat.data(ps), other.data(), sz);
+		rows_++;
+		return *this;
+	}
+
+	inline PIVector2D<T> & resize(size_t rows, size_t cols, const T & f = T()) {
+		mat.resize(rows*cols_, f);
+		rows_ = rows;
+		int cs = (cols - cols_);
+		if (cs < 0) {
+			for (size_t r=0; r<rows; ++r) {
+				mat.remove(r*cols_ + cols_, -cs);
+			}
+		}
+		mat.resize(rows*cols, f);
+		if (!mat.isEmpty()) {
+			if (cs > 0) {
+				for (size_t r=0; r<rows_; ++r) {
+					for (int i=0; i<cs; ++i)
+						mat.insert(r*cols + cols_, mat.take_back());
+				}
+			}
+		}
+		cols_ = cols;
+		return *this;
+	}
+
+	PIVector<PIVector<T> > toVectors() const {
+		PIVector<PIVector<T> > ret;
+		for(size_t i = 0; i < rows_; ++i)
+			ret << PIVector<T>(mat.data(i*cols_), cols_);
+		return ret;
+	}
+	PIVector<T> toPlainVector() const {return mat;}
+	PIVector<T> & plainVector() {return mat;}
+	const PIVector<T> & plainVector() const {return mat;}
+
+	inline void swap(PIVector2D<T> & other) {
+		mat.swap(other.mat);
+		piSwap<size_t>(rows_, other.rows_);
+		piSwap<size_t>(cols_, other.cols_);
+	}
+
+	inline PIVector2D<T> & _resizeRaw(size_t r, size_t c) {
+		piCout << "Error, \"resizeRaw()\" only allowed for simple type declared with __PIVECTOR_SIMPLE_TYPE__ macro!";
+		assert(0);
+		return *this;
+	}
+
+	inline void clear() {
+		rows_ = cols_ = 0;
+		mat.clear();
+	}
+
+protected:
+	size_t rows_, cols_;
+	PIVector<T> mat;
+};
+
+
+template<typename T>
+inline PICout operator <<(PICout s, const PIVector2D<T> & v) {
+	s.setControl(0, true);
+	s << "{";
+	for (size_t i = 0; i < v.rows(); ++i) {
+		s << "{ ";
+		for (size_t j = 0; j < v.cols(); ++j) {
+			s << v[i][j];
+			if (j < v.cols() - 1) s << ", ";
+		}
+		s << " }";
+		if (i < v.rows() - 1) s << PICoutManipulators::NewLine ;
+	}
+	if (v.isEmpty()) s << "{ }";
+	s << "}";
+	s.restoreControl();
+	return s;
+}
+
+#define __PIVECTOR2D_SIMPLE_TYPE__(T) \
+	template<> inline PIVector2D<T> & PIVector2D<T>::_resizeRaw(size_t r, size_t c) {rows_ = r; cols_ = c; mat._resizeRaw(r*c); return *this;}
+
+__PIVECTOR2D_SIMPLE_TYPE__(bool)
+__PIVECTOR2D_SIMPLE_TYPE__(char)
+__PIVECTOR2D_SIMPLE_TYPE__(uchar)
+__PIVECTOR2D_SIMPLE_TYPE__(short)
+__PIVECTOR2D_SIMPLE_TYPE__(ushort)
+__PIVECTOR2D_SIMPLE_TYPE__(int)
+__PIVECTOR2D_SIMPLE_TYPE__(uint)
+__PIVECTOR2D_SIMPLE_TYPE__(long)
+__PIVECTOR2D_SIMPLE_TYPE__(ulong)
+__PIVECTOR2D_SIMPLE_TYPE__(llong)
+__PIVECTOR2D_SIMPLE_TYPE__(ullong)
+__PIVECTOR2D_SIMPLE_TYPE__(float)
+__PIVECTOR2D_SIMPLE_TYPE__(double)
+__PIVECTOR2D_SIMPLE_TYPE__(ldouble)
+
+#endif // PIVECTOR2D_H