src/base/socket_api.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef SENDS_SOCKET_API_HH
#define SENDS_SOCKET_API_HH

#include <string>

namespace sends {

    class socket_api {
    public:
        enum sock_err {
            serr_OK = 0,
            serr_failure,
            serr_retry,
            serr_internal
        };

    public:
        socket_api(void);

        virtual ~socket_api(void);

        virtual socket_api* accept(void) = 0;

        virtual sock_err bind(const std::string& addr) = 0;

        virtual sock_err close(void) = 0;

        virtual sock_err connect(const std::string& s) = 0;

        sock_err error(void) const;

        virtual long gets(char* buf, long len, char term='\n');

        virtual sock_err handshake(void);

        virtual sock_err listen(const std::string& port, int lq) = 0;

        static sock_err parse_addr(const std::string& addr, unsigned int& node,
                                    unsigned short& port);

        const char* peer_name(void) const;

        virtual long read(char* buf, long len);

        virtual long read_available(char* buf, long len) = 0;

        void set_error(sock_err err);

        sock_err set_error(void);

        void set_verbose(int verb);

        virtual int socket_id(void) const = 0;

        int  verbose(void) const;

        virtual long write(const char* buf, long len) = 0;

        virtual int wait_data(double nsec);

    protected:
        sock_err mError;
        int      mVerbose;
        std::string mPeer;
    };

    //==================================  Inline methods
    inline socket_api::sock_err 
    socket_api::error(void) const {
        return mError;
    }

     inline const char* 
     socket_api::peer_name(void) const {
         return mPeer.c_str();
     }

    inline int
    socket_api::verbose(void) const {
        return mVerbose;
    }

}  // namespace sends

#endif // !defined(SENDS_SOCKET_API_HH)

---