Driver.hpp

Go to the documentation of this file.

#ifndef IODRIVERS_BASE_DRIVER_HH
#define IODRIVERS_BASE_DRIVER_HH

#include <stdexcept>
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>
#include <vector>
#include <unistd.h>
#include <iodrivers_base/Status.hpp>
#include <iodrivers_base/Exceptions.hpp>
#include <set>

struct addrinfo;

namespace iodrivers_base {

class IOStream;
class IOListener;

class FileGuard
{
    int fd;
public:
    explicit FileGuard(int fd = -1)
        : fd(fd) { }
    ~FileGuard() { reset(); };

    void reset(int new_fd = -1)
    {
        if (fd != -1) close(fd);
        fd = new_fd;
    }

    int get() const { return fd; }
    int release()
    {
        int ret = fd;
        fd = -1;
        return ret;
    }
};

class Driver
{
public:
    typedef iodrivers_base::Status Statistics;

    static const int INVALID_FD = -1;

private:
    uint8_t* internal_buffer;
    size_t internal_buffer_size;

public:
    int const MAX_PACKET_SIZE;

protected:
    IOStream* m_stream;

    std::set<IOListener*> m_listeners;

    bool m_auto_close;

    bool m_extract_last;

    base::Time m_read_timeout;

    base::Time m_write_timeout;

    std::pair<int, bool> readPacketInternal(uint8_t* buffer, int bufsize);

    std::pair<uint8_t const*, int> findPacket(uint8_t const* buffer, int buffer_size) const;

    std::pair<int, bool> extractPacketFromInternalBuffer(uint8_t* buffer, int out_buffer_size);

    int doPacketExtraction(uint8_t* buffer);

    mutable Status m_stats;

    void openIPClient(std::string const& hostname, int port, addrinfo const& hints);

public:
    Driver(int max_packet_size, bool extract_last = false);

    virtual ~Driver();

    void setReadTimeout(base::Time const& t);

    base::Time getReadTimeout() const;

    void setWriteTimeout(base::Time const& t);

    base::Time getWriteTimeout() const;

    void clear();

    Status getStatus() const;

    void resetStatus();

    Status getStats() const { return getStatus(); }

    void resetStats() { return resetStatus(); }

    void setExtractLastPacket(bool flag);

    bool getExtractLastPacket() const;

    virtual void openURI(std::string const& uri);
    
    bool openInet(const char *hostname, int port);
    
    void openTCP(std::string const& hostname, int port);
    
    void openUDP(std::string const& hostname, int remote_port);
    
    void openUDPBidirectional(std::string const& hostname, int out_port, int in_port);

    
    bool openSerial(std::string const& port, int baudrate);

    void openFile(std::string const& path);

    static int openSerialIO(std::string const& port, int baudrate);

    static bool setNonBlockingFlag(int fd);

    void setFileDescriptor(int fd, bool auto_close = true);

    int getFileDescriptor() const;

    bool isValid() const;

    // In most Linux systems also baudrates up to 1152000 are defined.
    enum SERIAL_RATES
    {
        SERIAL_1200 = 1200,
        SERIAL_2400 = 2400,
        SERIAL_4800 = 4800,
        SERIAL_9600 = 9600,
        SERIAL_19200 = 19200,
        SERIAL_38400 = 38400,
        SERIAL_57600 = 57600,
        SERIAL_115200 = 115200,
        SERIAL_230400 = 230400,
        SERIAL_460800 = 460800,
        SERIAL_576000 = 576000,
        SERIAL_921600 = 921600,
        SERIAL_1152000 = 1152000
    };

    bool setSerialBaudrate(int rate);

    static bool setSerialBaudrate(int fd, int rate);

    virtual void close();

    bool hasPacket() const;

    int readPacket(uint8_t* buffer, int bufsize);

    int readPacket(uint8_t* buffer, int bufsize, base::Time const& packet_timeout);

    int readPacket(uint8_t* buffer, int bufsize, int packet_timeout, int first_byte_timeout = -1);

    int readPacket(uint8_t* buffer, int bufsize, base::Time const& packet_timeout, base::Time const& first_byte_timeout);

    bool writePacket(uint8_t const* buffer, int bufsize);

    bool writePacket(uint8_t const* buffer, int bufsize, int timeout);

    bool writePacket(uint8_t const* buffer, int bufsize, base::Time const& timeout);

    virtual int extractPacket(uint8_t const* buffer, size_t buffer_size) const = 0;

    void setMainStream(IOStream* stream);

    IOStream* getMainStream() const;

    void openTestMode();

    void addListener(IOListener* stream);

    void removeListener(IOListener* stream);

    static std::string printable_com(std::string const& buffer);
    static std::string printable_com(uint8_t const* buffer, size_t buffer_size);
    static std::string printable_com(char const* buffer, size_t buffer_size);

    static std::string binary_com(std::string const& str);
    static std::string binary_com(uint8_t const* str, size_t str_size);
    static std::string binary_com(char const* str, size_t str_size);
};

}

#endif