Index: src/Parameters/Parameter.hpp
===================================================================
--- src/Parameters/Parameter.hpp	(revision adcfc6d7420c9cfd8c6d75e8eebbf82f22a4a9aa)
+++ src/Parameters/Parameter.hpp	(revision adcfc6d7420c9cfd8c6d75e8eebbf82f22a4a9aa)
@@ -0,0 +1,54 @@
+/*
+ * Parameter.hpp
+ *
+ *  Created on: Apr 16, 2012
+ *      Author: ankele
+ */
+
+#ifndef PARAMETER_HPP_
+#define PARAMETER_HPP_
+
+
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include "Value.hpp"
+#include "ParameterInterface.hpp"
+
+/** This class encapsulates a clonable, continuous value.
+ *
+ */
+template <typename T>
+class Parameter : public ParameterInterface<T>, public Value<T>
+{
+public:
+  Parameter(const std::string &_name);
+  Parameter(const std::string &_name, const T &_value);
+  Parameter(const std::string &_name, const Validator<T> &_Validator);
+  Parameter(const std::string &_name, const Validator<T> &_Validator, const T &_value);
+  Parameter(const std::string &_name, const std::vector<T> &_ValidValues);
+  Parameter(const std::string &_name, const std::vector<T> &_ValidValues, const T &_value);
+  Parameter(const std::string &_name, const range<T> &_ValidRange);
+  Parameter(const std::string &_name, const range<T> &_ValidRange, const T &_value);
+  virtual ~Parameter();
+
+  // comparator
+  bool operator==(const Parameter<T> &_instance) const;
+  bool operator!=(const Parameter<T> &_instance) const
+      { return !((*this)==(_instance)); }
+
+  ParameterInterface<T>* clone() const;
+
+private:
+  Parameter();
+};
+
+#include "Parameter_impl.hpp"
+
+
+#endif /* PARAMETER_HPP_ */
Index: src/Parameters/ParameterInterface.hpp
===================================================================
--- src/Parameters/ParameterInterface.hpp	(revision fc32ade39e7cbae7c4fce48e5330b97f6a5c37a5)
+++ src/Parameters/ParameterInterface.hpp	(revision adcfc6d7420c9cfd8c6d75e8eebbf82f22a4a9aa)
@@ -6,6 +6,6 @@
  */
 
-#ifndef PARAMETER_HPP_
-#define PARAMETER_HPP_
+#ifndef PARAMETERINTERFACE_HPP_
+#define PARAMETERINTERFACE_HPP_
 
 // include config.h
