JEvent_t.hh

Go to the documentation of this file.

#ifndef __JRUNCONTROL_JEVENT_T__
#define __JRUNCONTROL_JEVENT_T__
 
#include <string>
#include <istream>
#include <ostream>
#include <sstream>
#include <iomanip>
 
#include "JLang/JLangToolkit.hh"
#include "JRuncontrol/JRuncontrolToolkit.hh"
 
 
/**
 * \author mdejong
 */
 
namespace KM3NETDAQ {
 
  /**
   * Auxiliary class for handling event name and optional static information.
   */
  struct JEvent_t {
    /**
     * Default constructor.
     */
    JEvent_t() :
      name("?"),
      info(),
      more(false)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  name         event name
     */
    JEvent_t(const std::string& name) :
      name(name),
      info(),
      more(false)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  name         event name
     * \param  info         event information
     */
    JEvent_t(const std::string& name,
             const std::string& info) :
      name(name),
      info(info),
      more(true)
    {}
 
 
    /**
     * Get event name.
     *
     * \return              event name
     */
    const std::string& getName() const
    {
      return name;
    }
 
 
    /**
     * Check if this event has information.
     *
     * \return              true if information is available; else false
     */
    bool hasInfo() const
    {
      return more;
    }
 
 
    /**
     * Get event information.
     *
     * \return              event information.
     */
    const std::string& getInfo() const
    {
      return info;
    }
 
 
    /**
     * Convert string to event.
     *
     * \param  buffer       buffer
     * \return              event
     */
    static JEvent_t toValue(const std::string& buffer)
    {
      using namespace std;
      using namespace JPP;
 
      JEvent_t object;
 
      const string::size_type sep = buffer.find(EVENTNAME_DELIMETER);
      
      if (sep != string::npos) {
        
        object.name   = trim(buffer.substr(0, sep));
        object.info   = trim(buffer.substr(sep + 1));
        object.more   = true;
        
      } else {
        
        object.name   = trim(buffer);
        object.info   = "";
        object.more   = false;
      }
 
      return object;
    }
 
 
    /**
     * Read event name and optional number from input stream.
     *
     * \param  in           input stream
     * \param  object       event
     * \return              input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JEvent_t& object)
    {
      std::string buffer;
 
      in >> buffer;
 
      object = JEvent_t::toValue(buffer);
 
      return in;
    }
    
 
    /**
     * Write event to output stream.
     *
     * \param  out          output stream
     * \param  object       event
     * \return              output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JEvent_t& object)
    {
      out << object.name;
 
      if (object.more) {
        out << getEventnameDelimeter() << object.info;
      }
 
      return out;
    }
 
 
  protected:
    std::string name;
    std::string info;
    bool        more;
  };
}
 
#endif