JValue.hh

Go to the documentation of this file.

#ifndef __JLANG__JVALUE__
#define __JLANG__JVALUE__

#include <istream>
#include <ostream>
#include <sstream>
#include <string>

#include "JLang/JAbstractIO.hh"
#include "JLang/JEquationFacet.hh"


/**
 * \author mdejong
 */

namespace JLANG {}
namespace JPP { using namespace JLANG; }

namespace JLANG {


  /**
   * Forward declaration for friend declaration of JValueOutput inside JValueInput.
   */
  template<class T>
  class JValueOutput;


  /**
   * Wrapper class around template object.
   * This class implements the JStreamInput interface.
   * Note that this class can be used in conjuction with the JEquationFacet.
   */
  template<class T>
  class JValueInput :
    public JStreamInput
  {
  public:


    friend class JValueOutput<T>;


    /**
     * Constructor.
     *
     * \param  object  input object
     */
    JValueInput(T& object) :
      p(&object)
    {}


    /**
     * Constructor.
     *
     * \param  ps      pointer to valid object
     */
    JValueInput(void* ps) :
      p((T*) ps)
    {}


    operator const T&() const { return *p; }   //!< type conversion operator
    operator       T&()       { return *p; }   //!< type conversion operator

    
    /**
     * Stream input.
     *
     * \param  in      input stream
     * \return         input stream
     */
    virtual std::istream& read(std::istream& in) override 
    {
      return in >> *p;
    }


  protected:
    T* p;
  };


  /**
   * Wrapper class around template object.
   * This class implements the JStreamOutput interface.
   * Note that this class can be used in conjuction with the JEquationFacet.
   */
  template<class T>
  class JValueOutput :
    public JStreamOutput
  {
  public:
    /**
     * Constructor.
     *
     * \param  object  input object
     */
    JValueOutput(const T& object) :
      p(&object)
    {}


    /**
     * Constructor.
     *
     * \param  object  input object
     */
    JValueOutput(const JValueInput<T>& object) :
      p(object.p)
    {}


    /**
     * Constructor.
     *
     * \param  ps      pointer to valid object
     */
    JValueOutput(const void* ps) :
      p((const T*) ps)
    {}


    operator const T&() const { return *p; }   //!< type conversion operator


    /**
     * Stream output.
     *
     * \param  out     output stream
     * \return         output stream
     */
    virtual std::ostream& write(std::ostream& out) const override 
    {
      return out << *p;
    }


  protected:
    const T* p;
  };


  /**
   * Wrapper class around template object.
   * This class implements the JStreamInput and JStreamOutput interfaces.
   */
  template<class T>
  class JValue :
    public JValueInput <T>,
    public JValueOutput<T>
  {
  public:
    /**
     * Constructor.
     *
     * \param  object  input object
     */
    JValue(T& object) :
      JValueInput <T>(&object),
      JValueOutput<T>(&object)
    {}


    /**
     * Constructor.
     *
     * \param  ps      pointer to valid object
     */
    JValue(void* ps) :
      JValueInput <T>(ps) ,
      JValueOutput<T>(ps)
    {}
  };


  /**
   * Read JStreamInput from input stream.
   *
   * \param  in        input stream
   * \param  object    JStreamInput
   * \return           input stream
   */
  template<class T>
  inline std::istream& operator>>(std::istream& in, JValueInput<T>& object)
  {
    using namespace std;

    istream::sentry sentry(in);   // skips white spaces

    if (sentry) {

      const locale& loc = in.getloc();

      if (has_facet<JEquationFacet>(loc)) {

        string buffer;

        const JEquationFacet& facet = use_facet<JEquationFacet>(loc);

        facet.getline(in, buffer);

        istringstream is(buffer);

        is.imbue(locale(in.getloc(), facet.clone()));

        object.read(is);

        if (is.fail()) {
          in.setstate(ios_base::badbit);
        }

      } else {

        object.read(in);
      }
    }

    return in;
  }


  /**
   * Write JStreamOutput to output stream.
   *
   * \param  out       output stream
   * \param  object    JStreamOutput
   * \return           output stream
   */
  template<class T>
  inline std::ostream& operator<<(std::ostream& out, const JValueOutput<T>& object)
  {
    return object.write(out);
  }
}

#endif