Event.hpp

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <string>
#include <string_view>
#include <type_traits>
 
namespace precice::profiling {

struct SynchronizeTag {
};

enum struct Group {
  Default,
  Fundamental,
  API
};

static constexpr Group Fundamental = Group::Fundamental;

static constexpr Group API = Group::API;

static constexpr SynchronizeTag Synchronize{};
 
// Is the type a valid options tag?
template <typename T>
static constexpr bool isOptionsTag = std::is_same_v<T, Group> || std::is_same_v<T, SynchronizeTag>;

class Event {
public:
  enum class State : bool {
    STOPPED = false,
    RUNNING = true
  };

  using Clock = std::chrono::steady_clock;

  std::string name;
 
  struct Options {
    bool  synchronized = false;
    bool  fundamental  = false;
    Group group        = Group::Default;
 
    void handle(Group g)
    {
      group = g;
    }
    void handle(SynchronizeTag)
    {
      synchronized = true;
    }
  };
 
  template <typename... Args>
  constexpr Options optionsFromTags(Args... args)
  {
    static_assert((isOptionsTag<Args> && ...), "The Event only accepts tags as arguments.");
    Options options;
    (options.handle(args), ...);
    return options;
  }
 
  template <typename... Args>
  Event(std::string_view eventName, Args... args)
      : Event(eventName, optionsFromTags(args...))
  {
  }
 
  Event(std::string_view eventName, Options options);
 
  Event(Event &&)            = default;
  Event &operator=(Event &&) = default;
 
  // Copies would lead to duplicate entries
  Event(const Event &other)       = delete;
  Event &operator=(const Event &) = delete;

  ~Event();

  void start();

  void stop();

  void addData(std::string_view key, int value);
 
private:
  int   _eid;
  int   _sid{-1};
  State _state = State::STOPPED;
  Group _group = Group::Default;
  bool  _synchronize{false};
};
 
} // namespace precice::profiling