Buffer.h

Go to the documentation of this file.

// $Id: Buffer.h 4506 2020-05-26 07:55:57Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef DABC_Buffer
#define DABC_Buffer
 
#include <cstdint>
#include <cstdlib>
 
#ifndef DABC_Object
#include "dabc/Object.h"
#endif
 
#ifndef DABC_defines
#include "dabc/defines.h"
#endif
 
namespace dabc {
 
   typedef uint32_t BufferSize_t;
 
   extern const BufferSize_t BufferSizeError;
 
   class Pointer;
 
   enum EBufferTypes {
      mbt_Null         = 0,
      mbt_Generic      = 1,
      mbt_Int64        = 2,
      mbt_TymeSync     = 3,
      mbt_AcknCounter  = 4,
      mbt_RawData      = 5,
      mbt_EOF          = 6,   // such packet produced when transport is closed completely
      mbt_EOL          = 7,   // this is more like end-of-line case, where transport is not closed, but may deliver new kind of data (new event ids) afterwards
      mbt_User         = 1000
   };
 
   class MemoryPool;
 
   struct MemSegment {
      unsigned        id;        
      unsigned        datasize;  
      void*           buffer;    
      void copy_from(MemSegment* src)
        { id = src->id; datasize = src->datasize; buffer = src->buffer; }
   };
 
   class BufferContainer : public Object {
      friend class Buffer;
      friend class MemoryPool;
 
      protected:
         unsigned     fTypeId;       
 
         unsigned     fNumSegments;  
         unsigned     fCapacity;     
 
         Reference    fPool;         
 
         MemSegment*  fSegm;         
 
         BufferContainer() :
            Object(0, "", flAutoDestroy | flNoMutex),
            fTypeId(0),
            fNumSegments(0),
            fCapacity(0),
            fPool(),
            fSegm(0)
            {
              #ifdef DABC_EXTRA_CHECKS
                 DebugObject("Buffer", this, 1);
              #endif
            }
 
         void* operator new(size_t sz) {
            return malloc(sz);
         }
 
         void* operator new(size_t sz, void* area) {
            if (area) return area;
            return malloc(sz);
         }
 
         void operator delete(void* area)
         {
            free(area);
         }
 
      public:
 
         virtual ~BufferContainer();
   };
 
   class Buffer : public Reference {
 
      friend class MemoryPool;
 
      DABC_REFERENCE(Buffer, Reference, BufferContainer)
 
      protected:
 
         void Locate(BufferSize_t p, unsigned& seg_indx, unsigned& seg_shift) const;
 
         void AllocateContainer(unsigned capacity);
 
         MemoryPool* PoolPtr() const;
 
      public:
 
      void SetTypeId(unsigned tid) { if (!null()) GetObject()->fTypeId = tid; }
      inline unsigned GetTypeId() const { return null() ? 0 : GetObject()->fTypeId; }
 
      Reference GetPool() const;
 
      bool IsPool(const Reference& pool) const { return null() ? false : pool == GetObject()->fPool; }
 
      unsigned NumSegments() const { return null() ? 0 : GetObject()->fNumSegments; }
 
      MemSegment* Segments() const { return null() ? 0 : GetObject()->fSegm; }
 
      inline unsigned SegmentId(unsigned n = 0) const { return GetObject()->fSegm[n].id; }
 
      inline void* SegmentPtr(unsigned n = 0) const { return GetObject()->fSegm[n].buffer; }
 
      inline unsigned SegmentSize(unsigned n = 0) const { return GetObject()->fSegm[n].datasize; }
 
      BufferSize_t GetTotalSize() const;
 
      Buffer Duplicate() const;
 
      Buffer HandOver() { return Take(); }
 
 
      void MakeEmpty(unsigned capacity = 8) { AllocateContainer(capacity); }
 
      void SetTotalSize(BufferSize_t len);
 
      void CutFromBegin(BufferSize_t len);
 
      bool Append(Buffer& src, bool moverefs = true) throw();
 
      bool Prepend(Buffer& src, bool moverefs = true) throw();
 
      bool Insert(BufferSize_t pos, Buffer& src, bool moverefs = true);
 
      std::string AsStdString();
 
      BufferSize_t CopyFrom(const Buffer& srcbuf, BufferSize_t len = 0) throw();
 
      BufferSize_t CopyFromStr(const char* src, unsigned len = 0) throw();
 
      BufferSize_t CopyTo(void* ptr, BufferSize_t len) const throw();
 
 
      Buffer GetNextPart(Pointer& ptr, BufferSize_t len, bool allowsegmented = true) throw();
 
      bool CanSafelyChange() const;
 
      // ===================================================================================
 
      static Buffer CreateBuffer(BufferSize_t sz) throw();
 
      static Buffer CreateBuffer(const void* ptr, unsigned size, bool owner = false, bool makecopy = false) throw();
   };
 
};
 
#endif