mediaiorequest.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <functional>
#include <utility>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/error.h>
#include <promeki/eventloop.h>
#include <promeki/mediaiocommand.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MediaIORequest {
        public:
                using Callback = Function<void(Error)>;
 
                MediaIORequest() = default;
 
                explicit MediaIORequest(MediaIOCommand::Ptr cmd) : _cmd(std::move(cmd)) {}
 
                static MediaIORequest resolved(Error err);
 
                static MediaIORequest resolved(MediaIOCommand::Ptr cmd);
 
                Error wait(unsigned int timeoutMs = 0);
 
                bool isReady() const;
 
                void then(Callback cb);
 
                void cancel();
 
                bool isCancelled() const;
 
                MediaIOCommand::Ptr command() const { return _cmd; }
 
                template <typename CmdT> const CmdT *commandAs() const {
                        if (_cmd.isNull()) return nullptr;
                        return static_cast<const CmdT *>(_cmd.ptr());
                }
 
                MediaIOStats stats() const { return _cmd.isValid() ? _cmd->stats : MediaIOStats(); }
 
                bool isValid() const { return _cmd.isValid() || _hasOverride; }
 
        private:
                MediaIOCommand::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;
};
 
inline MediaIORequest MediaIORequest::resolved(Error err) {
        MediaIORequest r;
        r._overrideError = err;
        r._hasOverride = true;
        return r;
}
 
inline MediaIORequest MediaIORequest::resolved(MediaIOCommand::Ptr cmd) {
        if (cmd.isValid()) cmd.modify()->markCompleted();
        return MediaIORequest(std::move(cmd));
}
 
inline Error MediaIORequest::wait(unsigned int timeoutMs) {
        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;
}
 
inline bool MediaIORequest::isReady() const {
        if (_hasOverride) return true;
        return _cmd.isValid() && _cmd->isCompleted();
}
 
inline void MediaIORequest::then(Callback cb) {
        if (_hasOverride) {
                // Sentinel path: fire immediately (marshal through
                // the current loop when one is active so the
                // callback observes the same thread semantics as
                // the post-completion case).
                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());
}
 
inline void MediaIORequest::cancel() {
        _cancelledLocal = true;
        if (_cmd.isValid()) _cmd.modify()->cancelled.setValue(true);
}
 
inline bool MediaIORequest::isCancelled() const {
        if (_cancelledLocal) return true;
        return _cmd.isValid() && _cmd->cancelled.value();
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV