Event.h

Go to the documentation of this file.

#ifndef LINTEL_EVENT_H
#define LINTEL_EVENT_H
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string>
#include <type_traits>
 
namespace lintel {
class Event
{
public:
  static constexpr std::size_t NAME_SIZE = 32;
  static constexpr std::size_t CONTENT_SIZE = 256;
 
  Event() = default;
 
  Event(const std::string &topic, const std::string &type)
  {
    copyInto(m_topic, topic);
    copyInto(m_type, type);
  }
 
  void setTopic(const std::string &topic) { copyInto(m_topic, topic); }
 
  void setType(const std::string &type) { copyInto(m_type, type); }
 
  [[nodiscard]] const char *topic() const { return m_topic; }
 
  [[nodiscard]] const char *type() const { return m_type; }
 
  void setSequence(std::int64_t sequence) { m_sequence = sequence; }
 
  [[nodiscard]] std::int64_t sequence() const { return m_sequence; }
 
  void setTimestamp(std::int64_t timestamp) { m_timestamp = timestamp; }
 
  [[nodiscard]] std::int64_t timestamp() const { return m_timestamp; }
 
  void setContent(const std::byte *data, std::size_t size)
  {
    const std::size_t length = size > CONTENT_SIZE ? CONTENT_SIZE : size;
    if (length > 0 && data != nullptr) { std::memcpy(m_content, data, length); }
    m_contentLength = length;
  }
 
  template<typename T> void assign(const T &content)
  {
    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable to be stored in an Event");
    static_assert(sizeof(T) <= CONTENT_SIZE, "content is bigger than reserved size for content");
    std::memcpy(m_content, &content, sizeof(T));
    m_contentLength = sizeof(T);
  }
 
  template<typename T> [[nodiscard]] T as() const
  {
    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable to be read from an Event");
    static_assert(sizeof(T) <= CONTENT_SIZE, "content is bigger than reserved size for content");
    T result{};
    std::memcpy(&result, m_content, sizeof(T));
    return result;
  }
 
  [[nodiscard]] std::size_t contentLength() const { return m_contentLength; }
 
  [[nodiscard]] const std::byte *content() const { return reinterpret_cast<const std::byte *>(m_content); }
 
  [[nodiscard]] bool isContentEmpty() const { return m_contentLength == 0; }
 
private:
  char m_topic[NAME_SIZE]{};
  char m_type[NAME_SIZE]{};
  char m_content[CONTENT_SIZE]{};
  std::size_t m_contentLength = 0;
  std::int64_t m_sequence = 0;
  std::int64_t m_timestamp = 0;
 
  static constexpr void copyInto(char (&destination)[NAME_SIZE], std::string_view value)
  {
    const std::size_t length = value.size() >= NAME_SIZE ? NAME_SIZE - 1 : value.size();
    std::memcpy(destination, value.data(), length);
    destination[length] = '\0';
  }
};
 
static_assert(std::is_trivially_copyable_v<Event>, "Event must stay trivially copyable for the lock-free queues");
 
}// namespace lintel
#endif// LINTEL_EVENT_H