ShowcaseTypes.hpp

#pragma once

#include <Patterns/NotCopyable.hpp>

#include <cassert>
#include <functional>
#include <map>
#include <memory>
#include <typeinfo>
#include "Schema.hpp"

namespace Showcase
{

  template <typename T, template <typename> class Ptr>
  class ShowcaseFactoryT : public Patterns::NotCopyable
  {
  public:
    typedef std::function<Ptr<T>()> CreateFunc;

    ShowcaseFactoryT(const std::type_info & typeinfo, CreateFunc create);
    ~ShowcaseFactoryT() {}

    Ptr<T> create() const;

    void setSchema(const Schema& schema);

  private:
    CreateFunc m_create;
    Schema m_schema;
  };

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

  template <typename T>
  struct hasSchemaInitialization
  {
  private:
    typedef char one;
    typedef long two;

    template <typename C> static one test(decltype(&C::setSchema));
    template <typename C> static two test(...);

  public:
    static const bool value = sizeof(test<T>(0)) == sizeof(char);
  };

  template <typename T, template <typename> class Ptr, bool = hasSchemaInitialization<T>::value>
  struct ComponentInitializer
  {
    inline static Ptr<T> create(std::function<Ptr<T>()> createFunc,
                                const Schema& schema)
    {
      (void) schema;
      return createFunc();
    }
  };

  template <typename T, template <typename> class Ptr>
  struct ComponentInitializer<T, Ptr, true>
  {
    inline static Ptr<T> create(std::function<Ptr<T>()> createFunc,
                                const Schema& schema)
    {
      auto c = createFunc();
      c->setSchema(schema);
      return c;
    }
  };

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

  template <typename T, template <typename> class Ptr>
  ShowcaseFactoryT<T, Ptr>::ShowcaseFactoryT(const std::type_info & typeinfo,
                                             CreateFunc create)
    : m_create(create)
  {
    (void) typeinfo; 
  }

  template <typename T, template <typename> class Ptr>
  void ShowcaseFactoryT<T, Ptr>::setSchema(const Schema& schema)
  {
    m_schema = schema;
  }

  template <typename T, template <typename> class Ptr>
  Ptr<T> ShowcaseFactoryT<T, Ptr>::create() const
  {
    assert(m_create);
    return ComponentInitializer<T,Ptr>::create(m_create, m_schema);
  }

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

  template <typename T>
  using ShowcaseFactory = ShowcaseFactoryT<T, std::shared_ptr>;
  template <typename T>
  using ShowcaseFactoryPtr = std::shared_ptr<ShowcaseFactory<T>>;

  template <typename T>
  using FactoryMap = std::map<QString, ShowcaseFactoryPtr<T>>;

  template <typename T>
  using FactoryKey = typename FactoryMap<T>::iterator;

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

}