ResultDataRequester.h

Go to the documentation of this file.

#pragma once
#include <gii/gen/ResultData.h>
#include <misc/gen/ElapseTimer.h>
#include <misc/gen/Sustain.h>
#include <misc/gen/TBitSet.h>
 
namespace sf
{
class _GII_CLASS ResultDataRequester : public ResultDataTypes
{
  public:
    enum EReqEvent
    {
      reDataValid = reUserLocal,
      reTimedOut = reUserLocal + 1,
    };
 
    ResultDataRequester();
 
    virtual ~ResultDataRequester();
 
    void attachIndex(ResultData* rd);
 
    void attachData(ResultData* rd);
 
    void detachData(ResultData* rd);
 
    void release();
 
    bool requestIndex(size_type index);
 
    bool requestIndex(const Range& range);
 
    bool requestData(const Range& range);
 
    void setTimeout(const TimeSpec& timeout);
 
    void reset();
 
    [[nodiscard]] const Range& getIndexRange() const;
 
    [[nodiscard]] const Range& getDataRange() const;
 
    void setHandler(ResultDataHandler* handler);
 
    [[nodiscard]] const ResultDataHandler* getHandler() const;
 
    enum EState
    {
      drsError = -1,
      drsReady,
      drsGetIndex,
      drsReadIndex,
      drsTryData,
      drsGetData,
      drsApply,
      drsWait,
    };
 
    const char* getStateName(int state = -2);
 
    [[nodiscard]] EState getState() const;
 
    std::ostream& getStatus(std::ostream& os);
 
  private:
    TSustain<ResultDataRequester> _sustain;
 
    bool sustain(const timespec& t);
 
    TResultDataHandler<ResultDataRequester> _handlerData;
 
    void resultCallback(ResultDataTypes::EEvent event, const ResultData& caller, ResultData& link, const Range& rng, bool sameInst);
 
    ResultData* _rdIndex{nullptr};
    PtrVector _rdDataList;
    ElapseTimer _timeoutTimer;
 
    bool process();
 
    EState _state{drsReady};
    EState _statePrevious{drsReady};
    EState _stateWait{drsReady};
 
    bool setState(EState state);
 
    bool setError(const std::string& text);
 
    bool waitForState(EState state);
 
    void passIndexEvent(EReqEvent event);
 
    struct WorkData
    {
        WorkData()
        {
          clear();
        }
 
        void clear()
        {
          _indexRequest = false;
          _dataRequest._bits = 0;
          _range.clear();
          _index.clear();
          _dataRequest._bits = 0;
          _dataAccess._bits = 0;
        }
 
        Range _range;
        Range _index;
        bool _indexRequest{};
        TSet<int> _dataRequest;
        TSet<int> _dataAccess;
    };
 
    WorkData _work;
    ResultDataHandler* _handler;
    bool _byPass;
};
 
inline ResultDataRequester::EState ResultDataRequester::getState() const
{
  return _state;
}
 
inline void ResultDataRequester::setTimeout(const TimeSpec& timeout)
{
  _timeoutTimer.set(timeout);
}
 
inline bool ResultDataRequester::requestIndex(size_type index)
{
  return requestIndex(Range(index, index + 1));
}
 
inline const ResultDataHandler* ResultDataRequester::getHandler() const
{
  return _handler;
}
 
inline const Range& ResultDataRequester::getIndexRange() const
{
  return _work._index;
}
 
inline const Range& ResultDataRequester::getDataRange() const
{
  return _work._range;
}
}// namespace sf