diff --git a/alib2data/src/container/ObjectsDeque.cpp b/alib2data/src/container/ObjectsDeque.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e58d8cf87d989e7eb75ebfb5d4b4808fc903f9b
--- /dev/null
+++ b/alib2data/src/container/ObjectsDeque.cpp
@@ -0,0 +1,63 @@
+/*
+ * Deque.cpp
+ *
+ * Created on: Apr 1, 2013
+ * Author: Jan Travnicek
+ */
+
+#include "ObjectsDeque.h"
+
+#include "Container.h"
+#include "../object/Object.h"
+#include <sstream>
+
+namespace container {
+
+ObjectsDeque::ObjectsDeque ( std::deque < alib::Object > deque ) : std::deque < alib::Object > ( std::move ( deque ) ) {
+}
+
+ObjectsDeque::ObjectsDeque ( ) : std::deque < alib::Object > ( ) {
+}
+
+ContainerBase * ObjectsDeque::clone ( ) const {
+	return new ObjectsDeque ( * this );
+}
+
+ContainerBase * ObjectsDeque::plunder ( ) && {
+	return new ObjectsDeque ( std::move ( * this ) );
+}
+
+int ObjectsDeque::compare ( const ObjectsDeque & other ) const {
+	std::compare < std::deque < alib::Object > > comp;
+
+	return comp ( static_cast < const std::deque < alib::Object > > ( * this ), static_cast < const std::deque < alib::Object > > ( other ) );
+}
+
+void ObjectsDeque::operator >>( std::ostream & os ) const {
+	os << "(ObjectsDeque " << static_cast < const std::deque < alib::Object > > ( * this ) << ")";
+}
+
+ObjectsDeque::operator std::string ( ) const {
+	std::stringstream ss;
+	ss << * this;
+	return std::move ( ss ).str ( );
+}
+
+const std::string ObjectsDeque::XML_TAG_NAME = "Deque";
+
+ObjectsDeque ObjectsDeque::parse ( std::deque < sax::Token >::iterator & input ) {
+	return ObjectsDeque ( parseRaw < alib::Object > ( input ) );
+}
+
+void ObjectsDeque::compose ( std::deque < sax::Token > & out ) const {
+	compose ( out, * this );
+}
+
+} /* namespace container */
+
+namespace alib {
+
+xmlApi < container::Container >::ParserRegister < container::ObjectsDeque > objectsDequeParserRegister = xmlApi < container::Container >::ParserRegister < container::ObjectsDeque > ( container::ObjectsDeque::XML_TAG_NAME, container::ObjectsDeque::parse );
+xmlApi < alib::Object >::ParserRegister < container::ObjectsDeque > objectsDequeParserRegister2 = xmlApi < alib::Object >::ParserRegister < container::ObjectsDeque > ( container::ObjectsDeque::XML_TAG_NAME, container::ObjectsDeque::parse );
+
+} /* namespace alib */
diff --git a/alib2data/src/container/ObjectsDeque.h b/alib2data/src/container/ObjectsDeque.h
new file mode 100644
index 0000000000000000000000000000000000000000..e48cb2581f8c359fc4422ae1f11e768011ec61c6
--- /dev/null
+++ b/alib2data/src/container/ObjectsDeque.h
@@ -0,0 +1,120 @@
+/*
+ * Deque.h
+ *
+ * Created on: Apr 1, 2013
+ * Author: Jan Travnicek
+ */
+
+#ifndef OBJECTS_DEQUE_H_
+#define OBJECTS_DEQUE_H_
+
+#include <deque>
+#include <string>
+
+#include "../object/Object.h"
+#include "ContainerBase.h"
+
+#include "../XmlApi.hpp"
+
+namespace container {
+
+/**
+ * Basic container from which are derived all other containers.
+ * Contains reason why the container occured.
+ */
+class ObjectsDeque : public std::deque < alib::Object >, public ContainerBase {
+public:
+	explicit ObjectsDeque ( std::deque < alib::Object > );
+	explicit ObjectsDeque ( );
+
+	virtual ContainerBase * clone ( ) const;
+
+	virtual ContainerBase * plunder ( ) &&;
+
+	virtual int compare ( const ObjectBase & other ) const {
+		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
+
+		return std::type_index ( typeid ( * this ) ) - std::type_index ( typeid ( other ) );
+	}
+
+	virtual int compare ( const ObjectsDeque & other ) const;
+
+	virtual void operator >>( std::ostream & os ) const;
+
+	virtual explicit operator std::string ( ) const;
+
+	const static std::string XML_TAG_NAME;
+
+	static ObjectsDeque parse ( std::deque < sax::Token >::iterator & input );
+	template < class T >
+	static std::deque < T > parseRaw ( std::deque < sax::Token >::iterator & input );
+
+	void compose ( std::deque < sax::Token > & out ) const;
+	template < class T >
+	static void compose ( std::deque < sax::Token > & out, const std::deque < T > & input );
+};
+
+template < class T >
+std::deque < T > ObjectsDeque::parseRaw ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ObjectsDeque::XML_TAG_NAME );
+
+	std::deque < T > deque;
+
+	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
+		deque.push_back ( alib::xmlApi < T >::parse ( input ) );
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, ObjectsDeque::XML_TAG_NAME );
+	return deque;
+}
+
+template < class T >
+void ObjectsDeque::compose ( std::deque < sax::Token > & out, const std::deque < T > & input ) {
+	out.emplace_back ( ObjectsDeque::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
+
+	for ( const T & item : input )
+		alib::xmlApi < T >::compose ( out, item );
+
+	out.emplace_back ( ObjectsDeque::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace container */
+
+namespace std {
+
+template < >
+struct compare < container::ObjectsDeque > {
+	int operator ()( const container::ObjectsDeque & first, const container::ObjectsDeque & second ) const {
+		return first.compare ( second );
+	}
+
+};
+
+} /* namespace std */
+
+namespace alib {
+
+template < typename T >
+struct xmlApi < std::deque < T > > {
+	static std::deque < T > parse ( std::deque < sax::Token >::iterator & input );
+	static bool first ( const std::deque < sax::Token >::const_iterator & input );
+	static void compose ( std::deque < sax::Token > & output, const std::deque < T > & data );
+};
+
+template < typename T >
+std::deque < T > xmlApi < std::deque < T > >::parse ( std::deque < sax::Token >::iterator & input ) {
+	return container::ObjectsDeque::parseRaw < T > ( input );
+}
+
+template < typename T >
+bool xmlApi < std::deque < T > >::first ( const std::deque < sax::Token >::const_iterator & input ) {
+	return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, container::ObjectsDeque::XML_TAG_NAME );
+}
+
+template < typename T >
+void xmlApi < std::deque < T > >::compose ( std::deque < sax::Token > & output, const std::deque < T > & input ) {
+	return container::ObjectsDeque::compose < T > ( output, input );
+}
+
+} /* namespace alib */
+
+#endif /* OBJECTS_DEQUE_H_ */
diff --git a/alib2data/src/container/ObjectsList.cpp b/alib2data/src/container/ObjectsList.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df7b58509af155b2586b6b891f12ac73bb9563b1
--- /dev/null
+++ b/alib2data/src/container/ObjectsList.cpp
@@ -0,0 +1,63 @@
+/*
+ * List.cpp
+ *
+ * Created on: Apr 1, 2013
+ * Author: Jan Travnicek
+ */
+
+#include "ObjectsList.h"
+
+#include "Container.h"
+#include "../object/Object.h"
+#include <sstream>
+
+namespace container {
+
+ObjectsList::ObjectsList ( std::list < alib::Object > list ) : std::list < alib::Object > ( std::move ( list ) ) {
+}
+
+ObjectsList::ObjectsList ( ) : std::list < alib::Object > ( ) {
+}
+
+ContainerBase * ObjectsList::clone ( ) const {
+	return new ObjectsList ( * this );
+}
+
+ContainerBase * ObjectsList::plunder ( ) && {
+	return new ObjectsList ( std::move ( * this ) );
+}
+
+int ObjectsList::compare ( const ObjectsList & other ) const {
+	std::compare < std::list < alib::Object > > comp;
+
+	return comp ( static_cast < const std::list < alib::Object > > ( * this ), static_cast < const std::list < alib::Object > > ( other ) );
+}
+
+void ObjectsList::operator >>( std::ostream & os ) const {
+	os << "(ObjectsList " << static_cast < const std::list < alib::Object > > ( * this ) << ")";
+}
+
+ObjectsList::operator std::string ( ) const {
+	std::stringstream ss;
+	ss << * this;
+	return std::move ( ss ).str ( );
+}
+
+const std::string ObjectsList::XML_TAG_NAME = "List";
+
+ObjectsList ObjectsList::parse ( std::deque < sax::Token >::iterator & input ) {
+	return ObjectsList ( parseRaw < alib::Object > ( input ) );
+}
+
+void ObjectsList::compose ( std::deque < sax::Token > & out ) const {
+	compose ( out, * this );
+}
+
+} /* namespace container */
+
+namespace alib {
+
+xmlApi < container::Container >::ParserRegister < container::ObjectsList > objectsListParserRegister = xmlApi < container::Container >::ParserRegister < container::ObjectsList > ( container::ObjectsList::XML_TAG_NAME, container::ObjectsList::parse );
+xmlApi < alib::Object >::ParserRegister < container::ObjectsList > objectsListParserRegister2 = xmlApi < alib::Object >::ParserRegister < container::ObjectsList > ( container::ObjectsList::XML_TAG_NAME, container::ObjectsList::parse );
+
+} /* namespace alib */
diff --git a/alib2data/src/container/ObjectsList.h b/alib2data/src/container/ObjectsList.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e851b7ba9a61374de5e912cc059222518b4f2aa
--- /dev/null
+++ b/alib2data/src/container/ObjectsList.h
@@ -0,0 +1,120 @@
+/*
+ * List.h
+ *
+ * Created on: Apr 1, 2013
+ * Author: Jan Travnicek
+ */
+
+#ifndef OBJECTS_LIST_H_
+#define OBJECTS_LIST_H_
+
+#include <list>
+#include <string>
+
+#include "../object/Object.h"
+#include "ContainerBase.h"
+
+#include "../XmlApi.hpp"
+
+namespace container {
+
+/**
+ * Basic container from which are derived all other containers.
+ * Contains reason why the container occured.
+ */
+class ObjectsList : public std::list < alib::Object >, public ContainerBase {
+public:
+	explicit ObjectsList ( std::list < alib::Object > );
+	explicit ObjectsList ( );
+
+	virtual ContainerBase * clone ( ) const;
+
+	virtual ContainerBase * plunder ( ) &&;
+
+	virtual int compare ( const ObjectBase & other ) const {
+		if ( std::type_index ( typeid ( * this ) ) == std::type_index ( typeid ( other ) ) ) return this->compare ( ( decltype ( * this ) )other );
+
+		return std::type_index ( typeid ( * this ) ) - std::type_index ( typeid ( other ) );
+	}
+
+	virtual int compare ( const ObjectsList & other ) const;
+
+	virtual void operator >>( std::ostream & os ) const;
+
+	virtual explicit operator std::string ( ) const;
+
+	const static std::string XML_TAG_NAME;
+
+	static ObjectsList parse ( std::deque < sax::Token >::iterator & input );
+	template < class T >
+	static std::list < T > parseRaw ( std::deque < sax::Token >::iterator & input );
+
+	void compose ( std::deque < sax::Token > & out ) const;
+	template < class T >
+	static void compose ( std::deque < sax::Token > & out, const std::list < T > & input );
+};
+
+template < class T >
+std::list < T > ObjectsList::parseRaw ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ObjectsList::XML_TAG_NAME );
+
+	std::list < T > list;
+
+	while ( sax::FromXMLParserHelper::isTokenType ( input, sax::Token::TokenType::START_ELEMENT ) )
+		list.push_back ( alib::xmlApi < T >::parse ( input ) );
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, ObjectsList::XML_TAG_NAME );
+	return list;
+}
+
+template < class T >
+void ObjectsList::compose ( std::deque < sax::Token > & out, const std::list < T > & input ) {
+	out.emplace_back ( ObjectsList::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
+
+	for ( const T & item : input )
+		alib::xmlApi < T >::compose ( out, item );
+
+	out.emplace_back ( ObjectsList::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace container */
+
+namespace std {
+
+template < >
+struct compare < container::ObjectsList > {
+	int operator ()( const container::ObjectsList & first, const container::ObjectsList & second ) const {
+		return first.compare ( second );
+	}
+
+};
+
+} /* namespace std */
+
+namespace alib {
+
+template < typename T >
+struct xmlApi < std::list < T > > {
+	static std::list < T > parse ( std::deque < sax::Token >::iterator & input );
+	static bool first ( const std::deque < sax::Token >::const_iterator & input );
+	static void compose ( std::deque < sax::Token > & output, const std::list < T > & data );
+};
+
+template < typename T >
+std::list < T > xmlApi < std::list < T > >::parse ( std::deque < sax::Token >::iterator & input ) {
+	return container::ObjectsList::parseRaw < T > ( input );
+}
+
+template < typename T >
+bool xmlApi < std::list < T > >::first ( const std::deque < sax::Token >::const_iterator & input ) {
+	return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, container::ObjectsList::XML_TAG_NAME );
+}
+
+template < typename T >
+void xmlApi < std::list < T > >::compose ( std::deque < sax::Token > & output, const std::list < T > & input ) {
+	return container::ObjectsList::compose < T > ( output, input );
+}
+
+} /* namespace alib */
+
+#endif /* OBJECTS_LIST_H_ */
diff --git a/alib2std/src/extensions/deque.hpp b/alib2std/src/extensions/deque.hpp
index 0b317937c2bad45f64ab01c239f259a0e70e1b6f..87fe60a448b2b922365a5beaf31291498e8d1e82 100644
--- a/alib2std/src/extensions/deque.hpp
+++ b/alib2std/src/extensions/deque.hpp
@@ -10,13 +10,15 @@
 
 namespace std {
 
-template< class T >
-std::ostream& operator<<(std::ostream& out, const std::deque<T>& list) {
+template < class T >
+std::ostream & operator <<( std::ostream & out, const std::deque < T > & list ) {
 	out << "[";
 
 	bool first = true;
-	for(const T& item : list) {
-		if(!first) out << ", ";
+
+	for ( const T & item : list ) {
+		if ( !first ) out << ", ";
+
 		first = false;
 		out << item;
 	}
@@ -25,7 +27,26 @@ std::ostream& operator<<(std::ostream& out, const std::deque<T>& list) {
 	return out;
 }
 
+template < class T >
+struct compare < deque < T > > {
+	int operator ()( const deque < T > & first, const deque < T > & second ) const {
+		if ( first.size ( ) < second.size ( ) ) return -1;
+
+		if ( first.size ( ) > second.size ( ) ) return 1;
+
+		compare < T > comp;
+
+		for ( auto iterF = first.begin ( ), iterS = second.begin ( ); iterF != first.end ( ); ++iterF, ++iterS ) {
+			int res = comp ( * iterF, * iterS );
+
+			if ( res != 0 ) return res;
+		}
+
+		return 0;
+	}
+
+};
+
 } /* namespace std */
 
 #endif /* __DEQUE_HPP_ */
-