JRootObjectID.hh

Go to the documentation of this file.

#ifndef __JGIZMO__JROOTOBJECTID__
#define __JGIZMO__JROOTOBJECTID__

#include <string>
#include <istream>
#include <ostream>
#include <cctype>

#include "TString.h"

#include "JLang/JException.hh"


/**
 * \author mdejong
 */

namespace JGIZMO {}
namespace JPP { using namespace JGIZMO; }

namespace JGIZMO {

  using JLANG::JParseError;

  /**
   * Auxiliary class to handle file name, ROOT directory and object name.
   *
   * The general syntax is as follows:\n
   * <pre>
   *   <file name>:[<directory/>]<object name>
   * </pre>
   * where
   * <tt><directory></tt> is optional and 
   * <tt><object name></tt> may be a regular expression (TRegexp).
   */
  class JRootObjectID
  {
  public:
    
    static const char LABEL_L_BRACKET     =  '[';     //!< left  bracket for label
    static const char LABEL_R_BRACKET     =  ']';     //!< right bracket for label
    static const char FILENAME_SEPARATOR  =  ':';     //!< file name separator
    static const char PATHNAME_SEPARATOR  =  '/';     //!< path name separator


    /**
     * Default constructor.
     */
    JRootObjectID()
    {}


    /**
     * Constructor.
     *
     * \param  file_name    file name
     * \param  name         object name
     */
    JRootObjectID(const std::string& file_name,
                  const std::string& name) :
      file_name(file_name),
      directory(""),
      name     (name)
    {}


    /**
     * Constructor.
     *
     * \param  file_name    file name
     * \param  dir          directory name
     * \param  name         object name
     */
    JRootObjectID(const std::string& file_name,
                  const std::string& dir,
                  const std::string& name) :
      file_name(file_name),
      directory(dir),
      name     (name)
    {}


    /**
     * Constructor.
     *
     * \param  full_name    full object name
     */
    JRootObjectID(const std::string& full_name)
    {
      std::istringstream(full_name) >> *this;
    }
  
  
    /**
     * Get file name.
     *
     * \return              file name
     */
    const std::string& getFilename() const
    {
      return file_name;
    }
  
    
    /**
     * Get directory.
     *
     * \return              directory
     */
    TString getDirectory() const
    {
      return TString(directory.c_str());
    }
  
    
    /**
     * Get object name.
     *
     * \return              object name
     */
    TString getObjectName() const
    {
      return TString(name.c_str());
    }
  
    
    /**
     * Get full file name, including path.
     *
     * \return              file name
     */
    TString getFullFilename() const
    {
      if (getDirectory() == "")
        return getFilename();
      else
        return getFilename() + PATHNAME_SEPARATOR + getDirectory();
    }
  
    
    /**
     * Get full object name, including path.
     *
     * \return              object name
     */
    TString getFullObjectName() const
    {
      if (getDirectory() == "")
        return getObjectName();
      else
        return getDirectory() + PATHNAME_SEPARATOR + getObjectName();
    }


    /**
     * Check validity.
     *
     * \return              true if valid ROOT object identifier; else false
     */
    bool is_valid() const
    {
      return (file_name != "" &&
              name      != "");
    }

    /**
     * Clear.
     */
    void clear()
    {
      file_name.clear();
      directory.clear();
      name     .clear();
    }


    /**
     * Equal operator for object identifiers.
     *
     * \param  first        first  object identifier
     * \param  second       second object identifier
     * \return              true if first and second object identifier are equal; else false
     */
    friend inline bool operator==(const JRootObjectID& first, const JRootObjectID& second)
    {
      return (first.getFilename()   == second.getFilename()  &&
              first.getDirectory()  == second.getDirectory() &&
              first.getObjectName() == second.getObjectName());
    }
    

    /**
     * Read object identifier from input.
     *
     * \param  in           input stream
     * \param  object       object identifier
     * \return              input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JRootObjectID& object)
    {
      using namespace std;

      object.clear();

      string buffer;

      for (int bracket = 0; in.peek() != EOF; ) {

        const char c = (char) in.get();

        if        (c == LABEL_L_BRACKET) {

          ++bracket;

        } else if (c == LABEL_R_BRACKET) {

          --bracket;

        } else if (isspace(c)) {

          if (bracket <= 0) {
            break;
          }
        }

        buffer.push_back(c);
      }

      size_t pos = buffer.find(FILENAME_SEPARATOR);

      if (pos != string::npos) {

        object.file_name = buffer.substr(0, pos);
        object.name      = buffer.substr(pos + 1);

        pos = object.name.rfind(PATHNAME_SEPARATOR);

        if (pos != string::npos) {
          
          object.directory = object.name.substr(0, pos);
          object.name      = object.name.substr(pos + 1);
        }

      } else if (!buffer.empty()) {

        throw JParseError("JRootObjectID error parsing " + buffer);
      }

      return in;
    }


    /**
     * Write object identifier to output.
     *
     * \param  out          output stream
     * \param  object       object identifier
     * \return              output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JRootObjectID& object)
    {
      return out << object.getFilename() << FILENAME_SEPARATOR << object.getFullObjectName();
    }

  protected:
    std::string file_name;
    std::string directory;
    std::string name;
  };
}

#endif