FileHandler Class Reference

InputHandler which will read XML from plain files, optionally gzip compressed. More...

#include <FileHandler.h>

Inheritance diagram for FileHandler:

Collaboration diagram for FileHandler:

Public Types
typedef InputHandler *	Factory(const std::string &uri)
	Factory function which takes a backend uri and returns an InputHandler instance.

Public Member Functions
	FileHandler (const std::string &uri)
	Instantiate a new file handler, using the uri as base search path.
virtual	~FileHandler ()
	empty, virtual destructor
virtual InputContext *	open (const std::string &path) override
	create a new FileContext by searching the file system for a file named like path.

Protected Attributes
std::string	m_path
	Search path to look for files.
boost::format	m_pathformat
	format object in case of run-dependent data path
bool	m_rundependence {false}
	bool indicating whether the data path is run-dependent
std::string	m_uri
	URI for the InputHandler.

Detailed Description

InputHandler which will read XML from plain files, optionally gzip compressed.

This Handler will try to find the XML files as plain files in the file system. If a file with the exact name cannot be found, the Handler tries to append .gz to the filename and decompress it with gzip.

The uri is the base dir for all files to be searched and can contain the placeholders {EXP} and {RUN} to be replaced with the experiment and run number respectively. Optionally, the placeholders can contain the number of digits the result should have separated by a colon, filled with zeros, e.g. {EXP:4} to have the experiment number starting as 0001

If an file cannot be found (with or without .gz extension), the directory separators "/" will be successively replaced by dashes "-" (starting at the back) to allow for flat file structure. For example, if the uri is /data/ and the filename to be opened is geometry/Belle2.xml, the inputhandler will try to find /data/geometry/Belle2.xml /data/geometry/Belle2.xml.gz /data/geometry-Belle2.xml /data/geometry-Belle2.xml.gz /data-geometry-Belle2.xml /data-geometry-Belle2.xml.gz in that order the search path, stopping at the first success.

Definition at line 67 of file FileHandler.h.

Member Typedef Documentation

Factory

typedef InputHandler * Factory(const std::string &uri)

inherited

Factory function which takes a backend uri and returns an InputHandler instance.

Definition at line 53 of file InputHandler.h.

Constructor & Destructor Documentation

FileHandler()

FileHandler ( const std::string &  uri )

explicit

Instantiate a new file handler, using the uri as base search path.

If uri is empty, the default data search path will be used.

Parameters

uri	* path to search files in

Definition at line 35 of file FileHandler.cc.

                                              : InputHandler(uri), m_path(uri)
  {
 
    if (m_path.empty()) {
      m_path = "/data/";
    } else {
      //Check if we have placeholder for experiment or run information
      std::regex exp(R"(\{EXP(?::(\d+))?\})");
      std::regex run(R"(\{RUN(?::(\d+))?\})");
      m_rundependence = std::regex_search(m_path, exp) || std::regex_search(m_path, run);
      if (m_rundependence) {
        //Apparently we do have placeholders, replace them by something
        //boost::format will understand. The placeholder is something like
        //{EXP} or {EXP:<n>} where <n> is an integer to make the number
        //zero-filled with <n> digits, so we replace it with %1$0d or
        //%1$0<n>d to denote to the first argument in a boost format string.
        //Same for {RUN} and {RUN:<n>} but as second argument
        StoreObjPtr<EventMetaData> eventMetaDataPtr;
        eventMetaDataPtr.isRequired();
        std::string tmp = std::regex_replace(m_path, exp, std::string("%1$$0$1d"));
        tmp = std::regex_replace(tmp, run, std::string("%2$$0$1d"));
        B2DEBUG(300, "Found run-dependence in file path, resulting in " << tmp);
        m_pathformat = boost::format(tmp);
        m_pathformat.exceptions(boost::io::all_error_bits ^ boost::io::too_many_args_bit);
      }
    }
    B2DEBUG(300, "Created FileHandler for directory " << m_path);
  }

~FileHandler()

virtual ~FileHandler ( )

inlinevirtual

empty, virtual destructor

Definition at line 75 of file FileHandler.h.

{}

Member Function Documentation

open()

InputContext * open ( const std::string &  path )

overridevirtual

create a new FileContext by searching the file system for a file named like path.

Parameters

path	name of the file, relative to the FileHandler search path

Implements InputHandler.

Definition at line 64 of file FileHandler.cc.

  {
    if (m_rundependence) {
      StoreObjPtr<EventMetaData> eventMetaDataPtr;
      if (!eventMetaDataPtr.isValid()) {
        B2DEBUG(300, "No run info, probably initialize? Skipping backend");
        return nullptr;
      }
      int exp = eventMetaDataPtr->getExperiment();
      int run = eventMetaDataPtr->getRun();
      m_path = (m_pathformat % exp % run).str();
    }
    fs::path basedir(m_path);
    std::string filename = (basedir / path).string();
    bool repeat(false);
    do {
      //Ok, let's try to find the file
      B2DEBUG(350, "Trying to find " << filename);
 
      std::string fullpath = FileSystem::findFile(filename, true);
      if (!fullpath.empty()) {
        if (m_rundependence) B2INFO("gearbox::FileHandler: Reading '" << fullpath << "'");
        return new FileContext(fullpath, false);
      }
      fullpath = FileSystem::findFile(filename + ".gz", true);
      if (!fullpath.empty()) {
        if (m_rundependence) B2INFO("gearbox::FileHandler: Reading '" << fullpath << "' (gzip)");
        return new FileContext(fullpath, true);
      }
 
      //did not work, replace last slash by a - and try again if such a
      //replacement was successful. This allows flattening the directory
      //structure from e.g. data/pxd/PXD-Alignment.xml to
      //data-pxd-PXD-Alignment.xml to more easily override single files
      size_t last_slash = filename.find_last_of('/');
      //If the last slash we found is after the primary path we try again.
      //This means we try to replace all slashes in the requested filename
      //but not in the given base path, for example:
      // - if the base path is "/somedir/data/" and the file to be opened is
      //   "foo/bar/baz.xml", we will look only for files up to
      //   "/somedir/data/foo-bar-baz.xml"
      // - if the base path does not end in "/", e.g. "/somedir/data" we also
      //   look for "/somedir/data-foo-bar-baz.xml"
      repeat = (last_slash >= m_path.size()) && (last_slash != std::string::npos);
      if (repeat) {
        filename[last_slash] = '-';
      }
    } while (repeat);
    return nullptr;
  }

Member Data Documentation

m_path

std::string m_path

protected

Search path to look for files.

Definition at line 83 of file FileHandler.h.

m_pathformat

boost::format m_pathformat

protected

format object in case of run-dependent data path

Definition at line 85 of file FileHandler.h.

m_rundependence

bool m_rundependence {false}

protected

bool indicating whether the data path is run-dependent

Definition at line 87 of file FileHandler.h.

m_uri

std::string m_uri

protectedinherited

URI for the InputHandler.

Definition at line 79 of file InputHandler.h.

---

The documentation for this class was generated from the following files:

• framework/gearbox/include/FileHandler.h
• framework/gearbox/src/FileHandler.cc