diff --git a/zeus/Buffer_addParameter.cpp b/zeus/Buffer_addParameter.cpp
index d3cd3df..dfc1f0c 100644
--- a/zeus/Buffer_addParameter.cpp
+++ b/zeus/Buffer_addParameter.cpp
@@ -12,6 +12,7 @@
 #include <climits>
 #include <etk/os/FSNode.h>
 #include <zeus/mineType.h>
+#include <zeus/WebServer.h>
 
 
 void zeus::addType(std::vector<uint8_t>& _data, zeus::ParamType _type) {
@@ -45,260 +46,260 @@ void zeus::Buffer::addParameterEmptyVector() {
 	addType(data, createType<std::vector<void>>());
 	m_parameter.push_back(std::make_pair(2,data));
 }
-template<>
-void zeus::Buffer::internalAddParameter<std::string>(uint16_t _paramId, const std::string& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::string>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], _value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<std::string>>(uint16_t _paramId, const std::vector<std::string>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<std::string>>());
-	// count all datas:
-	uint32_t size = 0;
-	for (auto &it : _value) {
-		size+=it.size()+1;
-	}
-	uint16_t nb = _value.size();
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+size+2);
-	memcpy(&data[currentOffset], &nb, sizeof(uint16_t));
-	currentOffset += sizeof(uint16_t);
-	for (auto &it : _value) {
-		memcpy(&data[currentOffset], &it[0], it.size());
-		currentOffset += it.size();
-		data[currentOffset] = '\0';
-		currentOffset++;
-	}
-	m_parameter.push_back(std::make_pair(2,data));
-}
-
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<bool>>(uint16_t _paramId, const std::vector<bool>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<bool>>());
-	// add size:
-	uint16_t nb = _value.size();
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	for (const auto &it : _value) {
-		if (it == true) {
-			data[currentOffset] = 'T';
-		} else {
-			data[currentOffset] = 'F';
-		}
-		currentOffset++;
-	}
-	m_parameter.push_back(std::make_pair(2,data));
-}
-
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<int8_t>>(uint16_t _paramId, const std::vector<int8_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<int8_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(int8_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<int16_t>>(uint16_t _paramId, const std::vector<int16_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<int16_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(int16_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<int32_t>>(uint16_t _paramId, const std::vector<int32_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<int32_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(int32_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<int64_t>>(uint16_t _paramId, const std::vector<int64_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<int64_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(int64_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<uint8_t>>(uint16_t _paramId, const std::vector<uint8_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<uint8_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(uint8_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<uint16_t>>(uint16_t _paramId, const std::vector<uint16_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<uint16_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(uint16_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<uint32_t>>(uint16_t _paramId, const std::vector<uint32_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<uint32_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(uint32_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<uint64_t>>(uint16_t _paramId, const std::vector<uint64_t>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<uint64_t>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(uint64_t)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<float>>(uint16_t _paramId, const std::vector<float>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<float>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(float)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-
-template<>
-void zeus::Buffer::internalAddParameter<std::vector<double>>(uint16_t _paramId, const std::vector<double>& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<std::vector<double>>());
-	// add size:
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+_value.size());
-	memcpy(&data[currentOffset], &_value[0], sizeof(double)*_value.size());
-	m_parameter.push_back(std::make_pair(2,data));
-}
-
-template<>
-void zeus::Buffer::internalAddParameter<int8_t>(uint16_t _paramId, const int8_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<int8_t>());
-	data.push_back(uint8_t(_value));
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<uint8_t>(uint16_t _paramId, const uint8_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<uint8_t>());
-	data.push_back(_value);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<int16_t>(uint16_t _paramId, const int16_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<int16_t>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+2);
-	memcpy(&data[currentOffset], &_value, 2);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<uint16_t>(uint16_t _paramId, const uint16_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<uint16_t>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+2);
-	memcpy(&data[currentOffset], &_value, 2);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<int32_t>(uint16_t _paramId, const int32_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<int32_t>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+4);
-	memcpy(&data[currentOffset], &_value, 4);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<uint32_t>(uint16_t _paramId, const uint32_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<uint32_t>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+4);
-	memcpy(&data[currentOffset], &_value, 4);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<int64_t>(uint16_t _paramId, const int64_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<int64_t>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+8);
-	memcpy(&data[currentOffset], &_value, 8);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<uint64_t>(uint16_t _paramId, const uint64_t& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<uint64_t>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+8);
-	memcpy(&data[currentOffset], &_value, 8);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<float>(uint16_t _paramId, const float& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<float>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+4);
-	memcpy(&data[currentOffset], &_value, 4);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<double>(uint16_t _paramId, const double& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<double>());
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+8);
-	memcpy(&data[currentOffset], &_value, 8);
-	m_parameter.push_back(std::make_pair(2,data));
-}
-template<>
-void zeus::Buffer::internalAddParameter<bool>(uint16_t _paramId, const bool& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<bool>());
-	if (_value == true) {
-		data.push_back('T');
-	} else {
-		data.push_back('F');
-	}
-	m_parameter.push_back(std::make_pair(2,data));
-}
-#define ZEUS_MINIMUM_SIZE_MULTIPLE (1024*50)
-
 namespace zeus {
+	template<>
+	void Buffer::internalAddParameter<std::string>(uint16_t _paramId, const std::string& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::string>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], _value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<std::string>>(uint16_t _paramId, const std::vector<std::string>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<std::string>>());
+		// count all datas:
+		uint32_t size = 0;
+		for (auto &it : _value) {
+			size+=it.size()+1;
+		}
+		uint16_t nb = _value.size();
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+size+2);
+		memcpy(&data[currentOffset], &nb, sizeof(uint16_t));
+		currentOffset += sizeof(uint16_t);
+		for (auto &it : _value) {
+			memcpy(&data[currentOffset], &it[0], it.size());
+			currentOffset += it.size();
+			data[currentOffset] = '\0';
+			currentOffset++;
+		}
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	
+	template<>
+	void Buffer::internalAddParameter<std::vector<bool>>(uint16_t _paramId, const std::vector<bool>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<bool>>());
+		// add size:
+		uint16_t nb = _value.size();
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		for (const auto &it : _value) {
+			if (it == true) {
+				data[currentOffset] = 'T';
+			} else {
+				data[currentOffset] = 'F';
+			}
+			currentOffset++;
+		}
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	
+	template<>
+	void Buffer::internalAddParameter<std::vector<int8_t>>(uint16_t _paramId, const std::vector<int8_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<int8_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(int8_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<int16_t>>(uint16_t _paramId, const std::vector<int16_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<int16_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(int16_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<int32_t>>(uint16_t _paramId, const std::vector<int32_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<int32_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(int32_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<int64_t>>(uint16_t _paramId, const std::vector<int64_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<int64_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(int64_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<uint8_t>>(uint16_t _paramId, const std::vector<uint8_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<uint8_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(uint8_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<uint16_t>>(uint16_t _paramId, const std::vector<uint16_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<uint16_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(uint16_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<uint32_t>>(uint16_t _paramId, const std::vector<uint32_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<uint32_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(uint32_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<std::vector<uint64_t>>(uint16_t _paramId, const std::vector<uint64_t>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<uint64_t>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(uint64_t)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	
+	template<>
+	void Buffer::internalAddParameter<std::vector<float>>(uint16_t _paramId, const std::vector<float>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<float>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(float)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	
+	template<>
+	void Buffer::internalAddParameter<std::vector<double>>(uint16_t _paramId, const std::vector<double>& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<std::vector<double>>());
+		// add size:
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+_value.size());
+		memcpy(&data[currentOffset], &_value[0], sizeof(double)*_value.size());
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	
+	template<>
+	void Buffer::internalAddParameter<int8_t>(uint16_t _paramId, const int8_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<int8_t>());
+		data.push_back(uint8_t(_value));
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<uint8_t>(uint16_t _paramId, const uint8_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<uint8_t>());
+		data.push_back(_value);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<int16_t>(uint16_t _paramId, const int16_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<int16_t>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+2);
+		memcpy(&data[currentOffset], &_value, 2);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<uint16_t>(uint16_t _paramId, const uint16_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<uint16_t>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+2);
+		memcpy(&data[currentOffset], &_value, 2);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<int32_t>(uint16_t _paramId, const int32_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<int32_t>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+4);
+		memcpy(&data[currentOffset], &_value, 4);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<uint32_t>(uint16_t _paramId, const uint32_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<uint32_t>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+4);
+		memcpy(&data[currentOffset], &_value, 4);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<int64_t>(uint16_t _paramId, const int64_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<int64_t>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+8);
+		memcpy(&data[currentOffset], &_value, 8);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<uint64_t>(uint16_t _paramId, const uint64_t& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<uint64_t>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+8);
+		memcpy(&data[currentOffset], &_value, 8);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<float>(uint16_t _paramId, const float& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<float>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+4);
+		memcpy(&data[currentOffset], &_value, 4);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<double>(uint16_t _paramId, const double& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<double>());
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+8);
+		memcpy(&data[currentOffset], &_value, 8);
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	template<>
+	void Buffer::internalAddParameter<bool>(uint16_t _paramId, const bool& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<bool>());
+		if (_value == true) {
+			data.push_back('T');
+		} else {
+			data.push_back('F');
+		}
+		m_parameter.push_back(std::make_pair(2,data));
+	}
+	#define ZEUS_MINIMUM_SIZE_MULTIPLE (1024*50)
+	
 	class SendData {
 		private:
 			std::vector<uint8_t> m_data;
@@ -340,38 +341,36 @@ namespace zeus {
 				return false;
 			}
 	};
-}
-template<>
-void zeus::Buffer::internalAddParameter<zeus::File>(uint16_t _paramId, const zeus::File& _value) {
-	std::vector<uint8_t> data;
-	addType(data, createType<zeus::File>());
-	// set mine type in string:
-	std::string name = _value.getMineType();
-	int32_t currentOffset = data.size();
-	data.resize(data.size()+name.size()+1);
-	memcpy(&data[currentOffset], &name[0], name.size());
-	// finish with '\0'
-	currentOffset = data.size()-1;
-	data[currentOffset] = 0;
-	// set size if the file in int32_t
-	int32_t size = _value.getTheoricFileSize();
-	currentOffset = data.size();
-	data.resize(data.size()+sizeof(int32_t));
-	memcpy(&data[currentOffset], &size, sizeof(int32_t));
-	// and now the data (can be none ...):
-	const std::vector<uint8_t>& dataFile = _value.getData();
-	if (dataFile.size() != 0) {
+	template<>
+	void Buffer::internalAddParameter<zeus::File>(uint16_t _paramId, const zeus::File& _value) {
+		std::vector<uint8_t> data;
+		addType(data, createType<zeus::File>());
+		// set mine type in string:
+		std::string name = _value.getMineType();
+		int32_t currentOffset = data.size();
+		data.resize(data.size()+name.size()+1);
+		memcpy(&data[currentOffset], &name[0], name.size());
+		// finish with '\0'
+		currentOffset = data.size()-1;
+		data[currentOffset] = 0;
+		// set size if the file in int32_t
+		int32_t size = _value.getTheoricFileSize();
 		currentOffset = data.size();
-		if (dataFile.size() < ZEUS_MINIMUM_SIZE_MULTIPLE) {
-			data.resize(data.size()+dataFile.size());
-			memcpy(&data[currentOffset], &dataFile[0], dataFile.size());
-		} else {
-			m_multipleSend.push_back(zeus::SendData(dataFile, _paramId));
+		data.resize(data.size()+sizeof(int32_t));
+		memcpy(&data[currentOffset], &size, sizeof(int32_t));
+		// and now the data (can be none ...):
+		const std::vector<uint8_t>& dataFile = _value.getData();
+		if (dataFile.size() != 0) {
+			currentOffset = data.size();
+			if (dataFile.size() < ZEUS_MINIMUM_SIZE_MULTIPLE) {
+				data.resize(data.size()+dataFile.size());
+				memcpy(&data[currentOffset], &dataFile[0], dataFile.size());
+			} else {
+				m_multipleSend.push_back(zeus::SendData(dataFile, _paramId));
+			}
 		}
+		m_parameter.push_back(std::make_pair(2,data));
 	}
-	m_parameter.push_back(std::make_pair(2,data));
-}
-namespace zeus {
 	class SendFile {
 		private:
 			etk::FSNode m_node;
@@ -416,25 +415,26 @@ namespace zeus {
 				return false;
 			}
 	};
+	
+	template<>
+	void Buffer::internalAddParameter<zeus::FileServer>(uint16_t _paramId, const zeus::FileServer& _value) {
+		etk::FSNode node(_value.getFileName());
+		node.fileOpenRead();
+		std::string extention = std::string(_value.getFileName().begin()+_value.getFileName().size() -3, _value.getFileName().end());
+		ZEUS_WARNING("send file: '" << _value.getFileName() << "' with extention: '" << extention << "'");
+		uint64_t size = node.fileSize();
+		std::vector<uint8_t> fileData;
+		if (size < ZEUS_MINIMUM_SIZE_MULTIPLE) {
+			// if the file is small ==> send directly ...
+			fileData.resize(size);
+			node.fileRead(&fileData[0], 1, size);
+		}
+		zeus::File tmpFile(zeus::getMineType(extention), fileData, size);
+		internalAddParameter(_paramId, tmpFile);
+		node.fileClose();
+		if (size >= ZEUS_MINIMUM_SIZE_MULTIPLE) {
+			m_multipleSend.push_back(zeus::SendFile(_value.getFileName(), _paramId, size));
+		}
+	}
 }
 
-template<>
-void zeus::Buffer::internalAddParameter<zeus::FileServer>(uint16_t _paramId, const zeus::FileServer& _value) {
-	etk::FSNode node(_value.getFileName());
-	node.fileOpenRead();
-	std::string extention = std::string(_value.getFileName().begin()+_value.getFileName().size() -3, _value.getFileName().end());
-	ZEUS_WARNING("send file: '" << _value.getFileName() << "' with extention: '" << extention << "'");
-	uint64_t size = node.fileSize();
-	std::vector<uint8_t> fileData;
-	if (size < ZEUS_MINIMUM_SIZE_MULTIPLE) {
-		// if the file is small ==> send directly ...
-		fileData.resize(size);
-		node.fileRead(&fileData[0], 1, size);
-	}
-	zeus::File tmpFile(zeus::getMineType(extention), fileData, size);
-	internalAddParameter(_paramId, tmpFile);
-	node.fileClose();
-	if (size >= ZEUS_MINIMUM_SIZE_MULTIPLE) {
-		m_multipleSend.push_back(zeus::SendFile(_value.getFileName(), _paramId, size));
-	}
-}
diff --git a/zeus/Buffer_getParameter.cpp b/zeus/Buffer_getParameter.cpp
index 3377a58..fbe4032 100644
--- a/zeus/Buffer_getParameter.cpp
+++ b/zeus/Buffer_getParameter.cpp
@@ -10,1457 +10,1457 @@
 #include <etk/stdTools.h>
 #include <zeus/AbstractFunction.h>
 #include <climits>
-
-template<>
-bool zeus::Buffer::internalGetParameter<bool>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	if (createType<bool>() != type) {
+namespace zeus {
+	template<>
+	bool Buffer::internalGetParameter<bool>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		if (createType<bool>() != type) {
+			return 0;
+		}
+		const char* pointer2 = reinterpret_cast<const char*>(pointer);
+		if (    *pointer2 == 'T'
+		     || *pointer2 == '1'
+		     || *pointer2 == 1) {
+			return true;
+		}
+		return false;
+	}
+	
+	template<>
+	std::string Buffer::internalGetParameter<std::string>(int32_t _id) const {
+		std::string out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		out.resize(dataSize, 0);
+		memcpy(&out[0], pointer, out.size());
+		return out;
+	}
+	
+	
+	template<>
+	uint8_t Buffer::internalGetParameter<uint8_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return std::min(*tmp, uint16_t(UCHAR_MAX));
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return std::min(*tmp, uint32_t(UCHAR_MAX));
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return std::min(*tmp, uint64_t(UCHAR_MAX));
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return std::max(int8_t(0), *tmp);
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return etk::avg(int16_t(0), *tmp, int16_t(UCHAR_MAX));
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return etk::avg(int32_t(0), *tmp, int32_t(UCHAR_MAX));
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return etk::avg(int64_t(0), *tmp, int64_t(UCHAR_MAX));
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return uint8_t(etk::avg(float(0), *tmp, float(UCHAR_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return uint8_t(etk::avg(double(0), *tmp, double(UCHAR_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
 		return 0;
 	}
-	const char* pointer2 = reinterpret_cast<const char*>(pointer);
-	if (    *pointer2 == 'T'
-	     || *pointer2 == '1'
-	     || *pointer2 == 1) {
-		return true;
+	template<>
+	uint16_t Buffer::internalGetParameter<uint16_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return std::min(*tmp, uint32_t(USHRT_MAX));
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return std::min(*tmp, uint64_t(USHRT_MAX));
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return std::max(int8_t(0), *tmp);
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return std::max(int16_t(0), *tmp);
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return etk::avg(int32_t(0), *tmp, int32_t(USHRT_MAX));
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return etk::avg(int64_t(0), *tmp, int64_t(USHRT_MAX));
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return uint16_t(etk::avg(float(0), *tmp, float(USHRT_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return uint16_t(etk::avg(double(0), *tmp, double(USHRT_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0;
 	}
-	return false;
-}
-
-template<>
-std::string zeus::Buffer::internalGetParameter<std::string>(int32_t _id) const {
-	std::string out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	out.resize(dataSize, 0);
-	memcpy(&out[0], pointer, out.size());
-	return out;
-}
-
-
-template<>
-uint8_t zeus::Buffer::internalGetParameter<uint8_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return std::min(*tmp, uint16_t(UCHAR_MAX));
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return std::min(*tmp, uint32_t(UCHAR_MAX));
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return std::min(*tmp, uint64_t(UCHAR_MAX));
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return std::max(int8_t(0), *tmp);
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return etk::avg(int16_t(0), *tmp, int16_t(UCHAR_MAX));
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return etk::avg(int32_t(0), *tmp, int32_t(UCHAR_MAX));
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return etk::avg(int64_t(0), *tmp, int64_t(UCHAR_MAX));
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return uint8_t(etk::avg(float(0), *tmp, float(UCHAR_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return uint8_t(etk::avg(double(0), *tmp, double(UCHAR_MAX)));
+	
+	template<>
+	uint32_t Buffer::internalGetParameter<uint32_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return std::min(*tmp, uint64_t(ULONG_MAX));
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return std::max(int8_t(0), *tmp);
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return std::max(int16_t(0), *tmp);
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return std::max(int32_t(0), *tmp);
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return etk::avg(int64_t(0), *tmp, int64_t(ULONG_MAX));
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return uint32_t(etk::avg(float(0), *tmp, float(ULONG_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return uint32_t(etk::avg(double(0), *tmp, double(ULONG_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-template<>
-uint16_t zeus::Buffer::internalGetParameter<uint16_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return std::min(*tmp, uint32_t(USHRT_MAX));
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return std::min(*tmp, uint64_t(USHRT_MAX));
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return std::max(int8_t(0), *tmp);
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return std::max(int16_t(0), *tmp);
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return etk::avg(int32_t(0), *tmp, int32_t(USHRT_MAX));
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return etk::avg(int64_t(0), *tmp, int64_t(USHRT_MAX));
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return uint16_t(etk::avg(float(0), *tmp, float(USHRT_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return uint16_t(etk::avg(double(0), *tmp, double(USHRT_MAX)));
+	
+	template<>
+	uint64_t Buffer::internalGetParameter<uint64_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return *tmp;
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return std::max(int8_t(0), *tmp);
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return std::max(int16_t(0), *tmp);
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return std::max(int32_t(0), *tmp);
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return std::max(int64_t(0), *tmp);
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return uint64_t(etk::avg(float(0), *tmp, float(ULONG_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return uint64_t(etk::avg(double(0), *tmp, double(ULONG_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-
-template<>
-uint32_t zeus::Buffer::internalGetParameter<uint32_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return std::min(*tmp, uint64_t(ULONG_MAX));
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return std::max(int8_t(0), *tmp);
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return std::max(int16_t(0), *tmp);
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return std::max(int32_t(0), *tmp);
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return etk::avg(int64_t(0), *tmp, int64_t(ULONG_MAX));
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return uint32_t(etk::avg(float(0), *tmp, float(ULONG_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return uint32_t(etk::avg(double(0), *tmp, double(ULONG_MAX)));
+	
+	template<>
+	int8_t Buffer::internalGetParameter<int8_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return std::min(*tmp, uint8_t(SCHAR_MAX));
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return std::min(*tmp, uint16_t(SCHAR_MAX));
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return std::min(*tmp, uint32_t(SCHAR_MAX));
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return std::min(*tmp, uint64_t(SCHAR_MAX));
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return *tmp;
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return etk::avg(int16_t(SCHAR_MIN), *tmp, int16_t(SCHAR_MAX));
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return etk::avg(int32_t(SCHAR_MIN), *tmp, int32_t(SCHAR_MAX));
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return etk::avg(int64_t(SCHAR_MIN), *tmp, int64_t(SCHAR_MAX));
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return int8_t(etk::avg(float(SCHAR_MIN), *tmp, float(SCHAR_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return int8_t(etk::avg(double(SCHAR_MIN), *tmp, double(SCHAR_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-
-template<>
-uint64_t zeus::Buffer::internalGetParameter<uint64_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return *tmp;
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return std::max(int8_t(0), *tmp);
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return std::max(int16_t(0), *tmp);
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return std::max(int32_t(0), *tmp);
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return std::max(int64_t(0), *tmp);
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return uint64_t(etk::avg(float(0), *tmp, float(ULONG_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return uint64_t(etk::avg(double(0), *tmp, double(ULONG_MAX)));
+	
+	template<>
+	int16_t Buffer::internalGetParameter<int16_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return std::min(*tmp, uint16_t(SHRT_MAX));
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return std::min(*tmp, uint32_t(SHRT_MAX));
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return std::min(*tmp, uint64_t(SHRT_MAX));
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return *tmp;
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return *tmp;
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return etk::avg(int32_t(SHRT_MIN), *tmp, int32_t(SHRT_MAX));
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return etk::avg(int64_t(SHRT_MIN), *tmp, int64_t(SHRT_MAX));
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return int16_t(etk::avg(float(SHRT_MIN), *tmp, float(SHRT_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return int16_t(etk::avg(double(SHRT_MIN), *tmp, double(SHRT_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-
-template<>
-int8_t zeus::Buffer::internalGetParameter<int8_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return std::min(*tmp, uint8_t(SCHAR_MAX));
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return std::min(*tmp, uint16_t(SCHAR_MAX));
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return std::min(*tmp, uint32_t(SCHAR_MAX));
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return std::min(*tmp, uint64_t(SCHAR_MAX));
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return *tmp;
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return etk::avg(int16_t(SCHAR_MIN), *tmp, int16_t(SCHAR_MAX));
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return etk::avg(int32_t(SCHAR_MIN), *tmp, int32_t(SCHAR_MAX));
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return etk::avg(int64_t(SCHAR_MIN), *tmp, int64_t(SCHAR_MAX));
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return int8_t(etk::avg(float(SCHAR_MIN), *tmp, float(SCHAR_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return int8_t(etk::avg(double(SCHAR_MIN), *tmp, double(SCHAR_MAX)));
+	
+	template<>
+	int32_t Buffer::internalGetParameter<int32_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return std::min(*tmp, uint32_t(LONG_MAX));
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return std::min(*tmp, uint64_t(LONG_MAX));
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return *tmp;
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return *tmp;
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return *tmp;
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return etk::avg(int64_t(LONG_MIN), *tmp, int64_t(LONG_MAX));
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return int32_t(etk::avg(float(LONG_MIN), *tmp, float(LONG_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return int32_t(etk::avg(double(LONG_MIN), *tmp, double(LONG_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-
-template<>
-int16_t zeus::Buffer::internalGetParameter<int16_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return std::min(*tmp, uint16_t(SHRT_MAX));
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return std::min(*tmp, uint32_t(SHRT_MAX));
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return std::min(*tmp, uint64_t(SHRT_MAX));
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return *tmp;
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return *tmp;
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return etk::avg(int32_t(SHRT_MIN), *tmp, int32_t(SHRT_MAX));
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return etk::avg(int64_t(SHRT_MIN), *tmp, int64_t(SHRT_MAX));
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return int16_t(etk::avg(float(SHRT_MIN), *tmp, float(SHRT_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return int16_t(etk::avg(double(SHRT_MIN), *tmp, double(SHRT_MAX)));
+	
+	template<>
+	int64_t Buffer::internalGetParameter<int64_t>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return std::min(*tmp, uint64_t(LLONG_MAX));
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return *tmp;
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return *tmp;
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return *tmp;
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return *tmp;
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return int64_t(etk::avg(float(LLONG_MIN), *tmp, float(LLONG_MAX)));
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return int64_t(etk::avg(double(LLONG_MIN), *tmp, double(LLONG_MAX)));
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-
-template<>
-int32_t zeus::Buffer::internalGetParameter<int32_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return std::min(*tmp, uint32_t(LONG_MAX));
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return std::min(*tmp, uint64_t(LONG_MAX));
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return *tmp;
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return *tmp;
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return *tmp;
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return etk::avg(int64_t(LONG_MIN), *tmp, int64_t(LONG_MAX));
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return int32_t(etk::avg(float(LONG_MIN), *tmp, float(LONG_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return int32_t(etk::avg(double(LONG_MIN), *tmp, double(LONG_MAX)));
+	
+	template<>
+	float Buffer::internalGetParameter<float>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return *tmp;
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return *tmp;
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return *tmp;
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return *tmp;
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return *tmp;
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return *tmp;
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return *tmp;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0.0f;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-
-template<>
-int64_t zeus::Buffer::internalGetParameter<int64_t>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return std::min(*tmp, uint64_t(LLONG_MAX));
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return *tmp;
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return *tmp;
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return *tmp;
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return *tmp;
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return int64_t(etk::avg(float(LLONG_MIN), *tmp, float(LLONG_MAX)));
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return int64_t(etk::avg(double(LLONG_MIN), *tmp, double(LLONG_MAX)));
+	template<>
+	double Buffer::internalGetParameter<double>(int32_t _id) const {
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<uint8_t>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint16_t>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint32_t>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			return *tmp;
+		} else if (createType<uint64_t>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			return *tmp;
+		} else if (createType<int8_t>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			return *tmp;
+		} else if (createType<int16_t>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			return *tmp;
+		} else if (createType<int32_t>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			return *tmp;
+		} else if (createType<int64_t>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			return *tmp;
+		} else if (createType<float>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			return *tmp;
+		} else if (createType<double>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			return *tmp;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return 0.0;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0;
-}
-
-template<>
-float zeus::Buffer::internalGetParameter<float>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return *tmp;
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return *tmp;
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return *tmp;
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return *tmp;
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return *tmp;
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return *tmp;
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return *tmp;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0.0f;
-}
-template<>
-double zeus::Buffer::internalGetParameter<double>(int32_t _id) const {
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<uint8_t>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint16_t>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint32_t>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		return *tmp;
-	} else if (createType<uint64_t>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		return *tmp;
-	} else if (createType<int8_t>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		return *tmp;
-	} else if (createType<int16_t>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		return *tmp;
-	} else if (createType<int32_t>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		return *tmp;
-	} else if (createType<int64_t>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		return *tmp;
-	} else if (createType<float>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		return *tmp;
-	} else if (createType<double>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		return *tmp;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return 0.0;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-template<>
-std::vector<uint8_t> zeus::Buffer::internalGetParameter<std::vector<uint8_t>>(int32_t _id) const {
-	std::vector<uint8_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(uint8_t));
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint16_t(UCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint32_t(UCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint64_t(UCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int8_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int16_t(0), tmp[iii], int16_t(UCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int32_t(0), tmp[iii], int32_t(UCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int64_t(0), tmp[iii], int64_t(UCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint8_t(etk::avg(float(0), tmp[iii], float(UCHAR_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint8_t(etk::avg(double(0), tmp[iii], double(UCHAR_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-template<>
-std::vector<uint16_t> zeus::Buffer::internalGetParameter<std::vector<uint16_t>>(int32_t _id) const {
-	std::vector<uint16_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(uint16_t));
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint32_t(USHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint64_t(USHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int8_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int16_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int32_t(0), tmp[iii], int32_t(USHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int64_t(0), tmp[iii], int64_t(USHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint16_t(etk::avg(float(0), tmp[iii], float(USHRT_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint16_t(etk::avg(double(0), tmp[iii], double(USHRT_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<uint32_t> zeus::Buffer::internalGetParameter<std::vector<uint32_t>>(int32_t _id) const {
-	std::vector<uint32_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(uint32_t));
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint64_t(ULONG_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int8_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int16_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int32_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int64_t(0), tmp[iii], int64_t(ULONG_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint32_t(etk::avg(float(0), tmp[iii], float(ULONG_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint32_t(etk::avg(double(0), tmp[iii], double(ULONG_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<uint64_t> zeus::Buffer::internalGetParameter<std::vector<uint64_t>>(int32_t _id) const {
-	std::vector<uint64_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(uint64_t));
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int8_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int16_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int32_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::max(int64_t(0), tmp[iii]);
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint64_t(etk::avg(float(0), tmp[iii], float(ULONG_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = uint64_t(etk::avg(double(0), tmp[iii], double(ULONG_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<int8_t> zeus::Buffer::internalGetParameter<std::vector<int8_t>>(int32_t _id) const {
-	std::vector<int8_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint8_t(SCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint16_t(SCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint32_t(SCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint64_t(SCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(int8_t));
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int16_t(SCHAR_MIN), tmp[iii], int16_t(SCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int32_t(SCHAR_MIN), tmp[iii], int32_t(SCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int64_t(SCHAR_MIN), tmp[iii], int64_t(SCHAR_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int8_t(etk::avg(float(SCHAR_MIN), tmp[iii], float(SCHAR_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int8_t(etk::avg(double(SCHAR_MIN), tmp[iii], double(SCHAR_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<int16_t> zeus::Buffer::internalGetParameter<std::vector<int16_t>>(int32_t _id) const {
-	std::vector<int16_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint16_t(SHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint32_t(SHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint64_t(SHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(int16_t));
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int32_t(SHRT_MIN), tmp[iii], int32_t(SHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int64_t(SHRT_MIN), tmp[iii], int64_t(SHRT_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int16_t(etk::avg(float(SHRT_MIN), tmp[iii], float(SHRT_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int16_t(etk::avg(double(SHRT_MIN), tmp[iii], double(SHRT_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<int32_t> zeus::Buffer::internalGetParameter<std::vector<int32_t>>(int32_t _id) const {
-	std::vector<int32_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint32_t(LONG_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint64_t(LONG_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(int32_t));
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = etk::avg(int64_t(LONG_MIN), tmp[iii], int64_t(LONG_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int32_t(etk::avg(float(LONG_MIN), tmp[iii], float(LONG_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int32_t(etk::avg(double(LONG_MIN), tmp[iii], double(LONG_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<int64_t> zeus::Buffer::internalGetParameter<std::vector<int64_t>>(int32_t _id) const {
-	std::vector<int64_t> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = std::min(tmp[iii], uint64_t(LLONG_MAX));
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(int64_t));
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int64_t(etk::avg(float(LLONG_MIN), tmp[iii], float(LLONG_MAX)));
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = int64_t(etk::avg(double(LLONG_MIN), tmp[iii], double(LLONG_MAX)));
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<float> zeus::Buffer::internalGetParameter<std::vector<float>>(int32_t _id) const {
-	std::vector<float> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(float));
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		const double* tmp = reinterpret_cast<const double*>(pointer);
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<double> zeus::Buffer::internalGetParameter<std::vector<double>>(int32_t _id) const {
-	std::vector<double> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<uint8_t>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint16_t>>() == type) {
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint32_t>>() == type) {
-		const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<uint64_t>>() == type) {
-		const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int8_t>>() == type) {
-		const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int16_t>>() == type) {
-		const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int16_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int32_t>>() == type) {
-		const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int32_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<int64_t>>() == type) {
-		const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(int64_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<float>>() == type) {
-		const float* tmp = reinterpret_cast<const float*>(pointer);
-		int32_t nbElement = dataSize / sizeof(float);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii];
-		}
-		return out;
-	} else if (createType<std::vector<double>>() == type) {
-		int32_t nbElement = dataSize / sizeof(double);
-		out.resize(nbElement);
-		memcpy(&out, pointer, nbElement * sizeof(double));
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<bool> zeus::Buffer::internalGetParameter<std::vector<bool>>(int32_t _id) const {
-	std::vector<bool> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<bool>>() == type) {
-		const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
-		int32_t nbElement = dataSize / sizeof(uint8_t);
-		out.resize(nbElement);
-		for (size_t iii=0; iii<nbElement; ++iii) {
-			out[iii] = tmp[iii] == 'T';
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-std::vector<std::string> zeus::Buffer::internalGetParameter<std::vector<std::string>>(int32_t _id) const {
-	std::vector<std::string> out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	if (type == createType<std::vector<void>>()) {
-		return out;
-	} else if (createType<std::vector<std::string>>() == type) {
-		// first element is the number of elements:
-		const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
-		out.resize(*tmp);
-		pointer += sizeof(uint16_t);
-		//each string is separated with a \0:
-		for (int32_t iii=0; iii<out.size(); ++iii) {
-			const char* tmp2 = reinterpret_cast<const char*>(pointer);
-			out[iii] = tmp2;
-			pointer += out[iii].size() + 1;
-		}
-		return out;
-	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
-}
-
-template<>
-zeus::File zeus::Buffer::internalGetParameter<zeus::File>(int32_t _id) const {
-	zeus::File out;
-	zeus::ParamType type = internalGetParameterType(_id);
-	const uint8_t* pointer = internalGetParameterPointer(_id);
-	uint32_t dataSize = internalGetParameterSize(_id);
-	// TODO : Check size ...
-	if (createType<zeus::File>() == type) {
-		// get mine type in string:
-		std::string mineType;
-		int32_t currentOffset = 0;
-		while (    char(pointer[currentOffset]) != '\0'
-		        && currentOffset<dataSize) {
-			mineType += char(pointer[currentOffset]);
-			currentOffset++;
-		}
-		out.setMineType(mineType);
-		// finish with '\0'
-		currentOffset ++;
-		if (currentOffset >= dataSize) {
-			ZEUS_ERROR("Parameter size is wrong ...");
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	template<>
+	std::vector<uint8_t> Buffer::internalGetParameter<std::vector<uint8_t>>(int32_t _id) const {
+		std::vector<uint8_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(uint8_t));
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint16_t(UCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint32_t(UCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint64_t(UCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int8_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int16_t(0), tmp[iii], int16_t(UCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int32_t(0), tmp[iii], int32_t(UCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int64_t(0), tmp[iii], int64_t(UCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint8_t(etk::avg(float(0), tmp[iii], float(UCHAR_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint8_t(etk::avg(double(0), tmp[iii], double(UCHAR_MAX)));
+			}
 			return out;
 		}
-		// get size if the file in int32_t
-		int32_t size = 0;
-		memcpy(&size, &pointer[currentOffset], sizeof(int32_t));
-		currentOffset += sizeof(int32_t);
-		out.preSetDataSize(dataSize);
-		// Get the datas:
-		out.setData(0, &pointer[currentOffset], dataSize);
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	template<>
+	std::vector<uint16_t> Buffer::internalGetParameter<std::vector<uint16_t>>(int32_t _id) const {
+		std::vector<uint16_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(uint16_t));
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint32_t(USHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint64_t(USHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int8_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int16_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int32_t(0), tmp[iii], int32_t(USHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int64_t(0), tmp[iii], int64_t(USHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint16_t(etk::avg(float(0), tmp[iii], float(USHRT_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint16_t(etk::avg(double(0), tmp[iii], double(USHRT_MAX)));
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<uint32_t> Buffer::internalGetParameter<std::vector<uint32_t>>(int32_t _id) const {
+		std::vector<uint32_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(uint32_t));
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint64_t(ULONG_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int8_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int16_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int32_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int64_t(0), tmp[iii], int64_t(ULONG_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint32_t(etk::avg(float(0), tmp[iii], float(ULONG_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint32_t(etk::avg(double(0), tmp[iii], double(ULONG_MAX)));
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<uint64_t> Buffer::internalGetParameter<std::vector<uint64_t>>(int32_t _id) const {
+		std::vector<uint64_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(uint64_t));
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int8_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int16_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int32_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::max(int64_t(0), tmp[iii]);
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint64_t(etk::avg(float(0), tmp[iii], float(ULONG_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = uint64_t(etk::avg(double(0), tmp[iii], double(ULONG_MAX)));
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<int8_t> Buffer::internalGetParameter<std::vector<int8_t>>(int32_t _id) const {
+		std::vector<int8_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint8_t(SCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint16_t(SCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint32_t(SCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint64_t(SCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(int8_t));
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int16_t(SCHAR_MIN), tmp[iii], int16_t(SCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int32_t(SCHAR_MIN), tmp[iii], int32_t(SCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int64_t(SCHAR_MIN), tmp[iii], int64_t(SCHAR_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int8_t(etk::avg(float(SCHAR_MIN), tmp[iii], float(SCHAR_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int8_t(etk::avg(double(SCHAR_MIN), tmp[iii], double(SCHAR_MAX)));
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<int16_t> Buffer::internalGetParameter<std::vector<int16_t>>(int32_t _id) const {
+		std::vector<int16_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint16_t(SHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint32_t(SHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint64_t(SHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(int16_t));
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int32_t(SHRT_MIN), tmp[iii], int32_t(SHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int64_t(SHRT_MIN), tmp[iii], int64_t(SHRT_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int16_t(etk::avg(float(SHRT_MIN), tmp[iii], float(SHRT_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int16_t(etk::avg(double(SHRT_MIN), tmp[iii], double(SHRT_MAX)));
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<int32_t> Buffer::internalGetParameter<std::vector<int32_t>>(int32_t _id) const {
+		std::vector<int32_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint32_t(LONG_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint64_t(LONG_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(int32_t));
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = etk::avg(int64_t(LONG_MIN), tmp[iii], int64_t(LONG_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int32_t(etk::avg(float(LONG_MIN), tmp[iii], float(LONG_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int32_t(etk::avg(double(LONG_MIN), tmp[iii], double(LONG_MAX)));
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<int64_t> Buffer::internalGetParameter<std::vector<int64_t>>(int32_t _id) const {
+		std::vector<int64_t> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = std::min(tmp[iii], uint64_t(LLONG_MAX));
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(int64_t));
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int64_t(etk::avg(float(LLONG_MIN), tmp[iii], float(LLONG_MAX)));
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = int64_t(etk::avg(double(LLONG_MIN), tmp[iii], double(LLONG_MAX)));
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<float> Buffer::internalGetParameter<std::vector<float>>(int32_t _id) const {
+		std::vector<float> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(float));
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			const double* tmp = reinterpret_cast<const double*>(pointer);
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<double> Buffer::internalGetParameter<std::vector<double>>(int32_t _id) const {
+		std::vector<double> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<uint8_t>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint16_t>>() == type) {
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint32_t>>() == type) {
+			const uint32_t* tmp = reinterpret_cast<const uint32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<uint64_t>>() == type) {
+			const uint64_t* tmp = reinterpret_cast<const uint64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int8_t>>() == type) {
+			const int8_t* tmp = reinterpret_cast<const int8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int16_t>>() == type) {
+			const int16_t* tmp = reinterpret_cast<const int16_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int16_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int32_t>>() == type) {
+			const int32_t* tmp = reinterpret_cast<const int32_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int32_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<int64_t>>() == type) {
+			const int64_t* tmp = reinterpret_cast<const int64_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(int64_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<float>>() == type) {
+			const float* tmp = reinterpret_cast<const float*>(pointer);
+			int32_t nbElement = dataSize / sizeof(float);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii];
+			}
+			return out;
+		} else if (createType<std::vector<double>>() == type) {
+			int32_t nbElement = dataSize / sizeof(double);
+			out.resize(nbElement);
+			memcpy(&out, pointer, nbElement * sizeof(double));
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<bool> Buffer::internalGetParameter<std::vector<bool>>(int32_t _id) const {
+		std::vector<bool> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<bool>>() == type) {
+			const uint8_t* tmp = reinterpret_cast<const uint8_t*>(pointer);
+			int32_t nbElement = dataSize / sizeof(uint8_t);
+			out.resize(nbElement);
+			for (size_t iii=0; iii<nbElement; ++iii) {
+				out[iii] = tmp[iii] == 'T';
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	std::vector<std::string> Buffer::internalGetParameter<std::vector<std::string>>(int32_t _id) const {
+		std::vector<std::string> out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		if (type == createType<std::vector<void>>()) {
+			return out;
+		} else if (createType<std::vector<std::string>>() == type) {
+			// first element is the number of elements:
+			const uint16_t* tmp = reinterpret_cast<const uint16_t*>(pointer);
+			out.resize(*tmp);
+			pointer += sizeof(uint16_t);
+			//each string is separated with a \0:
+			for (int32_t iii=0; iii<out.size(); ++iii) {
+				const char* tmp2 = reinterpret_cast<const char*>(pointer);
+				out[iii] = tmp2;
+				pointer += out[iii].size() + 1;
+			}
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
+		return out;
+	}
+	
+	template<>
+	zeus::File Buffer::internalGetParameter<zeus::File>(int32_t _id) const {
+		zeus::File out;
+		zeus::ParamType type = internalGetParameterType(_id);
+		const uint8_t* pointer = internalGetParameterPointer(_id);
+		uint32_t dataSize = internalGetParameterSize(_id);
+		// TODO : Check size ...
+		if (createType<zeus::File>() == type) {
+			// get mine type in string:
+			std::string mineType;
+			int32_t currentOffset = 0;
+			while (    char(pointer[currentOffset]) != '\0'
+			        && currentOffset<dataSize) {
+				mineType += char(pointer[currentOffset]);
+				currentOffset++;
+			}
+			out.setMineType(mineType);
+			// finish with '\0'
+			currentOffset ++;
+			if (currentOffset >= dataSize) {
+				ZEUS_ERROR("Parameter size is wrong ...");
+				return out;
+			}
+			// get size if the file in int32_t
+			int32_t size = 0;
+			memcpy(&size, &pointer[currentOffset], sizeof(int32_t));
+			currentOffset += sizeof(int32_t);
+			out.preSetDataSize(dataSize);
+			// Get the datas:
+			out.setData(0, &pointer[currentOffset], dataSize);
+			return out;
+		}
+		ZEUS_ERROR("Can not get type from '" << type << "'");
 		return out;
 	}
-	ZEUS_ERROR("Can not get type from '" << type << "'");
-	return out;
 }
 
-