DbBlob.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// $Header: /cvs/PF/pool/StorageSvc/StorageSvc/DbBlob.h,v 1.14 2010/08/19 14:02:41 trentad Exp $
#ifndef POOL_STORAGESVC_DBBLOB_H
#define POOL_STORAGESVC_DBBLOB_H 1
 
// STL include files
#include <list>
#include <vector>
#include <string>
#include <iostream>
#include <cstring>
#include <typeinfo>
 
#if !(defined(WIN32) || defined(_WIN32))
#include <unistd.h>
#define _swab(source, target, radix) swab(source, target, radix)
#endif  /* WIN32 */
 
 
/*  
 *   POOL namespace declaration
 */
namespace pool    {
 
  class DbBlob  {
  public:
    enum Mode       {UNINITIALIZED, READING, WRITING};
    enum SwapAction {SINGLE_BYTE, SWAP, NOSWAP};
    enum    State   {INVALID=-1, VALID };
    typedef void (*Analyzer)(const void* data, int siz, const std::type_info& type);
 
  protected:
    Mode     m_mode;
    int      m_pointer;
    int      m_length;
    char*    m_buffer;
    bool     m_swapEnabled;
    Analyzer m_analyzer;
 
    SwapAction swapBuffer(int siz)  const;
 
  public:
    DbBlob(bool do_swap=true) : 
      m_mode(UNINITIALIZED), 
      m_pointer(0), 
      m_length(0), 
      m_buffer(0),
      m_swapEnabled(do_swap)      {      m_analyzer = 0;          }
    virtual ~DbBlob();
 
    DbBlob (const DbBlob&) = delete;
    DbBlob& operator= (const DbBlob&) = delete;
 
    const char* data()    const   {      return m_buffer;         }
    char* data()                  {      return m_buffer;         }
    void erase()                  {      m_pointer = 0;           }
    int size ()  const            {      return m_length;         }
    bool isReading()    const     {      return m_mode == READING;}
 
    bool isWriting()    const     {      return m_mode == WRITING;}
    int buffPointer() const       {      return m_pointer;        }
    void setBuffPointer(int ptr)  {      m_pointer = ptr;         }
    void setAnalyzer(Analyzer fun=0) {   m_analyzer = fun;        }
    inline void swapToBuffer(const void* source, int siz);
    inline void swapFromBuffer(void* target, int siz);
    void adopt(char* memory, int len);
    void reserve(int len);
    void extend(int len)    {
      if ( len + m_pointer > m_length )    {
        // We have to be a bit generous here in order not to run too often
        // into ::realloc().
        int new_len = (m_length < 16384) ? 16384 : 2*m_length;
        if ( m_length < len ) new_len += len;
        reserve(new_len);
      }
    }
    void setMode(Mode m)  {
      m_mode = m;
      m_pointer = 0;
    }
    DbBlob& writeBytes  (const char* str, int len);
 
  #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
 
    DbBlob& operator<<(long long int   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(long long int & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(int   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(int & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(unsigned int   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(unsigned int & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(long   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(long & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(unsigned long   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(unsigned long & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(short   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(short & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(unsigned short   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(unsigned short & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(char   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(char & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(unsigned char   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(unsigned char & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(float   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(float & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator<<(double   data)     {                       
      swapToBuffer(&data, sizeof(data));                              
      STREAM_ANALYSE(data, sizeof(data));                             
      return *this;                                                   
    }                                                                 
    DbBlob& operator>>(double & data)     {                       
      swapFromBuffer(&data, sizeof(data));                            
      return *this;                                                   
    }
    DbBlob& operator>>(char* data);
    DbBlob& operator<<(const char *data);
    DbBlob& operator>>(std::string& data);
    DbBlob& operator<<(const std::string& data);
  };
  #undef STREAM_ANALYSE
 
  inline DbBlob::SwapAction DbBlob::swapBuffer(int siz)  const    {
    switch(siz)   {
    case 1:  
      return SINGLE_BYTE;
    default:
  #if defined(__alpha) && !defined(__VMS)
      return NOSWAP;
  #elif defined(__sun) && defined(__SVR4) && defined(__i386)
      return NOSWAP;
  #elif defined(__linux) && !defined(__powerpc)
      return NOSWAP;
  #elif defined(BORLAND) || defined(_WIN32) || defined(WIN32)
      return NOSWAP;
  #elif defined(__APPLE__) && defined(__i386__)
      return NOSWAP;
  #elif defined(__APPLE__)
      return SWAP;
  #else
      return m_swapEnabled ? SWAP : NOSWAP;
  #endif
    }
  }
 
  inline void DbBlob::swapToBuffer(const void* source, int siz)   {
    char buff[8], *tar;
    const char* src = reinterpret_cast<const 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;
      // Fall through.
    case NOSWAP:
      memcpy(tar, src, siz);
      break;
    }
    m_pointer += siz;
  }
 
  inline void DbBlob::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 
  DbBlob& operator << (DbBlob& s, const std::vector<T>& v)  {
    int len = (int)v.size();
    s << len;
    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
  DbBlob& operator >> (DbBlob& s, std::vector<T>& v)  {
    int 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 
  DbBlob& operator << (DbBlob& s, const std::list<T>& l)  {
    int len = (int)l.size();
    s << len;
    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
  DbBlob& operator >> (DbBlob& s, std::list<T>& l)  {
    int i, len;
    s >> len;
    l.clear();
    for ( i = 0; i < len; i++ )  {
      T    temp;
      s >> temp;
      l.push_back(temp);
    }
    return s;
  }
 
}       // End namespace pool
#endif  // POOL_STORAGESVC_DBBLOB_H