RlinkServer.hpp

Go to the documentation of this file.

// $Id: RlinkServer.hpp 1185 2019-07-12 17:29:12Z mueller $
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright 2013-2019 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
// 
// Revision History: 
// Date         Rev Version  Comment
// 2019-06-07  1160   2.2.7  Stats() not longer const
// 2018-12-17  1088   2.2.6  use std::thread instead of boost
// 2018-12-16  1084   2.2.5  use =delete for noncopyable instead of boost
// 2018-12-15  1083   2.2.4  for std::function setups: use rval ref and move
// 2018-12-14  1081   2.2.3  use std::function instead of boost
// 2018-12-07  1078   2.2.2  use std::shared_ptr instead of boost
// 2017-04-07   868   2.2.1  Dump(): add detail arg
// 2015-01-10   632   2.2    Exec() without emsg now void, will throw
// 2014-12-30   625   2.1    adopt to Rlink V4 attn logic
// 2014-11-30   607   2.0    re-organize for rlink v4
// 2013-05-01   513   1.0.2  fTraceLevel now uint32_t
// 2013-04-21   509   1.0.1  add Resume(), reorganize server start handling
// 2013-03-06   495   1.0    Initial version
// 2013-01-12   474   0.5    First draft
// ---------------------------------------------------------------------------
 
#ifndef included_Retro_RlinkServer
#define included_Retro_RlinkServer 1
 
#include <poll.h>
 
#include <cstdint>
#include <vector>
#include <list>
#include <memory>
#include <functional>
#include <thread>
 
#include "librtools/Rstats.hpp"
#include "librtools/ReventFd.hpp"
 
#include "RlinkConnect.hpp"
#include "RlinkContext.hpp"
#include "RlinkServerEventLoop.hpp"
 
namespace Retro {
 
  class RlinkServer {
    public:
 
      struct AttnArgs {
        uint16_t    fAttnPatt;              
        uint16_t    fAttnMask;              
        uint16_t    fAttnHarvest;           
        bool        fHarvestDone;           
                    AttnArgs();
                    AttnArgs(uint16_t apatt, uint16_t amask);
      };
 
      typedef ReventLoop::pollhdl_t          pollhdl_t;
      typedef std::function<int(AttnArgs&)>  attnhdl_t;
      typedef std::function<int()>           actnhdl_t;
 
      explicit      RlinkServer();
      virtual      ~RlinkServer();
    
                    RlinkServer(const RlinkServer&) = delete;  // noncopyable 
      RlinkServer&  operator=(const RlinkServer&) = delete;    // noncopyable
 
      void          SetConnect(const std::shared_ptr<RlinkConnect>& spconn);
      const std::shared_ptr<RlinkConnect>& ConnectSPtr() const;
      RlinkConnect& Connect() const;
      RlogFile&     LogFile() const;
      RlinkContext& Context();  
 
      bool          Exec(RlinkCommandList& clist, RerrMsg& emsg);
      void          Exec(RlinkCommandList& clist);
 
      void          AddAttnHandler(attnhdl_t&& attnhdl, uint16_t mask,
                                   void* cdata = nullptr);
      void          RemoveAttnHandler(uint16_t mask, void* cdata = nullptr);
      void          GetAttnInfo(AttnArgs& args, RlinkCommandList& clist);
      void          GetAttnInfo(AttnArgs& args);
 
      void          QueueAction(actnhdl_t&& actnhdl);
 
      void          AddPollHandler(pollhdl_t&& pollhdl,
                                   int fd, short events=POLLIN);
      bool          TestPollHandler(int fd, short events=POLLIN);
      void          RemovePollHandler(int fd, short events, bool nothrow=false);
      void          RemovePollHandler(int fd);
 
      void          Start();
      void          Stop();
      void          Resume();
      void          Wakeup();
      void          SignalAttnNotify(uint16_t apat);
 
      bool          IsActive() const;
      bool          IsActiveInside() const;
      bool          IsActiveOutside() const;
 
      void          SetTraceLevel(uint32_t level);
      uint32_t      TraceLevel() const;
 
      Rstats&       Stats();
 
      void          Print(std::ostream& os) const;
      void          Dump(std::ostream& os, int ind=0, const char* text=0,
                         int detail=0) const;
 
    // statistics counter indices
      enum stats {
        kStatNEloopWait = 0,                
        kStatNEloopPoll,                    
        kStatNWakeupEvt,                    
        kStatNRlinkEvt,                     
        kStatNAttnHdl,                      
        kStatNAttnNoti,                     
        kStatNAttnHarv,                     
        kStatNAttn00,                       
        kStatNAttn01,                       
        kStatNAttn02,                       
        kStatNAttn03,                       
        kStatNAttn04,                       
        kStatNAttn05,                       
        kStatNAttn06,                       
        kStatNAttn07,                       
        kStatNAttn08,                       
        kStatNAttn09,                       
        kStatNAttn10,                       
        kStatNAttn11,                       
        kStatNAttn12,                       
        kStatNAttn13,                       
        kStatNAttn14,                       
        kStatNAttn15,                       
        kDimStat
      };
 
      friend class RlinkServerEventLoop;
 
    protected:
      void          StartOrResume(bool resume);
      bool          AttnPending() const;
      bool          ActnPending() const;
      void          CallAttnHandler();
      void          CallActnHandler();
      int           WakeupHandler(const pollfd& pfd);
      int           RlinkHandler(const pollfd& pfd);
 
    protected:
      struct AttnId {
        uint16_t    fMask;
        void*       fCdata;
                    AttnId();
                    AttnId(uint16_t mask, void* cdata);
        bool        operator==(const AttnId& rhs) const;
      };
 
      struct AttnDsc {
        attnhdl_t   fHandler;
        AttnId      fId;
                    AttnDsc();
                    AttnDsc(attnhdl_t&& hdl, const AttnId& id);
      };
 
      std::shared_ptr<RlinkConnect>  fspConn;
      RlinkContext  fContext;               
      std::vector<AttnDsc>  fAttnDsc;
      std::list<actnhdl_t>  fActnList;
      ReventFd      fWakeupEvent;
      RlinkServerEventLoop fELoop;
      std::thread   fServerThread;
      uint16_t      fAttnPatt;              
      uint16_t      fAttnNotiPatt;          
      uint32_t      fTraceLevel;            
      Rstats        fStats;                 
};
  
} // end namespace Retro
 
#include "RlinkServer.ipp"
 
#endif