Publisher.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_OS_PUBLISHER_H
#define YARP_OS_PUBLISHER_H
 
#include <yarp/os/AbstractContactable.h>
#include <yarp/os/BufferedPort.h>
#include <yarp/os/Log.h>
 
namespace yarp {
namespace os {
 
template <class T>
class Publisher : public AbstractContactable
{
public:
    using AbstractContactable::write;
 
    Publisher(const std::string& name = "")
    {
        buffered_port = nullptr;
        T example;
        port.promiseType(example.getType());
        port.setInputMode(false);
        port.setOutputMode(true);
        port.setRpcMode(false);
        if (name != "") {
            bool ret = topic(name);
            yAssert(ret);
            YARP_UNUSED(ret); // FIXME [[maybe-unused]]
        }
    }
 
    virtual ~Publisher()
    {
        clear();
    }
 
    bool topic(const std::string& name)
    {
        port.includeNodeInName(true);
        return open(name);
    }
 
    // documentation provided in Contactable
    bool open(const std::string& name) override
    {
        clear();
        return port.open(name);
    }
 
    // documentation provided in Contactable
    bool open(const Contact& contact, bool registerName = true) override
    {
        clear();
        return port.open(contact, registerName);
    }
 
    // documentation provided in Contactable
    void close() override
    {
        active().close();
    }
 
    // documentation provided in Contactable
    void interrupt() override
    {
        active().interrupt();
    }
 
    // documentation provided in Contactable
    void resume() override
    {
        active().resume();
    }
 
    // documented in Contactable
    void setReader(PortReader& reader) override
    {
        active().setReader(reader);
    }
 
    T& prepare()
    {
        return buffer().prepare();
    }
 
    bool unprepare()
    {
        return buffer().unprepare();
    }
 
    void write(bool forceStrict = false)
    {
        buffer().write(forceStrict);
    }
 
    void waitForWrite()
    {
        buffer().waitForWrite();
    }
 
    virtual int getPendingReads()
    {
        if (buffered_port)
            return buffered_port->getPendingReads();
        return 0;
    }
 
    Port& asPort() override
    {
        return port;
    }
 
    const Port& asPort() const override
    {
        return port;
    }
 
private:
    Port port;
    BufferedPort<T>* buffered_port;
 
    Contactable& active()
    {
        if (buffered_port)
            return *buffered_port;
        return port;
    }
 
    BufferedPort<T>& buffer()
    {
        if (!buffered_port) {
            buffered_port = new BufferedPort<T>(port);
        }
        return *buffered_port;
    }
 
    void clear()
    {
        if (!buffered_port)
            return;
        delete buffered_port;
        buffered_port = nullptr;
    }
};
 
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_PUBLISHER_H