Initial commit

Lts/Common/LtsUtils/LtsUtilsCore/promise.cpp

@@ -0,0 +1,127 @@
+/*
+  This is free and unencumbered software released into the public domain.
+
+  Anyone is free to copy, modify, publish, use, compile, sell, or
+  distribute this software, either in source code form or as a compiled
+  binary, for any purpose, commercial or non-commercial, and by any
+  means.
+
+  In jurisdictions that recognize copyright laws, the author or authors
+  of this software dedicate any and all copyright interest in the
+  software to the public domain. We make this dedication for the benefit
+  of the public at large and to the detriment of our heirs and
+  successors. We intend this dedication to be an overt act of
+  relinquishment in perpetuity of all present and future rights to this
+  software under copyright law.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+  OTHER DEALINGS IN THE SOFTWARE.
+
+  For more information, please refer to <http://unlicense.org/>
+*/
+
+#include "promise.h"
+
+#include <QTimer>
+
+namespace LtsUtils
+{
+
+Promise::Promise(const std::function<void(ResultFunction resolve, ResultFunction reject)> &function, QObject *parent)
+  : QObject(parent)
+  , m_functionAlreadySet(false)
+  , m_timeout(new QTimer(this))
+  , m_resultSet(false)
+  , m_timeoutSet(false)
+{
+  m_timeout->setSingleShot(true);
+  connect(m_timeout, &QTimer::timeout,
+          this, &Promise::slotTimeout);
+  setFunction(function);
+}
+
+
+void Promise::setFunction(const std::function<void(ResultFunction resolve, ResultFunction reject)> &function)
+{
+  if (!function || m_functionAlreadySet)
+    return;
+
+  m_functionAlreadySet = true;
+
+  if (m_timeoutSet)
+    m_timeout->start();
+
+  // run async (when back to event loop) - so there is enough time to set resolveFn & rejectFn
+  QTimer::singleShot(0, this, [this, function]()
+  {
+    // call function from parameter, to resolve or reject this promise
+    function([this](const QVariant &value)
+    { // function called resolve
+      resolve(value);
+    }, [this](const QVariant &value)
+    {
+      // function valled reject
+      reject(value);
+    });
+  });
+}
+
+
+void Promise::setTimeout(int interval)
+{
+  m_timeout->stop();
+  m_timeout->setInterval(interval);
+  m_timeoutSet = (interval != 0);
+
+  if (interval != 0 && m_functionAlreadySet)
+    m_timeout->start();
+}
+
+
+void Promise::slotTimeout()
+{
+  reject(QStringLiteral("timeout"));
+}
+
+
+void Promise::resolve(const QVariant &value)
+{
+  if (m_resultSet)
+    return;
+  m_resultSet = true;
+
+  m_timeout->stop();
+  m_resolveFn(value);
+}
+
+
+void Promise::reject(const QVariant &value)
+{
+  if (m_resultSet)
+    return;
+  m_resultSet = true;
+
+  m_timeout->stop();
+  m_rejectFn(value);
+}
+
+
+Promise &Promise::resolved(ResultFunction resolveFn)
+{
+  m_resolveFn = resolveFn;
+  return *this;
+}
+
+
+Promise &Promise::rejected(ResultFunction rejectFn)
+{
+  m_rejectFn = rejectFn;
+  return *this;
+}
+
+} // namespace LtsUtils