bufferrequest.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <functional>
#include <utility>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/error.h>
#include <promeki/buffercommand.h>
#include <promeki/eventloop.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class BufferRequest {
        public:
                using Callback = Function<void(Error)>;
 
                BufferRequest() = default;
 
                explicit BufferRequest(BufferCommand::Ptr cmd) : _cmd(std::move(cmd)) {}
 
                static BufferRequest resolved(Error err) {
                        BufferRequest r;
                        r._overrideError = err;
                        r._hasOverride = true;
                        return r;
                }
 
                static BufferRequest resolved(BufferCommand::Ptr cmd) {
                        if (cmd.isValid()) cmd.modify()->markCompleted();
                        return BufferRequest(std::move(cmd));
                }
 
                Error wait(unsigned int timeoutMs = 0) {
                        if (_hasOverride) return _overrideError;
                        if (_cmd.isNull()) return Error::Invalid;
                        const Error waitErr = _cmd.modify()->waitForCompletion(timeoutMs);
                        if (waitErr == Error::Timeout) return Error::Timeout;
                        return _cmd->result;
                }
 
                bool isReady() const {
                        if (_hasOverride) return true;
                        return _cmd.isValid() && _cmd->isCompleted();
                }
 
                void then(Callback cb) {
                        if (_hasOverride) {
                                EventLoop *loop = EventLoop::current();
                                Error      err = _overrideError;
                                if (loop != nullptr) {
                                        loop->postCallable(
                                                [cb = std::move(cb), err]() mutable { cb(err); });
                                } else {
                                        cb(err);
                                }
                                return;
                        }
                        if (_cmd.isNull()) return;
                        _cmd.modify()->setCompletionCallback(std::move(cb), EventLoop::current());
                }
 
                void cancel() {
                        _cancelledLocal = true;
                        if (_cmd.isValid()) _cmd.modify()->cancelled.setValue(true);
                }
 
                bool isCancelled() const {
                        if (_cancelledLocal) return true;
                        return _cmd.isValid() && _cmd->cancelled.value();
                }
 
                BufferCommand::Ptr command() const { return _cmd; }
 
                template <typename CmdT> const CmdT *commandAs() const {
                        if (_cmd.isNull()) return nullptr;
                        return static_cast<const CmdT *>(_cmd.ptr());
                }
 
                bool isValid() const { return _cmd.isValid() || _hasOverride; }
 
        private:
                BufferCommand::Ptr _cmd;
                Error              _overrideError = Error::Invalid;
                bool               _hasOverride = false;
                // Sentinel-path cancellation flag — when there is no
                // command, cancel() has nothing to forward to, so the
                // bit lives here.  When _cmd is valid, the cmd's own
                // atomic flag is the source of truth and isCancelled
                // ORs both.
                bool _cancelledLocal = false;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE