Events.hpp

#pragma once

#include "Export.hpp"
#include "GraphTypes.hpp"

#include <QString>
#include <QVariant>

namespace Showcase
{
  enum class GraphEventSource : int {
    NODE = 1,
    NODE_PROPERTY = 2,
    EDGE_PROPERTY = 4,

    ALL_SOURCES = NODE | NODE_PROPERTY | EDGE_PROPERTY,
  };


  enum class NodeEventType {
    FOUND,

    LOST,

    PENDING
  };

  enum class PropertyEventType {
    FOUND,

    LOST,

    CHANGED,

    PENDING
  };

  class SHOWCASE_API NodeEvent
  {
  public:

    NodeEvent(const GraphNode& n = GraphNode(GraphNode::emptyId()))
      : node(n),
        edge(GraphEdge::emptyId()),
        type(NodeEventType::PENDING)
    {}

    NodeEvent(const GraphNode& n, const EdgeId& e, NodeEventType t)
      : node(n),
        edge(e),
        type(t)
    {}

    ~NodeEvent() {}

    bool isPending() const { return type == NodeEventType::PENDING; }

    GraphNode node;
    EdgeId edge;
    NodeEventType type;
  };



  class SHOWCASE_API PropertyEvent
  {
  public:
    PropertyEvent()
      : type(PropertyEventType::PENDING)
    {}

    PropertyEvent(const Property& prop, PropertyEventType t, EdgeId edge = EdgeId())
      : property(prop),
        type(t),
        edgeId(edge)
    {}

    PropertyEvent(const PropertyKey& key, const PropertyValue& val,
                  PropertyEventType t, EdgeId edge = EdgeId())
      : property(key, val),
        type(t),
        edgeId(edge)
    {}

    ~PropertyEvent() {}

    bool isPending() const { return type == PropertyEventType::PENDING; }

    Property property;
    PropertyEventType type;

    EdgeId edgeId;
  };

}