v1.4.4

attic/unneeded/StarPromise.hpp

@@ -0,0 +1,120 @@
+#ifndef STAR_PROMISE_HPP
+#define STAR_PROMISE_HPP
+
+#include "StarAtomicSharedPtr.hpp"
+
+namespace Star {
+
+STAR_EXCEPTION(PromiseException, StarException);
+
+// Wraps a ThreadInvoker, and can hold the value for consumption by more than
+// one thread, and is sharable.  The return value is not taken on get(), and
+// access to the value via get() by multiple threads is safe.
+template<typename Result>
+class Promise {
+public:
+  Promise();
+  Promise(ThreadInvoker<Result> invoker);
+  Promise(Result result);
+
+  bool valid() const;
+  operator bool() const;
+
+  bool fulfilled() const;
+
+  Maybe<Result const&> maybe() const;
+  Maybe<Result&> maybe();
+
+  Result const& get() const;
+  Result& get();
+
+private:
+  void checkValid();
+
+  struct Data {
+    mutable Mutex mutex;
+    Maybe<ThreadInvoker<Result>> invoker;
+    Maybe<Result> result;
+  };
+
+  AtomicSharedPtr<Data> m_data;
+};
+
+template<typename Result>
+Promise<Result>::Promise() {}
+
+template<typename Result>
+Promise<Result>::Promise(ThreadInvoker<Result> invoker) {
+  m_data = make_shared<Data>(Data{{}, move(invoker), {}});
+}
+
+template<typename Result>
+Promise<Result>::Promise(Result result) {
+  m_data = make_shared<Data>(Data{{}, {}, move(result)});
+}
+
+template<typename Result>
+bool Promise<Result>::valid() const {
+  return m_data.valid();
+}
+
+template<typename Result>
+Promise<Result>::operator bool() const {
+  return (bool)m_data;
+}
+
+template<typename Result>
+bool Promise<Result>::fulfilled() const {
+  if (!m_data)
+    return false;
+  MutexLocker locker(m_data->mutex);
+  return m_data->result.isValid();
+}
+
+template<typename Result>
+Maybe<Result const&> Promise<Result>::maybe() const {
+  if (!m_data)
+    return {};
+  MutexLocker locker(m_data->mutex);
+  return *m_data->result;
+}
+
+template<typename Result>
+Maybe<Result&> Promise<Result>::maybe() {
+  if (!m_data)
+    return {};
+  MutexLocker locker(m_data->mutex);
+  return *m_data->result;
+}
+
+template<typename Result>
+Result const& Promise<Result>::get() const {
+  checkValid();
+  MutexLocker locker(m_data->mutex);
+  if (m_data->invoker) {
+    m_data->result = m_data->invoker->finish();
+    m_data->invoker.reset();
+  }
+  return *m_data->result;
+}
+
+template<typename Result>
+Result& Promise<Result>::get() {
+  checkValid();
+  MutexLocker locker(m_data->mutex);
+  if (m_data->invoker) {
+    m_data->result = m_data->invoker->finish();
+    m_data->invoker.reset();
+  }
+  return *m_data->result;
+}
+
+template<typename Result>
+void Promise<Result>::checkValid() {
+  if (!m_data)
+    throw PromiseException("Unset Promise was accessed");
+}
+
+}
+
+#endif