Index: c/Parser/ContinuousValue.hpp
===================================================================
--- src/Parser/ContinuousValue.hpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,69 +1,0 @@
-/*
- * ContinuousValue.hpp
- *
- *  Created on: Sep 28, 2011
- *      Author: heber
- */
-
-#ifndef CONTINUOUSVALUE_HPP_
-#define CONTINUOUSVALUE_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <string>
-
-#include "CodePatterns/Range.hpp"
-#include "CodePatterns/toString.hpp"
-
-#include "ValueInterface.hpp"
-
-class ContinuousValueTest;
-
-/** This class represents a discrete value, it implements ValueInterface.
- *
- */
-template <class T>
-class ContinuousValue : public ValueInterface
-{
-  //!> unit test needs to have access to internal values
-  friend class ContinuousValueTest;
-public:
-  ContinuousValue();
-  ContinuousValue(const range<T> &_ValidRange);
-  virtual ~ContinuousValue();
-
-  // functions for ValueInterface
-  bool isValid(const std::string _value) const;
-  const std::string get() const;
-  void set(const std::string _value);
-
-  // getter/setter for valid ranges
-  void setValidRange(const range<T> &_range);
-  const range<T> & getValidRange() const;
-
-  // internal functions alike to ValueInterface
-  bool isValidValue(const T &_value) const;
-  void setValue(const T &_value);
-  const T &getValue() const;
-
-private:
-  //!> Internal converter from string to internal type
-  static ConvertTo<T> Converter;
-
-  //!> whether \a value has been set
-  bool ValueSet;
-  //!> contained value
-  T value;
-
-  //!> whether \a min, i.e. a minimal value, has been set
-  range<bool> ValidRangeSet;
-  //!> valid range of values
-  range<T> ValidRange;
-};
-
-#include "ContinuousValue_impl.hpp"
-
-#endif /* CONTINUOUSVALUE_HPP_ */
Index: c/Parser/ContinuousValue_impl.hpp
===================================================================
--- src/Parser/ContinuousValue_impl.hpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,182 +1,0 @@
-/*
- * ContinuousValue_impl.hpp
- *
- *  Created on: Sep 29, 2011
- *      Author: heber
- */
-
-#ifndef CONTINUOUSVALUE_IMPL_HPP_
-#define CONTINUOUSVALUE_IMPL_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <string>
-
-#include <boost/any.hpp>
-
-#include "CodePatterns/Assert.hpp"
-#include "CodePatterns/Log.hpp"
-#include "CodePatterns/Range.hpp"
-
-#include "ContinuousValue.hpp"
-
-// static member
-template <class T> ConvertTo<T> ContinuousValue<T>::Converter;
-
-/** Constructor of class DiscreteValue.
- */
-template <class T>
-ContinuousValue<T>::ContinuousValue() :
-  ValueSet(false),
-  ValidRangeSet(range<bool>(false, false))
-{}
-
-/** Constructor of class DiscreteValue with set of valid values.
- *
- * @param _ValidValues vector with all valid values
- */
-template <class T>
-ContinuousValue<T>::ContinuousValue(const range<T> &_ValidRange) :
-  ValueSet(false),
-  ValidRangeSet(range<bool>(true, true)),
-  ValidRange(_ValidRange)
-{
-//  LOG(0, "STATUS: Valid range is now " << ValidRange << ".");
-}
-
-/** Destructor of class DiscreteValue.
- */
-template <class T>
-ContinuousValue<T>::~ContinuousValue()
-{}
-
-/** Checks whether \a _value is a valid value.
- * \param _value value to check for validity.
- * \return true - \a _value is valid, false - is not
- */
-template <class T>
-bool ContinuousValue<T>::isValid(const std::string _value) const
-{
-  const T castvalue = Converter(_value);
-//  LOG(0, "Converted value reads " << castvalue <<".");
-  return isValidValue(castvalue);
-}
-
-/** Getter of value, returning string.
- *
- * @return string value
- */
-template <class T>
-const std::string ContinuousValue<T>::get() const
-{
-  ASSERT(ValueSet,
-      "ContinuousValue<T>::get() - requesting unset value.");
-  return toString(value);
-}
-
-/** Setter of value for string
- *
- * @param _value string containing new value
- */
-template <class T>
-void ContinuousValue<T>::set(const std::string _value)
-{
-  const T castvalue = Converter(_value);
-//  LOG(0, "Converted value reads " << castvalue <<".");
-  setValue(castvalue);
-//  LOG(0, "STATUS: Value is now set to " << value << ".");
-}
-
-/** Setter for the valid range.
- *
- * If value is invalid in new range, we throw AssertFailure and set ValueSet to false.
- *
- * @param _range range (pair of values)
- */
-template <class T>
-void ContinuousValue<T>::setValidRange(const range<T> &_range)
-{
-
-  ValidRangeSet = range<bool>(true, true);
-  ValidRange = _range;
-  if (ValueSet) {
-    //std::cout << "Checking whether " << value << " is in range " << ValidRange << "." << std::endl;
-    if (!((ValidRange.isInRange(value)) || (value == ValidRange.last))) {
-      //std::cout << "ValueSet to false." << std::endl;
-      ValueSet = false;
-      // have full check again in assert such that it appears in output, too
-      ASSERT(ValidRange.isInRange(value) || (value == ValidRange.last),
-          "ContinuousValue<T>::setValidRange() - new range "
-          +toString(_range)+" invalidates current value "+toString(value)+".");
-    }
-  }
-//  LOG(0, "STATUS: Valid range is now " << ValidRange << ".");
-}
-
-/** Getter for the valid range.
- *
- * @return _range range (pair of values)
- */
-template <class T>
-const range<T> & ContinuousValue<T>::getValidRange() const
-{
-  ASSERT(ValidRangeSet.first && ValidRangeSet.last,
-      "ContinuousValue<T>::getValidRange() called though no valid range set so far.");
-  return ValidRange;
-}
-
-/** Checks whether \a _value is a valid value.
- * \param _value value to check for validity.
- * \return true - \a _value is valid, false - is not
- */
-template <class T>
-bool ContinuousValue<T>::isValidValue(const T &_value) const
-{
-  bool isBefore = true;
-  bool isBeyond = true;
-  // check left boundary
-  isBefore = !((!ValidRangeSet.first) || (!ValidRange.isBefore(_value)));
-//  if (isBefore)
-//    LOG(0, "INFO: " << _value << " is before " << ValidRange.first << ".");
-  // check right boundary
-  isBeyond = !((!ValidRangeSet.last) || (!ValidRange.isBeyond(_value)) || (_value == ValidRange.last));
-//  if (isBeyond)
-//    LOG(0, "INFO: " << _value << " is beyond " << ValidRange.last << ".");
-  return (!isBefore) && (!isBeyond);
-}
-
-
-/** Sets the value.
- *
- * We check for its validity, otherwise we throw an Assert::AssertionFailure.
- *
- * @param _value const reference of value to set
- */
-template <class T>
-void ContinuousValue<T>::setValue(const T &_value)
-{
-  ASSERT(isValidValue(_value),
-      "ContinuousValue<T>::setValue() - trying to set invalid value "+toString(_value)+".");
-  if (!ValueSet)
-    ValueSet = true;
-  value = _value;
-}
-
-/** Getter fot the set value.
- *
- * We check whether it has been set, otherwise we throw an Assert::AssertionFailure.
- *
- * @return set value
- */
-template <class T>
-const T &ContinuousValue<T>::getValue() const
-{
-  ASSERT(ValueSet,
-      "ContinuousValue<T>::get() - value has never been set.");
-  return value;
-}
-
-#endif /* CONTINUOUSVALUE_IMPL_HPP_ */
Index: c/Parser/DiscreteValue.hpp
===================================================================
--- src/Parser/DiscreteValue.hpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,74 +1,0 @@
-/*
- * DiscreteValue.hpp
- *
- *  Created on: Sep 28, 2011
- *      Author: heber
- */
-
-#ifndef DISCRETEVALUE_HPP_
-#define DISCRETEVALUE_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <string>
-#include <vector>
-
-#include "CodePatterns/toString.hpp"
-
-#include "ValueInterface.hpp"
-
-class DiscreteValueTest;
-
-/** This class represents a discrete value.
- *
- */
-template <class T>
-class DiscreteValue : public ValueInterface
-{
-  //!> unit test needs to have access to internal values
-  friend class DiscreteValueTest;
-public:
-  DiscreteValue();
-  DiscreteValue(const std::vector<T> &_ValidValues);
-  virtual ~DiscreteValue();
-
-  // functions for ValueInterface
-  bool isValid(const std::string _value) const;
-  const std::string get() const;
-  void set(const std::string _value);
-
-  // setter/getter for valid values
-  void appendValidValue(const T &_value);
-  const std::vector<T> &getValidValues() const;
-
-  // internal getter and setter
-  bool isValidValue(const T &_value) const;
-  void setValue(const T &_value);
-  const T & getValue() const;
-  const size_t getIndexOfValue() const { return value; }
-
-private:
-  const size_t findIndexOfValue(const T &_value) const;
-
-private:
-  //!> Internal converter from string to internal type
-  static ConvertTo<T> Converter;
-
-  //!> Typedef for the vector of valid values.
-  typedef std::vector<T> ValidRange;
-
-  //!> whether a value has been set or not
-  bool ValueSet;
-
-  //!> we only store the index within the \a ValidValues for the value
-  size_t value;
-  //!> list of valid values
-  std::vector<T> ValidValues;
-};
-
-#include "DiscreteValue_impl.hpp"
-
-#endif /* DISCRETEVALUE_HPP_ */
Index: c/Parser/DiscreteValue_impl.hpp
===================================================================
--- src/Parser/DiscreteValue_impl.hpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,181 +1,0 @@
-/*
- * DiscreteValues_impl.hpp
- *
- *  Created on: Sep 28, 2011
- *      Author: heber
- */
-
-#ifndef DISCRETEVALUE_IMPL_HPP_
-#define DISCRETEVALUE_IMPL_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <algorithm>
-#include <vector>
-
-#include <boost/any.hpp>
-
-#include "CodePatterns/Assert.hpp"
-
-#include "CodePatterns/Log.hpp"
-
-// static member
-template <class T> ConvertTo<T> DiscreteValue<T>::Converter;
-
-/** Constructor of class DiscreteValue.
- */
-template <class T>
-DiscreteValue<T>::DiscreteValue() :
-  ValueSet(false)
-{}
-
-/** Constructor of class DiscreteValue with set of valid values.
- *
- * @param _ValidValues vector with all valid values
- */
-template <class T>
-DiscreteValue<T>::DiscreteValue(const std::vector<T> &_ValidValues) :
-  ValueSet(false),
-  ValidValues(_ValidValues)
-{}
-
-/** Destructor of class DiscreteValue.
- */
-template <class T>
-DiscreteValue<T>::~DiscreteValue()
-{}
-
-/** Checks whether \a _value is a valid value.
- * \param _value value to check for validity.
- * \return true - \a _value is valid, false - is not
- */
-template <class T>
-bool DiscreteValue<T>::isValid(const std::string _value) const
-{
-  const T castvalue = Converter(_value);
-  return isValidValue(castvalue);
-}
-
-/** Getter of value, returning string.
- *
- * @return string value
- */
-template <class T>
-const std::string DiscreteValue<T>::get() const
-{
-  ASSERT(ValueSet,
-      "DiscreteValue<T>::get() - requesting unset value.");
-  return toString(getValue());
-}
-
-/** Setter of value for string
- *
- * @param _value string containing new value
- */
-template <class T>
-void DiscreteValue<T>::set(const std::string _value)
-{
-  const T castvalue = Converter(_value);
-  setValue(castvalue);
-}
-
-
-/** Internal function for finding the index of a desired value.
- *
- * \note As this is internal, we do not ASSERT value's presence, but return -1
- * such that other functions may ASSERT on that.
- *
- * \param _value value to get the index of
- * \return index such that ValidValues[index] == _value
- */
-template <class T>
-const size_t DiscreteValue<T>::findIndexOfValue(const T &_value) const
-{
-  size_t index = 0;
-  const size_t max = ValidValues.size();
-  for (; index < max; ++index) {
-    if (ValidValues[index] == _value)
-      break;
-  }
-  if (index == max)
-    return (size_t)-1;
-  else
-    return index;
-}
-
-/** Adds another value to the valid ones.
- *
- * We check whether its already present, otherwise we throw an Assert::AssertionFailure.
- *
- * @param _value value to add
- */
-template <class T>
-void DiscreteValue<T>::appendValidValue(const T &_value)
-{
-  ASSERT(!isValidValue(_value),
-      "DiscreteValue<>::appendValidValue() - value "+toString(_value)+" is already among the valid");
-  ValidValues.push_back(_value);
-}
-
-/** Returns all possible valid values.
- *
- * @return vector with all allowed values
- */
-template <class T>
-const std::vector<T> &DiscreteValue<T>::getValidValues() const
-{
-  return ValidValues;
-}
-
-/** Sets the value.
- *
- * We check for its validity, otherwise we throw an Assert::AssertionFailure.
- *
- * @param _value const reference of value to set
- */
-template <class T>
-void DiscreteValue<T>::setValue(const T &_value)
-{
-  const size_t index = findIndexOfValue(_value);
-  ASSERT(index != (size_t)-1,
-      "DiscreteValue<>::set() - value "+toString(_value)+" is not valid.");
-  if (!ValueSet)
-    ValueSet = true;
-  value = index;
-}
-
-/** Getter for the set value.
- *
- * We check whether it has been set, otherwise we throw an Assert::AssertionFailure.
- *
- * @return set value
- */
-template <class T>
-const T & DiscreteValue<T>::getValue() const
-{
-  ASSERT(ValueSet,
-      "DiscreteValue<>::get() - value has never been set.");
-  return ValidValues[value];
-}
-
-/** Checks whether \a _value is a valid value.
- * \param _value value to check for validity.
- * \return true - \a _value is valid, false - is not
- */
-template <class T>
-bool DiscreteValue<T>::isValidValue(const T &_value) const
-{
-  typename ValidRange::const_iterator iter = std::find(ValidValues.begin(), ValidValues.end(), _value);
-  if (iter != ValidValues.end()) {
-    //std::cout << "Found " << _value << ":" << *iter << std::endl;
-    return true;
-  } else {
-    //std::cout << "Did not find " << _value << "." << std::endl;
-    return false;
-  }
-}
-
-#endif /* DISCRETEVALUE_IMPL_HPP_ */
Index: src/Parser/Makefile.am
===================================================================
--- src/Parser/Makefile.am	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ src/Parser/Makefile.am	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -42,9 +42,17 @@
   Parser/XyzParser.hpp
 
