JFileRecorder.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JFILERECORDER__
#define __JSUPPORT__JFILERECORDER__
 
#include <string>
#include <iostream>
 
#include <TString.h>
 
#include "JLang/JObjectWriter.hh"
#include "JLang/JObjectOutput.hh"
#include "JLang/JException.hh"
#include "JROOT/JRootFileWriter.hh"
#include "JIO/JBinaryFileWriter.hh"
#include "JSupport/JDAQFileWriter.hh"
#include "JSupport/JMonteCarloFileWriter.hh"
#include "JSupport/JFilenameSupportkit.hh"
 
 
/**
 * \file
 * Recording of objects on file according a format that follows from the file name extension.
 * \author mdejong
 */
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using JLANG::JAccessibleObjectWriter;
  using JLANG::JProtocolException;
  using JLANG::JFileOpenException;
 
 
  /**
   * Object writing to file.
   *
   * This class implements the method open of the JLANG::JAccessible interface.
   * The file format is derived from the file name extension.
   * The method open can be called to open a file after reading the file name.
   */
  template<class T>
  class JFileRecorder :
    public JAccessibleObjectWriter<T>
  {
  public:
    /**
     * Default constructor.
     */
    JFileRecorder() :
      JAccessibleObjectWriter<T>(),
      fileName("")
    {}
 
 
    /**
     * Constructor.
     *
     * \param  file_name     file name
     */
    JFileRecorder(const char* file_name) :
      JAccessibleObjectWriter<T>(),
      fileName(file_name)
    {}
 
 
    /**
     * Get file name.
     *
     * \return               file name
     */
    const std::string& getFilename() const
    {
      return fileName;
    }
 
 
    /**
     * Set file name.
     *
     * \param  file_name     file name
     */
    const void setFilename(const std::string& file_name)
    {
      fileName = file_name;
    }
 
 
    /**
     * Open file.
     *
     * \param  file_name     file name
     */
    virtual void open(const char* file_name) override 
    {
      fileName = file_name;
 
      open();
    }
      
 
    /**
     * Open file.
     */
    void open()
    {
      using namespace JPP;
 
      this->reset();
 
      if        (isROOTFile(fileName.c_str())) {
        
        this->reset(new JRootFileWriter<T>());
 
      } else if (isDAQFile(fileName.c_str())) {
 
        this->reset(new JDAQFileWriter<T>());
 
      } else if (isJppFile(fileName.c_str())) {
 
        this->reset(new JBinaryFileWriter<T>());
 
      } else if (isMonteCarloFile(fileName.c_str())) {
 
        this->reset(new JMonteCarloFileWriter<T>());
 
      } else if (fileName.empty() || fileName == "/dev/null") {
 
        this->reset(new JNullAccessibleOutput<T>());
 
      } else {
 
        THROW(JProtocolException, "Protocol not defined: " << fileName);
      }
 
      if (this->is_valid()) {
        this->get()->open(fileName.c_str());
      }
 
      if (!this->get()->is_open()) {
        THROW(JFileOpenException, "Error opening file: " << fileName);
      }
    }
 
 
    /**
     * Read file recorder from input.
     *
     * \param  in         input stream
     * \param  recorder   JFileRecorder
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JFileRecorder& recorder)
    {
      in >> recorder.fileName;
 
      return in;
    }
 
 
    /**
     * Write file recorder to output.
     *
     * \param  out        output stream
     * \param  recorder   JFileRecorder
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JFileRecorder& recorder)
    {
      out << recorder.fileName;
 
      return out;
    }
 
  protected:
    std::string fileName;
  };
}
 
#endif