Component.hpp

#pragma once

#include "Export.hpp"

#include "CachedGraph.hpp"
#include "CachedNode.hpp"
#include "Slot.hpp"
#include "Schema.hpp"

#include "GraphTypes.hpp"

#include <MultiWidgets/Widget.hpp>

#include <QString>
#include <memory>

namespace Showcase
{

  class ComponentInstance;
  class Component;

  typedef std::shared_ptr<ComponentInstance> ComponentInstancePtr;
  typedef std::list<ComponentInstancePtr>::iterator ComponentInstanceKey;


  class SHOWCASE_API ComponentInstance : public std::enable_shared_from_this<ComponentInstance>
  {
  public:
    ComponentInstance(std::shared_ptr<Component> component);

    virtual ~ComponentInstance();


    virtual MultiWidgets::WidgetPtr widgetInstance();

    virtual MultiWidgets::OperatorPtr operatorInstance(MultiWidgets::Widget & host,
                                                       bool immediate = false);

    // Maybe for services
    //virtual ServicePtr serviceInstance();

    std::shared_ptr<Component> creator() const;

    virtual void propertyReceived(const PropertyKey& key,
                                  const PropertyValue& value);

    virtual void propertyLost(const PropertyKey& key,
                              const PropertyValue& value);

  protected:
    virtual void removeInstance() = 0;

    void onDelete();

    virtual void setCache(CachedNode::Cache& cache);

    void setKey(ComponentInstanceKey key);

  private:
    std::weak_ptr<Component> m_creator;
    ComponentInstanceKey m_key;

    friend class Component;
  };

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

  class ComponentPlaceholder;
  typedef std::shared_ptr<ComponentPlaceholder> ComponentPlaceholderPtr;

  class SHOWCASE_API Component : public std::enable_shared_from_this<Component>
  {
  public:
    Component(CachedGraphPtr uiGraph=nullptr);
    virtual ~Component();

    void setCachedGraph(CachedGraphPtr uiGraph);

    void init(const GraphNode& confNode);

    const QString& name() const;

    void setComponentName(const QString& name);

    void setSchema(const Schema& schema);

    const Schema& schema() const;

    ComponentInstancePtr createInstance();

    void instanceDestroyed(ComponentInstanceKey key);

    size_t numInstances() const;

    CachedGraphPtr cachedGraph() const;

    CachedNodePtr cachedNode() const;

    const NodeId& nodeId() const;

    const std::list<ComponentInstancePtr>& instances() const;

  protected:
    void childFound(const NodeId& id);
    void childLost(const NodeId& id);

    virtual void placeholderStatusChanged(const NodeId& id) = 0;

    void setConfigurationNode(const GraphNode& confNode);
    void addInstance(ComponentInstancePtr instance);
    virtual void propertyReceived(const Property& property);
    virtual void propertyLost(const Property& property);

    virtual ComponentInstancePtr instanceImpl() = 0;

    ComponentPlaceholderPtr placeholder(const NodeId& id) const;
    virtual void initPlaceholder(ComponentPlaceholderPtr placeholder);

    void applyForInstances(std::function<void(ComponentInstancePtr)>&& f);

    void removeInstances();

  private:
    CachedGraphPtr m_cachedGraph;

    CachedNodePtr m_cachedNode;

    mutable std::mutex m_placeholderMutex; 
    std::unordered_map<NodeId, ComponentPlaceholderPtr> m_placeholders;

    QString m_name;
    // is it needed here? it is assumed that this is write-once on the initialization
    Schema m_schema;

    std::mutex m_instanceMutex;
    std::list<ComponentInstancePtr> m_instances;

    friend class ComponentPlaceholder;
  };
  typedef std::shared_ptr<Component> ComponentPtr;

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

  class ComponentPlaceholder : public std::enable_shared_from_this<ComponentPlaceholder>
  {
  public:
    ComponentPlaceholder(const NodeId& id, std::weak_ptr<Component> parent);

    void init(CachedGraphPtr cgraph);
    bool ready() const;

    void addRequiredProperty(const PropertyKey& propertyName);
    PropertyValue propertyValue(const PropertyKey& key) const;

    void setOnReady(std::function<void(void)> func);

    NodeId targetId() const;

  private:
    bool checkReady() const;

    void notify();
    void onPropertyEvent(const PropertyEvent& event);
    void onProperty(const Property& prop);

    StreamConsumerPtr<PropertyEvent> m_propertyConsumer;

    NodeId m_targetId;
    std::weak_ptr<Component> m_parent;

    PropertyMap m_properties;
    std::set<PropertyKey> m_requiredProperties;

    std::function<void(void)> m_onReady;

    bool m_ready;
  };

}