JRootFile.hh

Go to the documentation of this file.

#ifndef __JROOTFILE__
#define __JROOTFILE__

#include <string>
#include <stdlib.h>
#include <string.h>

#include "TFile.h"
#include "TError.h"

#include "JLang/JAccessible.hh"
#include "JLang/JException.hh"
#include "JLang/JThrow.hh"
#include "JLang/JStorage.hh"


/**
 * \author mdejong
 */

namespace JROOT {}
namespace JPP { using namespace JROOT; }

namespace JROOT {

  using JLANG::JAccessible;
  using JLANG::JStorage;
  using JLANG::JFileOpenException;
  using JLANG::JFileRecoveryException;
  using JLANG::JThrow;

  /**
   * Environment variable to disable ROOT file recovery.
   *
   * If not set or set to 0, allow recovery of ROOT file, else do not.
   */
  static const char* const ROOT_FILE_RECOVERY_DISABLE = "ROOT_FILE_RECOVERY_DISABLE";
 

  /**
   * ROOT file.
   *
   * This class implements the method is_open() of the JLANG::JAccessible interface.
   */
  class JRootFile :
    public virtual JAccessible,
    public JStorage<TFile>
  {
  protected:
    /**
     * Default constructor.
     * The printing of ROOT errors is suppressed. 
     */
    JRootFile()
    {
      gErrorIgnoreLevel = kError;
    }


  public:
    /**
     * Get file.
     *
     * \return                 pointer to file
     */
    TFile* getFile() const 
    {
      return get();
    }


    /**
     * Check is file is open.
     *
     * \return                 true if open; else false
     */
    virtual bool is_open() const override 
    {
      return (getFile() != NULL && getFile()->IsOpen());
    }

  private:
    JRootFile(const JRootFile&);
    JRootFile(JRootFile&&);
    JRootFile& operator=(const JRootFile&);
    JRootFile& operator=(JRootFile&&);
  };


  /**
   * ROOT input file.
   *
   * This class implements the methods open() and close() of the JLANG::JAccessible interface.
   */
  class JRootInputFile :
    public JRootFile
  {
  public:
    /**
     * Default constructor.
     */
    JRootInputFile() :
      JRootFile()
    {}


    /**
     * Constructor.
     *
     * \param  file_name      file name
     */
    JRootInputFile(const char* file_name) :
      JRootFile()
    {
      do_open(file_name);
    }


    /**
     * Destructor.
     *
     * The destructor closes the file if it is still open.
     */
    ~JRootInputFile()
    {
      do_close();
    }


    /**
     * Open file.
     * The file is not opened when no file exists with the given name.
     *
     * \param  file_name      file name
     */
    virtual void open(const char* file_name) override 
    {
      do_open(file_name);
    }


    /**
     * Close file.
     */
    virtual void close() override 
    {
      do_close();
    }


  private:
    /**
     * Open file.
     * The file is not opened when no file exists with the given name.
     *
     * \param  file_name      file name
     */
    void do_open(const char* file_name)
    {
      set(TFile::Open(file_name, "READ"));

      if (!is_open()) {
        Throw(MAKE_EXCEPTION(JFileOpenException, "Error opening file " << file_name));
      }
      
      if (getFile()->TestBit(TFile::kRecovered)) {

        const char* const value = getenv(ROOT_FILE_RECOVERY_DISABLE);

        if (value != NULL && strcmp(value,"0") != 0) {
          Throw(MAKE_EXCEPTION(JFileRecoveryException, "Error recovery file " << file_name << " disabled"));
        }
      }
    }


    /**
     * Close file.
     */
    void do_close()
    {
      if (getFile() != NULL && getFile()->IsOpen()) {
        getFile()->Close();
      }

      reset();
    }
  };


  /**
   * ROOT output file.
   *
   * This class implements the methods open() and close() of the JLANG::JAccessible interface.
   */
  class JRootOutputFile :
    public JRootFile
  {
  public:
    /**
     * Default constructor.
     */
    JRootOutputFile() :
      JRootFile()
    {}


    /**
     * Constructor.
     *
     * \param  file_name      file name
     */
    JRootOutputFile(const char* file_name) :
      JRootFile()
    {
      do_open(file_name);
    }


    /**
     * Destructor.
     *
     * The destructor writes and closes the file if it is still open.
     */
    ~JRootOutputFile()
    {
      do_close();
    }


    /**
     * Open file.
     * The file is not opened when a file exists with the given name.
     *
     * \param  file_name      file name
     */
    virtual void open(const char* file_name) override 
    {
      do_open(file_name);
    }


    /**
     * Close file.
     * This method calls the TFile::Write method before closing the file.
     */
    virtual void close() override 
    {
      do_close();
    }


  private:
    /**
     * Open file.
     * The file is not opened when a file exists with the given name.
     *
     * \param  file_name      file name
     */
    void do_open(const char* file_name)
    {
      set(TFile::Open(file_name, "CREATE"));

      if (!is_open()) {
        Throw(MAKE_EXCEPTION(JFileOpenException, "Error opening file " << file_name));
      }
    }


    /**
     * Close file.
     * This method calls the TFile::Write method before closing the file.
     */
    void do_close()
    {
      if (getFile() != NULL && getFile()->IsOpen()) {
        getFile()->Write();
        getFile()->Close();
      }

      reset();
    }
  };
}

#endif