Process.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_PROCESS_H
#define PDCOM5_PROCESS_H

#include "ClientStatistics.h"
#include "Variable.h"

#include <chrono>
#include <memory>
#include <pdcom5_export.h>
#include <stddef.h>
#include <stdint.h>
#include <string>
#include <vector>

namespace PdCom {
namespace impl {
class Process;
}

class SecureProcess;
class Variable;
class Sasl;
class Subscription;
class Subscriber;
class MessageManagerBase;

class PDCOM5_PUBLIC Process
{
    friend class impl::Process;
    friend class SecureProcess;

  public:
    Process();
    Process(Process &&)      = delete;
    Process(Process const &) = delete;
    Process &operator=(Process &&) = delete;
    Process &operator=(Process const &) = delete;

  protected:
    virtual ~Process();

  public:
    std::string name() const;

    std::string version() const;

    void asyncData();

    void callPendingCallbacks();

    void
    broadcast(const std::string &message, const std::string &attr = "text");

    struct SubscriptionInfo
    {
        const PdCom::Subscription *subscription;
        const PdCom::Subscriber *subscriber;
        PdCom::Variable variable;

        SubscriptionInfo(
                const PdCom::Subscription *subscription,
                const PdCom::Subscriber *subscriber,
                PdCom::Variable variable) :
            subscription(subscription),
            subscriber(subscriber),
            variable(variable)
        {}
    };

    std::vector<SubscriptionInfo> getActiveSubscriptions() const;

  protected:
    void reset();

    virtual std::string applicationName() const { return "pdcom5"; }

    virtual std::string hostname() const { return {}; }

    virtual int read(char *buf, int count) = 0;

    virtual void write(const char *buf, size_t count) = 0;

    virtual void flush() = 0;

    virtual void connected() = 0;

    bool list(const std::string &path = "");

    virtual void
    listReply(std::vector<Variable> variables, std::vector<std::string> dirs);

    bool find(const std::string &path);

    virtual void findReply(const Variable &variable);

    void getClientStatistics();

    virtual void
    clientStatisticsReply(std::vector<ClientStatistics> statistics);

    void ping();

    virtual void pingReply() {}

    virtual bool alive() { return true; }

    void setAuthManager(Sasl *);

    Sasl *getAuthManager() const;

    void setMessageManager(MessageManagerBase *);

    virtual void broadcastReply(
            const std::string &message,
            const std::string &attr,
            std::chrono::nanoseconds time_ns,
            const std::string &user);

  private:
    std::shared_ptr<impl::Process> pimpl;
    explicit Process(std::shared_ptr<impl::Process> impl);
};
}  // namespace PdCom

#endif  // PDCOM5_PROCESS_H