wip file reading and writing in cli

alib2abstraction/src/abstraction/PackingAbstraction.hpp

+/*
+ * PackingAbstraction.hpp
+ *
+ *  Created on: 29. 5. 2018
+ *	  Author: Jan Travnicek
+ */
+
+#ifndef _PACKING_ABSTRACTION_HPP_
+#define _PACKING_ABSTRACTION_HPP_
+
+#include <abstraction/ValueOperationAbstraction.hpp>
+#include <alib/memory>
+#include <alib/array>
+#include <registry/Registry.h>
+
+namespace abstraction {
+
+template < class ... ParamTypes >
+class PackingAbstraction : public OperationAbstraction {
+	struct ConnectionTarget {
+		unsigned targetId;
+		unsigned paramPosition;
+	};
+
+	ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > m_abstractions;
+	ext::array < ext::vector < ConnectionTarget >, sizeof ... ( ParamTypes ) > m_connections;
+	unsigned m_resultId;
+
+public:
+	PackingAbstraction ( ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions, unsigned resultId ) : m_abstractions ( std::move ( abstractions ) ), m_resultId ( resultId ) {
+	}
+
+	bool setInnerConnection ( unsigned sourceId, unsigned targetId, unsigned paramPosition, bool move ) {
+		return m_abstractions [ targetId ]->attachInput ( m_abstractions [ sourceId ], paramPosition, move );
+	}
+
+	bool clearInnerConnection ( unsigned targetId, unsigned paramPosition ) {
+		return m_abstractions [ targetId ]->detachInput ( paramPosition );
+	}
+
+	void setOuterConnection ( unsigned sourceId, unsigned targetId, unsigned paramPosition ) {
+		m_connections [ sourceId ].push_back ( ConnectionTarget { targetId, paramPosition } );
+	}
+
+private:
+	virtual bool attachInput ( const std::shared_ptr < OperationAbstraction > & input, unsigned index, bool move ) override {
+		for ( const ConnectionTarget & target : m_connections [ index ] )
+			m_abstractions [ target.targetId ]->attachInput ( input, target.paramPosition, move );
+
+		return true;
+	}
+
+	virtual bool detachInput ( unsigned index ) override {
+		for ( const ConnectionTarget & target : m_connections [ index ] )
+			m_abstractions [ target.targetId ]->detachInput ( target.paramPosition );
+
+		return true;
+	}
+public:
+	virtual bool inputsReady ( ) const override {
+		for ( const std::shared_ptr < abstraction::OperationAbstraction > & operation : m_abstractions )
+			if ( operation->inputsReady ( ) == false )
+				return false;
+
+		return true;
+	}
+
+	virtual bool inputsAttached ( ) const override {
+		for ( const std::shared_ptr < abstraction::OperationAbstraction > & operation : m_abstractions )
+			if ( operation->inputsAttached ( ) == false )
+				return false;
+
+		return true;
+	}
+
+	virtual bool run ( ) override {
+		if ( ! this->inputsReady ( ) )
+			return false;
+
+		if ( this->cached ( ) )
+			return true;
+
+		return m_abstractions [ m_resultId ]->run ( );
+	}
+
+	virtual bool eval ( ) override {
+		if ( ! inputsAttached ( ) )
+			return false;
+
+		if ( this->cached ( ) )
+			return true;
+
+		return m_abstractions [ m_resultId ]->eval ( );
+	}
+
+	virtual unsigned numberOfParams ( ) const override {
+		return sizeof ... ( ParamTypes );
+	}
+
+	virtual bool isReady ( ) const override {
+		return m_abstractions [ m_resultId ]->isReady ( );
+	}
+
+	virtual bool cached ( ) const override {
+		return isReady ( );
+	}
+
+	virtual ext::type_index getParamTypeIndex ( unsigned index ) const override {
+		return m_abstractions [ m_connections.at ( index ) [ 0 ].targetId ]->getParamTypeIndex ( m_connections.at ( index ) [ 0 ].paramPosition );
+	}
+
+	virtual ext::type_index getReturnTypeIndex ( ) const override {
+		return m_abstractions [ m_resultId ]->getReturnTypeIndex ( );
+	}
+
+	virtual ext::type_index getRuntimeReturnTypeIndex ( ) const override {
+		return m_abstractions [ m_resultId ]->getRuntimeReturnTypeIndex ( );
+	}
+
+	virtual std::shared_ptr < abstraction::OperationAbstraction > getProxyAbstraction ( ) override {
+		return m_abstractions [ m_resultId ]->getProxyAbstraction ( );
+	}
+
+};
+
+} /* namespace abstraction */
+
+#endif /* _PACKING_ABSTRACTION_HPP_ */

