BackendComponents.hpp

#pragma once

#include <folly/futures/Future.h>
#include <folly/Executor.h>

#include <mutex>

namespace Showcase
{



  template <typename T>
  class Generator :
      public std::enable_shared_from_this<Generator<T>>
  {
  public:
    typedef T ValueType;

    virtual ~Generator() {}
    virtual folly::Future<T> next(folly::Executor* executor = nullptr) = 0;
  };


  // --------------------------------------------------------------------

  template <typename T>
  struct HasValueType
  {
    template <typename C> static char test(typename C::ValueType*);
    template <typename C> static long test(...);
    static const bool value = sizeof(test<T>(0)) == sizeof(char);
  };

  template <typename T, bool = HasValueType<T>::value>
  struct IsGenerator
  {
    static const bool value = false;
  };

  template <typename T>
  struct IsGenerator<T, true>
  {
    typedef typename T::ValueType type;
    static const bool value = std::is_base_of<Generator<type>, T>::value;
  };

  // --------------------------------------------------------------------

  template <typename GeneratorType>
  class SynchronousGenerator : public GeneratorType
  {
  public:
    static_assert(IsGenerator<GeneratorType>::value,
                  "Need to use Generator or its subclass as a type "
                  "parameter for SynchronousGenerator.");
    typedef typename GeneratorType::ValueType ValueType;

    virtual folly::Future<ValueType> next(folly::Executor* executor = nullptr) override;

  protected:
    virtual ValueType generateNextItem() = 0;

  private:
    std::mutex m_mutex;
  };

  // --------------------------------------------------------------------


  template <typename GeneratorType>
  folly::Future<typename SynchronousGenerator<GeneratorType>::ValueType>
  SynchronousGenerator<GeneratorType>::next(folly::Executor* executor)
  {
    typedef SynchronousGenerator<GeneratorType> Me;

    auto ptr = this->shared_from_this();

    std::shared_ptr<Me> me = std::dynamic_pointer_cast<Me>(ptr);
    if(!me)
      return folly::makeFuture<ValueType>(ValueType());

    std::weak_ptr<Me> weak = me;

    auto func = [weak]() -> ValueType {
      std::shared_ptr<Me> me = weak.lock();
      if(me) {
        std::lock_guard<std::mutex> g(me->m_mutex);
        return me->generateNextItem();
      } else {
        return ValueType();
      }
    };

    if(executor)
      return folly::via(executor, func);
    else
      return folly::makeFutureWith(func);
  }



}