/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/eformat/eformat-00-00-04/eformat/Header.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-

#ifndef EFORMAT_HEADER_H
#define EFORMAT_HEADER_H

#include "eformat/Version.h"
#include "eformat/SourceIdentifier.h"
#include "eformat/util.h"
#include "eformat/SizeCheckIssue.h"
#include "eformat/BadVersionIssue.h"
#include "eformat/WrongMarkerIssue.h"
#include "eformat/WrongSizeIssue.h"
#include "eformat/NoSuchChildIssue.h"
#include "ers/ers.h"

namespace eformat {

  template <class TPointer> class Header {

  public:
   
    Header (const TPointer& it, uint32_t match);

    Header () : m_start() {}

    Header (const Header& other) : m_start(other.m_start) {}

    virtual ~Header() {}

    Header& operator= (const Header& other)
    { m_start = other.m_start; return *this; }

    Header& assign (const TPointer& it, uint32_t match);

    virtual bool check () const;

    inline uint32_t marker() const { return m_start[0]; }

    inline uint32_t fragment_size_word() const { return m_start[1]; }

    inline uint32_t header_size_word() const { return m_start[2]; }

    inline uint32_t version() const { return m_start[3]; }

    inline uint32_t source_id() const { return m_start[4]; }

    inline uint32_t nstatus () const { return m_start[5]; }

    inline void start (TPointer& it) const { it = m_start; }

    inline void payload (TPointer& it) const
    { it = m_start; it+= header_size_word(); }

    inline void end (TPointer& it) const 
    { it = m_start; it += fragment_size_word(); }

    inline uint32_t payload_size_word (void) const
    { return fragment_size_word() - header_size_word(); }

    inline void status (TPointer& it) const { it = m_start; it += 6; }


    inline uint32_t nspecific () const { return m_start[6 + nstatus()]; }

    inline void specific_header (TPointer& it) const
    { it = m_start; it += 7 + nstatus(); }

    virtual uint32_t nchildren () const;

    virtual void child (TPointer& p, size_t n) const;

    virtual void child_check (TPointer& p, size_t n) const;

    virtual uint32_t children (TPointer* p, size_t max) const;

  private: 

    TPointer m_start; 

  };

}

template <class TPointer>
eformat::Header<TPointer>::Header (const TPointer& it, uint32_t match)
  : m_start(it)
{
  ERS_DEBUG_3("Building header 0x%x from iterator", match);
  if (marker() != match) {
    throw EFORMAT_WRONG_MARKER(marker(), match);
  }
  ERS_DEBUG_1("Initialized header with source identifier = %s",
              eformat::helper::SourceIdentifier(match).human().c_str());
}

template <class TPointer> eformat::Header<TPointer>& 
eformat::Header<TPointer>::assign (const TPointer& it, uint32_t match)
{
  ERS_DEBUG_3("Rebuilding header 0x%x from iterator", match);
  m_start = it;
  if (marker() != match) {
    throw EFORMAT_WRONG_MARKER(marker(), match);
  }
  ERS_DEBUG_1("Re-initialized header with source identifier = %s",
              eformat::helper::SourceIdentifier(match).human().c_str());
  return *this;
}

template <class TPointer>
bool eformat::Header<TPointer>::check () const
{
  ERS_DEBUG_2("Checking for consistency of fragment of type %s [%s]",
              eformat::marker2string(marker()).c_str(),
              eformat::helper::SourceIdentifier(source_id()).human().c_str());
  if ( version() >> 16 != eformat::MAJOR_DEFAULT_VERSION )
    throw EFORMAT_BAD_VERSION(version() >> 16, eformat::MAJOR_DEFAULT_VERSION);
  if ( header_size_word() != (7 + nstatus() + nspecific()) )
    throw EFORMAT_SIZE_CHECK(header_size_word(),
                             (7 + nstatus() + nspecific()));
  return true;
}

template <class TPointer>
uint32_t eformat::Header<TPointer>::nchildren () const
{
  ERS_DEBUG_2("User asked for number of children of fragment type %s [%s]",
              eformat::marker2string(marker()).c_str(),
              eformat::helper::SourceIdentifier(source_id()).human().c_str());
  return children(0,0);
}

template <class TPointer> 
void eformat::Header<TPointer>::child (TPointer& p, size_t n) const
{
  ERS_DEBUG_2("User asked for child %ud of fragment type %s [%s]", n,
              eformat::marker2string(marker()).c_str(),
              eformat::helper::SourceIdentifier(source_id()).human().c_str());
  TPointer next;
  payload(next);
  for (size_t i=0; i<n; ++i) next += next[1];
  ERS_DEBUG_3("Set user object");
  p = next;
}

template <class TPointer>
void eformat::Header<TPointer>::child_check (TPointer& p, size_t n) const
{
  uint32_t total = nchildren();
  if (n >= total) throw EFORMAT_NO_SUCH_CHILD(n, total);
  child(p, n);
}

template <class TPointer> 
uint32_t eformat::Header<TPointer>::children (TPointer* p, size_t max) const
{
  ERS_DEBUG_2("Retrieving all children...");
  TPointer payload_start;
  payload(payload_start);
  try {
    return find_fragments(child_marker(static_cast<HeaderMarker>(marker())),
                          payload_start, payload_size_word(), p, max);
  }
  catch (WrongMarkerIssue& ex) {
    //This normally means the fragment size is wrong...
    throw EFORMAT_WRONG_SIZE(fragment_size_word());
  }
  return 0;
}

#endif //EFORMAT_HEADER_H

---