Iterator.h

Go to the documentation of this file.

// $Id: Iterator.h 3862 2018-05-11 10:06:18Z 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 MBS_Iterator
#define MBS_Iterator
 
#ifndef MBS_MbsTypeDefs
#include "mbs/MbsTypeDefs.h"
#endif
 
#ifndef DABC_Buffer
#include "dabc/Buffer.h"
#endif
 
#ifndef DABC_Pointer
#include "dabc/Pointer.h"
#endif
 
#ifndef DABC_eventsapi
#include "dabc/eventsapi.h"
#endif
 
 
namespace mbs {
 
   class ReadIterator {
      protected:
         bool           fFirstEvent;
         dabc::Pointer  fEvPtr;
         dabc::Pointer  fSubPtr;
         dabc::Pointer  fRawPtr;
 
      public:
         ReadIterator();
 
         ReadIterator(const dabc::Buffer& buf);
 
         ReadIterator(const ReadIterator& src);
 
         ReadIterator& operator=(const ReadIterator& src);
 
         ~ReadIterator() { Close(); }
 
         bool Reset(const dabc::Buffer& buf);
 
         bool Reset() { Close(); return true; }
 
         void Close();
 
         bool IsData() const { return !fEvPtr.null(); }
 
         bool IsLastEvent() const;
 
         bool NextEvent();
         bool NextSubEvent();
 
         EventHeader* evnt() const { return (EventHeader*) fEvPtr(); }
         // return actual event size, will not exceed buffers limit
         unsigned GetEventSize() const;
         bool AssignEventPointer(dabc::Pointer& ptr);
 
         dabc::Pointer GetEventPointer();
 
         dabc::Pointer GetSubeventsPointer();
 
         SubeventHeader* subevnt() const { return (SubeventHeader*) fSubPtr(); }
         void* rawdata() const { return fRawPtr(); }
         unsigned rawdatasize() const { return fRawPtr.fullsize(); }
 
         static unsigned NumEvents(const dabc::Buffer& buf);
   };
 
   // ___________________________________________________________________________
 
   class WriteIterator {
      protected:
         dabc::Buffer   fBuffer;  
         dabc::Pointer  fEvPtr;   
         dabc::Pointer  fSubPtr;  
         dabc::Pointer  fSubData; 
         dabc::BufferSize_t fFullSize; 
 
      public:
         WriteIterator();
         WriteIterator(dabc::Buffer& buf);
         ~WriteIterator();
 
         bool Reset(dabc::Buffer& buf);
 
         bool IsBuffer() const { return !fBuffer.null(); }
         bool IsEmpty() const { return fFullSize == 0; }
 
         bool IsAnyEvent() const { return fFullSize != 0; }
 
         bool IsAnyIncompleteData() const { return !fSubPtr.null(); }
 
         bool IsAnyData() const { return IsAnyEvent() || IsAnyIncompleteData(); }
 
         bool IsPlaceForEvent(uint32_t subeventsize, bool add_subev_header = false);
         bool NewEvent(EventNumType event_number = 0, uint32_t subeventsize = 0);
         bool IsEventStarted() const { return !fSubPtr.null(); }
 
         bool NewSubevent(uint32_t minrawsize = 0, uint8_t crate = 0, uint16_t procid = 0, uint8_t control = 0);
         bool NewSubevent2(uint32_t fullid);
 
         bool IsPlaceForRawData(unsigned len) const;
         bool AddRawData(const void* src, unsigned len);
 
         bool FinishSubEvent(uint32_t rawdatasz = 0);
         bool AddSubevent(const dabc::Pointer& source);
         bool AddSubevent(SubeventHeader* sub);
 
         bool FinishEvent();
 
         void DiscardEvent();
 
         bool CopyEventFrom(const dabc::Pointer& ptr, bool finish = true);
 
         dabc::Buffer Close();
 
         dabc::Buffer CloseAndTransfer(dabc::Buffer& newbuf);
 
         EventHeader* evnt() const { return (EventHeader*) fEvPtr(); }
         SubeventHeader* subevnt() const { return (SubeventHeader*) fSubPtr(); }
         void* rawdata() const { return subevnt() ? subevnt()->RawData() : 0; }
         uint32_t maxrawdatasize() const { return fSubPtr.null() ? 0 : fSubPtr.fullsize() - sizeof(SubeventHeader); }
   };
 
   // ________________________________________________________________________________
 
   class EventsIterator : public dabc::EventsIterator {
      protected:
         ReadIterator fIter;
 
      public:
         EventsIterator(const std::string &name) : dabc::EventsIterator(name), fIter() {}
         virtual ~EventsIterator() {}
 
         virtual bool Assign(const dabc::Buffer& buf) { return fIter.Reset(buf); }
         virtual void Close() { return fIter.Close(); }
 
         virtual bool NextEvent() { return fIter.NextEvent(); };
         virtual void* Event() { return fIter.evnt(); }
         virtual dabc::BufferSize_t EventSize() { return fIter.GetEventSize(); }
   };
 
}
 
#endif