diff --git a/alib2common/src/abstraction/CastRegistry.cpp b/alib2common/src/abstraction/CastRegistry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9338ebdc74fa547c6a32624ebe1e766dc928c56a
--- /dev/null
+++ b/alib2common/src/abstraction/CastRegistry.cpp
@@ -0,0 +1,93 @@
+/*
+ * CastRegistry.cpp
+ *
+ * Created on: 21. 7. 2017
+ * Author: Jan Travnicek
+ */
+
+#include <abstraction/CastRegistry.hpp>
+
+namespace abstraction {
+
+std::shared_ptr < abstraction::OperationAbstraction > CastRegistry::getAbstraction ( const std::string & target, const std::string & param, bool & normalize ) {
+ std::set < std::string > targetTypes;
+ if ( alib::namingApi::hasTypes ( target ) )
+ targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( target ), [ ] ( const ext::type_index & type ) { return ext::to_string ( type ); } );
+ else
+ targetTypes.insert ( target );
+
+ for ( const std::string & toType : targetTypes ) {
+ auto cast = getEntries ( ).find ( std::make_pair ( toType, param ) );
+ if ( cast != getEntries ( ).end ( ) ) {
+ normalize = cast->second->getNormalize ( );
+ return cast->second->getAbstraction ( );
+ }
+ }
+
+ throw exception::CommonException ( "Entry from " + param + " to " + target + " not available." );
+}
+
+bool CastRegistry::isNoOp ( const std::string & target, const std::string & param ) {
+ std::set < std::string > targetTypes;
+ if ( alib::namingApi::hasTypes ( target ) )
+ targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( target ), [ ] ( const ext::type_index & type ) { return ext::to_string ( type ); } );
+ else
+ targetTypes.insert ( target );
+
+ for ( const std::string & toType : targetTypes )
+ if ( param == toType )
+ return true;
+
+ return false;
+}
+
+bool CastRegistry::castAvailable ( const std::string & target, const std::string & param ) {
+ std::set < std::string > targetTypes;
+ if ( alib::namingApi::hasTypes ( target ) )
+ targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( target ), [ ] ( const ext::type_index & type ) { return ext::to_string ( type ); } );
+ else
+ targetTypes.insert ( target );
+
+ for ( const std::string & toType : targetTypes ) {
+ auto cast = getEntries ( ).find ( std::make_pair ( toType, param ) );
+ if ( cast != getEntries ( ).end ( ) )
+ return true;
+ }
+
+ return false;
+}
+
+std::shared_ptr < abstraction::OperationAbstraction > CastRegistry::getAbstraction ( const std::string & target, const std::string & param ) {
+ bool normalize;
+ return getAbstraction ( target, param, normalize );
+}
+
+void CastRegistry::listFrom ( const std::string & type ) {
+ std::set < std::string > sourceTypes;
+ if ( alib::namingApi::hasTypes ( type ) )
+ sourceTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( type ), [ ] ( const ext::type_index & raw_type ) { return ext::to_string ( raw_type ); } );
+ else
+ sourceTypes.insert ( type );
+
+ for ( const std::pair < const std::pair < std::string, std::string >, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
+ if ( sourceTypes.count ( entry.first.first ) ) {
+ std::cout << entry.first.second << std::endl;
+ }
+ }
+}
+
+void CastRegistry::listTo ( const std::string & type ) {
+ std::set < std::string > targetTypes;
+ if ( alib::namingApi::hasTypes ( type ) )
+ targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( type ), [ ] ( const ext::type_index & raw_type ) { return ext::to_string ( raw_type ); } );
+ else
+ targetTypes.insert ( type );
+
+ for ( const std::pair < const std::pair < std::string, std::string >, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
+ if ( targetTypes.count ( entry.first.second ) ) {
+ std::cout << entry.first.first << std::endl;
+ }
+ }
+}
+
+} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/CastRegistry.hpp b/alib2common/src/abstraction/CastRegistry.hpp
index 5b6d34135efe4ad9362f319aac0421fc5492cc94..06532d93d5467e76eda44ee93162725bc10e992a 100644
--- a/alib2common/src/abstraction/CastRegistry.hpp
+++ b/alib2common/src/abstraction/CastRegistry.hpp
@@ -101,86 +101,17 @@ public:
registerCastAlgorithm < TargetType, ParamType > ( target, param, callback, normalize );
}
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & target, const std::string & param, bool & normalize ) {
- std::set < std::string > targetTypes;
- if ( alib::namingApi::hasTypes ( target ) )
- targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( target ), [ ] ( const ext::type_index & type ) { return ext::to_string ( type ); } );
- else
- targetTypes.insert ( target );
-
- for ( const std::string & toType : targetTypes ) {
- auto cast = getEntries ( ).find ( std::make_pair ( toType, param ) );
- if ( cast != getEntries ( ).end ( ) ) {
- normalize = cast->second->getNormalize ( );
- return cast->second->getAbstraction ( );
- }
- }
-
- throw exception::CommonException ( "Entry from " + param + " to " + target + " not available." );
- }
-
- static bool isNoOp ( const std::string & target, const std::string & param ) {
- std::set < std::string > targetTypes;
- if ( alib::namingApi::hasTypes ( target ) )
- targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( target ), [ ] ( const ext::type_index & type ) { return ext::to_string ( type ); } );
- else
- targetTypes.insert ( target );
-
- for ( const std::string & toType : targetTypes )
- if ( param == toType )
- return true;
-
- return false;
- }
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & target, const std::string & param, bool & normalize );
- static bool castAvailable ( const std::string & target, const std::string & param ) {
- std::set < std::string > targetTypes;
- if ( alib::namingApi::hasTypes ( target ) )
- targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( target ), [ ] ( const ext::type_index & type ) { return ext::to_string ( type ); } );
- else
- targetTypes.insert ( target );
-
- for ( const std::string & toType : targetTypes ) {
- auto cast = getEntries ( ).find ( std::make_pair ( toType, param ) );
- if ( cast != getEntries ( ).end ( ) )
- return true;
- }
+ static bool isNoOp ( const std::string & target, const std::string & param );
- return false;
- }
+ static bool castAvailable ( const std::string & target, const std::string & param );
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & target, const std::string & param ) {
- bool normalize;
- return getAbstraction ( target, param, normalize );
- }
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & target, const std::string & param );
- static void listFrom ( const std::string & type ) {
- std::set < std::string > sourceTypes;
- if ( alib::namingApi::hasTypes ( type ) )
- sourceTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( type ), [ ] ( const ext::type_index & raw_type ) { return ext::to_string ( raw_type ); } );
- else
- sourceTypes.insert ( type );
-
- for ( const std::pair < const std::pair < std::string, std::string >, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
- if ( sourceTypes.count ( entry.first.first ) ) {
- std::cout << entry.first.second << std::endl;
- }
- }
- }
+ static void listFrom ( const std::string & type );
- static void listTo ( const std::string & type ) {
- std::set < std::string > targetTypes;
- if ( alib::namingApi::hasTypes ( type ) )
- targetTypes = ext::transform < std::string > ( alib::namingApi::getTypes ( type ), [ ] ( const ext::type_index & raw_type ) { return ext::to_string ( raw_type ); } );
- else
- targetTypes.insert ( type );
-
- for ( const std::pair < const std::pair < std::string, std::string >, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
- if ( targetTypes.count ( entry.first.second ) ) {
- std::cout << entry.first.first << std::endl;
- }
- }
- }
+ static void listTo ( const std::string & type );
};
diff --git a/alib2common/src/abstraction/DowncastRegistry.cpp b/alib2common/src/abstraction/DowncastRegistry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6d1be650413a519b2bda028c6b41bfd2312ee4da
--- /dev/null
+++ b/alib2common/src/abstraction/DowncastRegistry.cpp
@@ -0,0 +1,20 @@
+/*
+ * DowncastRegistry.cpp
+ *
+ * Created on: 21. 8. 2017
+ * Author: Jan Travnicek
+ */
+
+#include <abstraction/DowncastRegistry.hpp>
+
+namespace abstraction {
+
+std::shared_ptr < abstraction::OperationAbstraction > DowncastRegistry::getAbstraction ( const std::string & concrete, const std::string & base ) {
+ auto res = getEntries ( ).find ( std::make_pair ( concrete, base ) );
+ if ( res == getEntries ( ).end ( ) )
+ throw exception::CommonException ( "Entry " + concrete + ", " + base + " not available." );
+
+ return res->second->getAbstraction ( );
+}
+
+} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/DowncastRegistry.hpp b/alib2common/src/abstraction/DowncastRegistry.hpp
index 25e4621ecb28e6353df608cd6247c2bde97ef980..331f477e699a5a25063e343fd28991820290bfaa 100644
--- a/alib2common/src/abstraction/DowncastRegistry.hpp
+++ b/alib2common/src/abstraction/DowncastRegistry.hpp
@@ -46,13 +46,7 @@ public:
throw ::exception::CommonException ( "Downcasting for " + base + " to " + concrete + " already registered." );
}
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & concrete, const std::string & base ) {
- auto res = getEntries ( ).find ( std::make_pair ( concrete, base ) );
- if ( res == getEntries ( ).end ( ) )
- throw exception::CommonException ( "Entry " + concrete + ", " + base + " not available." );
-
- return res->second->getAbstraction ( );
- }
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & concrete, const std::string & base );
};
} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/ImmediateRegistry.cpp b/alib2common/src/abstraction/ImmediateRegistry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4dcd5cd19e83386b08a8ce4f39ef3a202bddb008
--- /dev/null
+++ b/alib2common/src/abstraction/ImmediateRegistry.cpp
@@ -0,0 +1,20 @@
+/*
+ * ImmediateRegistry.cpp
+ *
+ * Created on: 21. 8. 2017
+ * Author: Jan Travnicek
+ */
+
+#include <abstraction/ImmediateRegistry.hpp>
+
+namespace abstraction {
+
+std::shared_ptr < abstraction::OperationAbstraction > ImmediateRegistry::getAbstraction ( const std::string & result, std::string value ) {
+ auto res = getEntries ( ).find ( result );
+ if ( res == getEntries ( ).end ( ) )
+ throw exception::CommonException ( "Entry " + result + " not available." );
+
+ return res->second->getAbstraction ( std::move ( value ) );
+}
+
+} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/ImmediateRegistry.hpp b/alib2common/src/abstraction/ImmediateRegistry.hpp
index d7884d14db5de6041462f7a1af65b97fc98299b9..369995e00170859c4a54a23afd92355eabe736d1 100644
--- a/alib2common/src/abstraction/ImmediateRegistry.hpp
+++ b/alib2common/src/abstraction/ImmediateRegistry.hpp
@@ -52,13 +52,7 @@ public:
registerImmediate < ResultType > ( std::move ( result ) );
}
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & result, std::string value ) {
- auto res = getEntries ( ).find ( result );
- if ( res == getEntries ( ).end ( ) )
- throw exception::CommonException ( "Entry " + result + " not available." );
-
- return res->second->getAbstraction ( std::move ( value ) );
- }
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & result, std::string value );
};
} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/NormalizeRegistry.cpp b/alib2common/src/abstraction/NormalizeRegistry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c47a9153ee0cd43449ba694fdbceef5d3d68a1e
--- /dev/null
+++ b/alib2common/src/abstraction/NormalizeRegistry.cpp
@@ -0,0 +1,20 @@
+/*
+ * NormalizeRegistry.cpp
+ *
+ * Created on: 21. 8. 2017
+ * Author: Jan Travnicek
+ */
+
+#include <abstraction/NormalizeRegistry.hpp>
+
+namespace abstraction {
+
+std::shared_ptr < abstraction::OperationAbstraction > NormalizeRegistry::getAbstraction ( const std::string & param ) {
+ auto res = getEntries ( ).find ( param );
+ if ( res == getEntries ( ).end ( ) )
+ throw exception::CommonException ( "Entry " + param + " not available." );
+
+ return res->second->getAbstraction ( );
+}
+
+} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/NormalizeRegistry.hpp b/alib2common/src/abstraction/NormalizeRegistry.hpp
index a777bc7190c69fa36f711dead00e8a9dd6a0929e..a5791d6d000991d4bcf78a1b0cc2644eda553be9 100644
--- a/alib2common/src/abstraction/NormalizeRegistry.hpp
+++ b/alib2common/src/abstraction/NormalizeRegistry.hpp
@@ -49,13 +49,7 @@ public:
registerNormalize < ParamType > ( std::move ( param ) );
}
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param ) {
- auto res = getEntries ( ).find ( param );
- if ( res == getEntries ( ).end ( ) )
- throw exception::CommonException ( "Entry " + param + " not available." );
-
- return res->second->getAbstraction ( );
- }
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
};
} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/ValuePrinterRegistry.cpp b/alib2common/src/abstraction/ValuePrinterRegistry.cpp
index 39e39fc57965b4d3e46a821af6626a0a6fa7b08c..89c5198a72266cc7ac9fcb4998923fe3fc43948d 100644
--- a/alib2common/src/abstraction/ValuePrinterRegistry.cpp
+++ b/alib2common/src/abstraction/ValuePrinterRegistry.cpp
@@ -9,6 +9,14 @@
namespace abstraction {
+std::shared_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::getAbstraction ( const std::string & param ) {
+ auto res = getEntries ( ).find ( param );
+ if ( res == getEntries ( ).end ( ) )
+ throw exception::CommonException ( "Entry " + param + " not available." );
+
+ return res->second->getAbstraction ( );
+}
+
template < >
std::shared_ptr < abstraction::OperationAbstraction > ValuePrinterRegistry::EntryImpl < void >::getAbstraction ( ) const {
return std::make_shared < abstraction::ValuePrinterAbstraction < void > > ( );
diff --git a/alib2common/src/abstraction/ValuePrinterRegistry.hpp b/alib2common/src/abstraction/ValuePrinterRegistry.hpp
index 92b4f370ad3eba18ffa5b75a41a8dc305b046163..ccf6d3694a17915214c9f270995444ee97177293 100644
--- a/alib2common/src/abstraction/ValuePrinterRegistry.hpp
+++ b/alib2common/src/abstraction/ValuePrinterRegistry.hpp
@@ -49,13 +49,7 @@ public:
registerValuePrinter < ParamType > ( std::move ( param ) );
}
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param ) {
- auto res = getEntries ( ).find ( param );
- if ( res == getEntries ( ).end ( ) )
- throw exception::CommonException ( "Entry " + param + " not available." );
-
- return res->second->getAbstraction ( );
- }
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param );
};
} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/XmlFileWriterRegistry.cpp b/alib2common/src/abstraction/XmlFileWriterRegistry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad3209356877e0539bab8c0448da40867b54b07c
--- /dev/null
+++ b/alib2common/src/abstraction/XmlFileWriterRegistry.cpp
@@ -0,0 +1,33 @@
+/*
+ * XmlFileWriterRegistry.cpp
+ *
+ * Created on: 21. 8. 2017
+ * Author: Jan Travnicek
+ */
+
+#include <abstraction/XmlFileWriterRegistry.hpp>
+
+namespace abstraction {
+
+std::shared_ptr < abstraction::OperationAbstraction > XmlFileWriterRegistry::getAbstraction ( const std::string & param, std::string filename ) {
+ auto res = getEntries ( ).find ( param );
+ if ( res == getEntries ( ).end ( ) )
+ throw exception::CommonException ( "Entry " + param + " not available." );
+
+ return res->second->getAbstraction ( std::move ( filename ) );
+}
+
+void XmlFileWriterRegistry::listGroup ( const std::string & group ) {
+ for ( const std::pair < const std::string, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
+ if ( entry.first.find ( group ) == 0 ) //found at the begining
+ std::cout << entry.first << std::endl;
+ }
+}
+
+void XmlFileWriterRegistry::list ( ) {
+ for ( const std::pair < const std::string, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
+ std::cout << entry.first << std::endl;
+ }
+}
+
+} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/XmlFileWriterRegistry.hpp b/alib2common/src/abstraction/XmlFileWriterRegistry.hpp
index 937360501cf83689ac990473b0036eba258b98f1..2f1ae777843e692c487bad92b22b9dac317b2942 100644
--- a/alib2common/src/abstraction/XmlFileWriterRegistry.hpp
+++ b/alib2common/src/abstraction/XmlFileWriterRegistry.hpp
@@ -49,26 +49,11 @@ public:
registerXmlFileWriter < ParamType > ( std::move ( param ) );
}
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param, std::string filename ) {
- auto res = getEntries ( ).find ( param );
- if ( res == getEntries ( ).end ( ) )
- throw exception::CommonException ( "Entry " + param + " not available." );
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & param, std::string filename );
- return res->second->getAbstraction ( std::move ( filename ) );
- }
-
- static void listGroup ( const std::string & group ) {
- for ( const std::pair < const std::string, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
- if ( entry.first.find ( group ) == 0 ) //found at the begining
- std::cout << entry.first << std::endl;
- }
- }
+ static void listGroup ( const std::string & group );
- static void list ( ) {
- for ( const std::pair < const std::string, std::unique_ptr < Entry > > & entry : getEntries ( ) ) {
- std::cout << entry.first << std::endl;
- }
- }
+ static void list ( );
};
} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/XmlParserRegistry.cpp b/alib2common/src/abstraction/XmlParserRegistry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c5a2f12c595117e506df0357e3ce618c27ec1a3
--- /dev/null
+++ b/alib2common/src/abstraction/XmlParserRegistry.cpp
@@ -0,0 +1,20 @@
+/*
+ * XmlParserRegistry.cpp
+ *
+ * Created on: 21. 8. 2017
+ * Author: Jan Travnicek
+ */
+
+#include <abstraction/XmlParserRegistry.hpp>
+
+namespace abstraction {
+
+std::shared_ptr < abstraction::OperationAbstraction > XmlParserRegistry::getAbstraction ( const std::string & typeName, ext::deque < sax::Token > tokens ) {
+ auto type = getEntries ( ).find ( typeName );
+ if ( type == getEntries ( ).end ( ) )
+ throw exception::CommonException ( "Entry " + typeName + " not available." );
+
+ return type->second->getAbstraction ( std::move ( tokens ) );
+}
+
+} /* namespace abstraction */
diff --git a/alib2common/src/abstraction/XmlParserRegistry.hpp b/alib2common/src/abstraction/XmlParserRegistry.hpp
index 40664eff9f1ce13ebaa69c122dd0e346bd450843..7adf27a9d021819a11d75360360aee63c5a64d62 100644
--- a/alib2common/src/abstraction/XmlParserRegistry.hpp
+++ b/alib2common/src/abstraction/XmlParserRegistry.hpp
@@ -45,13 +45,7 @@ public:
getEntries ( ).insert ( std::make_pair ( ret, std::unique_ptr < Entry > ( new EntryImpl < ReturnType > ( ) ) ) );
}
- static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typeName, ext::deque < sax::Token > tokens ) {
- auto type = getEntries ( ).find ( typeName );
- if ( type == getEntries ( ).end ( ) )
- throw exception::CommonException ( "Entry " + typeName + " not available." );
-
- return type->second->getAbstraction ( std::move ( tokens ) );
- }
+ static std::shared_ptr < abstraction::OperationAbstraction > getAbstraction ( const std::string & typeName, ext::deque < sax::Token > tokens );
};
} /* namespace abstraction */