alib2abstraction/src/abstraction/WrapperAbstraction.hpp

@@ -104,7 +104,7 @@ public:
 		for ( unsigned index = 0; index < sizeof ... ( ParamTypes ); ++ index )
 			abstraction->attachInput ( ext::call_on_nth < std::shared_ptr < abstraction::OperationAbstraction > > ( m_params, index, getParam ), index, m_moves [ index ] );
-		return m_data.template get < std::shared_ptr < OperationAbstraction > > ( )->run ( );
+		return abstraction->run ( );
 	}
 	virtual bool eval ( ) override {

alib2cli/src/registration/InputFileTypeRegistration.cpp

 #include "InputFileTypeRegistration.hpp"
-#include <common/XmlParserHelper.h>
 #include <registry/XmlRegistry.h>
+#include <abstraction/ImmediateValueAbstraction.hpp>
+#include <abstraction/XmlTokensParserAbstraction.hpp>
+#include <abstraction/WrapperAbstraction.hpp>
+#include <abstraction/PackingAbstraction.hpp>
+
 namespace {
-	std::shared_ptr < abstraction::OperationAbstraction > dummy ( const std::string & file, const std::string & type, const ext::vector < std::string > & templateParams ) {
-		if ( type == "set" || type == "Set" ) {
-			std::shared_ptr < abstraction::UnaryOperationAbstraction < ext::deque < sax::Token >, const std::string & > > tokens = abstraction::XmlRegistry::fileToTokensAbstraction ( file );
-			tokens->eval ( );
-			std::shared_ptr < abstraction::OperationAbstraction > res = abstraction::XmlRegistry::getXmlContainerParserAbstraction ( "Set", templateParams [ 0 ] );
-			res->attachInput ( tokens, 0, true );
-			res->eval ( );
-			return res;
+	std::shared_ptr < abstraction::OperationAbstraction > dummy ( const std::string & filename, const std::string & typehint, const ext::vector < std::string > & templateParams ) {
+		if ( typehint == "set" || typehint == "Set" ) {
+			ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
+
+			abstractions.push_back ( std::make_shared < abstraction::XmlTokensParserAbstraction > ( ) );
+			abstractions.push_back ( abstraction::XmlRegistry::getXmlContainerParserAbstraction ( "Set", templateParams [ 0 ] ) );
+
+			std::shared_ptr < abstraction::PackingAbstraction < std::string > > res = std::make_shared < abstraction::PackingAbstraction < std::string > > ( std::move ( abstractions ), 1 );
+			res->setInnerConnection ( 0, 1, 0, true );
+			res->setOuterConnection ( 0, 0, 0 );
+			std::shared_ptr < abstraction::OperationAbstraction > tmp = res;
+			std::shared_ptr < abstraction::ImmediateValueAbstraction < std::string > > file = std::make_shared < abstraction::ImmediateValueAbstraction < std::string > > ( filename );
+			tmp->attachInput ( file, 0, false );
+			tmp->eval ( );
+			return tmp;
 		} else {
-			return abstraction::XmlParserHelper::eval ( std::move ( type ), file );
+			ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > abstractions;
+
+			abstractions.push_back ( std::make_shared < abstraction::XmlTokensParserAbstraction > ( ) );
+
+			auto xmlParserAbstractionFinder = [ = ] ( const ext::deque < sax::Token > & tokens ) {
+				std::string type;
+				if ( typehint == "" )
+					type = tokens [ 0 ].getData ( );
+				else
+					type = typehint;
+
+				return abstraction::XmlRegistry::getXmlParserAbstraction ( type );
+			};
+
+			abstractions.push_back ( std::make_shared < abstraction::WrapperAbstraction < const ext::deque < sax::Token > & > > ( xmlParserAbstractionFinder ) );
+
+			std::shared_ptr < abstraction::PackingAbstraction < std::string > > res = std::make_shared < abstraction::PackingAbstraction < std::string > > ( std::move ( abstractions ), 1 );
+			res->setInnerConnection ( 0, 1, 0, true );
+			res->setOuterConnection ( 0, 0, 0 );
+
+			std::shared_ptr < abstraction::OperationAbstraction > tmp = res;
+			std::shared_ptr < abstraction::ImmediateValueAbstraction < std::string > > file = std::make_shared < abstraction::ImmediateValueAbstraction < std::string > > ( filename );
+			tmp->attachInput ( file, 0, false );
+			tmp->eval ( );
+			return tmp;
 		}
 	}
+	std::shared_ptr < abstraction::OperationAbstraction > dummy2 ( const std::string & /*filename*/, const std::string & /*typehint*/, const ext::vector < std::string > & /*templateParams*/ ) {
+		return nullptr;
+	}
+
 auto xmlInputFileHandler = registration::InputFileRegister ( "xml", dummy );
+auto stringInputFileHandler = registration::InputFileRegister ( "", dummy2 );
 }

alib2cli/src/registration/OutputFileTypeRegistration.cpp

 #include "OutputFileTypeRegistration.hpp"
-#include <common/XmlComposerHelper.h>
+#include <exception/CommonException.h>
+
+#include <registry/XmlRegistry.h>
+#include <abstraction/ImmediateValueAbstraction.hpp>
+#include <abstraction/XmlTokensComposerAbstraction.hpp>
 namespace {
-	std::shared_ptr < abstraction::OperationAbstraction > dummy ( std::shared_ptr < abstraction::OperationAbstraction > param, const std::string & file ) {
-		return abstraction::XmlComposerHelper::eval ( param, file );
+	std::shared_ptr < abstraction::OperationAbstraction > dummy ( std::shared_ptr < abstraction::OperationAbstraction > param, const std::string & filename ) {
+		std::shared_ptr < abstraction::OperationAbstraction > tokens = abstraction::XmlRegistry::getXmlComposerAbstraction ( param->getReturnType ( ) );
+		if ( ! tokens->attachInput ( param, 0, false ) )
+			throw exception::CommonException ( "Can't connect param at 0 of result file statement with result of type " + param->getReturnType ( ) + "." );
+		if ( ! tokens->eval ( ) )
+			throw exception::CommonException ( "Eval of result file statement failed." );
+
+		std::shared_ptr < abstraction::ImmediateValueAbstraction < std::string > > file = std::make_shared < abstraction::ImmediateValueAbstraction < std::string > > ( filename );
+
+		std::shared_ptr < abstraction::OperationAbstraction > res = std::make_shared < abstraction::XmlTokensComposerAbstraction > ( );
+
+		res->attachInput ( file, 1, false );
+		res->attachInput ( tokens, 0, true );
+		res->eval ( );
+
+		return res;
 	}
 auto xmlOutputFileHandler = registration::OutputFileRegister ( "xml", dummy );

alib2cli/src/registry/InputFileRegistry.cpp

@@ -10,12 +10,12 @@
 namespace abstraction {
-std::shared_ptr < abstraction::OperationAbstraction > InputFileRegistry::getAbstraction ( const std::string & file, const std::string & fileType, const std::string & type, const ext::vector < std::string > & templateParams ) {
+std::shared_ptr < abstraction::OperationAbstraction > InputFileRegistry::getAbstraction ( const std::string & filename, const std::string & fileType, const std::string & type, const ext::vector < std::string > & templateParams ) {
 	auto res = getEntries ( ).find ( fileType );
 	if ( res == getEntries ( ).end ( ) )
 		throw exception::CommonException ( "Entry " + fileType + " not available." );
-	return res->second->getAbstraction ( file, type, templateParams );
+	return res->second->getAbstraction ( filename, type, templateParams );
 }
 std::shared_ptr < abstraction::OperationAbstraction > InputFileRegistry::EntryImpl::getAbstraction ( const std::string & file, const std::string & type, const ext::vector < std::string > & templateParams ) const {

alib2xml/src/abstraction/XmlTokensComposerAbstraction.hpp

@@ -9,6 +9,7 @@
 #define _XML_TOKENS_COMPOSER_ABSTRACTION_HPP_
 #include <abstraction/BinaryOperationAbstraction.hpp>
+#include <sax/SaxComposeInterface.h>
 namespace abstraction {

alib2xml/src/abstraction/XmlTokensParserAbstraction.hpp

@@ -9,6 +9,7 @@
 #define _XML_TOKENS_PARSER_ABSTRACTION_HPP_
 #include <abstraction/UnaryOperationAbstraction.hpp>
+#include <sax/SaxParseInterface.h>
 namespace abstraction {

alib2xml/src/common/XmlComposerHelper.cpp

-/*
- * XmlComposerHelper.cpp
- *
- *  Created on: 25. 8. 2017
- *	  Author: Jan Travnicek
- */
-
-#include <exception/CommonException.h>
-
-#include <common/XmlComposerHelper.h>
-
-#include <registry/XmlRegistry.h>
-#include <abstraction/ImmediateValueAbstraction.hpp>
-
-namespace abstraction {
-
-std::shared_ptr < abstraction::OperationAbstraction > XmlComposerHelper::eval ( std::shared_ptr < abstraction::OperationAbstraction > param, const std::string & file ) {
-	std::shared_ptr < abstraction::OperationAbstraction > tokens = abstraction::XmlRegistry::getXmlComposerAbstraction ( param->getReturnType ( ) );
-	if ( ! tokens->attachInput ( param, 0, false ) )
-		throw exception::CommonException ( "Can't connect param at 0 of result file statement with result of type " + param->getReturnType ( ) + "." );
-	if ( ! tokens->eval ( ) )
-		throw exception::CommonException ( "Eval of result file statement failed." );
-
-	std::shared_ptr < abstraction::OperationAbstraction > res = abstraction::XmlRegistry::tokensToFileAbstraction ( file );
-	res->attachInput ( tokens, 0, true );
-	res->eval ( );
-
-	return res;
-}
-
-
-} /* namespace abstraction */

alib2xml/src/common/XmlComposerHelper.h

-/*
- * AbstractionHelper.hpp
- *
- *  Created on: 25. 8. 2017
- *	  Author: Jan Travnicek
- */
-
-#ifndef _XML_COMPOSER_HELPER_HPP_
-#define _XML_COMPOSER_HELPER_HPP_
-
-#include <alib/string>
-#include <alib/memory>
-#include <abstraction/OperationAbstraction.hpp>
-
-namespace abstraction {
-
-class XmlComposerHelper {
-public:
-	static std::shared_ptr < abstraction::OperationAbstraction > eval ( std::shared_ptr < abstraction::OperationAbstraction > type, const std::string & file );
-
-};
-
-} /* namespace abstraction */
-
-#endif /* _XML_COMPOSER_HELPER_HPP_ */

alib2xml/src/common/XmlParserHelper.cpp

-/*
- * XmlParserHelper.cpp
- *
- *  Created on: 25. 8. 2017
- *	  Author: Jan Travnicek
- */
-
-#include <common/XmlParserHelper.h>
-
-#include <registry/XmlRegistry.h>
-#include <abstraction/ImmediateValueAbstraction.hpp>
-
-namespace abstraction {
-
-std::shared_ptr < abstraction::OperationAbstraction > XmlParserHelper::eval ( std::string type, const std::string & file ) {
-	std::shared_ptr < abstraction::UnaryOperationAbstraction < ext::deque < sax::Token >, const std::string & > > tokens = abstraction::XmlRegistry::fileToTokensAbstraction ( file );
-	tokens->eval ( );
-
-	if ( type == "" )
-		type = std::dynamic_pointer_cast < abstraction::ValueProvider < const ext::deque < sax::Token > & > > ( tokens )->getValue ( false ) [ 0 ].getData ( );
-
-	std::shared_ptr < abstraction::OperationAbstraction > res = abstraction::XmlRegistry::getXmlParserAbstraction ( type );
-	res->attachInput ( tokens, 0, true );
-	res->eval ( );
-	return res;
-}
-
-
-} /* namespace abstraction */

alib2xml/src/common/XmlParserHelper.h

-/*
- * AbstractionHelper.hpp
- *
- *  Created on: 25. 8. 2017
- *	  Author: Jan Travnicek
- */
-
-#ifndef _XML_PARSER_HELPER_HPP_
-#define _XML_PARSER_HELPER_HPP_
-
-#include <alib/string>
-#include <alib/memory>
-#include <abstraction/OperationAbstraction.hpp>
-
-namespace abstraction {
-
-class XmlParserHelper {
-public:
-	static std::shared_ptr < abstraction::OperationAbstraction > eval ( std::string type, const std::string & file );
-
-};
-
-} /* namespace abstraction */
-
-#endif /* _XML_PARSER_HELPER_HPP_ */

alib2xml/src/registry/XmlRegistry.cpp

@@ -12,8 +12,6 @@
 #include <registry/XmlContainerParserRegistry.hpp>
 #include <abstraction/ImmediateValueAbstraction.hpp>
-#include <abstraction/XmlTokensComposerAbstraction.hpp>
-#include <abstraction/XmlTokensParserAbstraction.hpp>
 namespace abstraction {
@@ -37,27 +35,4 @@ std::shared_ptr < abstraction::OperationAbstraction > XmlRegistry::getXmlContain
 	return XmlContainerParserRegistry::getAbstraction ( container, type );
 }
-std::shared_ptr < abstraction::UnaryOperationAbstraction < ext::deque < sax::Token >, const std::string & > > XmlRegistry::fileToTokensAbstraction ( const std::string & filename ) {
-	std::shared_ptr < abstraction::ImmediateValueAbstraction < std::string > > file = std::make_shared < abstraction::ImmediateValueAbstraction < std::string > > ( filename );
-
-	std::shared_ptr < abstraction::UnaryOperationAbstraction < ext::deque < sax::Token >, const std::string & > > res = std::make_shared < abstraction::XmlTokensParserAbstraction > ( );
-	std::shared_ptr < abstraction::OperationAbstraction > tmp = res;
-
-	tmp->attachInput ( file, 0, false );
-
-	return res;
-}
-
-std::shared_ptr < abstraction::BinaryOperationAbstraction < void, const ext::deque < sax::Token > &, const std::string & > > XmlRegistry::tokensToFileAbstraction ( const std::string & filename ) {
-	std::shared_ptr < abstraction::ImmediateValueAbstraction < std::string > > file = std::make_shared < abstraction::ImmediateValueAbstraction < std::string > > ( filename );
-
-	std::shared_ptr < abstraction::BinaryOperationAbstraction < void, const ext::deque < sax::Token > &, const std::string & > > res = std::make_shared < abstraction::XmlTokensComposerAbstraction > ( );
-	std::shared_ptr < abstraction::OperationAbstraction > tmp = res;
-
-	tmp->attachInput ( file, 1, false );
-
-	return res;
-
-}
-
 } /* namespace abstraction */

alib2xml/src/registry/XmlRegistry.h

@@ -29,9 +29,6 @@ public:
 	static std::shared_ptr < abstraction::OperationAbstraction > getXmlParserAbstraction ( const std::string & type );
 	static std::shared_ptr < abstraction::OperationAbstraction > getXmlContainerParserAbstraction ( const std::string & container, const std::string & type );
-
-	static std::shared_ptr < abstraction::UnaryOperationAbstraction < ext::deque < sax::Token >, const std::string & > > fileToTokensAbstraction ( const std::string & filename );
-	static std::shared_ptr < abstraction::BinaryOperationAbstraction < void, const ext::deque < sax::Token > &, const std::string & > > tokensToFileAbstraction ( const std::string & filename );
 };
 } /* namespace abstraction */