CachedNode.hpp

#pragma once

#include "Export.hpp"

#include "Graph.hpp"
#include "StreamConsumer.hpp"

#include "ValueStream.hpp"
#include "ValueStreamChannels.hpp"

#include "Hashes.hpp"

#include <unordered_map>

namespace Showcase
{

  class SHOWCASE_API CachedNode : public std::enable_shared_from_this<CachedNode>
  {
  public:
    struct Cache
    {
      PropertyMap properties;
      std::map<NodeId, PropertyMap> edges;

      NodeEventStreamPtr childStream;
      PropertyEventStreamPtr propertyStream;
      std::unordered_map<EdgeId, PropertyEventStreamPtr> edgePropertyStreams;
    };

    struct PausedCache
    {
    public:
      PropertyMap properties;
      std::map<NodeId, PropertyMap> edges;

    private:
      ChannelGuard<ValueStreamChannel<NodeEvent>> childGuard;
      std::vector<ChannelGuard<ValueStreamChannel<PropertyEvent>>> propertyGuards;

      friend class CachedNode;
    };

    typedef std::function<void(const PropertyEvent& ev)> PropFunc;
    typedef std::function<void(const NodeId& child, const PropertyEvent& ev)> EdgePropFunc;
    typedef std::function<void(const NodeEvent& ev)> ChildFunc;


    CachedNode(GraphPtr graph, const NodeId& node, std::size_t maxChildren=0);
    ~CachedNode();

    void startStreams();

    void injectEvent(const NodeEvent& ev);

    const NodeId& nodeId() const;

    PausedCache pausedCache();
    Cache cache();
    std::shared_ptr<CachedNode> clone();

    void setOnChildEvent(ChildFunc f);
    void setOnPropertyEvent(PropFunc f);
    void setOnEdgePropertyEvent(EdgePropFunc f);

    void addOnChildEvent(ChildFunc f);
    void addOnPropertyEvent(PropFunc f);
    void addOnEdgePropertyEvent(EdgePropFunc f);

    void setChildrenPaused(bool paused);

  private:
    void onChildEvent(const NodeEvent& ev);
    void onEdgePropertyEvent(const NodeId& childId, const PropertyEvent& ev);
    void onPropertyEvent(const PropertyEvent& ev);

    struct Key {};

  public:
    CachedNode(Key& k);

  private:
    typedef CallbackLock<PropertyEvent> PropEvType;
    typedef CallbackLock<NodeEvent> NodeEvType;

    typedef CloneableValueStreamChannelPtr<NodeEvent> NodeEventChannelPtr;
    typedef CloneableValueStreamChannelPtr<PropertyEvent> PropertyEventChannelPtr;

    void initChildConsumer();
    void initPropertyConsumer();
    StreamConsumerPtr<PropEvType> initEdgePropertyConsumer(const NodeId& childId);

    void handlePropertyEvent(PropertyMap& targetMap, const PropertyEvent& ev);

    NodeId m_nodeId;
    std::weak_ptr<Graph> m_graph;

    std::size_t m_maxChildren;

    PropertyMap m_properties;
    std::map<NodeId, PropertyMap> m_edges;

    std::mutex m_childMutex;

    StreamConsumerPtr<NodeEvType> m_childConsumer;
    StreamConsumerPtr<PropEvType> m_propertyConsumer;
    std::unordered_map<EdgeId, StreamConsumerPtr<PropEvType>> m_edgePropertyConsumers;

    NodeEventChannelPtr m_childStream;
    PropertyEventChannelPtr m_propertyStream;
    std::unordered_map<EdgeId, PropertyEventChannelPtr> m_edgePropertyStreams;

    std::vector<ChildFunc> m_onChild;
    std::vector<EdgePropFunc> m_onEdgeProp;
    std::vector<PropFunc> m_onProp;
  };
  typedef std::shared_ptr<CachedNode> CachedNodePtr;

}