Protocol.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_IMPL_PROTOCOL_H
#define YARP_OS_IMPL_PROTOCOL_H
 
#include <yarp/os/Carrier.h>
#include <yarp/os/ConnectionState.h>
#include <yarp/os/InputProtocol.h>
#include <yarp/os/NullConnection.h>
#include <yarp/os/OutputProtocol.h>
#include <yarp/os/ShiftStream.h>
#include <yarp/os/impl/StreamConnectionReader.h>
 
namespace yarp {
namespace os {
namespace impl {
 
class YARP_os_impl_API Protocol :
        public yarp::os::OutputProtocol,
        public yarp::os::InputProtocol,
        public yarp::os::ConnectionState
{
public:
    Protocol(TwoWayStream* stream);
 
     ~Protocol() override;
 
    // yarp::os::ConnectionState.
    void setRoute(const Route& route) override;
    const Route& getRoute() const override;
    TwoWayStream& getStreams() override;
    void takeStreams(TwoWayStream* streams) override;
    TwoWayStream* giveStreams() override;
    bool checkStreams() const override;
    void setReference(yarp::os::Portable* ref) override;
    std::string getSenderSpecifier() const override;
    const std::string& getEnvelope() const override;
    void setRemainingLength(int len) override;
    Connection& getConnection() override;
    Contactable* getContactable() const override;
 
 
    // yarp::os::InputProtocol.
    bool open(const std::string& name) override;
    void close() override;
    void interrupt() override;
    OutputStream& getOutputStream() override;
    InputStream& getInputStream() override;
    void reply(SizedWriter& writer) override;
    OutputProtocol& getOutput() override;
    yarp::os::ConnectionReader& beginRead() override;
    void endRead() override;
    void suppressReply() override;
    bool setTimeout(double timeout) override;
    void setEnvelope(const std::string& str) override;
    Connection& getReceiver() override;
    void attachPort(yarp::os::Contactable* port) override;
    bool isReplying() const override;
 
 
    // yarp::os::OutputProtocol.
    bool open(const Route& route) override;
    void rename(const Route& route) override;
    bool isOk() const override;
    bool write(SizedWriter& writer) override;
    InputProtocol& getInput() override;
    void beginWrite() override;
    Connection& getSender() override;
 
 
    void willReply()
    {
        pendingReply = true;
    }
 
private:
    bool getRecvDelegate();
 
    bool getSendDelegate();
 
    bool expectProtocolSpecifier();
 
    bool expectSenderSpecifier();
 
    bool expectHeader();
 
    void setCarrier(const std::string& carrierNameBase);
 
    bool sendHeader();
 
    bool expectReplyToHeader();
 
    bool respondToHeader();
 
    bool expectIndex();
 
    bool respondToIndex();
 
    bool expectAck();
 
    bool sendAck();
 
    void closeHelper();
 
    int messageLen;                
    bool pendingAck;               
    ShiftStream shift;             
    bool active;                   
    Carrier* delegate;             
    Carrier* recv_delegate;        
    Carrier* send_delegate;        
    bool need_recv_delegate;       
    bool need_send_delegate;       
    bool recv_delegate_fail;       
    bool send_delegate_fail;       
    Route route;                   
    SizedWriter* writer;           
    StreamConnectionReader reader; 
    yarp::os::Portable* ref;       
    std::string envelope;          
    NullConnection nullConnection; 
    yarp::os::Contactable* port;   
    bool pendingReply;             
};
 
} // namespace impl
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_IMPL_PROTOCOL_H