JDriver.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JDRIVER__
#define __JTOOLS__JDRIVER__
 
#include <istream>
#include <ostream>
#include <type_traits>
 
#include "JLang/JStreamAvailable.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }
 
namespace JTOOLS {
 
 
 
  /**
   * 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(std::false_type 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, std::false_type 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, std::true_type option)
    {
      JClass_t* p = load(std::false_type());
 
      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, std::false_type 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, std::true_type option)
    {
      if (p != NULL) {
        out << *p;
      }
    }
 
 
  public:
    /**
     * Load object.
     *
     * \return               pointer to newly loaded object
     */
    static inline JClass_t* load()
    {
      return load(std::bool_constant<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, std::bool_constant<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), std::bool_constant<JStreamAvailable<JClass_t>::has_ostream>());
    }
  };
}
 
#endif