DeviceDriver.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-FileCopyrightText: 2006-2010 RobotCub Consortium
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_DEV_DEVICEDRIVER_H
#define YARP_DEV_DEVICEDRIVER_H
 
#include <yarp/os/ConnectionReader.h>
#include <yarp/os/ConnectionWriter.h>
#include <yarp/os/BufferedPort.h>
#include <yarp/os/Property.h>
#include <yarp/os/IConfig.h>
 
#include <yarp/dev/api.h>
 
namespace yarp::dev {
class DeviceDriver;
class DeprecatedDeviceDriver;
class DeviceResponder;
}
 
class YARP_dev_API yarp::dev::DeviceDriver : public yarp::os::IConfig
{
public:
    DeviceDriver();
    DeviceDriver(const DeviceDriver& other) = delete;
    DeviceDriver(DeviceDriver&& other) noexcept = delete;
    DeviceDriver& operator=(const DeviceDriver& other) = delete;
    DeviceDriver& operator=(DeviceDriver&& other) noexcept = delete;
 
    ~DeviceDriver() override;
 
    bool open(yarp::os::Searchable& config) override { YARP_UNUSED(config); return true; }
 
    bool close() override { return true; }
 
 
    virtual std::string id() const;
 
    virtual void setId(const std::string& id);
 
    template <class T>
    bool view(T *&x) {
        x = nullptr;
 
        // This is not super-portable; and it requires RTTI compiled
        // in.  For systems on which this is a problem, suggest:
        // either replace it with a regular cast (and warn user) or
        // implement own method for checking interface support.
        T *v = dynamic_cast<T *>(getImplementation());
 
        if (v != nullptr) {
            x = v;
            return true;
        }
 
        return false;
    }
 
    virtual DeviceDriver *getImplementation() {
        return this;
    }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    class Private;
    Private* mPriv = nullptr;
#endif
};
 
class YARP_dev_API yarp::dev::DeprecatedDeviceDriver : virtual public yarp::dev::DeviceDriver
{
};
 
 
class YARP_dev_API yarp::dev::DeviceResponder : public yarp::os::PortReader,
            public yarp::os::TypedReaderCallback<yarp::os::Bottle>
{
 
private:
    yarp::os::Bottle examples;
    yarp::os::Bottle explains;
    yarp::os::Bottle details;
 
public:
    DeviceResponder();
 
    void addUsage(const char *txt, const char *explain = nullptr);
 
    void addUsage(const yarp::os::Bottle& bot, const char *explain = nullptr);
 
    virtual bool respond(const yarp::os::Bottle& command,
                         yarp::os::Bottle& reply);
 
    bool read(yarp::os::ConnectionReader& connection) override;
 
    using yarp::os::TypedReaderCallback<yarp::os::Bottle>::onRead;
    void onRead(yarp::os::Bottle& v) override {
        yarp::os::Bottle reply;
        respond(v,reply);
    }
 
    void makeUsage();
 
    void attach(yarp::os::TypedReader<yarp::os::Bottle>& source) {
        source.useCallback(*this);
        source.setReplier(*this);
    }
};
 
 
#endif // YARP_DEV_DEVICEDRIVER_H