Parameter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_NUMERIC_PARAMETER_H
#define BPP_NUMERIC_PARAMETER_H


#include "../Clonable.h"
#include "Constraints.h"
#include "ParameterExceptions.h"

// From the STL:
#include <string>
#include <iostream>
#include <vector>
#include <memory>

namespace bpp
{
class Parameter;

class ParameterEvent :
  public virtual Clonable
{
protected:
  Parameter* parameter_;

public:
  ParameterEvent(Parameter* parameter);

  ParameterEvent(const ParameterEvent& pe) : parameter_(pe.parameter_) {}
  ParameterEvent& operator=(const ParameterEvent& pe)
  {
    parameter_ = pe.parameter_;
    return *this;
  }

  ParameterEvent* clone() const { return new ParameterEvent(*this); }

public:
  const Parameter* parameter() const { return parameter_; }
  Parameter* parameter() { return parameter_; }
};

class ParameterListener :
  public virtual Clonable
{
public:
  ParameterListener* clone() const = 0;

public:
  virtual const std::string& getId() const = 0;

  virtual void parameterNameChanged(ParameterEvent& event) = 0;

  virtual void parameterValueChanged(ParameterEvent& event) = 0;

  virtual void parameterConstraintChanged(ParameterEvent& event) = 0;
};

class Parameter :
  public virtual Clonable
{
protected:
  std::string name_;             // Parameter name
  double value_;            // Parameter value
  double precision_;  // Precision needed for Parameter value
  std::shared_ptr<ConstraintInterface> constraint_;
  std::vector< std::shared_ptr<ParameterListener>> listeners_;

public:
  // Class constructors and destructors:

  Parameter() : name_(""), value_(0), precision_(0), constraint_(0), listeners_() {}

  Parameter(const std::string& name, double value, std::shared_ptr<ConstraintInterface> constraint = 0, double precision = 0);

  Parameter(const std::string& name, double value, std::shared_ptr<ConstraintInterface> constraint, bool precision) = delete;

  Parameter(const Parameter& param);

  Parameter& operator=(const Parameter& param);

  virtual ~Parameter();

  Parameter* clone() const { return new Parameter(*this); }

public:
  virtual void setName(const std::string& name)
  {
    name_ = name;
    ParameterEvent event(this);
    fireParameterNameChanged(event);
  }

  virtual void setValue(double value);

  void setPrecision(double precision);

  virtual const std::string& getName() const { return name_; }

  virtual double getValue() const { return value_; }

  virtual double getPrecision() const { return precision_; }

  virtual std::shared_ptr<const ConstraintInterface> getConstraint() const { return constraint_; }

  virtual const ConstraintInterface& constraint() const
  {
    if (constraint_)
      return *constraint_;
    else
      throw NullPointerException("Parameter::constraint(). No contraint is associated to this parameter.");
  }

  virtual std::shared_ptr<ConstraintInterface> getConstraint() { return constraint_; }

  virtual ConstraintInterface& constraint()
  {
    if (constraint_)
      return *constraint_;
    else
      throw NullPointerException("Parameter::constraint(). No contraint is associated to this parameter.");
  }

  virtual bool hasConstraint() const { return constraint_ != nullptr; }

  virtual std::shared_ptr<ConstraintInterface> removeConstraint();

  virtual void setConstraint(std::shared_ptr<ConstraintInterface> constraint);

  virtual void addParameterListener(std::shared_ptr<ParameterListener> listener)
  {
    listeners_.push_back(listener);
  }

  virtual void removeParameterListener(const std::string& listenerId);

  virtual bool hasParameterListener(const std::string& listenerId);

protected:
  void fireParameterNameChanged(ParameterEvent& event)
  {
    for (auto listener : listeners_)
    {
      listener->parameterNameChanged(event);
    }
  }

  void fireParameterValueChanged(ParameterEvent& event)
  {
    for (auto listener : listeners_)
    {
      listener->parameterValueChanged(event);
    }
  }

  void fireParameterConstraintChanged(ParameterEvent& event)
  {
    for (auto listener : listeners_)
    {
      listener->parameterConstraintChanged(event);
    }
  }

public:
  static const std::shared_ptr<IntervalConstraint> R_PLUS;
  static const std::shared_ptr<IntervalConstraint> R_PLUS_STAR;
  static const std::shared_ptr<IntervalConstraint> R_MINUS;
  static const std::shared_ptr<IntervalConstraint> R_MINUS_STAR;
  static const std::shared_ptr<IntervalConstraint> PROP_CONSTRAINT_IN;
  static const std::shared_ptr<IntervalConstraint> PROP_CONSTRAINT_EX;
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_PARAMETER_H