Subscriber.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * Copyright (C) 2021 Richard Hacker (lerichi at gmx dot net),
 *                    Florian Pose (fp at igh dot de),
 *                    Bjarne von Horn (vh at igh dot de).
 *
 * This file is part of the PdCom library.
 *
 * The PdCom library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * The PdCom library 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 Lesser General Public
 * License for more .
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with the PdCom library. If not, see <http://www.gnu.org/licenses/>.
 *
 ****************************************************************************/
 
#ifndef PDCOM5_SUBSCRIBER_H
#define PDCOM5_SUBSCRIBER_H
 
#include "pdcom5_export.h"
 
#include <chrono>
#include <functional>
#include <pdcom5/Exception.h>
 
namespace PdCom {
 
namespace impl {
class Subscription;
}
 
class Subscription;
 
constexpr struct event_mode_tag
{
} event_mode;
 
constexpr struct poll_mode_tag
{
} poll_mode;
 
class PDCOM5_PUBLIC Transmission
{
    double interval_;
 
    static constexpr double checkInterval(double d)
    {
        return d <= 0 ? throw PdCom::InvalidArgument(
                       "period must be greater than zero")
                      : d;
    }
 
  public:
    constexpr double getInterval() const noexcept { return interval_; }
    template <typename T, typename R>
    constexpr Transmission(std::chrono::duration<T, R> d) :
        interval_(checkInterval(
                std::chrono::duration_cast<std::chrono::duration<double>>(d)
                        .count()))
    {}
    constexpr Transmission(event_mode_tag) noexcept : interval_(0) {}
    constexpr Transmission(poll_mode_tag) noexcept : interval_(-1) {}
    bool operator==(const Transmission &o) const noexcept
    {
        return o.interval_ == interval_;
    }
 
    static constexpr Transmission fromDouble(double d)
    {
        return d == 0
                ? Transmission(event_mode)
                : (d == -1 ? Transmission(poll_mode)
                           : Transmission(std::chrono::duration<double>(d)));
    }
};
 
class PDCOM5_PUBLIC Subscriber
{
    Transmission td_;
    friend class impl::Subscription;
 
  public:
    explicit Subscriber(const Transmission &td) noexcept : td_(td) {}
    Subscriber(Subscriber const &)            = delete;
    Subscriber(Subscriber &&)                 = delete;
    Subscriber &operator=(Subscriber const &) = delete;
    Subscriber &operator=(Subscriber &&)      = delete;
 
    const Transmission &getTransmission() const noexcept { return td_; }
 
  private:
    virtual void stateChanged(PdCom::Subscription const &subscription) = 0;
 
    virtual void newValues(std::chrono::nanoseconds time_ns) = 0;
 
  protected:
    ~Subscriber() = default;
};
 
}  // namespace PdCom
 
namespace std {
 
template <>
struct hash<PdCom::Transmission>
{
    size_t operator()(PdCom::Transmission t) const
            noexcept(__cplusplus >= 201703L)
    {
        return std::hash<double>()(t.getInterval());
    }
};
 
}  // namespace std
 
#endif  // PDCOM5_SUBSCRIBER_H