CommonAPI 3.1.4

1 files changed, 124 insertions, 124 deletions

diff --git a/include/CommonAPI/InputStream.hpp b/include/CommonAPI/InputStream.hpp
index f5cbc12..5e8da99 100644
--- a/include/CommonAPI/InputStream.hpp
+++ b/include/CommonAPI/InputStream.hpp
@@ -22,218 +22,218 @@
 
 namespace CommonAPI {
 
-template<class _Derived>
+template<class Derived_>
 class InputStream {
 public:
-    template<class _Deployment>
-    InputStream &readValue(bool &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(bool &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(int8_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(int8_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(int16_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(int16_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(int32_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(int32_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(int64_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(int64_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(uint8_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(uint8_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(uint16_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(uint16_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(uint32_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(uint32_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(uint64_t &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(uint64_t &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(float &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(float &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(double &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(double &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(std::string &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(std::string &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment, typename _Base>
-    InputStream &readValue(Enumeration<_Base> &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_, typename Base_>
+    InputStream &readValue(Enumeration<Base_> &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment, typename... _Types>
-    InputStream &readValue(Struct<_Types...> &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_, typename... Types_>
+    InputStream &readValue(Struct<Types_...> &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment, class _PolymorphicStruct>
-    InputStream &readValue(std::shared_ptr<_PolymorphicStruct> &_value,
-    					   const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_, class PolymorphicStruct_>
+    InputStream &readValue(std::shared_ptr<PolymorphicStruct_> &_value,
+                           const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment, typename... _Types>
-    InputStream &readValue(Variant<_Types...> &_value, const _Deployment *_depl = nullptr) {
+    template<class Deployment_, typename... Types_>
+    InputStream &readValue(Variant<Types_...> &_value, const Deployment_ *_depl = nullptr) {
         return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment, typename _ElementType>
-    InputStream &readValue(std::vector<_ElementType> &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_, typename ElementType_>
+    InputStream &readValue(std::vector<ElementType_> &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment, typename _KeyType, typename _ValueType, typename _HasherType>
-    InputStream &readValue(std::unordered_map<_KeyType, _ValueType, _HasherType> &_value,
-    					   const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_, typename KeyType_, typename ValueType_, typename HasherType_>
+    InputStream &readValue(std::unordered_map<KeyType_, ValueType_, HasherType_> &_value,
+                           const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
-    template<class _Deployment>
-    InputStream &readValue(Version &_value, const _Deployment *_depl = nullptr) {
-    	return get()->readValue(_value, _depl);
+    template<class Deployment_>
+    InputStream &readValue(Version &_value, const Deployment_ *_depl = nullptr) {
+        return get()->readValue(_value, _depl);
     }
 
     bool hasError() const {
-    	return get()->hasError();
+        return get()->hasError();
     }
 
 private:
-    inline _Derived *get() {
-    	return static_cast<_Derived *>(this);
+    inline Derived_ *get() {
+        return static_cast<Derived_ *>(this);
     }
 
-    inline const _Derived *get() const {
-    	return static_cast<const _Derived *>(this);
+    inline const Derived_ *get() const {
+        return static_cast<const Derived_ *>(this);
     }
 };
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, bool &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, bool &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, int8_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, int8_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, int16_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, int16_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, int32_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, int32_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, int64_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, int64_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, uint8_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, uint8_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, uint16_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, uint16_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, uint32_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, uint32_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, uint64_t &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, uint64_t &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, float &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, float &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, double &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, double &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, std::string &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, std::string &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, Version &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, Version &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived, typename _Base>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, Enumeration<_Base> &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_, typename Base_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, Enumeration<Base_> &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived, typename... _Types>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, Struct<_Types...> &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_, typename... Types_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, Struct<Types_...> &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived, class _PolymorphicStruct>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, std::shared_ptr<_PolymorphicStruct> &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_, class PolymorphicStruct_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, std::shared_ptr<PolymorphicStruct_> &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived, typename... _Types>
-InputStream<_Derived> & operator>>(InputStream<_Derived> &_input, Variant<_Types...> &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_, typename... Types_>
+InputStream<Derived_> & operator>>(InputStream<Derived_> &_input, Variant<Types_...> &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived, typename _ElementType>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, std::vector<_ElementType> &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_, typename ElementType_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, std::vector<ElementType_> &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived, typename _KeyType, typename _ValueType, typename _HasherType>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, std::unordered_map<_KeyType, _ValueType, _HasherType> &_value) {
-	return _input.template readValue<EmptyDeployment>(_value);
+template<class Derived_, typename KeyType_, typename ValueType_, typename HasherType_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, std::unordered_map<KeyType_, ValueType_, HasherType_> &_value) {
+    return _input.template readValue<EmptyDeployment>(_value);
 }
 
-template<class _Derived, typename _Type, typename _TypeDeployment>
-InputStream<_Derived> &operator>>(InputStream<_Derived> &_input, Deployable<_Type, _TypeDeployment> &_value) {
-	return _input.template readValue<_TypeDeployment>(_value.getValue(), _value.getDepl());
+template<class Derived_, typename Type_, typename TypeDeployment_>
+InputStream<Derived_> &operator>>(InputStream<Derived_> &_input, Deployable<Type_, TypeDeployment_> &_value) {
+    return _input.template readValue<TypeDeployment_>(_value.getValue(), _value.getDepl());
 }
 
 } // namespace CommonAPI