JOscParametersHelper.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JOSCPARAMETERSHELPER__
#define __JOSCPROB__JOSCPARAMETERSHELPER__
 
#include <memory>
 
#include "JLang/JException.hh"
 
#include "JOscParametersInterface.hh"
 
 
/**
 * \author bjung
 */
 
namespace JOSCPROB {}
namespace JPP { using namespace JOSCPROB; }
 
namespace JOSCPROB {
  
  /**
   * Helper class for oscillation parameters.
   */
  template<class T>
  struct JOscParametersHelper :
    public std::shared_ptr<JOscParametersInterface<T> >
  {
    typedef JOscParametersHelper<T>                     JOscParametersHelper_t;
    typedef JOscParametersInterface<T>                  JOscParameters_t;
    
    typedef typename JOscParameters_t::JOscParameter_t  JOscParameter_t;
    typedef typename JOscParameters_t::JParameter_t     JParameter_t;
 
    typedef typename JOscParameters_t::argument_type    argument_type;    
    typedef typename JOscParameters_t::value_type       value_type;
    
    typedef std::shared_ptr<JOscParameters_t>           pointer_type;
 
    using pointer_type::reset;
 
    
    /**
     * Default constructor.
     */
    JOscParametersHelper() :
      pointer_type()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  p               pointer to oscillation parameters
     */
    JOscParametersHelper(const pointer_type& p) :
      pointer_type(p)
    {}
    
 
    /**
     * Constructor.
     *
     * \param  parameters      oscillation parameters
     */
    JOscParametersHelper(const JOscParameters_t& parameters)
    {
      this->configure(parameters);
    }
 
 
    /**
     * Constructor.
     *
     * \param  parameters      oscillation parameters
     * \param  name            parameter name
     * \param  value           parameter value
     * \param  args            remaining pairs of parameter names and values
     */
    template<class ...Args>
    JOscParametersHelper(const JOscParameters_t& parameters,
                         const std::string&      name,
                         argument_type           value,
                         const Args&          ...args)
    {
      this->configure(parameters);
      this->set(name, value, args...);
    }
 
 
    /**
     * Configure oscillation parameters.
     *
     * \param  p               shared pointer to oscillation parameters
     */    
    void configure(const pointer_type& p)
    {
      static_cast<pointer_type&>(*this);
    }
    
 
    /**
     * Configure oscillation parameters.
     *
     * \param  parameters      oscillation parameters
     */    
    void configure(const JOscParameters_t& parameters)
    {
      using namespace std;
      using namespace JPP;
      
      JOscParameters_t* p = dynamic_cast<JOscParameters_t*>(parameters.clone());
 
      if (p != NULL) {
        reset(p);
      } else {
        THROW(JNullPointerException, "JOscParametersHelper::configure(): Unable to retrieve oscillation parameters interface.");
      }
    }
 
 
    /**
     * Get reference to oscillation parameters interface.
     *
     * \return                 reference to oscillation parameters interface
     */
    JOscParameters_t& getParameters() const
    {
      using namespace JPP;
 
      if (static_cast<const JOscParametersHelper_t&>(*this)) {
        return *(this->get());
      } else {
        THROW(JNullPointerException, "JOscParametersHelper::getParameters(): Oscillation parameters interface is not set.");
      }
    }
 
 
    /**
     * Get pointer to oscillation parameters interface.
     *
     * \return                 pointer to oscillation parameters interface
     */
    JOscParameters_t* get() const
    {
      return pointer_type::get();
    }
 
 
    /**
     * Get oscillation parameter.
     *
     * \param  name            parameter name
     * \return                 parameter
     */
    JOscParameter_t& get(const std::string& name) const
    {
      return getParameters().get(name);
    }
    
 
 
    /**
     * Set value for a given oscillation parameter.
     *
     * \param  name            parameter name
     * \param  value           parameter value
     */
    void set(const std::string& name,
             const value_type&  value) const
    {
      getParameters().set(name, value);
    }
 
 
    /**
     * Set value for given list of oscillation parameters.
     *
     * \param  name            parameter name
     * \param  value           parameter value
     * \param  args            remaining pairs of parameter names and values
     */
    template<class ...Args>
    void set(const std::string& name,
             const value_type&  value,
             const Args&     ...args) const
    {
      this->set(name, value);
      this->set(args...);
    }
 
 
    /**
     * Set oscillation parameters.
     *
     * \param  parameters      oscillation parameters
     */
    void set(const JOscParametersInterface<value_type>& parameters) const
    {
      using namespace std;
      using namespace JPP;
 
      const JProperties properties = parameters.getProperties();
 
      for (JProperties::const_iterator i = properties.cbegin(); i != properties.cend(); ++i) {
        
        const JOscParameter<value_type>& parameter = i->second.getValue<const JOscParameter<value_type> >();
        
        this->set(i->first, parameter.getValue());
      }
    }
 
 
    /**
     * Check validity of oscillation parameters.
     *
     * \return                 true if all oscillation parameters are valid; else false
     */
    bool is_valid() const
    {
      return getParameters().is_valid();
    }
  };
}
 
#endif