JParameter.hh

Go to the documentation of this file.

#ifndef __JLANG__JPARAMETER__
#define __JLANG__JPARAMETER__
 
#include <istream>
#include <ostream>
 
#include "JLang/JClass.hh"
#include "JLang/JComparable.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
  /**
   * Parameter class.
   *
   * This class is a simple wrapper around the template parameter with a status value.
   * The status value indicates whether the parameter has been defined or not.
   * A parameter is defined when a value has been assigned or correctly read.
   * Note that the comparisons between parameter objects are based on the philosphy "undefined = any value".
   * Hence, if any of the two parameter values is undefined, they are considered equal.
   * The comparison between a paramater object with a template value is based 
   * on the internal value of the parameter object, regardless of its state.
   */
  template<class T>
  class JParameter :
    JComparable< JParameter<T> >
  {
  public:
 
    typedef typename JClass<T>::argument_type  argument_type;
 
    /**
     * Default constructor.
     */
    JParameter() :
      __value(),
      is_defined(false)
    {}
 
  
    /**
     * Constructor.
     *
     * \param  value        value
     */
    explicit JParameter(argument_type value) :
      __value(value),
      is_defined(true)
    {}
 
 
    /**
     * Assignment operator.
     *
     * \param  value        value
     * \return              this parameter
     */
    JParameter<T>& operator=(argument_type value)
    {
      setValue(value);
 
      return *this;
    }
 
 
    /**
     * Get value of parameter.
     *
     * \return              value
     */
    const T& getValue() const 
    { 
      return __value; 
    }
 
 
    /**
     * Get value of parameter.
     *
     * \return              value
     */
    T& getValue() 
    { 
      return __value; 
    }
 
 
    /**
     * Set value.
     *
     * \param  value        value
     */
    void setValue(argument_type value)
    {
      __value    = value;
      is_defined = true;
    }
 
 
    /**
     * Type conversion operator.
     *
     * \return              value
     */
    operator const T&() const
    { 
      return getValue();
    }
 
 
    /**
     * Type conversion operator.
     *
     * \return              value
     */
    operator T&()       
    {
      return getValue();
    }
 
 
    /**
     * Get status of parameter.
     *
     * \return              true if value has been defined (by read or assignment); else false
     */
    const bool isDefined() const
    {
      return is_defined;
    }
 
 
    /**
     * Less than method.
     *
     * This method evaluates to true if both parameter values are defined and
     * this value is less than the value of the given parameter object.
     *
     * \param   parameter   parameter
     * \return              true if both defined and first value less than second value; else false
     */
    inline bool less(const JParameter& parameter) const
    {
      return this->isDefined() && parameter.isDefined() && this->getValue() < parameter.getValue();
    }
 
 
    /**
     * Stream input.
     *
     * \param  in           input stream
     * \param  parameter    parameter
     * \return              input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JParameter<T>& parameter)
    {
      in >> parameter.__value;
 
      parameter.is_defined = (bool) in;
 
      return in;
    }
 
 
    /**
     * Stream output.
     *
     * \param  out          output stream
     * \param  parameter    parameter
     * \return              output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JParameter<T>& parameter)
    {
      return out << parameter.__value;
    }
 
 
  protected:
    T    __value;
    bool is_defined;
  };
}
 
#endif