event.h

Go to the documentation of this file.

/*
 *  rtmlib is a Real-Time Monitoring Library.
 *
 *    Copyright (C) 2018-2020 André Pedro
 *
 *  This file is part of rtmlib.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _MONITOR_EVENT_H_
#define _MONITOR_EVENT_H_

#include <time.h>

#include "debug_compat.h"
#include "time_compat.h"

template <typename T> class Event {
private:
  T data;
  timespan time;

public:
  typedef T data_t;

  Event();

  Event(const T &data, const timespan &time);

  const T &getData() const;

  const timespan &getTime() const;

  void set(T &, timespan &);

  void setTime(timespan &);

  void setData(T &);

  void debug() const;

  Event<T> &operator=(const Event<T> *event);

  bool operator<(const Event &event) const;

  bool operator<=(const Event &event) const;

  bool operator>(const Event &event) const;

  bool operator>=(const Event &event) const;

  bool operator==(const Event &event) const;

  bool operator!=(const Event &event) const;

  bool operator<(const timespan &time) const;

  bool operator<=(const timespan &time) const;

  bool operator>(const timespan &time) const;

  bool operator>=(const timespan &time) const;

  bool operator==(const timespan &time) const;

  bool operator!=(const timespan &time) const;

  template <typename D>
  friend bool operator<(const timespan &time, const Event<D> &event);

  template <typename D>
  friend bool operator<=(const timespan &time, const Event<D> &event);

  template <typename D>
  friend bool operator>(const timespan &time, const Event<D> &event);

  template <typename D>
  friend bool operator>=(const timespan &time, const Event<D> &event);

  template <typename D>
  friend bool operator==(const timespan &time, const Event<D> &event);

  template <typename D>
  friend bool operator!=(const timespan &time, const Event<D> &event);
};

template <typename T> Event<T>::Event() : data(), time(0) {}

template <typename T>
Event<T>::Event(const T &ddata, const timespan &ttime)
    : data(ddata), time(ttime) {}

template <typename T> const T &Event<T>::getData() const { return data; }

template <typename T> const timespan &Event<T>::getTime() const { return time; }

template <typename T> void Event<T>::set(T &d, timespan &t) {
  time = t;
  data = d;
}

template <typename T> void Event<T>::setTime(timespan &t) { time = t; }

template <typename T> void Event<T>::setData(T &d) { data = d; }

template <typename T> void Event<T>::debug() const {
  DEBUGV3_APPEND("%d,%lu; ", getData(), getTime());
}

template <typename T> Event<T> &Event<T>::operator=(const Event *event) {
  data = event->data;
  time = event->time;
  return *this;
}

template <typename T> bool Event<T>::operator<(Event const &event) const {
  return time < event.time;
}

template <typename T> bool Event<T>::operator<=(Event const &event) const {
  return time <= event.time;
}

template <typename T> bool Event<T>::operator>(Event const &event) const {
  return time > event.time;
}

template <typename T> bool Event<T>::operator>=(Event const &event) const {
  return time >= event.time;
}

template <typename T> bool Event<T>::operator==(Event<T> const &event) const {
  return time == event.time && data == event.data;
}

template <typename T> bool Event<T>::operator!=(Event<T> const &event) const {
  return time != event.time;
}

template <typename T> bool Event<T>::operator<(const timespan &ttime) const {
  return this->time < ttime;
}

template <typename T> bool Event<T>::operator<=(const timespan &ttime) const {
  return this->time <= ttime;
}

template <typename T> bool Event<T>::operator>(const timespan &ttime) const {
  return this->time > ttime;
}

template <typename T> bool Event<T>::operator>=(const timespan &ttime) const {
  return this->time >= ttime;
}

template <typename T> bool Event<T>::operator==(const timespan &ttime) const {
  return this->time == ttime;
}

template <typename T> bool Event<T>::operator!=(const timespan &ttime) const {
  return this->time != ttime;
}

template <typename T>
bool operator<(const timespan &ttime, const Event<T> &event) {
  return ttime < event.time;
}

template <typename T>
bool operator<=(const timespan &ttime, const Event<T> &event) {
  return ttime <= event.time;
}

template <typename T>
bool operator>(const timespan &ttime, const Event<T> &event) {
  return ttime > event.time;
}

template <typename T>
bool operator>=(const timespan &ttime, const Event<T> &event) {
  return ttime >= event.time;
}

template <typename T>
bool operator==(const timespan &ttime, const Event<T> &event) {
  return ttime == event.time;
}

template <typename T>
bool operator!=(const timespan &ttime, const Event<T> &event) {
  return ttime != event.time;
}
#endif //_MONITOR_EVENT_H_