stream_socket.h

//
//  Copyright (C) 2009-2012 Artyom Beilis (Tonkikh)
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOSTER_AIO_STREAM_SOCKET_H
#define BOOSTER_AIO_STREAM_SOCKET_H

#include <booster/aio/types.h>
#include <booster/callback.h>
#include <booster/hold_ptr.h>
#include <booster/noncopyable.h>
#include <booster/aio/endpoint.h>
#include <booster/aio/basic_io_device.h>
#include <booster/aio/basic_socket.h>

namespace booster {
namespace aio {
        class mutable_buffer;
        class const_buffer;
        class io_service;
        
        
        
        class BOOSTER_API stream_socket : public basic_socket {
        public:
                typedef enum {
                        shut_rd, //< Shutdown read operations 
                        shut_wr, //< Shutdown write operations
                        shut_rdwr //< Shutdown both read and write operations
                } how_type;

                stream_socket();
                stream_socket(io_service &srv);
                ~stream_socket();

                void open(family_type d);
                void open(family_type d,system::error_code &e);

                void shutdown(how_type h);
                void shutdown(how_type h,system::error_code &e);

                void connect(endpoint const &ep);
                void connect(endpoint const &ep,system::error_code &e);
                void async_connect(endpoint const &ep,event_handler const &h);

                size_t read_some(mutable_buffer const &buffer);
                size_t read_some(mutable_buffer const &buffer,system::error_code &e);
                
                size_t write_some(const_buffer const &buffer);
                size_t write_some(const_buffer const &buffer,system::error_code &e);

                size_t read(mutable_buffer const &buffer);
                size_t write(const_buffer const &buffer);
                
                size_t read(mutable_buffer const &buffer,system::error_code &e);
                size_t write(const_buffer const &buffer,system::error_code &e);

                void async_read_some(mutable_buffer const &buffer,io_handler const &h);
                void async_write_some(const_buffer const &buffer,io_handler const &h);

                void async_read(mutable_buffer const &buffer,io_handler const &h);
                void async_write(const_buffer const &buffer,io_handler const &h);

                size_t bytes_readable(booster::system::error_code &e);

                size_t bytes_readable();

        private:
                int readv(mutable_buffer const &b);
                int writev(const_buffer const &b);

                struct data;
                hold_ptr<data> d;
        };

        BOOSTER_API void socket_pair(stream_socket &s1,stream_socket &s2,system::error_code &e);
        BOOSTER_API void socket_pair(stream_socket &s1,stream_socket &s2);
        

} // aio
} // booster

#endif