@@ -43,3 +43,3 @@
 
 
-#endif /* PARAMETER_HPP_ */
+#endif /* PARAMETERINTERFACE_HPP_ */
Index: src/Parameters/Parameter_impl.hpp
===================================================================
--- src/Parameters/Parameter_impl.hpp	(revision adcfc6d7420c9cfd8c6d75e8eebbf82f22a4a9aa)
+++ src/Parameters/Parameter_impl.hpp	(revision adcfc6d7420c9cfd8c6d75e8eebbf82f22a4a9aa)
@@ -0,0 +1,150 @@
+/*
+ * Parameter_impl.hpp
+ *
+ *  Created on: Apr 16, 2012
+ *      Author: ankele
+ */
+
+#ifndef PARAMETER_IMPL_HPP_
+#define PARAMETER_IMPL_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "Parameter.hpp"
+
+/** Constructor for class Parameter.
+ *
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name) :
+  ParameterInterface<T>(_name),
+  Value<T>()
+{};
+
+/** Constructor for class Parameter.
+ *
+ * @param _name name of this parameter
+ * @param _value initial value to set
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name, const T &_value) :
+  ParameterInterface<T>(_name),
+  Value<T>()
+{
+  Value<T>::set(_value);
+};
+
+/** Constructor for class Parameter.
+ *
+ * @param _name name of this parameter
+ * @param _ValidRange valid range for this ContinuousValue
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name, const Validator<T> &_Validator) :
+  ParameterInterface<T>(_name),
+  Value<T>(_Validator)
+{};
+
+/** Constructor for class Parameter.
+ *
+ * @param _name name of this parameter
+ * @param _ValidRange valid range for this ContinuousValue
+ * @param _value initial value to set
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name, const Validator<T> &_Validator, const T &_value) :
+  ParameterInterface<T>(_name),
+  Value<T>(_Validator)
+{
+  Value<T>::set(_value);
+};
+
+/** Constructor for class Parameter.
+ *
+ * @param _name name of this parameter
+ * @param _ValidRange valid range for this ContinuousValue
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name, const std::vector<T> &_ValidValues) :
+  ParameterInterface<T>(_name),
+  Value<T>(_ValidValues)
+{};
+
+/** Constructor for class Parameter.
+ *
+ * @param _name name of this parameter
+ * @param _ValidRange valid range for this ContinuousValue
+ * @param _value initial value to set
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name, const std::vector<T> &_ValidValues, const T &_value) :
+  ParameterInterface<T>(_name),
+  Value<T>(_ValidValues)
+{
+  Value<T>::set(_value);
+};
+
+/** Constructor for class Parameter.
+ *
+ * @param _name name of this parameter
+ * @param _ValidRange valid range for this ContinuousValue
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name, const range<T> &_ValidRange) :
+  ParameterInterface<T>(_name),
+  Value<T>(_ValidRange)
+{};
+
+/** Constructor for class Parameter.
+ *
+ * @param _name name of this parameter
+ * @param _ValidRange valid range for this ContinuousValue
+ * @param _value initial value to set
+ */
+template<typename T>
+Parameter<T>::Parameter(const std::string &_name, const range<T> &_ValidRange, const T &_value) :
+  ParameterInterface<T>(_name),
+  Value<T>(_ValidRange)
+{
+  Value<T>::set(_value);
+};
+
+/** Destructor for class Parameter.
+ *
+ */
+template<typename T>
+Parameter<T>::~Parameter()
+{};
+
+/** Compares this continuous value against another \a _instance.
+ *
+ * @param _instance other value to compare to
+ * @return true - if contained ContinuousValue and name are the same, false - else
+ */
+template <class T>
+bool Parameter<T>::operator==(const Parameter<T> &_instance) const
+{
+  bool status = true;
+  status = status &&
+      (*dynamic_cast<const Value<T> *>(this) == dynamic_cast<const Value<T> &>(_instance));
+  status = status && (ParameterInterface<T>::getName() == _instance.ParameterInterface<T>::getName());
+  return status;
+}
+
+/** Creates a clone of this Parameter instance.
+ *
+ * @return cloned instance
+ */
+template<typename T>
+ParameterInterface<T>* Parameter<T>::clone() const
+{
+  Parameter<T> *instance = new Parameter<T>(ParameterInterface<T>::getName(), Value<T>::getValidator());
+  instance->set(Value<T>::get());
+  return instance;
+}
+
+
+#endif /* Parameter_IMPL_HPP_ */
Index: src/Parameters/unittests/ContinuousParameterTest.cpp
===================================================================
--- src/Parameters/unittests/ContinuousParameterTest.cpp	(revision fc32ade39e7cbae7c4fce48e5330b97f6a5c37a5)
+++ src/Parameters/unittests/ContinuousParameterTest.cpp	(revision adcfc6d7420c9cfd8c6d75e8eebbf82f22a4a9aa)
@@ -24,5 +24,5 @@
 #include <cppunit/ui/text/TestRunner.h>
 
-#include "Parameters/ContinuousParameter.hpp"
+#include "Parameters/Parameter.hpp"
 
 #include "../Range.hpp"
@@ -59,14 +59,14 @@
 {
   // create instance
-  ContinuousParameter<int> test("intParam", *ValidIntRange);
-  ContinuousParameter<int> samenamedsamevalued("intParam", *ValidIntRange);
-  ContinuousParameter<int> samenamedelsevalued("intParam", *ValidIntRange);
-  ContinuousParameter<int> elsenamedsamevalued("int2Param", *ValidIntRange);
-  ContinuousParameter<int> elsenamedelsevalued("int2Param", *ValidIntRange);
-  test.setValue(1);
-  samenamedsamevalued.setValue(1);
-  samenamedelsevalued.setValue(2);
-  elsenamedsamevalued.setValue(1);
-  elsenamedelsevalued.setValue(2);
+  Parameter<int> test("intParam", *ValidIntRange);
+  Parameter<int> samenamedsamevalued("intParam", *ValidIntRange);
+  Parameter<int> samenamedelsevalued("intParam", *ValidIntRange);
+  Parameter<int> elsenamedsamevalued("int2Param", *ValidIntRange);
+  Parameter<int> elsenamedelsevalued("int2Param", *ValidIntRange);
+  test.set(1);
+  samenamedsamevalued.set(1);
+  samenamedelsevalued.set(2);
+  elsenamedsamevalued.set(1);
+  elsenamedelsevalued.set(2);
 
   CPPUNIT_ASSERT( test == samenamedsamevalued );
@@ -82,5 +82,5 @@
 {
   // create instance
-  ContinuousParameter<int> test("intParam", *ValidIntRange);
+  Parameter<int> test("intParam", *ValidIntRange);
 
   // check that we throw because of unset parameter
@@ -91,9 +91,9 @@
 
   // set parameter
-  test.setValue(2);
+  test.set(2);
 
   // is returned as Parameter but we can compare only in true class as
   // Parameter may also be a DiscreteParameter where comparison is nonsense
-  ContinuousParameter<int> *instance = dynamic_cast< ContinuousParameter<int> *> (test.clone());
+  Parameter<int> *instance = dynamic_cast< Parameter<int> *> (test.clone());
 
   // different places in memory
