ObjectsDeque.h

/*
 * 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 <core/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;

	static const std::string & getXmlTagName() {
		static std::string xmlTagName = "Deque";

		return xmlTagName;
	}

	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::getXmlTagName() );

	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::getXmlTagName() );
	return deque;
}

template < class T >
void ObjectsDeque::compose ( std::deque < sax::Token > & out, const std::deque < T > & input ) {
	out.emplace_back ( ObjectsDeque::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );

	for ( const T & item : input )
		alib::xmlApi < T >::compose ( out, item );

	out.emplace_back ( ObjectsDeque::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
}

} /* namespace container */

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::getXmlTagName() );
}

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_ */