JValve.hh

Go to the documentation of this file.

#ifndef __JLANG__JVALVE__
#define __JLANG__JVALVE__
 
#include "JLang/JDefault.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JType.hh"
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
  /**
   * Auxiliary class for selection of data type.
   */
  template<class T>
  class JValve :
    public JDefault< JValve<T> >
  {
  public:
    /**
     * Default constructor.
     *
     * By default, the valve is open.
     */
    JValve() :
      status(true)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  controller controller of valve
     */
    template<class JController_t>
    JValve(const JController_t& controller)
    {
      (*this)(controller);
    }
 
    
    /**
     * Check if valve is open.
     *
     * \return            true if open; else false
     */
    bool is_open() const
    {
      return status;
    }
 
    
    /**
     * Open valve.
     */
    void open()
    {
      status = true;
    }
 
    
    /**
     * Close valve.
     */
    void close()
    {
      status = false;
    }
 
 
    /**
     * Set valve.
     *
     * The template argument <tt>JController_t</tt> refers to a data structure 
     * which should provide for the function object operator:
     * <pre>
     *   bool operator()(JType<T>& type) const;    // get status of valve
     * </pre>
     *
     * \param  controller controller of valve
     */
    template<class JController_t>
    JValve& operator()(const JController_t& controller)
    {
      if (controller(JType<T>()))
        this->open();
      else
        this->close();
 
      return *this;
    }
    
  protected:
    bool status;
  };
  
 
  /**
   * Auxiliary class for selection of multiple data types.
   *
   * This class recursively defines the JLANG::JValve interface
   * for all data types by deriving from:
   *  - JValve<JHead_t>; and 
   *  - JValve<JTail_t>.
   */
  template<class JHead_t, class JTail_t>
  class JValve< JTypeList<JHead_t, JTail_t> > :
    public JDefault< JValve< JTypeList<JHead_t, JTail_t> > >,
    public JValve<JHead_t>,
    public JValve<JTail_t>
  {
  public:
    using JDefault< JValve< JTypeList<JHead_t, JTail_t> > >::getDefault;
 
    /**
     * Default constructor.
     */
    JValve()
    {}
 
    
    /**
     * Constructor.
     *
     * \param  controller controller of valve
     */
    template<class JController_t>
    JValve(const JController_t& controller)
    {
      (*this)(controller);
    }
 
 
    /**
     * Set valve.
     *
     * The template argument <tt>JController_t</tt> refers to a data structure 
     * which should provide for the function object operator:
     * <pre>
     *   bool operator()(JType<T>& type) const;    // get status of valve
     * </pre>
     *
     * \param  controller controller of valve
     */
    template<class JController_t>
    JValve& operator()(const JController_t& controller)
    {
      static_cast<JValve<JHead_t>&>(*this)(controller);
      static_cast<JValve<JTail_t>&>(*this)(controller);
 
      return *this;
    }
  };
 
  
  /**
   * Terminator class of recursive JValve class.
   */
  template<class JHead_t>
  class JValve< JTypeList<JHead_t, JNullType> > :
    public JValve<JHead_t>
  {
  public:
    /**
     * Default constructor.
     */
    JValve()
    {}
 
    
    /**
     * Constructor.
     *
     * \param  controller controller of valve
     */
    template<class JController_t>
    JValve(const JController_t& controller)
    {
      (*this)(controller);
    }
  };
}
 
#endif