+PARSERPARAMETERSSOURCE =
+
+PARSERPARAMETERSHEADER = \
+  Parser/Parameters/ContinuousValue.hpp \
+  Parser/Parameters/ContinuousValue_impl.hpp \
+  Parser/Parameters/DiscreteValue.hpp \
+  Parser/Parameters/DiscreteValue_impl.hpp \
+  Parser/Parameters/ValueInterface.hpp
 
 noinst_LTLIBRARIES += libMolecuilderParser.la
 libMolecuilderParser_la_includedir = $(includedir)/MoleCuilder/Parser/
 
-nobase_libMolecuilderParser_la_include_HEADERS = ${PARSERHEADER}
+nobase_libMolecuilderParser_la_include_HEADERS = ${PARSERHEADER} ${PARSERPARAMETERSHEADER}
 
 ## Define the source file list for the "libexample-@MOLECUILDER_API_VERSION@.la"
@@ -56,5 +64,5 @@
 ## from each source file.  Note that it is not necessary to list header files
 ## which are already listed elsewhere in a _HEADERS variable assignment.
-libMolecuilderParser_la_SOURCES = ${PARSERSOURCE}
+libMolecuilderParser_la_SOURCES = ${PARSERSOURCE} ${PARSERPARAMETERSSOURCE}
 
 ## Instruct libtool to include ABI version information in the generated shared
