Carrier.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * Copyright (C) 2006-2010 RobotCub Consortium
 * 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_CARRIER_H
#define YARP_OS_CARRIER_H
 
#include <yarp/os/Connection.h>
 
#define YARP_ENACT_CONNECT 1
#define YARP_ENACT_DISCONNECT 2
#define YARP_ENACT_EXISTS 3
 
 
namespace yarp {
namespace os {
 
class SizedWriter;
class Bytes;
class Contact;
class ContactStyle;
class ConnectionReader;
class ConnectionState;
class Face;
 
 
class YARP_os_API Carrier : public Connection
{
public:
    virtual Carrier* create() const = 0;
 
    virtual bool checkHeader(const Bytes& header) = 0;
 
    virtual void setParameters(const Bytes& header) = 0;
 
    void getHeader(Bytes& header) const override = 0;
 
 
    bool isConnectionless() const override = 0;
 
 
    bool isBroadcast() const override;
 
    virtual bool canAccept() const = 0;
 
    virtual bool canOffer() const = 0;
 
    bool isTextMode() const override = 0;
 
    bool canEscape() const override = 0;
 
    void handleEnvelope(const std::string& envelope) override;
 
    bool requireAck() const override = 0;
 
    bool supportReply() const override = 0;
 
    bool isLocal() const override = 0;
 
 
    bool isPush() const override;
 
    virtual bool prepareSend(ConnectionState& proto) = 0;
 
    virtual bool sendHeader(ConnectionState& proto) = 0;
 
    virtual bool expectReplyToHeader(ConnectionState& proto) = 0;
 
    virtual bool write(ConnectionState& proto, SizedWriter& writer) = 0;
 
 
    virtual bool reply(ConnectionState& proto, SizedWriter& writer);
 
    virtual bool expectExtraHeader(ConnectionState& proto) = 0;
 
    virtual bool respondToHeader(ConnectionState& proto) = 0;
 
    virtual bool expectIndex(ConnectionState& proto) = 0;
 
    virtual bool expectSenderSpecifier(ConnectionState& proto) = 0;
 
    virtual bool sendAck(ConnectionState& proto) = 0;
 
    virtual bool expectAck(ConnectionState& proto) = 0;
 
    bool isActive() const override = 0;
 
    void prepareDisconnect() override;
 
 
    virtual std::string toString() const = 0;
 
    virtual void close();
 
    virtual ~Carrier();
 
    virtual std::string getBootstrapCarrierName() const;
 
    virtual int connect(const Contact& src,
                        const Contact& dest,
                        const ContactStyle& style,
                        int mode,
                        bool reversed);
 
 
    bool modifiesIncomingData() const override;
 
    ConnectionReader& modifyIncomingData(ConnectionReader& reader) override;
 
    bool acceptIncomingData(ConnectionReader& reader) override;
 
    bool modifiesOutgoingData() const override;
 
    const PortWriter& modifyOutgoingData(const PortWriter& writer) override;
 
    bool modifiesReply() const override;
 
    PortReader& modifyReply(PortReader& reader) override;
 
    bool acceptOutgoingData(const PortWriter& writer) override;
 
    virtual bool configure(ConnectionState& proto);
 
    virtual bool configureFromProperty(yarp::os::Property& options);
 
    void setCarrierParams(const Property& params) override;
    void getCarrierParams(Property& params) const override;
 
    virtual yarp::os::Face* createFace() const;
};
 
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_CARRIER_H