StreamBuffer.h

Go to the documentation of this file.

// $Header: /tmp/svngaudi/tmp.jEpFh25751/Gaudi/GaudiKernel/GaudiKernel/StreamBuffer.h,v 1.9 2008/10/27 16:41:33 marcocle Exp $
#ifndef GAUDIKERNEL_STREAMBUFFER_H
#define GAUDIKERNEL_STREAMBUFFER_H 1

// STL include files
#include <list>
#include <vector>
#include <string>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <typeinfo>

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/swab.h"

// forward declarations
class StreamBuffer;
class DataObject;
class ContainedObject;

class StreamBuffer /* : public std::string  */  {
public:
  class DataIO   {
  public:
    DataIO()    {
    }
    virtual ~DataIO()    {
    }
    void badStreamMode()    {
      throw("Not acceptable stream mode!");
    }
    virtual void serialize(StreamBuffer& stream)   {
      if (stream.isReading())
        load(stream);
      else if (stream.isWriting())
        dump(stream);
      else
        badStreamMode();
    }
    virtual void load(StreamBuffer&)   {
      badStreamMode();
    }
    virtual void dump(StreamBuffer&)   {
      badStreamMode();
    }
  };

  class Istream : public DataIO  {
    std::istream* m_stream;
  public:
    Istream(std::istream& str) : m_stream(&str)   {
    }
    virtual ~Istream()  {
    }
    virtual void load(StreamBuffer& stream)   {
      // Generic implementation for istreams:
      int  len;
      (*m_stream) >> len;
      stream.erase();
      stream.reserve(len);
      m_stream->read(stream.data(),len);
    }
  };
  class Ostream : public DataIO  {
    std::ostream* m_stream;
  public:
    Ostream(std::ostream& str) : m_stream(&str)   {
    }
    virtual ~Ostream()  {
    }
    virtual void dump(StreamBuffer& stream)   {
      // Generic implementation for ostreams:
      (*m_stream) << stream.buffPointer();
      m_stream->write(stream.data(), stream.buffPointer());
    }
  };
public:
  enum Mode       {UNINITIALIZED, READING, WRITING};
  enum SwapAction {SINGLE_BYTE, SWAP, NOSWAP};
  enum    State   {INVALID=-1, VALID };
  class ContainedLink   {
  public:
    ContainedObject* first;
    long second;
    long third;
    ContainedLink() : first(0), second(INVALID), third(INVALID)  {
    }
    ContainedLink(const ContainedLink& copy)
      : first(copy.first), second(copy.second), third(copy.third)  {
    }
    ContainedLink(ContainedObject* pObj, long hint, long link)
      : first(pObj), second(hint), third(link)  {
    }
  };
  class IdentifiedLink   {
  public:
    DataObject* first;
    long second;
    IdentifiedLink() : first(0), second(INVALID)  {
    }
    IdentifiedLink(const IdentifiedLink& copy)
      : first(copy.first), second(copy.second)  {
    }
    IdentifiedLink(DataObject* pObj, long hint)
      : first(pObj), second(hint)  {
    }
  };

  typedef std::vector<ContainedLink>   ContainedLinks;
  typedef std::vector<IdentifiedLink>  IdentifiedLinks;
  typedef void (*AnalyzeFunction)(const void* data, int siz, const std::type_info& type);
  friend class DataObject;

protected:
  Mode             m_mode;

  long             m_pointer;

  long             m_length;

  char*            m_buffer;

  bool             m_swapEnabled;

  ContainedLinks   m_containedLinks;

  IdentifiedLinks  m_identifiedLinks;

  AnalyzeFunction  m_analyzer;

  SwapAction swapBuffer(int siz)  const;

  template <class TYPE> StreamBuffer& getObjectPointer(const DataObject* /*pObject*/, TYPE*& refpObject) {
    IdentifiedLink& link = m_identifiedLinks.back();
    DataObject* pObj = link.first;
    m_identifiedLinks.pop_back();
    refpObject = dynamic_cast<TYPE*>(pObj);
    return *this;
  }
  template <class TYPE> StreamBuffer& getObjectPointer(const ContainedObject* /*pObject*/, TYPE*& refpObject) {
    ContainedLink& link = m_containedLinks.back();
    ContainedObject* pObj = link.first;
    m_containedLinks.pop_back();
    refpObject = dynamic_cast<TYPE*>(pObj);
    return *this;
  }
public:
  StreamBuffer(bool do_swap=true) :
    m_mode(UNINITIALIZED),
    m_pointer(0),
    m_length(0),
    m_buffer(0),
    m_swapEnabled(do_swap)
  {
    m_analyzer = 0;
  }
  virtual ~StreamBuffer()   {
    ::free( m_buffer );
  }
  const char* data()    const   {
    return m_buffer;
  }
  char* data()   {
    return m_buffer;
  }
  void erase()    {
    m_pointer = 0;
  }
  void reserve(long len)   {
    if ( len > m_length )   {
      m_length = (len < 16384) ? 16384 : len;
      m_buffer = (char*)::realloc (m_buffer,m_length);
    }
  }
  void extend(long len)    {
    if ( len + m_pointer > m_length )    {
      // We have to be a bit generous here in order not to run too often
      // into ::realloc().
    long new_len = (m_length < 16384) ? 16384 : 2*m_length;
      if ( m_length < len ) new_len += len;
      reserve(new_len);
    }
  }
  long size ()  const   {
    return m_length;
  }
  ContainedLinks& containedLinks()   {
    return m_containedLinks;
  }
  const ContainedLinks& containedLinks()   const {
    return m_containedLinks;
  }

