Subscription.h

Go to the documentation of this file.

/*****************************************************************************
 * vim:tw=78
 *
 * 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 details.
 *
 * 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_SUBSCRIPTION_H
#define PDCOM5_SUBSCRIPTION_H

#include "Exception.h"
#include "Variable.h"
#include "details.h"
#include "visibility.h"

#include <chrono>
#include <functional>
#include <memory>
#include <string>

namespace PdCom {
namespace impl {
class Subscription;
}

class Process;
class Variable;
class Subscriber;

struct PDCOM5_PUBLIC Selector
{
    using CopyFunctionType = std::function<
            void(void * /* destination */, const void * /* src */)>;

    virtual ~Selector() = default;
    virtual std::unique_ptr<Selector> clone() const;
    virtual std::size_t getRequiredSize(const Variable &variable) const;
    virtual CopyFunctionType getCopyFunction(const Variable &variable) const;
};

class PDCOM5_PUBLIC Subscription
{
  public:
    struct PDCOM5_PUBLIC invalid_subscription : Exception
    {
        invalid_subscription() : Exception("invalid subscription") {}
    };

    enum class State {
        Invalid = 0,
        Pending,
        Active,
    };

    enum class SubscriberState {
        FullyConstructed,
        UnderConstruction,
    };

    Subscription() = default;
    Subscription(Subscription &&) noexcept;
    Subscription &operator=(Subscription &&) noexcept;

    Subscription(
            Subscriber &subscriber,
            const Variable &variable,
            const Selector &selector = {});

    Subscription(
            Subscriber &subscriber,
            Process &process,
            const std::string &path,
            const Selector &selector = {});

    void poll();
    const void *getData() const;
    template <typename T>
    typename std::enable_if<!std::is_arithmetic<T>::value, void>::type
    getValue(T &dest) const
    {
        details::copyData(
                &dest[0],
                details::TypeInfoTraits<typename T::value_type>::type_info.type,
                getData(), getVariable().getTypeInfo().type,
                std::min<size_t>(
                        dest.size(),
                        getVariable().getSizeInfo().totalElements()));
    }
    template <typename T>
    typename std::enable_if<std::is_arithmetic<T>::value, void>::type
    getValue(T &dest) const
    {
        details::copyData(
                &dest, details::TypeInfoTraits<T>::type_info.type, getData(),
                getVariable().getTypeInfo().type, 1);
    }

    Variable getVariable() const noexcept;

    void print(std::ostream &os, char delimiter) const;

    bool empty() const noexcept { return !(pimpl); }
    State getState() const noexcept { return state_; }

  private:
    friend impl::Subscription;
    struct ImplDeleter
    {
        void operator()(impl::Subscription *) const;
    };
    std::unique_ptr<impl::Subscription, ImplDeleter> pimpl;
    State state_ = State::Invalid;
};

}  // namespace PdCom


#endif  // PDCOM5_SUBSCRIPTION_H