/*
 * Value_vector.hpp
 *
 *  Created on: Mar 29, 2017
 *      Author: heber
 */

#ifndef VALUE_VECTOR_HPP_
#define VALUE_VECTOR_HPP_

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

#include <string>

#include "LinearAlgebra/Vector.hpp"

#include "Parameters/Value.hpp"

/** This class represents a the Vector class specialization of a general value.
 *
 * Instead of a Vector we internally store a string.
 * This allows us to override the default get() behavior and allows us to first
 * do the parsing of the string into vector components.
 *
 */
template <>
class Value<Vector> :
  public ValueAsString,
  public ValueInterface<Vector>
{
  //!> unit test needs to have access to internal values
  friend class ValueTest;
  friend class ContinuousValueTest;
  friend class Parameter<Vector>;
public:
  Value();
  Value(const Validator<Vector> &_validator);
  Value(const std::vector<Vector> &_ValidValues);
  Value(const range<Vector> &_ValidRange);
  virtual ~Value();

  // functions for ValueInterface
  bool isValid(const Vector &_value) const throw(ParameterValidatorException);
  const Vector & getUnvalidated() const throw(ParameterValueException);
  const Vector & get() const throw(ParameterValueException);
  void set(const Vector & _value) throw(ParameterException);
  bool isSet() const;

  // string functions for ValueInterface
  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(ParameterException);

  // comfortable setter
  Value<Vector> &operator=(const Vector &_value)
  { set(_value);  return *this;  }

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

  const Validator<Vector> & getValidator() const;
  Validator<Vector> & getValidator();

  // comfortable validator functions
  const range<Vector> & getValidRange() const throw(ParameterValidatorException);
  void setValidRange(const range<Vector> &_range) throw(ParameterValueException);
  void appendValidValue(const Vector &_value) throw(ParameterValidatorException);
  const std::vector<Vector> &getValidValues() const throw(ParameterValidatorException);

  static const Vector parseAsVector(const std::string &_value);
  static const std::string setFromVector(const Vector &_vec);

private:
  //!> whether a value has been set or not
  bool ValueSet;
  //!> contained value
  std::string value;
  //!> converted value for allowing to return a ref
  mutable Vector converted_value;

  //!> the validator
  Validator<Vector> *validator;
};


#endif /* VALUE_VECTOR_HPP_ */