  IdentifiedLinks& identifiedLinks()   {
    return m_identifiedLinks;
  }
  const IdentifiedLinks& identifiedLinks()   const {
    return m_identifiedLinks;
  }

  void setMode(Mode m)  {
    m_mode = m;
    m_pointer = 0;
    m_containedLinks.erase (m_containedLinks.begin(), m_containedLinks.end());
    m_identifiedLinks.erase(m_identifiedLinks.begin(),m_identifiedLinks.end());
  }

  bool isReading()    const     {
    return m_mode == READING;
  }

  bool isWriting()    const     {
    return m_mode == WRITING;
  }
  long buffPointer()    const   {
    return m_pointer;
  }
  void setBuffPointer(long ptr)   {
    m_pointer = ptr;
  }
  void setAnalyzer(AnalyzeFunction fun=0)  {
    m_analyzer = fun;
  }
  void swapToBuffer(const void* source, int siz);

  void swapFromBuffer(void* target, int siz);

  StreamBuffer& writeBytes  (const char* str, long len)    {
    extend( m_pointer+len+4 );
    *this << len;
    memcpy(data()+buffPointer(), str, len);
    m_pointer += len;
    return *this;
  }

  void getIdentifiedLink (DataObject*& pObject, long& hint)   {
    IdentifiedLink& l = m_identifiedLinks.back();
    pObject = l.first;
    hint    = l.second;
    m_identifiedLinks.pop_back();
  }
  void addIdentifiedLink (const DataObject* pObject, long hint)   {
    m_identifiedLinks.push_back( IdentifiedLink((DataObject*)pObject, hint) );
  }

  void getContainedLink (ContainedObject*& pObject, long& hint, long& link)   {
    ContainedLink& l = m_containedLinks.back();
    pObject = l.first;
    hint    = l.second;
    link    = l.third;
    m_containedLinks.pop_back();
  }
  void addContainedLink (const ContainedObject* pObject, long hint, long link)   {
    m_containedLinks.push_back( ContainedLink((ContainedObject*)pObject, hint, link) );
  }

#ifdef USE_STREAM_ANALYSER
  #define STREAM_ANALYSE(data, len)   if ( 0 != m_analyzer ) m_analyzer(&data, len, typeid(data))
#else
  #define STREAM_ANALYSE(data, len)
#endif

  // Implement streamer macros for primivive data types.
#define IMPLEMENT_STREAMER(TYPE)                                    \
  /*  Output Streamer                                   */          \
  StreamBuffer& operator<<(TYPE   data)     {                       \
    swapToBuffer(&data, sizeof(data));                              \
    STREAM_ANALYSE(data, sizeof(data));                             \
    return *this;                                                   \
  }                                                                 \
  /*  Input Streamer                                    */          \
  StreamBuffer& operator>>(TYPE & data)     {                       \
    swapFromBuffer(&data, sizeof(data));                            \
    return *this;                                                   \
  }
// RootCint does not understand this macro....
// But we can easily live without it!
#undef IMPLEMENT_STREAMER

