JLoadProperty.hh

Go to the documentation of this file.

#ifndef __JLANG__JLOADPROPERTY__
#define __JLANG__JLOADPROPERTY__
 
#include <string>
#include <iostream>
 
 
/**
 * \author bjjung
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
 
  /**
   * Data structure for object properties which require reloading whenever the property is reread.
   *
   * The first template parameter refers to the loadable object.\n
   * This object needs to have an implementation of the method `void load()`\n.
   * The second template parameter refers to the property type.\n
   */
  template<class JLoadableObject_t, class T>
  class JLoadProperty :
    public T
  {
  public:
 
    typedef JLoadProperty<JLoadableObject_t, T>   JLoadProperty_t;
    
 
    /**
     * Constructor.
     *
     * \param  object        pointer to loadable object
     */
    JLoadProperty(JLoadableObject_t& object) :
      T     (),
      object(object)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  object        pointer to loadable object
     * \param  value         property value
     */
    JLoadProperty(JLoadableObject_t& object,
                  const T&           value) :
      T     (value),
      object(object)
    {}
 
 
    /**
     * Read property from input.
     *
     * \param  in            input stream.
     * \return               input stream
     */
    inline std::istream& read(std::istream& in)
    {
      in >> static_cast<T&>(*this);
      
      object.load();
      
      return in;
    }
 
 
    /**
     * Assignment operator.
     *
     * \param  buffer        buffer
     * \return               property
     */
    inline JLoadProperty_t& operator=(const T& buffer)
    {
      static_cast<T&>(*this) = buffer;
 
      return *this;
    }
 
      
    /**
     * Input stream.
     *
     * \param  in            input stream
     * \param  property      property
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JLoadProperty& property)
    {
      return property.read(in);
    }
 
 
    /**
     * Output stream
     *
     * \param  out           output stream
     * \param  property      property
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JLoadProperty& property)
    {
      return out << static_cast<const T&>(property);
    }
    
    
  private:
 
    JLoadableObject_t& object; // Reference to loadable object
  };
}
 
#endif