#ifndef __JTOOLS__JDRIVER__
#define __JTOOLS__JDRIVER__

#include <istream>
#include <ostream>

#include "JLang/JStreamAvailable.hh"
#include "JLang/JBool.hh"


/**
 * \author mdejong
 */

namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }

namespace JTOOLS {

  using JLANG::JBool;


  /**
   * Auxiliary class to load and store objects.
   */
  template<class JClass_t>
  class JDriver {
  private:
    /**
     * Load object without input.
     *
     * \param  option        I/O option
     * \return               pointer to newly loaded object
     */
    static inline JClass_t* load(JLANG::JBool<false> option)
    {
      return new JClass_t();
    }


    /**
     * Load object without input.
     *
     * \param  in            input stream
     * \param  option        I/O option
     * \return               pointer to newly loaded object
     */
    static inline JClass_t* load(std::istream& in, JLANG::JBool<false> option)
    {
      return load(option);
    }


    /**
     * Load object with input.
     *
     * \param  in            input stream
     * \param  option        I/O option
     * \return               pointer to newly loaded object
     */
    static inline JClass_t* load(std::istream& in, JLANG::JBool<true> option)
    {
      JClass_t* p = load(JLANG::JBool<false>());

      in >> *p;
    
      if (in.fail()) {

	delete p;
      
	p = NULL;
      }

      return p;
    }


    /**
     * Store object without output.
     * This implementation doesn't do anything.
     *
     * \param  out           output stream
     * \param  option        I/O option
     * \param  p             pointer to object
     */
    static inline void store(std::ostream& out, const JClass_t* p, JBool<false> option)
    {}


    /**
     * Store object with output.
     *
     * \param  out           output stream
     * \param  option        I/O option
     * \param  p             pointer object
     */
    static inline void store(std::ostream& out, const JClass_t* p, JBool<true> option)
    {
      if (p != NULL) {
	out << *p;
      }
    }


  public:
    /**
     * Load object.
     *
     * \return               pointer to newly loaded object
     */
    static inline JClass_t* load()
    {
      return load(JLANG::JBool<JStreamAvailable<JClass_t>::has_istream>());
    }


    /**
     * Load object.
     *
     * \param  in            input stream
     * \return               pointer to newly loaded object
     */
    static inline JClass_t* load(std::istream& in)
    {
      return load(in, JBool<JStreamAvailable<JClass_t>::has_istream>());
    }


    /**
     * Store object.
     *
     * \param  out           output stream
     * \param  p             pointer to object
     */
    template<class T>
    static inline void store(std::ostream& out, const T* p)
    {
      store(out, dynamic_cast<const JClass_t*>(p), JLANG::JBool<JStreamAvailable<JClass_t>::has_ostream>());
    }
  };
}

#endif