future.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <future>
#include <chrono>
#include <promeki/namespace.h>
#include <promeki/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct PromiseError {
                Error error;
                explicit PromiseError(Error e) : error(e) {}
};
 
template <typename T> class Future {
        public:
                Future() = default;
 
                Future(std::future<T> &&f) : _future(std::move(f)) {}
 
                ~Future() = default;
 
                Future(const Future &) = delete;
                Future &operator=(const Future &) = delete;
 
                Future(Future &&other) = default;
 
                Future &operator=(Future &&other) = default;
 
                bool isReady() const {
                        return _future.valid() &&
                               _future.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
                }
 
                Result<T> result(unsigned int timeoutMs = 0) {
                        if (!_future.valid()) return Result<T>(T{}, Error::Invalid);
                        if (timeoutMs != 0) {
                                if (_future.wait_for(std::chrono::milliseconds(timeoutMs)) !=
                                    std::future_status::ready) {
                                        return Result<T>(T{}, Error::Timeout);
                                }
                        }
                        try {
                                return Result<T>(_future.get(), Error::Ok);
                        } catch (const PromiseError &pe) {
                                return Result<T>(T{}, pe.error);
                        } catch (const std::future_error &) {
                                return Result<T>(T{}, Error::Invalid);
                        } catch (...) {
                                return Result<T>(T{}, Error::LibraryFailure);
                        }
                }
 
                void waitForFinished() {
                        if (_future.valid()) _future.wait();
                }
 
                Error waitForFinished(unsigned int timeoutMs) {
                        if (!_future.valid()) return Error::Invalid;
                        if (_future.wait_for(std::chrono::milliseconds(timeoutMs)) == std::future_status::ready) {
                                return Error::Ok;
                        }
                        return Error::Timeout;
                }
 
                bool isValid() const { return _future.valid(); }
 
        private:
                mutable std::future<T> _future;
};
 
template <> class Future<void> {
        public:
                Future() = default;
 
                Future(std::future<void> &&f) : _future(std::move(f)) {}
 
                ~Future() = default;
 
                Future(const Future &) = delete;
                Future &operator=(const Future &) = delete;
                Future(Future &&other) = default;
                Future &operator=(Future &&other) = default;
 
                bool isReady() const {
                        return _future.valid() &&
                               _future.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
                }
 
                Error result(unsigned int timeoutMs = 0) {
                        if (!_future.valid()) return Error::Invalid;
                        if (timeoutMs != 0) {
                                if (_future.wait_for(std::chrono::milliseconds(timeoutMs)) !=
                                    std::future_status::ready) {
                                        return Error::Timeout;
                                }
                        }
                        try {
                                _future.get();
                                return Error::Ok;
                        } catch (const PromiseError &pe) {
                                return pe.error;
                        } catch (const std::future_error &) {
                                return Error::Invalid;
                        } catch (...) {
                                return Error::LibraryFailure;
                        }
                }
 
                void waitForFinished() {
                        if (_future.valid()) _future.wait();
                }
 
                Error waitForFinished(unsigned int timeoutMs) {
                        if (!_future.valid()) return Error::Invalid;
                        if (_future.wait_for(std::chrono::milliseconds(timeoutMs)) == std::future_status::ready) {
                                return Error::Ok;
                        }
                        return Error::Timeout;
                }
 
                bool isValid() const { return _future.valid(); }
 
        private:
                mutable std::future<void> _future;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE