BufferedConnectionWriter.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_OS_IMPL_BUFFEREDCONNECTIONWRITER_H
#define YARP_OS_IMPL_BUFFEREDCONNECTIONWRITER_H
 
#include <yarp/os/ConnectionWriter.h>
#include <yarp/os/SizedWriter.h>
 
#include <string>
#include <vector>
 
 
namespace yarp {
namespace os {
 
class Bytes;
class ManagedBytes;
 
namespace impl {
 
/*
 * When allocating space to store serialized data, we start off with
 * a block of this size.  It will be resized as necessary.
 * Data can optionally have a header, serialized separately.
 */
constexpr size_t BUFFERED_CONNECTION_INITIAL_POOL_SIZE = 1024;
 
class YARP_os_impl_API BufferedConnectionWriter :
        public yarp::os::ConnectionWriter,
        public yarp::os::SizedWriter
{
public:
    BufferedConnectionWriter(bool textMode = false,
                             bool bareMode = false);
 
    ~BufferedConnectionWriter() override;
 
    void reset(bool textMode);
 
    void restart();
 
    void clear() override;
 
    bool addPool(const yarp::os::Bytes& data);
 
    void stopPool();
 
    void push(const Bytes& data, bool copy);
 
    // defined by yarp::os::ConnectionWriter
    bool isTextMode() const override;
    bool isBareMode() const override;
    bool convertTextMode() override;
    void declareSizes(int argc, int* argv) override; // FIXME Remove?
    void setReplyHandler(PortReader& reader) override;
    void appendInt8(std::int8_t data) override;
    void appendInt16(std::int16_t data) override;
    void appendInt32(std::int32_t data) override;
    void appendInt64(std::int64_t data) override;
    void appendFloat32(yarp::conf::float32_t data) override;
    void appendFloat64(yarp::conf::float64_t data) override;
    void appendBlock(const char* data, size_t len) override;
    void appendText(const std::string& str, const char terminate = '\n') override;
    void appendExternalBlock(const char* data, size_t len) override;
 
    virtual void appendBlock(const yarp::os::Bytes& data);
 
    virtual void appendBlockCopy(const Bytes& data);
 
    virtual void appendLine(const std::string& data);
 
 
    // defined by yarp::os::SizedWriter
    size_t length() const override;
    size_t headerLength() const override;
    size_t length(size_t index) const override;
    const char* data(size_t index) const override;
    bool write(ConnectionWriter& connection) const override;
    void write(OutputStream& os) override;
 
    bool write(PortReader& obj);
 
    virtual size_t dataSize() const;
 
    size_t bufferCount() const;
 
 
    // defined by yarp::os::SizedWriter
    PortReader* getReplyHandler() override;
 
    void addToHeader();
 
 
    // defined by yarp::os::SizedWriter
    yarp::os::Portable* getReference() override;
 
 
    // defined by yarp::os::ConnectionWriter
    void setReference(yarp::os::Portable* obj) override;
    bool isValid() const override;
    bool isActive() const override;
    bool isError() const override;
    void requestDrop() override;
 
    // defined by yarp::os::SizedWriter
    bool dropRequested() override;
    void startWrite() const override;
    void stopWrite() const override;
 
    // defined by yarp::os::ConnectionWriter
    SizedWriter* getBuffer() const override;
 
    void setInitialPoolSize(size_t size);
 
 
    std::string toString() const;
 
 
private:
    bool applyConvertTextMode();
    bool applyConvertTextMode() const;
 
 
    YARP_SUPPRESS_DLL_INTERFACE_WARNING_ARG(std::vector<yarp::os::ManagedBytes*>) lst;     
    YARP_SUPPRESS_DLL_INTERFACE_WARNING_ARG(std::vector<yarp::os::ManagedBytes*>) header;  
    YARP_SUPPRESS_DLL_INTERFACE_WARNING_ARG(std::vector<yarp::os::ManagedBytes*>*) target; 
    yarp::os::ManagedBytes* pool; 
    size_t poolIndex;             
    size_t poolCount;             
    size_t poolLength;            
    yarp::os::PortReader* reader; 
    bool textMode;                
    bool bareMode;                
    bool convertTextModePending;  
    yarp::os::Portable* ref;      
    bool shouldDrop;              
    size_t lst_used;              
    size_t header_used;           
    size_t* target_used;          
    size_t initialPoolSize;       
};
 
 
} // namespace impl
} // namespace os
} // namespace yarp
 
#endif // YARP_OS_IMPL_BUFFEREDCONNECTIONWRITER_H