In This Package:

TagHeader.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************

#ifndef TagEvent_TagHeader_H
#define TagEvent_TagHeader_H 1

// Include files
#include "Event/HeaderObject.h"
#include "Event/TagData.h"
#include "GaudiKernel/boost_allocator.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations
  
  // Class ID definition
  static const CLID CLID_TagHeader = 51802;
  
  // Namespace for locations in TDS
  namespace TagHeaderLocation {
    static const std::string& Default = "/Event/Tags/Default";
  }
  

  class TagHeader: public HeaderObject
  {
  public:

  static const std::string& defaultLocation() { return TagHeaderLocation::Default; }
  virtual const std::string& defLoc() const { return TagHeaderLocation::Default; }
  
    enum TagType{ Unknown = 0,   // Undefined, indicates error
                  Generic,       // Generic Tag
                  AdEvent,       // An event in the AD
                  Positron,      // A positron
                  Neutron,       // A neutron capture
                  Radiation,     // An event due to a radioactive decay
                  MuonFragment,  // Event due to passage of a muon through a detector
                  Muon,          // One or more MuonFragments
                  MuonShower,    // A MuonTrack and one or more other things
                  MuonDecay,     // A MuonTrack and Michele electron
                  AdCoincidence, // Time-correlated AD events
                  IBD            // Set of inverse beta decay events
      };
  
    TagHeader() : m_tagID(Unknown),
                  m_isA(false),
                  m_data(0) {}
  
    virtual ~TagHeader() {}
  
    // Retrieve pointer to class definition structure
    virtual const CLID& clID() const;
    static const CLID& classID();
  
   virtual std::ostream& fillStream(std::ostream& s) const;
  
    template <class TDTYPE>
    TDTYPE* dataAs() const;
  
    std::string tagName() const;
  
    std::vector<const DayaBay::TagHeader*> taggedHeaders(const TagType& tagType) const;
  
  const TagType& tagID() const;
  
  void setTagID(const TagType& value);
  
  bool isA() const;
  
  void setIsA(bool value);
  
  const DayaBay::TagData* data() const;
  
  void setData(DayaBay::TagData* value);
  
  
  #ifndef GOD_NOALLOC
    static void* operator new ( size_t size )
    {
      return ( sizeof(TagHeader) == size ? 
               boost::singleton_pool<TagHeader, sizeof(TagHeader)>::malloc() :
               ::operator new(size) );
    }
  
    static void* operator new ( size_t size, void* pObj )
    {
      return ::operator new (size,pObj);
    }
  
    static void operator delete ( void* p )
    {
      boost::singleton_pool<TagHeader, sizeof(TagHeader)>::is_from(p) ?
      boost::singleton_pool<TagHeader, sizeof(TagHeader)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    TagType           m_tagID; 
    bool              m_isA;   
    DayaBay::TagData* m_data;  
  
  }; // class TagHeader

  inline std::ostream& operator<< (std::ostream& str, const TagHeader& obj)
  {
    return obj.fillStream(str);
  }
  
  inline std::ostream & operator << (std::ostream & s, DayaBay::TagHeader::TagType e) {
    switch (e) {
      case DayaBay::TagHeader::Unknown       : return s << "Unknown";
      case DayaBay::TagHeader::Generic       : return s << "Generic";
      case DayaBay::TagHeader::AdEvent       : return s << "AdEvent";
      case DayaBay::TagHeader::Positron      : return s << "Positron";
      case DayaBay::TagHeader::Neutron       : return s << "Neutron";
      case DayaBay::TagHeader::Radiation     : return s << "Radiation";
      case DayaBay::TagHeader::MuonFragment  : return s << "MuonFragment";
      case DayaBay::TagHeader::Muon          : return s << "Muon";
      case DayaBay::TagHeader::MuonShower    : return s << "MuonShower";
      case DayaBay::TagHeader::MuonDecay     : return s << "MuonDecay";
      case DayaBay::TagHeader::AdCoincidence : return s << "AdCoincidence";
      case DayaBay::TagHeader::IBD           : return s << "IBD";
      default : return s << "ERROR wrong value for enum DayaBay::TagHeader::TagType";
    }
  }
  
  
} // namespace DayaBay;

// -----------------------------------------------------------------------------
// end of class
// -----------------------------------------------------------------------------

// Including forward declarations

inline const CLID& DayaBay::TagHeader::clID() const
{
  return DayaBay::TagHeader::classID();
}

inline const CLID& DayaBay::TagHeader::classID()
{
  return CLID_TagHeader;
}

inline std::ostream& DayaBay::TagHeader::fillStream(std::ostream& s) const
{
  char l_isA = (m_isA) ? 'T' : 'F';
  HeaderObject::fillStream(s);
  s << "{ " << "tagID : " << m_tagID << std::endl
            << "isA :   " << l_isA << std::endl
            << "data :  " << m_data << std::endl << " }";
  return s;
}


inline const DayaBay::TagHeader::TagType& DayaBay::TagHeader::tagID() const 
{
  return m_tagID;
}

inline void DayaBay::TagHeader::setTagID(const TagType& value) 
{
  m_tagID = value;
}

inline bool DayaBay::TagHeader::isA() const 
{
  return m_isA;
}

inline void DayaBay::TagHeader::setIsA(bool value) 
{
  m_isA = value;
}

inline const DayaBay::TagData* DayaBay::TagHeader::data() const 
{
  return m_data;
}

inline void DayaBay::TagHeader::setData(DayaBay::TagData* value) 
{
  m_data = value;
}

template <class TDTYPE>
inline TDTYPE* DayaBay::TagHeader::dataAs() const 
{
    return dynamic_cast<TDTYPE*>(m_data);
}


#endif 

---