Index: src/Parser/Parameters/ContinuousValue.hpp
===================================================================
--- src/Parser/Parameters/ContinuousValue.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/ContinuousValue.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,69 @@
+/*
+ * ContinuousValue.hpp
+ *
+ *  Created on: Sep 28, 2011
+ *      Author: heber
+ */
+
+#ifndef CONTINUOUSVALUE_HPP_
+#define CONTINUOUSVALUE_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include "CodePatterns/Range.hpp"
+#include "CodePatterns/toString.hpp"
+
+#include "ValueInterface.hpp"
+
+class ContinuousValueTest;
+
+/** This class represents a discrete value, it implements ValueInterface.
+ *
+ */
+template <class T>
+class ContinuousValue : public ValueInterface
+{
+  //!> unit test needs to have access to internal values
+  friend class ContinuousValueTest;
+public:
+  ContinuousValue();
+  ContinuousValue(const range<T> &_ValidRange);
+  virtual ~ContinuousValue();
+
+  // functions for ValueInterface
+  bool isValid(const std::string _value) const;
+  const std::string get() const;
+  void set(const std::string _value);
+
+  // getter/setter for valid ranges
+  void setValidRange(const range<T> &_range);
+  const range<T> & getValidRange() const;
+
+  // internal functions alike to ValueInterface
+  bool isValidValue(const T &_value) const;
+  void setValue(const T &_value);
+  const T &getValue() const;
+
+private:
+  //!> Internal converter from string to internal type
+  static ConvertTo<T> Converter;
+
+  //!> whether \a value has been set
+  bool ValueSet;
+  //!> contained value
+  T value;
+
+  //!> whether \a min, i.e. a minimal value, has been set
+  range<bool> ValidRangeSet;
+  //!> valid range of values
+  range<T> ValidRange;
+};
+
+#include "ContinuousValue_impl.hpp"
+
+#endif /* CONTINUOUSVALUE_HPP_ */
Index: src/Parser/Parameters/ContinuousValue_impl.hpp
===================================================================
--- src/Parser/Parameters/ContinuousValue_impl.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/ContinuousValue_impl.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,182 @@
+/*
+ * ContinuousValue_impl.hpp
+ *
+ *  Created on: Sep 29, 2011
+ *      Author: heber
+ */
+
+#ifndef CONTINUOUSVALUE_IMPL_HPP_
+#define CONTINUOUSVALUE_IMPL_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include <boost/any.hpp>
+
+#include "CodePatterns/Assert.hpp"
+#include "CodePatterns/Log.hpp"
+#include "CodePatterns/Range.hpp"
+
+#include "ContinuousValue.hpp"
+
+// static member
+template <class T> ConvertTo<T> ContinuousValue<T>::Converter;
+
+/** Constructor of class DiscreteValue.
+ */
+template <class T>
+ContinuousValue<T>::ContinuousValue() :
+  ValueSet(false),
+  ValidRangeSet(range<bool>(false, false))
+{}
+
+/** Constructor of class DiscreteValue with set of valid values.
+ *
+ * @param _ValidValues vector with all valid values
+ */
+template <class T>
+ContinuousValue<T>::ContinuousValue(const range<T> &_ValidRange) :
+  ValueSet(false),
+  ValidRangeSet(range<bool>(true, true)),
+  ValidRange(_ValidRange)
+{
+//  LOG(0, "STATUS: Valid range is now " << ValidRange << ".");
+}
+
+/** Destructor of class DiscreteValue.
+ */
+template <class T>
+ContinuousValue<T>::~ContinuousValue()
+{}
+
+/** Checks whether \a _value is a valid value.
+ * \param _value value to check for validity.
+ * \return true - \a _value is valid, false - is not
+ */
+template <class T>
+bool ContinuousValue<T>::isValid(const std::string _value) const
+{
+  const T castvalue = Converter(_value);
+//  LOG(0, "Converted value reads " << castvalue <<".");
+  return isValidValue(castvalue);
+}
+
+/** Getter of value, returning string.
+ *
+ * @return string value
+ */
+template <class T>
+const std::string ContinuousValue<T>::get() const
+{
+  ASSERT(ValueSet,
+      "ContinuousValue<T>::get() - requesting unset value.");
+  return toString(value);
+}
+
+/** Setter of value for string
+ *
+ * @param _value string containing new value
+ */
+template <class T>
+void ContinuousValue<T>::set(const std::string _value)
+{
+  const T castvalue = Converter(_value);
+//  LOG(0, "Converted value reads " << castvalue <<".");
+  setValue(castvalue);
+//  LOG(0, "STATUS: Value is now set to " << value << ".");
+}
+
+/** Setter for the valid range.
+ *
+ * If value is invalid in new range, we throw AssertFailure and set ValueSet to false.
+ *
+ * @param _range range (pair of values)
+ */
+template <class T>
+void ContinuousValue<T>::setValidRange(const range<T> &_range)
+{
+
+  ValidRangeSet = range<bool>(true, true);
+  ValidRange = _range;
+  if (ValueSet) {
+    //std::cout << "Checking whether " << value << " is in range " << ValidRange << "." << std::endl;
+    if (!((ValidRange.isInRange(value)) || (value == ValidRange.last))) {
+      //std::cout << "ValueSet to false." << std::endl;
+      ValueSet = false;
+      // have full check again in assert such that it appears in output, too
+      ASSERT(ValidRange.isInRange(value) || (value == ValidRange.last),
+          "ContinuousValue<T>::setValidRange() - new range "
+          +toString(_range)+" invalidates current value "+toString(value)+".");
+    }
+  }
+//  LOG(0, "STATUS: Valid range is now " << ValidRange << ".");
+}
+
+/** Getter for the valid range.
+ *
+ * @return _range range (pair of values)
+ */
+template <class T>
+const range<T> & ContinuousValue<T>::getValidRange() const
+{
+  ASSERT(ValidRangeSet.first && ValidRangeSet.last,
+      "ContinuousValue<T>::getValidRange() called though no valid range set so far.");
+  return ValidRange;
+}
+
+/** Checks whether \a _value is a valid value.
+ * \param _value value to check for validity.
+ * \return true - \a _value is valid, false - is not
+ */
+template <class T>
+bool ContinuousValue<T>::isValidValue(const T &_value) const
+{
+  bool isBefore = true;
+  bool isBeyond = true;
+  // check left boundary
+  isBefore = !((!ValidRangeSet.first) || (!ValidRange.isBefore(_value)));
+//  if (isBefore)
+//    LOG(0, "INFO: " << _value << " is before " << ValidRange.first << ".");
+  // check right boundary
+  isBeyond = !((!ValidRangeSet.last) || (!ValidRange.isBeyond(_value)) || (_value == ValidRange.last));
+//  if (isBeyond)
+//    LOG(0, "INFO: " << _value << " is beyond " << ValidRange.last << ".");
+  return (!isBefore) && (!isBeyond);
+}
+
+
+/** Sets the value.
+ *
+ * We check for its validity, otherwise we throw an Assert::AssertionFailure.
+ *
+ * @param _value const reference of value to set
+ */
+template <class T>
+void ContinuousValue<T>::setValue(const T &_value)
+{
+  ASSERT(isValidValue(_value),
+      "ContinuousValue<T>::setValue() - trying to set invalid value "+toString(_value)+".");
+  if (!ValueSet)
+    ValueSet = true;
+  value = _value;
+}
+
+/** Getter fot the set value.
+ *
+ * We check whether it has been set, otherwise we throw an Assert::AssertionFailure.
+ *
+ * @return set value
+ */
+template <class T>
+const T &ContinuousValue<T>::getValue() const
+{
+  ASSERT(ValueSet,
+      "ContinuousValue<T>::get() - value has never been set.");
+  return value;
+}
+
+#endif /* CONTINUOUSVALUE_IMPL_HPP_ */
Index: src/Parser/Parameters/DiscreteValue.hpp
===================================================================
--- src/Parser/Parameters/DiscreteValue.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/DiscreteValue.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,74 @@
+/*
+ * DiscreteValue.hpp
+ *
+ *  Created on: Sep 28, 2011
+ *      Author: heber
+ */
+
+#ifndef DISCRETEVALUE_HPP_
+#define DISCRETEVALUE_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+#include <vector>
+
+#include "CodePatterns/toString.hpp"
+
+#include "ValueInterface.hpp"
+
+class DiscreteValueTest;
+
+/** This class represents a discrete value.
+ *
+ */
+template <class T>
+class DiscreteValue : public ValueInterface
+{
+  //!> unit test needs to have access to internal values
+  friend class DiscreteValueTest;
+public:
+  DiscreteValue();
+  DiscreteValue(const std::vector<T> &_ValidValues);
+  virtual ~DiscreteValue();
+
+  // functions for ValueInterface
+  bool isValid(const std::string _value) const;
+  const std::string get() const;
+  void set(const std::string _value);
+
+  // setter/getter for valid values
+  void appendValidValue(const T &_value);
+  const std::vector<T> &getValidValues() const;
+
+  // internal getter and setter
+  bool isValidValue(const T &_value) const;
+  void setValue(const T &_value);
+  const T & getValue() const;
+  const size_t getIndexOfValue() const { return value; }
+
+private:
+  const size_t findIndexOfValue(const T &_value) const;
+
+private:
+  //!> Internal converter from string to internal type
+  static ConvertTo<T> Converter;
+
+  //!> Typedef for the vector of valid values.
+  typedef std::vector<T> ValidRange;
+
+  //!> whether a value has been set or not
+  bool ValueSet;
+
+  //!> we only store the index within the \a ValidValues for the value
+  size_t value;
+  //!> list of valid values
+  std::vector<T> ValidValues;
+};
+
+#include "DiscreteValue_impl.hpp"
+
+#endif /* DISCRETEVALUE_HPP_ */
Index: src/Parser/Parameters/DiscreteValue_impl.hpp
===================================================================
--- src/Parser/Parameters/DiscreteValue_impl.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/DiscreteValue_impl.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,181 @@
+/*
+ * DiscreteValues_impl.hpp
+ *
+ *  Created on: Sep 28, 2011
+ *      Author: heber
+ */
+
+#ifndef DISCRETEVALUE_IMPL_HPP_
+#define DISCRETEVALUE_IMPL_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/any.hpp>
+
+#include "CodePatterns/Assert.hpp"
+
+#include "CodePatterns/Log.hpp"
+
+// static member
+template <class T> ConvertTo<T> DiscreteValue<T>::Converter;
+
+/** Constructor of class DiscreteValue.
+ */
+template <class T>
+DiscreteValue<T>::DiscreteValue() :
+  ValueSet(false)
+{}
+
+/** Constructor of class DiscreteValue with set of valid values.
+ *
+ * @param _ValidValues vector with all valid values
+ */
+template <class T>
+DiscreteValue<T>::DiscreteValue(const std::vector<T> &_ValidValues) :
+  ValueSet(false),
+  ValidValues(_ValidValues)
+{}
+
+/** Destructor of class DiscreteValue.
+ */
+template <class T>
+DiscreteValue<T>::~DiscreteValue()
+{}
+
+/** Checks whether \a _value is a valid value.
+ * \param _value value to check for validity.
+ * \return true - \a _value is valid, false - is not
+ */
+template <class T>
+bool DiscreteValue<T>::isValid(const std::string _value) const
+{
+  const T castvalue = Converter(_value);
+  return isValidValue(castvalue);
+}
+
+/** Getter of value, returning string.
+ *
+ * @return string value
+ */
+template <class T>
+const std::string DiscreteValue<T>::get() const
+{
+  ASSERT(ValueSet,
+      "DiscreteValue<T>::get() - requesting unset value.");
+  return toString(getValue());
+}
+
+/** Setter of value for string
+ *
+ * @param _value string containing new value
+ */
+template <class T>
+void DiscreteValue<T>::set(const std::string _value)
+{
+  const T castvalue = Converter(_value);
+  setValue(castvalue);
+}
+
+
+/** Internal function for finding the index of a desired value.
+ *
+ * \note As this is internal, we do not ASSERT value's presence, but return -1
+ * such that other functions may ASSERT on that.
+ *
+ * \param _value value to get the index of
+ * \return index such that ValidValues[index] == _value
+ */
+template <class T>
+const size_t DiscreteValue<T>::findIndexOfValue(const T &_value) const
+{
+  size_t index = 0;
+  const size_t max = ValidValues.size();
+  for (; index < max; ++index) {
+    if (ValidValues[index] == _value)
+      break;
+  }
+  if (index == max)
+    return (size_t)-1;
+  else
+    return index;
+}
+
+/** Adds another value to the valid ones.
+ *
+ * We check whether its already present, otherwise we throw an Assert::AssertionFailure.
+ *
+ * @param _value value to add
+ */
+template <class T>
+void DiscreteValue<T>::appendValidValue(const T &_value)
+{
+  ASSERT(!isValidValue(_value),
+      "DiscreteValue<>::appendValidValue() - value "+toString(_value)+" is already among the valid");
+  ValidValues.push_back(_value);
+}
+
+/** Returns all possible valid values.
+ *
+ * @return vector with all allowed values
+ */
+template <class T>
+const std::vector<T> &DiscreteValue<T>::getValidValues() const
+{
+  return ValidValues;
+}
+
+/** Sets the value.
+ *
+ * We check for its validity, otherwise we throw an Assert::AssertionFailure.
+ *
+ * @param _value const reference of value to set
+ */
+template <class T>
+void DiscreteValue<T>::setValue(const T &_value)
+{
+  const size_t index = findIndexOfValue(_value);
+  ASSERT(index != (size_t)-1,
+      "DiscreteValue<>::set() - value "+toString(_value)+" is not valid.");
+  if (!ValueSet)
+    ValueSet = true;
+  value = index;
+}
+
+/** Getter for the set value.
+ *
+ * We check whether it has been set, otherwise we throw an Assert::AssertionFailure.
+ *
+ * @return set value
+ */
+template <class T>
+const T & DiscreteValue<T>::getValue() const
+{
+  ASSERT(ValueSet,
+      "DiscreteValue<>::get() - value has never been set.");
+  return ValidValues[value];
+}
+
+/** Checks whether \a _value is a valid value.
+ * \param _value value to check for validity.
+ * \return true - \a _value is valid, false - is not
+ */
+template <class T>
+bool DiscreteValue<T>::isValidValue(const T &_value) const
+{
+  typename ValidRange::const_iterator iter = std::find(ValidValues.begin(), ValidValues.end(), _value);
+  if (iter != ValidValues.end()) {
+    //std::cout << "Found " << _value << ":" << *iter << std::endl;
+    return true;
+  } else {
+    //std::cout << "Did not find " << _value << "." << std::endl;
+    return false;
+  }
+}
+
+#endif /* DISCRETEVALUE_IMPL_HPP_ */
Index: src/Parser/Parameters/ValueInterface.hpp
===================================================================
--- src/Parser/Parameters/ValueInterface.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/ValueInterface.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,29 @@
+/*
+ * ValueInterface.hpp
+ *
+ *  Created on: Sep 28, 2011
+ *      Author: heber
+ */
+
+#ifndef VALUEINTERFACE_HPP_
+#define VALUEINTERFACE_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/** Interface definition for general parameter values.
+ *
+ */
+class ValueInterface
+{
+public:
+  virtual ~ValueInterface() {};
+
+  virtual bool isValid(const std::string _value) const=0;
+  virtual const std::string get() const=0;
+  virtual void set(const std::string _value)=0;
+};
+
+#endif /* VALUEINTERFACE_HPP_ */
Index: src/Parser/Parameters/unittests/ContinuousValueUnitTest.cpp
===================================================================
--- src/Parser/Parameters/unittests/ContinuousValueUnitTest.cpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/unittests/ContinuousValueUnitTest.cpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,194 @@
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
+
+/*
+ * ContinuousValueUnitTest.cpp
+ *
+ *  Created on: Sep 29, 2011
+ *      Author: heber
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "ContinuousValueUnitTest.hpp"
+
+#include <cppunit/CompilerOutputter.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/ui/text/TestRunner.h>
+
+#include "Parser/Parameters/ContinuousValue.hpp"
+
+#include "CodePatterns/toString.hpp"
+
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
+
+// Registers the fixture into the 'registry'
+CPPUNIT_TEST_SUITE_REGISTRATION( ContinuousValueTest );
+
+
+void ContinuousValueTest::setUp()
+{
+  // failing asserts should be thrown
+  ASSERT_DO(Assert::Throw);
+
+  ValidRange = new range<int>(1,4);
+}
+
+void ContinuousValueTest::tearDown()
+{
+  delete ValidRange;
+}
+
+/************************************ tests ***********************************/
+
+/** Unit test for isValid.
+ *
+ */
+void ContinuousValueTest::isValidValueTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidRange);
+
+  // checking valid values
+  for (int i=1; i<=4;++i)
+    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
+
+  // checking invalid values
+  for (int i=-10; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+  for (int i=5; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+}
+
+/** Unit test for isValid.
+ *
+ */
+void ContinuousValueTest::isValidTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidRange);
+
+  // checking valid values
+  for (int i=1; i<=4;++i)
+    CPPUNIT_ASSERT_EQUAL(true, test.isValid(toString(i)));
+
+  // checking invalid values
+  for (int i=-10; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
+  for (int i=5; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
+}
+
+/** Unit test for setting/getting valid range.
+ *
+ */
+void ContinuousValueTest::setgetValidRangeTest()
+{
+  {
+    // create instance
+    ContinuousValue<int> test(*ValidRange);
+
+    // extending range and checking
+    for (int i=5; i<=6;++i)
+      CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+    test.setValidRange(range<int>(1,6));
+    for (int i=5; i<=6;++i)
+      CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
+  }
+
+  {
+    // create instance
+    ContinuousValue<int> test(*ValidRange);
+
+    // lowering range with set value
+    test.setValue(4);
+    CPPUNIT_ASSERT_EQUAL(true, test.ValueSet);
+#ifndef NDEBUG
+    std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+    CPPUNIT_ASSERT_THROW(test.setValidRange(range<int>(1,3)), Assert::AssertionFailure);
+#else
+    test.setValidRange(range<int>(1,3));
+#endif
+#ifndef NDEBUG
+    // no value is not set
+    std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+    CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
+#endif
+    // value gets invalidated in either case
+    CPPUNIT_ASSERT_EQUAL(false, test.ValueSet);
+  }
+}
+
+/** Unit test for setValue and getValue.
+ *
+ */
+void ContinuousValueTest::settergetterValueTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidRange);
+
+  // unset calling of get, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.getValue(), Assert::AssertionFailure);
+#endif
+
+  // setting invalid, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.setValue(5), Assert::AssertionFailure);
+#endif
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.setValue(0), Assert::AssertionFailure);
+#endif
+
+  CPPUNIT_ASSERT_EQUAL(false, test.ValueSet);
+  // checking all valid ones
+  for (int i=1; i<=4;++i) {
+    test.setValue(i);
+    CPPUNIT_ASSERT_EQUAL(true, test.ValueSet);
+    CPPUNIT_ASSERT_EQUAL(i, test.getValue());
+  }
+}
+
+/** Unit test for setters and getters.
+ *
+ */
+void ContinuousValueTest::settergetterTest()
+{
+  // create instance
+  ContinuousValue<int> test(*ValidRange);
+
+  // unset calling of get, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
+#endif
+
+  // setting invalid, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.set(toString(5)), Assert::AssertionFailure);
+#endif
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.set(toString(0)), Assert::AssertionFailure);
+#endif
+
+  // checking all valid ones
+  for (int i=1; i<=4;++i) {
+    test.set(toString(i));
+    CPPUNIT_ASSERT_EQUAL(toString(i), test.get());
+  }
+}
+
Index: src/Parser/Parameters/unittests/ContinuousValueUnitTest.hpp
===================================================================
--- src/Parser/Parameters/unittests/ContinuousValueUnitTest.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/unittests/ContinuousValueUnitTest.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,45 @@
+/*
+ * ContinuousValueUnitTest.hpp
+ *
+ *  Created on: Sep 29, 2011
+ *      Author: heber
+ */
+#ifndef CONTINUOUSVALUEUNITTEST_HPP_
+#define CONTINUOUSVALUEUNITTEST_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include <cppunit/extensions/HelperMacros.h>
+
+template<class T> struct range;
+
+class ContinuousValueTest :  public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( ContinuousValueTest ) ;
+  CPPUNIT_TEST ( isValidValueTest );
+  CPPUNIT_TEST ( isValidTest );
+  CPPUNIT_TEST ( setgetValidRangeTest );
+  CPPUNIT_TEST ( settergetterValueTest );
+  CPPUNIT_TEST ( settergetterTest );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void isValidValueTest();
+  void isValidTest();
+  void setgetValidRangeTest();
+  void settergetterValueTest();
+  void settergetterTest();
+
+private:
+  range<int> *ValidRange;
+};
+
+#endif /* CONTINUOUSVALUEUNITTEST_HPP_ */
Index: src/Parser/Parameters/unittests/DiscreteValueUnitTest.cpp
===================================================================
--- src/Parser/Parameters/unittests/DiscreteValueUnitTest.cpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/unittests/DiscreteValueUnitTest.cpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,213 @@
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
+
+/*
+ * DiscreteValueUnitTest.cpp
+ *
+ *  Created on: Sep 28, 2011
+ *      Author: heber
+ */
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "DiscreteValueUnitTest.hpp"
+
+#include <cppunit/CompilerOutputter.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/ui/text/TestRunner.h>
+
+#include "Parser/Parameters/DiscreteValue.hpp"
+
+#include "CodePatterns/toString.hpp"
+
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
+
+using namespace std;
+
+// Registers the fixture into the 'registry'
+CPPUNIT_TEST_SUITE_REGISTRATION( DiscreteValueTest );
+
+
+void DiscreteValueTest::setUp()
+{
+  // failing asserts should be thrown
+  ASSERT_DO(Assert::Throw);
+
+  for (int i=1; i<=3;++i) {
+    ValidValues.push_back(i);
+  }
+}
+
+void DiscreteValueTest::tearDown()
+{
+  ValidValues.clear();
+}
+
+/************************************ tests ***********************************/
+
+/** Unit test for findIndexOfValue.
+ *
+ */
+void DiscreteValueTest::findIndexOfValueTest()
+{
+  // create instance
+  DiscreteValue<int> test(ValidValues);
+
+  // check valid values indices
+  CPPUNIT_ASSERT_EQUAL((size_t)0, test.findIndexOfValue(1));
+  CPPUNIT_ASSERT_EQUAL((size_t)1, test.findIndexOfValue(2));
+  CPPUNIT_ASSERT_EQUAL((size_t)2, test.findIndexOfValue(3));
+
+  // check invalid ones
+  for (int i=-10; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL((size_t)-1, test.findIndexOfValue(i));
+  for (int i=4; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL((size_t)-1, test.findIndexOfValue(i));
+}
+
+/** Unit test for isValidValue.
+ *
+ */
+void DiscreteValueTest::isValidValueTest()
+{
+  // create instance
+  DiscreteValue<int> test(ValidValues);
+
+  // checking valid values
+  for (int i=1; i<=3;++i)
+    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
+
+  // checking invalid values
+  for (int i=-10; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+  for (int i=4; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+}
+
+/** Unit test for isValid.
+ *
+ */
+void DiscreteValueTest::isValidTest()
+{
+  // create instance
+  DiscreteValue<int> test(ValidValues);
+
+  // checking valid values
+  for (int i=1; i<=3;++i)
+    CPPUNIT_ASSERT_EQUAL(true, test.isValid(toString(i)));
+
+  // checking invalid values
+  for (int i=-10; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
+  for (int i=4; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
+}
+
+/** Unit test for appendValidValue.
+ *
+ */
+void DiscreteValueTest::appendValidValueTest()
+{
+  // create instance
+  DiscreteValue<int> test(ValidValues);
+
+  // adding values 4,5,6
+  for (int i=4; i<=6;++i) {
+    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+    test.appendValidValue(i);
+    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
+  }
+
+  // adding same value, throws assertion
+  const size_t size_before = test.ValidValues.size();
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  for (int i=1; i<=6;++i)
+    CPPUNIT_ASSERT_THROW(test.appendValidValue(i), Assert::AssertionFailure);
+#endif
+  CPPUNIT_ASSERT_EQUAL( size_before, test.ValidValues.size() );
+
+  // checking valid values
+  for (int i=1; i<=6;++i)
+    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
+
+  // checking invalid values
+  for (int i=-10; i<=0;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+
+  // checking invalid values
+  for (int i=7; i<=10;++i)
+    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
+}
+
+/** Unit test for setters and getters.
+ *
+ */
+void DiscreteValueTest::settergetterTest()
+{
+  // create instance
+  DiscreteValue<int> test(ValidValues);
+
+  // unset calling of get, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
+#endif
+
+  // setting invalid, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.set(toString(4)), Assert::AssertionFailure);
+#endif
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.set(toString(0)), Assert::AssertionFailure);
+#endif
+
+  // checking all valid ones
+  for (int i=1; i<=3;++i) {
+    test.set(toString(i));
+    CPPUNIT_ASSERT_EQUAL(toString(i), test.get());
+  }
+
+}
+
+/** Unit test for setValue and getValue.
+ *
+ */
+void DiscreteValueTest::settergetterValueTest()
+{
+  // create instance
+  DiscreteValue<int> test(ValidValues);
+
+  // unset calling of get, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.getValue(), Assert::AssertionFailure);
+#endif
+
+  // setting invalid, throws
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.setValue(4), Assert::AssertionFailure);
+#endif
+#ifndef NDEBUG
+  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
+  CPPUNIT_ASSERT_THROW(test.setValue(0), Assert::AssertionFailure);
+#endif
+
+  // checking all valid ones
+  for (int i=1; i<=3;++i) {
+    test.setValue(i);
+    CPPUNIT_ASSERT_EQUAL(i, test.getValue());
+  }
+}
Index: src/Parser/Parameters/unittests/DiscreteValueUnitTest.hpp
===================================================================
--- src/Parser/Parameters/unittests/DiscreteValueUnitTest.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/unittests/DiscreteValueUnitTest.hpp	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,45 @@
+/*
+ * DiscreteValueUnitTest.hpp
+ *
+ *  Created on: Sep 28, 2011
+ *      Author: heber
+ */
+#ifndef DISCRETEVALUEUNITTEST_HPP_
+#define DISCRETEVALUEUNITTEST_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <cppunit/extensions/HelperMacros.h>
+
+#include <vector>
+
+class DiscreteValueTest :  public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( DiscreteValueTest ) ;
+  CPPUNIT_TEST ( findIndexOfValueTest );
+  CPPUNIT_TEST ( isValidValueTest );
+  CPPUNIT_TEST ( isValidTest );
+  CPPUNIT_TEST ( appendValidValueTest );
+  CPPUNIT_TEST ( settergetterTest );
+  CPPUNIT_TEST ( settergetterValueTest );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void findIndexOfValueTest();
+  void isValidValueTest();
+  void isValidTest();
+  void appendValidValueTest();
+  void settergetterTest();
+  void settergetterValueTest();
+
+private:
+  std::vector<int> ValidValues;
+};
+
+#endif /* DISCRETEVALUEUNITTEST_HPP_ */
Index: src/Parser/Parameters/unittests/Makefile.am
===================================================================
--- src/Parser/Parameters/unittests/Makefile.am	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
+++ src/Parser/Parameters/unittests/Makefile.am	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -0,0 +1,40 @@
+# PLEASE adhere to the alphabetical ordering in this Makefile!
+# Also indentation by a single tab
+
+
+PARSERPARAMETERSTESTSSOURCES = \
+	../Parser/Parameters/unittests/ContinuousValueUnitTest.cpp \
+	../Parser/Parameters/unittests/DiscreteValueUnitTest.cpp
+
+PARSERPARAMETERSTESTSHEADERS = \
+	../Parser/Parameters/unittests/ContinuousValueUnitTest.hpp \
+	../Parser/Parameters/unittests/DiscreteValueUnitTest.hpp
+
+PARSERPARAMETERSTESTS = \
+	ContinuousValueUnitTest \
+	DiscreteValueUnitTest
+
+TESTS += $(PARSERPARAMETERSTESTS)
+check_PROGRAMS += $(PARSERPARAMETERSTESTS) 
+noinst_PROGRAMS += $(PARSERPARAMETERSTESTS)
+
+PARSERPARAMETERSLIBS =
+
+
+ContinuousValueUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
+	../Parser/Parameters/unittests/ContinuousValueUnitTest.cpp \
+	../Parser/Parameters/unittests/ContinuousValueUnitTest.hpp \
+	../Parser/Parameters/ContinuousValue.hpp \
+	../Parser/Parameters/ContinuousValue_impl.hpp
+ContinuousValueUnitTest_LDADD = \
+	$(PARSERPARAMETERSLIBS)
+ 
+DiscreteValueUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
+	../Parser/Parameters/unittests/DiscreteValueUnitTest.cpp \
+	../Parser/Parameters/unittests/DiscreteValueUnitTest.hpp \
+	../Parser/Parameters/DiscreteValue.hpp \
+	../Parser/Parameters/DiscreteValue_impl.hpp
+DiscreteValueUnitTest_LDADD = \
+	$(PARSERPARAMETERSLIBS)
+ 
+#AUTOMAKE_OPTIONS = parallel-tests
Index: c/Parser/ValueInterface.hpp
===================================================================
--- src/Parser/ValueInterface.hpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,29 +1,0 @@
-/*
- * ValueInterface.hpp
- *
- *  Created on: Sep 28, 2011
- *      Author: heber
- */
-
-#ifndef VALUEINTERFACE_HPP_
-#define VALUEINTERFACE_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-/** Interface definition for general parameter values.
- *
- */
-class ValueInterface
-{
-public:
-  virtual ~ValueInterface() {};
-
-  virtual bool isValid(const std::string _value) const=0;
-  virtual const std::string get() const=0;
-  virtual void set(const std::string _value)=0;
-};
-
-#endif /* VALUEINTERFACE_HPP_ */
Index: c/Parser/unittests/ContinuousValueUnitTest.cpp
===================================================================
--- src/Parser/unittests/ContinuousValueUnitTest.cpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,194 +1,0 @@
-/*
- * Project: MoleCuilder
- * Description: creates and alters molecular systems
- * Copyright (C)  2010 University of Bonn. All rights reserved.
- * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
- */
-
-/*
- * ContinuousValueUnitTest.cpp
- *
- *  Created on: Sep 29, 2011
- *      Author: heber
- */
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "ContinuousValueUnitTest.hpp"
-
-#include <cppunit/CompilerOutputter.h>
-#include <cppunit/extensions/TestFactoryRegistry.h>
-#include <cppunit/ui/text/TestRunner.h>
-
-#include "Parser/ContinuousValue.hpp"
-
-#include "CodePatterns/toString.hpp"
-
-#ifdef HAVE_TESTRUNNER
-#include "UnitTestMain.hpp"
-#endif /*HAVE_TESTRUNNER*/
-
-// Registers the fixture into the 'registry'
-CPPUNIT_TEST_SUITE_REGISTRATION( ContinuousValueTest );
-
-
-void ContinuousValueTest::setUp()
-{
-  // failing asserts should be thrown
-  ASSERT_DO(Assert::Throw);
-
-  ValidRange = new range<int>(1,4);
-}
-
-void ContinuousValueTest::tearDown()
-{
-  delete ValidRange;
-}
-
-/************************************ tests ***********************************/
-
-/** Unit test for isValid.
- *
- */
-void ContinuousValueTest::isValidValueTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
-
-  // checking valid values
-  for (int i=1; i<=4;++i)
-    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
-
-  // checking invalid values
-  for (int i=-10; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-  for (int i=5; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-}
-
-/** Unit test for isValid.
- *
- */
-void ContinuousValueTest::isValidTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
-
-  // checking valid values
-  for (int i=1; i<=4;++i)
-    CPPUNIT_ASSERT_EQUAL(true, test.isValid(toString(i)));
-
-  // checking invalid values
-  for (int i=-10; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
-  for (int i=5; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
-}
-
-/** Unit test for setting/getting valid range.
- *
- */
-void ContinuousValueTest::setgetValidRangeTest()
-{
-  {
-    // create instance
-    ContinuousValue<int> test(*ValidRange);
-
-    // extending range and checking
-    for (int i=5; i<=6;++i)
-      CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-    test.setValidRange(range<int>(1,6));
-    for (int i=5; i<=6;++i)
-      CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
-  }
-
-  {
-    // create instance
-    ContinuousValue<int> test(*ValidRange);
-
-    // lowering range with set value
-    test.setValue(4);
-    CPPUNIT_ASSERT_EQUAL(true, test.ValueSet);
-#ifndef NDEBUG
-    std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-    CPPUNIT_ASSERT_THROW(test.setValidRange(range<int>(1,3)), Assert::AssertionFailure);
-#else
-    test.setValidRange(range<int>(1,3));
-#endif
-#ifndef NDEBUG
-    // no value is not set
-    std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-    CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
-#endif
-    // value gets invalidated in either case
-    CPPUNIT_ASSERT_EQUAL(false, test.ValueSet);
-  }
-}
-
-/** Unit test for setValue and getValue.
- *
- */
-void ContinuousValueTest::settergetterValueTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
-
-  // unset calling of get, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.getValue(), Assert::AssertionFailure);
-#endif
-
-  // setting invalid, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.setValue(5), Assert::AssertionFailure);
-#endif
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.setValue(0), Assert::AssertionFailure);
-#endif
-
-  CPPUNIT_ASSERT_EQUAL(false, test.ValueSet);
-  // checking all valid ones
-  for (int i=1; i<=4;++i) {
-    test.setValue(i);
-    CPPUNIT_ASSERT_EQUAL(true, test.ValueSet);
-    CPPUNIT_ASSERT_EQUAL(i, test.getValue());
-  }
-}
-
-/** Unit test for setters and getters.
- *
- */
-void ContinuousValueTest::settergetterTest()
-{
-  // create instance
-  ContinuousValue<int> test(*ValidRange);
-
-  // unset calling of get, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
-#endif
-
-  // setting invalid, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.set(toString(5)), Assert::AssertionFailure);
-#endif
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.set(toString(0)), Assert::AssertionFailure);
-#endif
-
-  // checking all valid ones
-  for (int i=1; i<=4;++i) {
-    test.set(toString(i));
-    CPPUNIT_ASSERT_EQUAL(toString(i), test.get());
-  }
-}
-
Index: c/Parser/unittests/ContinuousValueUnitTest.hpp
===================================================================
--- src/Parser/unittests/ContinuousValueUnitTest.hpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,45 +1,0 @@
-/*
- * ContinuousValueUnitTest.hpp
- *
- *  Created on: Sep 29, 2011
- *      Author: heber
- */
-#ifndef CONTINUOUSVALUEUNITTEST_HPP_
-#define CONTINUOUSVALUEUNITTEST_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <string>
-
-#include <cppunit/extensions/HelperMacros.h>
-
-template<class T> struct range;
-
-class ContinuousValueTest :  public CppUnit::TestFixture
-{
-  CPPUNIT_TEST_SUITE( ContinuousValueTest ) ;
-  CPPUNIT_TEST ( isValidValueTest );
-  CPPUNIT_TEST ( isValidTest );
-  CPPUNIT_TEST ( setgetValidRangeTest );
-  CPPUNIT_TEST ( settergetterValueTest );
-  CPPUNIT_TEST ( settergetterTest );
-  CPPUNIT_TEST_SUITE_END();
-
-public:
-  void setUp();
-  void tearDown();
-
-  void isValidValueTest();
-  void isValidTest();
-  void setgetValidRangeTest();
-  void settergetterValueTest();
-  void settergetterTest();
-
-private:
-  range<int> *ValidRange;
-};
-
-#endif /* CONTINUOUSVALUEUNITTEST_HPP_ */
Index: c/Parser/unittests/DiscreteValueUnitTest.cpp
===================================================================
--- src/Parser/unittests/DiscreteValueUnitTest.cpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,213 +1,0 @@
-/*
- * Project: MoleCuilder
- * Description: creates and alters molecular systems
- * Copyright (C)  2010 University of Bonn. All rights reserved.
- * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
- */
-
-/*
- * DiscreteValueUnitTest.cpp
- *
- *  Created on: Sep 28, 2011
- *      Author: heber
- */
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "DiscreteValueUnitTest.hpp"
-
-#include <cppunit/CompilerOutputter.h>
-#include <cppunit/extensions/TestFactoryRegistry.h>
-#include <cppunit/ui/text/TestRunner.h>
-
-#include "Parser/DiscreteValue.hpp"
-
-#include "CodePatterns/toString.hpp"
-
-#ifdef HAVE_TESTRUNNER
-#include "UnitTestMain.hpp"
-#endif /*HAVE_TESTRUNNER*/
-
-using namespace std;
-
-// Registers the fixture into the 'registry'
-CPPUNIT_TEST_SUITE_REGISTRATION( DiscreteValueTest );
-
-
-void DiscreteValueTest::setUp()
-{
-  // failing asserts should be thrown
-  ASSERT_DO(Assert::Throw);
-
-  for (int i=1; i<=3;++i) {
-    ValidValues.push_back(i);
-  }
-}
-
-void DiscreteValueTest::tearDown()
-{
-  ValidValues.clear();
-}
-
-/************************************ tests ***********************************/
-
-/** Unit test for findIndexOfValue.
- *
- */
-void DiscreteValueTest::findIndexOfValueTest()
-{
-  // create instance
-  DiscreteValue<int> test(ValidValues);
-
-  // check valid values indices
-  CPPUNIT_ASSERT_EQUAL((size_t)0, test.findIndexOfValue(1));
-  CPPUNIT_ASSERT_EQUAL((size_t)1, test.findIndexOfValue(2));
-  CPPUNIT_ASSERT_EQUAL((size_t)2, test.findIndexOfValue(3));
-
-  // check invalid ones
-  for (int i=-10; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL((size_t)-1, test.findIndexOfValue(i));
-  for (int i=4; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL((size_t)-1, test.findIndexOfValue(i));
-}
-
-/** Unit test for isValidValue.
- *
- */
-void DiscreteValueTest::isValidValueTest()
-{
-  // create instance
-  DiscreteValue<int> test(ValidValues);
-
-  // checking valid values
-  for (int i=1; i<=3;++i)
-    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
-
-  // checking invalid values
-  for (int i=-10; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-  for (int i=4; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-}
-
-/** Unit test for isValid.
- *
- */
-void DiscreteValueTest::isValidTest()
-{
-  // create instance
-  DiscreteValue<int> test(ValidValues);
-
-  // checking valid values
-  for (int i=1; i<=3;++i)
-    CPPUNIT_ASSERT_EQUAL(true, test.isValid(toString(i)));
-
-  // checking invalid values
-  for (int i=-10; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
-  for (int i=4; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValid(toString(i)));
-}
-
-/** Unit test for appendValidValue.
- *
- */
-void DiscreteValueTest::appendValidValueTest()
-{
-  // create instance
-  DiscreteValue<int> test(ValidValues);
-
-  // adding values 4,5,6
-  for (int i=4; i<=6;++i) {
-    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-    test.appendValidValue(i);
-    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
-  }
-
-  // adding same value, throws assertion
-  const size_t size_before = test.ValidValues.size();
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  for (int i=1; i<=6;++i)
-    CPPUNIT_ASSERT_THROW(test.appendValidValue(i), Assert::AssertionFailure);
-#endif
-  CPPUNIT_ASSERT_EQUAL( size_before, test.ValidValues.size() );
-
-  // checking valid values
-  for (int i=1; i<=6;++i)
-    CPPUNIT_ASSERT_EQUAL(true, test.isValidValue(i));
-
-  // checking invalid values
-  for (int i=-10; i<=0;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-
-  // checking invalid values
-  for (int i=7; i<=10;++i)
-    CPPUNIT_ASSERT_EQUAL(false, test.isValidValue(i));
-}
-
-/** Unit test for setters and getters.
- *
- */
-void DiscreteValueTest::settergetterTest()
-{
-  // create instance
-  DiscreteValue<int> test(ValidValues);
-
-  // unset calling of get, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.get(), Assert::AssertionFailure);
-#endif
-
-  // setting invalid, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.set(toString(4)), Assert::AssertionFailure);
-#endif
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.set(toString(0)), Assert::AssertionFailure);
-#endif
-
-  // checking all valid ones
-  for (int i=1; i<=3;++i) {
-    test.set(toString(i));
-    CPPUNIT_ASSERT_EQUAL(toString(i), test.get());
-  }
-
-}
-
-/** Unit test for setValue and getValue.
- *
- */
-void DiscreteValueTest::settergetterValueTest()
-{
-  // create instance
-  DiscreteValue<int> test(ValidValues);
-
-  // unset calling of get, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.getValue(), Assert::AssertionFailure);
-#endif
-
-  // setting invalid, throws
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.setValue(4), Assert::AssertionFailure);
-#endif
-#ifndef NDEBUG
-  std::cout << "The following Assert failures are intended and do not indicate a failure of the test." << std::endl;
-  CPPUNIT_ASSERT_THROW(test.setValue(0), Assert::AssertionFailure);
-#endif
-
-  // checking all valid ones
-  for (int i=1; i<=3;++i) {
-    test.setValue(i);
-    CPPUNIT_ASSERT_EQUAL(i, test.getValue());
-  }
-}
Index: c/Parser/unittests/DiscreteValueUnitTest.hpp
===================================================================
--- src/Parser/unittests/DiscreteValueUnitTest.hpp	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ 	(revision )
@@ -1,45 +1,0 @@
-/*
- * DiscreteValueUnitTest.hpp
- *
- *  Created on: Sep 28, 2011
- *      Author: heber
- */
-#ifndef DISCRETEVALUEUNITTEST_HPP_
-#define DISCRETEVALUEUNITTEST_HPP_
-
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <cppunit/extensions/HelperMacros.h>
-
-#include <vector>
-
-class DiscreteValueTest :  public CppUnit::TestFixture
-{
-  CPPUNIT_TEST_SUITE( DiscreteValueTest ) ;
-  CPPUNIT_TEST ( findIndexOfValueTest );
-  CPPUNIT_TEST ( isValidValueTest );
-  CPPUNIT_TEST ( isValidTest );
-  CPPUNIT_TEST ( appendValidValueTest );
-  CPPUNIT_TEST ( settergetterTest );
-  CPPUNIT_TEST ( settergetterValueTest );
-  CPPUNIT_TEST_SUITE_END();
-
-public:
-  void setUp();
-  void tearDown();
-
-  void findIndexOfValueTest();
-  void isValidValueTest();
-  void isValidTest();
-  void appendValidValueTest();
-  void settergetterTest();
-  void settergetterValueTest();
-
-private:
-  std::vector<int> ValidValues;
-};
-
-#endif /* DISCRETEVALUEUNITTEST_HPP_ */
Index: src/Parser/unittests/Makefile.am
===================================================================
--- src/Parser/unittests/Makefile.am	(revision a7d753240301a775068e9e813720c7f0c9744b03)
+++ src/Parser/unittests/Makefile.am	(revision 84e752ece4991982e2abc41c173b1a6d98ab98b0)
@@ -2,8 +2,7 @@
 # Also indentation by a single tab
 
+include ../../src/Parser/Parameters/unittests/Makefile.am
 
 PARSERTESTSSOURCES = \
-  ../Parser/unittests/ContinuousValueUnitTest.cpp \
-  ../Parser/unittests/DiscreteValueUnitTest.cpp \
 	../Parser/unittests/ParserMpqcUnitTest.cpp \
 	../Parser/unittests/ParserPcpUnitTest.cpp \
@@ -13,6 +12,4 @@
 
 PARSERTESTSHEADERS = \
-  ../Parser/unittests/ContinuousValueUnitTest.hpp \
-  ../Parser/unittests/DiscreteValueUnitTest.hpp \
 	../Parser/unittests/ParserMpqcUnitTest.hpp \
 	../Parser/unittests/ParserPcpUnitTest.hpp \
@@ -22,6 +19,4 @@
 
 PARSERTESTS = \
-	ContinuousValueUnitTest \
-  DiscreteValueUnitTest \
   ParserMpqcUnitTest \
   ParserPcpUnitTest \
@@ -41,18 +36,4 @@
 
 
-ContinuousValueUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
-  ../Parser/unittests/ContinuousValueUnitTest.cpp \
-  ../Parser/unittests/ContinuousValueUnitTest.hpp \
-  ../Parser/ContinuousValue.hpp \
-  ../Parser/ContinuousValue_impl.hpp
-#ContinuousValueUnitTest_LDADD
- 
-DiscreteValueUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
-  ../Parser/unittests/DiscreteValueUnitTest.cpp \
-  ../Parser/unittests/DiscreteValueUnitTest.hpp \
-  ../Parser/DiscreteValue.hpp \
-  ../Parser/DiscreteValue_impl.hpp
-#DiscreteValueUnitTest_LDADD
- 
 ParserMpqcUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
 	../Parser/unittests/ParserMpqcUnitTest.cpp \
