JTemplate.hh

Go to the documentation of this file.

#ifndef __JLANG__JTEMPLATE__
#define __JLANG__JTEMPLATE__
 
#include <istream>
#include <ostream>
#include <type_traits>
 
#include "JLang/JTypeList.hh"
#include "JLang/JConversion.hh"
#include "JLang/JConstructor.hh"
 
 
/**
 * \file
 *
 * Auxiliary class to alleviate the diamond problem due to multiple inheritance.
 * \author mdejong
 */
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
  
  /**
   * Auxiliary class for managing multiple objects.
   *
   * This class can be used to replace regular base classes by corresponding data members.
   * The various operators and methods facilitate the access to these data members.
   *
   * The template value <tt>use_polymorfism</tt> in methods <tt>get</tt> and <tt>set</tt>
   * applies to the given template parameter of these methods.
   * If <tt>false</tt>, only exact type matches are allowed. 
   * If <tt>true</tt>,
   * method <tt>get</tt> will return a reference to the first data member
   * of which the type derives from the specified class and
   * method <tt>set</tt> will assign the given value to the first data member
   * for which a matching constructor exists.
   */
  template<class JType_t>
  struct JTemplate {
 
    typedef JTemplate<JType_t>                                template_type;
 
    
    /**
     * Default constructor.
     */
    JTemplate() :
      object()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  value       value
     */
    JTemplate(const JType_t& value) :
      object(value)
    {}
 
    
    /**
     * Type conversion.
     *
     * \return             reference to object
     */
    inline operator const JType_t&() const
    {
      return object;
    }
    
   
    /**
     * Type conversion.
     *
     * \return             reference to object
     */
    inline operator JType_t&()
    {
      return object;
    }
 
 
    /**
     * Smart pointer operator.
     *
     * \return             pointer to object
     */
    const JType_t* operator->() const 
    { 
      return &object;
    }
 
 
    /**
     * Smart pointer operator.
     *
     * \return             pointer to object
     */
    JType_t* operator->() 
    { 
      return &object;
    }
    
 
    /**
     * Get reference to object
     *
     * \return             reference to object
     */
    template<class T, bool use_polymorphism = false>
    const T& get() const
    {
      return this->c_get(std::bool_constant<use_polymorphism ? JConversion<JType_t, T> ::is_derived :  JConversion<JType_t, T>::is_same>());
    }
 
 
    /**
     * Get reference to object
     *
     * \return             reference to object
     */    
    template<class T, bool use_polymorphism = false>
    T& get()
    {
      return this->c_get(std::bool_constant<use_polymorphism ? JConversion<JType_t, T> ::is_derived :  JConversion<JType_t, T>::is_same>());
    }
 
 
    /**
     * Set value.
     *
     * \param  value       value
     * \return             this object
     */
    inline template_type& set(const JType_t& value)
    {
      return c_set(value, std::true_type());
    }
 
 
    /**
     * Set value.
     *
     * \param  value       value
     * \return             this object
     */
    template<bool use_polymorphism, class T>
    inline template_type& set(const T& value)
    {
      return this->c_set(value, std::bool_constant<use_polymorphism ? JConstructor<JType_t, T> ::has_constructor :  JConversion<JType_t, T>::is_same>());
    }
    
    
    /**
     * Read object from input.
     *
     * \param  in          input stream
     * \param  object      object
     * \return             input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTemplate<JType_t>& object)
    {
      return in >> object.object;
    }
 
 
    /**
     * Write object to output.
     *
     * \param  out         output stream
     * \param  object      object
     * \return             output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTemplate<JType_t>& object)
    {
      return out << object.object;
    }
 
  protected:
    /**
     * Get reference to object
     *
     * \param  option      true
     * \return             reference to object
     */
    const JType_t& c_get(std::true_type option) const
    {
      return object;
    }
 
    
    /**
     * Get reference to object
     *
     * \param  option      true
     * \return             reference to object
     */
    JType_t& c_get(std::true_type option)
    {
      return object;
    }
 
 
    /**
     * Set value.
     *
     * \param  value       value
     * \param  option      true
     * \return             this object
     */
    template<class T>
    inline template_type& c_set(const T& value, std::true_type option)
    {
      object = value;
 
      return *this;
    }
 
 
    JType_t object;   //!< object
  };
 
 
  /**
   * Auxiliary class for managing multiple objects.
   */
  template<class JHead_t, class JTail_t>
  struct JTemplate< JTypeList<JHead_t, JTail_t> > :
    public JTemplate<JHead_t>,
    public JTemplate<JTail_t>
  {
    
    typedef JTemplate< JTypeList<JHead_t, JTail_t> >          template_type;
 
 
    /**
     * Default constructor.
     */
    JTemplate() :
      JTemplate<JHead_t>(),
      JTemplate<JTail_t>()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  head        value
     * \param  tail        value
     */
    JTemplate(const JHead_t& head,
              const JTail_t& tail) :
      JTemplate<JHead_t>(head),
      JTemplate<JTail_t>(tail)
    {}
 
 
    /**
     * Get reference to object
     *
     * \return             reference to object
     */    
    template<class T, bool use_polymorphism = false>
    const T& get() const
    {
      return this->c_get<T, use_polymorphism>(std::bool_constant<use_polymorphism ? JConversion<JHead_t, T> ::is_derived :  JConversion<JHead_t, T>::is_same>());
    }
 
 
    /**
     * Get reference to object
     *
     * \return             reference to object
     */    
    template<class T, bool use_polymorphism = false>
    T& get()
    {
      return this->c_get<T, use_polymorphism>(std::bool_constant<use_polymorphism ? JConversion<JHead_t, T> ::is_derived :  JConversion<JHead_t, T>::is_same>());
    }
 
 
    /**
     * Set value.
     *
     * \param  value       value
     * \return             this object
     */
    template<class T>
    inline template_type& set(const T& value)
    {
      return this->c_set<false>(value, std::bool_constant<JConversion<JHead_t, T>::is_same>());
    }
 
 
    /**
     * Set value.
     *
     * \param  value       value
     * \return             this object
     */
    template<bool use_polymorphism, class T>
    inline template_type& set(const T& value)
    {
      return this->c_set<use_polymorphism>(value, std::bool_constant<use_polymorphism ? JConstructor<JHead_t, T> ::has_constructor :  JConversion<JHead_t, T>::is_same>());
    }
    
    
    /**
     * Read object from input.
     *
     * \param  in          input stream
     * \param  object      object
     * \return             input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTemplate< JTypeList<JHead_t, JTail_t> >& object)
    {
      return in >> static_cast<JTemplate<JHead_t>&>(object)
                >> static_cast<JTemplate<JTail_t>&>(object);
    }
 
 
    /**
     * Write object to output.
     *
     * \param  out         output stream
     * \param  object      object
     * \return             output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTemplate< JTypeList<JHead_t, JTail_t> >& object)
    {
      return out << static_cast<const JTemplate<JHead_t>&>(object) << ' '
                 << static_cast<const JTemplate<JTail_t>&>(object);
    }
 
  protected:
    /**
     * Get reference to object
     *
     * \param  option      true
     * \return             reference to object
     */    
    template<class T, bool use_polymorphism>
    const T& c_get(std::true_type option) const
    {
      return static_cast<JTemplate<JHead_t>&>(*this).template get<T, use_polymorphism>();
    }
 
    
    /**
     * Get reference to object
     *
     * \param  option      false
     * \return             reference to object
     */    
    template<class T, bool use_polymorphism>
    const T& c_get(std::false_type option) const
    {
      return static_cast<JTemplate<JTail_t>&>(*this).template get<T, use_polymorphism>();
    }
 
 
    /**
     * Get reference to object
     *
     * \param  option      true
     * \return             reference to object
     */    
    template<class T, bool use_polymorphism>
    T& c_get(std::true_type option)
    {
      return static_cast<JTemplate<JHead_t>&>(*this).template get<T, use_polymorphism>();
    }
 
    
    /**
     * Get reference to object
     *
     * \param  option      false
     * \return             reference to object
     */    
    template<class T, bool use_polymorphism>
    T& c_get(std::false_type option)
    {
      return static_cast<JTemplate<JTail_t>&>(*this).template get<T, use_polymorphism>();
    }
 
 
    /**
     * Set value.
     *
     * \param  value       value
     * \param  option      true
     * \return             this object
     */
    template<bool use_polymorphism, class T>
    inline template_type& c_set(const T& value, std::true_type option)
    {
      static_cast<JTemplate<JHead_t>&>(*this).template set<use_polymorphism>(value);
 
      return *this;
    }
 
 
    /**
     * Set value.
     *
     * \param  value       value
     * \param  option      false
     * \return             this object
     */
    template<bool use_polymorphism, class T>
    inline template_type& c_set(const T& value, std::false_type option)
    {
      static_cast<JTemplate<JTail_t>&>(*this).template set<use_polymorphism>(value);
 
      return *this;
    }
  };
 
 
  /**
   * Auxiliary class for managing multiple objects.
   */
  template<class JHead_t>
  struct JTemplate< JTypeList<JHead_t> > :
    public JTemplate<JHead_t>
  {
    /**
     * Default constructor.
     */
    JTemplate() :
      JTemplate<JHead_t>()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  value       value
     */
    JTemplate(const JHead_t& value) :
      JTemplate<JHead_t>(value)
    {}
  };
}
 
#endif