Events.hpp

 
#pragma once
#include <string>
 
namespace covellite
{
 
namespace events
{
 
class Gui
{
public:
  using TypeId_t = ::std::string;
 
  class Document
  {
  public:
    class Element
    {
    public:
      const TypeId_t m_Id;
 
    public:
      explicit Element(const TypeId_t & _Id) : m_Id(_Id) { }
    };
 
  public:
    Element ElementId(const TypeId_t & _Id) const
    {
      return Element{ m_Id + "::" + _Id };
    }
 
  public:
    const TypeId_t m_Id;
 
  public:
    explicit Document(const TypeId_t & _Id) : m_Id(_Id) { }
  };
 
public:
  Document DocumentId(const TypeId_t & _Id) const
  {
    return Document{ m_EventType + "::" + _Id };
  }
 
public:
  const TypeId_t m_EventType;
 
public:
  explicit Gui(const TypeId_t & _EventType) : m_EventType(_EventType) { }
};
 
class Click_t final :
  public Gui
{
public:
  Click_t(void) : Gui("click") {}
};
 
namespace { Click_t Click; }
 
class Press_t final :
  public Gui
{
public:
  Press_t(void) : Gui("mousedown") {}
};
 
namespace { Press_t Press; }
 
class Change_t final :
  public Gui
{
public:
  Change_t(void) : Gui("change") {}
};
 
namespace { Change_t Change; }
 
} // namespace events
 
} // namespace covellite
 
namespace std
{
 
template<>
struct hash<::covellite::events::Gui::Document::Element>
{
  using Element_t = ::covellite::events::Gui::Document::Element;
 
public:
  inline size_t operator()(const Element_t & _Id) const
  {
    return ::std::hash<::covellite::events::Gui::TypeId_t>{}(_Id.m_Id);
  }
};
 
}