Input.h

Go to the documentation of this file.

// $Id: Input.h 2216 2014-04-03 13:59:28Z 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 SAFT_INPUT_H
#define SAFT_INPUT_H
 
#ifndef DABC_DataIO
#include "dabc/DataIO.h"
#endif
 
#include "dabc/logging.h"
 
#include <string>
#include <queue>
#include <cstdint>
 
#include <iostream>
//#include <iomanip>
 
 
 
#include "saftdabc/Device.h"
#include "saftdabc/Definitions.h"
 
#ifndef DABC_SAFT_USE_2_0
#include <giomm.h>
#include <glib.h>
#endif
 
 
namespace saftdabc
{
 
//class DeviceRef;
 
 
enum EventFormats_t
{
  saft_Format_Raw,
  saft_Format_Mbs,
  saft_Format_Hadaq
};
 
 
 
class Input: public dabc::DataInput
{
 
private:
 
 
 
  std::queue<saftdabc::Timing_Event> fTimingEventQueue;
 
 
  dabc::Mutex fQueueMutex;
 
  bool fWaitingForCallback;
 
 
  uint64_t fOverflowCount;
 
  uint64_t fLastOverflowCount;
 
 
 
protected:
 
 
 
  DeviceRef fDevice;
 
  dabc::Reference fTransport;
 
  double fTimeout;
 
  bool fUseCallbackMode;
 
 
  unsigned fSubeventId;
 
  long fEventNumber;
 
 
  bool fVerbose;
 
  bool fSingleEvents;
 
  EventFormats_t fEventFormat;
 
  std::vector<std::string> fInput_Names;
 
//  /** Translation table IO name <> prefix
//   * like in  saft-io-ctl implementation*/
//  std::map<Glib::ustring, guint64> fMap_PrefixName;
//
 
  std::vector<uint64_t> fSnoop_Masks;
 
  std::vector<uint64_t> fSnoop_Ids;
 
  /* contains offsets of all events to be snooped*/
  std::vector<uint64_t> fSnoop_Offsets;
 
  /* contains  accept flag bitmask of all events to be snooped:
   * 0x1=late, 0x2=early, 0x4= conflict, 0x8=delayed
   * TODO:*/
  std::vector<uint64_t> fSnoop_Flags;
 
  bool SetupConditions ();
 
 
  void ResetDescriptors ()
  {
    fInput_Names.clear ();
    fSnoop_Masks.clear ();
    fSnoop_Ids.clear ();
    fSnoop_Offsets.clear ();
    fSnoop_Flags.clear ();
  }
 
  void ClearEventQueue ();
 
  bool Close ();
 
  unsigned Write_Mbs (dabc::Buffer& buf);
 
  unsigned Write_Hadaq (dabc::Buffer& buf);
 
  unsigned Write_Raw (dabc::Buffer& buf);
 
public:
  Input (const saftdabc::DeviceRef &owner);
  virtual ~Input ();
 
  virtual bool Read_Init (const dabc::WorkerRef& wrk, const dabc::Command& cmd);
 
  void SetTransportRef(dabc::InputTransport* trans);
 
  virtual unsigned Read_Size ();
  virtual unsigned Read_Start (dabc::Buffer& buf);
  virtual unsigned Read_Complete (dabc::Buffer& buf);
 
  virtual double Read_Timeout ()
  {
    return fTimeout;
  }
 
#ifdef DABC_SAFT_USE_2_0
    void EventHandler (uint64_t event, uint64_t param, uint64_t deadline, uint64_t executed, uint16_t flags = 0xF);
 
 
    void OverflowHandler(uint64_t count);
 
#else
    void EventHandler (guint64 event, guint64 param, guint64 deadline, guint64 executed, guint16 flags = 0xF);
 
 
    void OverflowHandler(guint64 count);
#endif
    
    
};
 
}
 
#endif