  StreamBuffer& operator<<(longlong   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(longlong & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(int   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(int & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(unsigned int   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(unsigned int & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(long   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(long & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(unsigned long   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(unsigned long & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(short   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(short & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(unsigned short   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(unsigned short & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(char   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(char & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(unsigned char   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(unsigned char & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(float   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(float & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator<<(double   data)     {
    swapToBuffer(&data, sizeof(data));
    STREAM_ANALYSE(data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(double & data)     {
    swapFromBuffer(&data, sizeof(data));
    return *this;
  }
  StreamBuffer& operator>>(char* data)    {
    long i, len;
    *this >> len;
    for ( i = 0, data[0]=0; i < len; i++ )    {
      data[i] = m_buffer[m_pointer++];
    }
    return *this;
  }
  StreamBuffer& operator<<(const char *data)     {
    const char* ptr = 0 == data ? "" : data;
    int len = strlen(ptr)+1;
    if ( 0 == m_analyzer )
      writeBytes(ptr, len);
    else  {
      STREAM_ANALYSE(data, len);
    }
    return *this;
  }
  StreamBuffer& operator>>(std::string& data)   {
    long i, len;
    *this >> len;
    for ( i = 0, data = ""; i < len; i++ )    {
      data.append( 1, m_buffer[m_pointer++] );
    }
    return *this;
  }
  StreamBuffer& operator<<(const std::string& data)   {
    if ( 0 == m_analyzer)   {
      const char* ptr = data.c_str();
      long len = data.length();
      writeBytes(ptr, len);
    }
    else    {
      STREAM_ANALYSE(data, sizeof(data));
    }
    return *this;
  }
  template<class TYPE> StreamBuffer& operator>>(TYPE*& refpObject)    {
    return getObjectPointer(refpObject, refpObject);
  }

  StreamBuffer& operator<<(const ContainedObject* pObject)   {
    STREAM_ANALYSE(pObject, sizeof(pObject));
    addContainedLink(pObject, INVALID, INVALID);
    return *this;
  }

  StreamBuffer& operator<<(const DataObject* pObject)   {
    STREAM_ANALYSE(pObject, sizeof(pObject));
    addIdentifiedLink(pObject, INVALID);
    return *this;
  }

  void serialize(DataIO& ioObject)   {
    ioObject.serialize ( *this );
    m_pointer = 0;
  }
};

#undef STREAM_ANALYSE

inline StreamBuffer::SwapAction StreamBuffer::swapBuffer(int siz)  const    {
  switch(siz)   {
  case 1:
    return SINGLE_BYTE;
  default:
#if defined(__alpha) && !defined(__VMS)
//    return m_swapEnabled ? SWAP : NOSWAP;
    return NOSWAP;
#elif defined(__sun) && defined(__SVR4) && defined(__i386)
//    return m_swapEnabled ? SWAP : NOSWAP;
    return NOSWAP;
#elif defined(__APPLE__)
//    return m_swapEnabled ? SWAP : NOSWAP;
    return SWAP;
#elif defined(__linux) && !defined(__powerpc)
//    return m_swapEnabled ? SWAP : NOSWAP;
    return NOSWAP;
#elif defined(BORLAND) || defined(_WIN32) || defined(WIN32)
//    return m_swapEnabled ? SWAP : NOSWAP;
    return NOSWAP;
#else
    return m_swapEnabled ? SWAP : NOSWAP;
//    return NOSWAP;
#endif
  }
}

inline void StreamBuffer::swapToBuffer(const void* source, int siz)   {
  char buff[8], *tar, *src = (char*)source;
  extend (m_pointer+siz);
  tar = (char*)m_buffer+m_pointer;
  switch ( swapBuffer(siz) )   {
  case SINGLE_BYTE:
    *tar = *src;
    break;
  case SWAP:
#ifdef __APPLE__
    for(int i = 0,j = siz-1;i<siz;i++,j--) tar[j] = src[i];
#else
    ::_swab (src, buff, siz);
#endif
    src = buff;
    /* no break */
  case NOSWAP:
    memcpy(tar, src, siz);
    break;
  }
  m_pointer += siz;
}

inline void StreamBuffer::swapFromBuffer(void* target, int siz)   {
  char* tar = (char*)target;
  char* src = (char*)m_buffer+m_pointer;
  switch ( swapBuffer(siz) )   {
  case SINGLE_BYTE:
    *tar = *src;
    break;
  case SWAP:
#ifdef __APPLE__
    for(int i = 0,j = siz-1;i<siz;i++,j--) tar[j] = src[i];
#else
    ::_swab (src, tar, siz);
#endif
    break;
  case NOSWAP:
    ::memcpy(tar, src, siz);
    break;
  }
  m_pointer += siz;
}

// Output serialize a vector of items
template <class T> inline
StreamBuffer& operator << (StreamBuffer& s, const std::vector<T>& v)  {
  s << v.size();
  for ( typename std::vector<T>::const_iterator i = v.begin(); i != v.end(); i++ )  {
    s << (*i);
  }
  return s;
}

// Input serialize a vector of items
template <class T> inline
StreamBuffer& operator >> (StreamBuffer& s, std::vector<T>& v)  {
  long i, len;
  s >> len;
  v.clear();
  for ( i = 0; i < len; i++ )  {
    T    temp;
    s >> temp;
    v.push_back(temp);
  }
  return s;
}

// Output serialize a list of items
template <class T> inline
StreamBuffer& operator << (StreamBuffer& s, const std::list<T>& l)  {
  s << l.size();
  for ( typename std::list<T>::const_iterator i = l.begin(); i != l.end(); i++ )  {
    s << (*i);
  }
  return s;
}

// Input serialize a list of items
template <class T> inline
StreamBuffer& operator >> (StreamBuffer& s, std::list<T>& l)  {
  long i, len;
  s >> len;
  l.clear();
  for ( i = 0; i < len; i++ )  {
    T    temp;
    s >> temp;
    l.push_back(temp);
  }
  return s;
}
#endif // GAUDIKERNEL_STREAMBUFFER_H