/*
 * Parameter_vector.hpp
 *
 *  Created on: Mar 31, 2017
 *      Author: heber
 */


#ifndef PARAMETERS_SPECIFICS_PARAMETER_VECTOR_HPP_
#define PARAMETERS_SPECIFICS_PARAMETER_VECTOR_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "LinearAlgebra/Vector.hpp"

#include "Parameters/Parameter.hpp"

template <>
class Parameter<Vector> :
  public ParameterInterface,
  public ValueInterface<Vector>
{
public:
  Parameter(const Parameter<Vector> &instance);
  Parameter(const std::string &_name);
  Parameter(const std::string &_name, const Vector &_value);
  Parameter(const std::string &_name, const Validator<Vector> &_Validator);
  Parameter(const std::string &_name, const Validator<Vector> &_Validator, const Vector &_value);
  Parameter(const std::string &_name, const std::vector<Vector> &_ValidValues);
  Parameter(const std::string &_name, const std::vector<Vector> &_ValidValues, const Vector &_value);
  Parameter(const std::string &_name, const range<Vector> &_ValidRange);
  Parameter(const std::string &_name, const range<Vector> &_ValidRange, const Vector &_value);
  virtual ~Parameter();

  // wrap the following functions from ValueAsString to add exception information
  bool isValidAsString(const std::string &_value) const throw(ParameterValidatorException);
  const std::string getAsString() const throw(ParameterValueException);
  const std::string getAsStringUnvalidated() const throw(ParameterValueException);
  void setAsString(const std::string &_value) throw(ParameterValueException);

  // wrap the following functions from Value<Vector> to add exception information
  bool isValid(const Vector &_value) const throw(ParameterValidatorException);
  const Vector & get() const throw(ParameterValueException);
  const Vector & getUnvalidated() const throw(ParameterValueException);
  void set(const Vector & _value) throw(ParameterValueException);
  bool isSet() const
  { return value.isSet(); }

  const Validator<Vector> & getValidator() const
  { return value.getValidator(); }
  Validator<Vector> & getValidator()
  { return value.getValidator(); }

  // comparator
  bool operator==(const Parameter<Vector> &_instance) const throw(ParameterException);
  bool operator!=(const Parameter<Vector> &_instance) const throw(ParameterException)
      { return !((*this)==(_instance)); }

  ParameterInterface* clone() const;

//private: // TODO...
  Parameter();

private:
  //!> contained value of this parameter
  Value<Vector> value;
};


#endif /* PARAMETERS_SPECIFICS_PARAMETER_VECTOR_HPP_ */