MsgHandler.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/pcore/EvtMessage.h>
#include <TMessage.h>
 
#include <string>
#include <memory>
 
class TObject;
 
namespace Belle2 {
  class CharBuffer {
    std::unique_ptr<char[]> m_data; 
    size_t m_capacity{0}; 
    size_t m_size{0}; 
  public:
    explicit CharBuffer(size_t initial_capacity = 0): m_data{initial_capacity > 0 ? new char[initial_capacity] : nullptr}
    {}
    void add(const void* data, size_t len)
    {
      auto old_size = m_size;
      resize(m_size + len);
      memcpy(m_data.get() + old_size, data, len);
    }
    char* data() { return m_data.get(); }
    size_t size() const { return m_size; }
    void clear() { m_size = 0; }
    void resize(size_t size)
    {
      if (size > m_capacity) {
        // grow by basically doubling each time, except if the size we need to
        // grow to is even more than that
        m_capacity = std::max(size, m_capacity * 2);
        //c++14: auto newbuf = std::make_unique<char[]>(m_capacity);
        std::unique_ptr<char[]> newbuf{new char[m_capacity]};
        memcpy(newbuf.get(), m_data.get(), m_size);
        std::swap(m_data, newbuf);
      }
      m_size = size;
    }
  };
 
  class InMessage : public TMessage {
  public:
    InMessage() : TMessage()
    {
      SetReadMode();
      SetWhat(kMESS_OBJECT);
    }
 
    void SetBuffer(const void* ptr, UInt_t bufsize)
    {
      TBuffer::SetBuffer(const_cast<void*>(ptr), bufsize, false);
      // TMessage has an extra header of two ints: a reserved size field and a
      // fWhat pointer indicating the type of the message.  We force the message
      // to be MESS_OBJECT so we don't care. Let's put the buffer where we need
      // it to be. The original constructor has a ReadClass() here but we skip
      // it since we read everything as TObject.
      SetBufferOffset(sizeof(UInt_t) * 2);
      // and reset the map of objects/classes seen so far
      ResetMap();
    }
 
    TObject* readTObject() { return static_cast<TObject*>(ReadObjectAny(TObject::Class())); }
  };
 
  class MsgHandler {
  public:
    explicit MsgHandler(int complevel = 0);
    virtual ~MsgHandler();
 
    virtual void clear();
    virtual void add(const TObject*, const std::string& name);
 
    virtual EvtMessage* encode_msg(ERecordType rectype);
    virtual void decode_msg(EvtMessage* msg, std::vector<TObject*>& objlist, std::vector<std::string>& namelist);
 
  private:
    CharBuffer m_buf; 
    CharBuffer m_compBuf; 
    std::unique_ptr<TMessage> m_msg; 
    InMessage m_inMsg; 
    int m_complevel; 
  };
 
} // namespace Belle2