//////////////////////////////////////////////////////////////////////
// Copyright:
//   GSI, Gesellschaft fuer Schwerionenforschung mbH
//   Planckstr. 1
//   D-64291 Darmstadt
//   Germany
// created 16. 2.1999 by Horst Goeringer
//////////////////////////////////////////////////////////////////////
// MRevBuffer.h
//   description of class MRevBuffer
//   ROOT client package for multithreaded remote event server (MBS)
//////////////////////////////////////////////////////////////////////
// 20. 8.1999, H.G.: MRevBuffer::RevGetI added
//  6. 3.2000, H.G.: new member function RevStatus
//////////////////////////////////////////////////////////////////////

#ifndef MRevBuffer_H
#define MRevBuffer_H

#include "TObject.h"                    // for TObject

#include "Rtypes.h"                     // for Int_t, ClassDef, etc

class TSocket;

class REvent : public TObject
{
  private:
    Int_t  iSize;              // event size (byte)
    Int_t  iNumb;              // event number
    Int_t*  piData;            // event parameter

    REvent(const REvent&);
    REvent& operator=(const REvent&);

  public:
    REvent();                  // constructor
    ~REvent();                 // destructor

    void ReFillHead(Int_t* pHead);   // unpack and fill event header
    void ReFillData(Int_t* pData);   // unpack and fill event data

    Int_t ReGetNumb();               // get event number
    Int_t ReGetSize();               // get event size
    Int_t ReGetData(Int_t ichan);    // get event parameter ichan
    Int_t* GetData() { return piData; }

    Int_t nSubEvt;
    Int_t subEvtSize[100];
    Short_t subEvtType[100];
    Short_t subEvtSubType[100];
    Short_t subEvtProcId[100];
    Short_t subEvtSubCrate[100];
    Short_t subEvtControl[100];
    Int_t* pSubEvt[100];

    ClassDef(REvent, 0)           // prototype for event
};

//////////////////////////////////////////////////////////////////////

class MRevBuffer : public TObject
{
  private:
    TSocket* pTSocket;     // ptr socket of channel to event server
    Int_t  iSocket;        // socket id of channel to event server
    Int_t  iBufNo1;        // first buffer no. received (test)
    Int_t  iBufNo2;        // last buffer no. received (test)
    Int_t  iDebug;         // verbosity level (test)
    Int_t  iSwap;          // > 0: swap event data
    Int_t  iStatus;        // current status of server

    Int_t  iBufSizeAlloc;  // allocated buffer size
    Int_t  iBufSize;       // size current buffer
    Int_t  iBufNo;         // current buffer no.
    Int_t  iFragBegin;     // > 0: last buffer ended with fragment
    Int_t  iFragConc;      // no. of concatenated fragments
    Int_t  iFragBeginIgn;  // no. of ignored fragment begins
    Int_t  iFragEndIgn;    // no. of ignored fragment ends

    Int_t  iHeadPar;       // no. of (4 byte) parms buffer header
    Int_t  iEvtMax;        // no. of events requested
    Int_t  iEvtNo;         // last event no. handled
    Int_t  iEvtRel;        // rel. event no. in buffer
    Int_t  iEvtBuf;        // no. of events in current buffer
    Int_t  iEvtPar;        // no. of parameters in event (incl. len)
    Int_t*  piBuf;         // ptr event buffer
    Int_t*  piNextEvt;     // ptr first element next event
    REvent* pEvt;          // ptr event class

    MRevBuffer(const MRevBuffer&);
    MRevBuffer& operator=(const MRevBuffer&);

  public:
    MRevBuffer( Int_t iMode); // constructor
    ~MRevBuffer();            // destructor

    TSocket* RevOpen( char* pNode, Int_t iPort, Int_t iEvent);
    // input: node name and port number server, req. no. of events
    // returns Socket ptr of server connection

    Int_t* RevGetI( TSocket* pSocket, Int_t iFlush);
    // get next event (pointer) from buffer, input:
    // Socket ptr,
    // iFlush = 1: skip current buffer (not impl)

    REvent* RevGet( TSocket* pSocket, Int_t iFlush, Int_t iSkip);
    // get next event (pointer) from buffer, input:
    // Socket ptr,
    // iFlush = 1: skip current buffer (not impl)
    // iSkip > 0: take only each iSkip event (not impl)

    Int_t RevStatus(Int_t iOut);
    // get status information (iOut = 1: also message to stdout)
    // = 0: last event request successfull
    // = 1: server not yet connected
    // = 2: server connected, but still no request for events
    // = 3: server connection okay, but currently no DAQ events
    // = 4: connection to server closed
    // = 5: connection to server closed after user break (CTL C)
    // = 6: connection to server closed after failure

    void RevBufWait(Int_t iWait);
    // wait for iWait seconds

    Int_t RevBufsize();
    // get size of current buffer (byte)

    void  RevClose( TSocket* pSocket );           // input Socket ptr

    ClassDef(MRevBuffer, 0)        // prototype for remote event buffer
};

#endif     // !MRevBuffer_H