EventIDBase.h File Reference

This class provides a unique identification for each event, in terms of run/event number and/or a time stamp. More...

#include <iostream>
#include <tuple>
#include <stdint.h>

Include dependency graph for EventIDBase.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	EventIDBase
	This class provides a unique identification for each event, in terms of run/event number and/or a time stamp. More...
class	EventIDBase::SortByTimeStamp
class	EventIDBase::SortByRunEvent
class	EventIDBase::SortByLumiEvent

Functions
bool	operator< (const EventIDBase &lhs, const EventIDBase &rhs)
bool	operator== (const EventIDBase &lhs, const EventIDBase &rhs)
bool	operator> (const EventIDBase &lhs, const EventIDBase &rhs)
bool	operator!= (const EventIDBase &lhs, const EventIDBase &rhs)
bool	operator<= (const EventIDBase &lhs, const EventIDBase &rhs)
bool	operator>= (const EventIDBase &lhs, const EventIDBase &rhs)
std::ostream &	operator<< (std::ostream &os, const EventIDBase &rhs)

Detailed Description

This class provides a unique identification for each event, in terms of run/event number and/or a time stamp.

Author

RD Schaffer R.D.S.nosp@m.chaf.nosp@m.fer@c.nosp@m.ern..nosp@m.ch

Paolo Calafiura pcala.nosp@m.fiur.nosp@m.a@lbl.nosp@m..gov

Charles Leggett

Definition in file EventIDBase.h.

Function Documentation

bool operator!= ( const EventIDBase &  lhs, const EventIDBase &  rhs  )

inline

Definition at line 211 of file EventIDBase.h.

                                                                       {
  return !(lhs == rhs);
}

bool operator< ( const EventIDBase &  lhs, const EventIDBase &  rhs  )

inline

Definition at line 185 of file EventIDBase.h.

                                                                      {
  // first try ordering by timestamp if both are non-zero
  // then try ordering by lumi/event if both have non-zero lumi
  // then order by run/event

  if (lhs.isTimeStamp() && rhs.isTimeStamp()) {
    return (lhs.m_time_stamp < rhs.m_time_stamp);
  } else {
    if (lhs.isLumiEvent() && rhs.isLumiEvent()) {
      return (std::tie(lhs.m_lumiBlock, lhs.m_event_number) < 
              std::tie(rhs.m_lumiBlock, rhs.m_event_number) );
    } else {
      return (std::tie(lhs.m_run_number, lhs.m_event_number) < 
              std::tie(rhs.m_run_number, rhs.m_event_number) );
    }
  }
}

std::ostream& operator<< ( std::ostream &  os, const EventIDBase &  rhs  )

inline

Definition at line 221 of file EventIDBase.h.

                                                                      {
  if (rhs.m_type == EventIDBase::Invalid) {
    os << "[INVALID]";
    return os;
  }

  os << "[" 
     << rhs.m_run_number 
     << "," << rhs.m_event_number;
  
  if ( rhs.isTimeStamp() != 0 ) {
    os << "," << rhs.m_time_stamp << ":" << rhs.m_time_stamp_ns_offset;
  }

  if ( rhs.isLumiEvent() != 0) {
    os << ",l:" << rhs.m_lumiBlock;
  }

  if ( rhs.m_bunch_crossing_id != 0) {
    os << ",b:" << rhs.m_bunch_crossing_id;
  }
  os << "]";
  return os;
}

bool operator<= ( const EventIDBase &  lhs, const EventIDBase &  rhs  )

inline

Definition at line 214 of file EventIDBase.h.

                                                                       {
  return !(lhs > rhs);
}

bool operator== ( const EventIDBase &  lhs, const EventIDBase &  rhs  )

inline

Definition at line 203 of file EventIDBase.h.

                                                                       {
  // We assume that equality via run/event numbers is sufficient
  return ( lhs.m_run_number  == rhs.m_run_number && 
           lhs.m_event_number == rhs.m_event_number );
}

bool operator> ( const EventIDBase &  lhs, const EventIDBase &  rhs  )

inline

Definition at line 208 of file EventIDBase.h.

                                                                      {
  return !( (lhs < rhs) || (lhs == rhs));
}

bool operator>= ( const EventIDBase &  lhs, const EventIDBase &  rhs  )

inline

Definition at line 217 of file EventIDBase.h.

                                                                       {
  return !(lhs < rhs);
}