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 FundamentalTag {
};
 
struct SynchronizeTag {
};
 
static constexpr FundamentalTag Fundamental{};
static constexpr SynchronizeTag Synchronize{};
 
// Is the type a valid options tag?
template <typename T>
static constexpr bool isOptionsTag = std::is_same_v<T, FundamentalTag> || 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;
 
    void handle(FundamentalTag)
    {
      fundamental = true;
    }
    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;
  State _state = State::STOPPED;
  bool  _fundamental{false};
  bool  _synchronize{false};
};
 
class ScopedEventPrefix {
public:
  ScopedEventPrefix(std::string_view name);
 
  ~ScopedEventPrefix();
 
  void pop();
 
private:
  std::string previousName = "";
};
 
} // namespace precice::profiling