#ifndef NAMED_PIPE_HPP
#define NAMED_PIPE_HPP

#include <boost/asio/detail/throw_error.hpp>
#include <boost/asio/basic_io_object.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/asio/error.hpp>
#include <windows.h>

#include "named_pipe_service.hpp"

class named_pipe : public boost::asio::basic_io_object<named_pipe_service>
{
public:
    typedef named_pipe_service::native_type native_type;
    typedef named_pipe lowest_layer_type;

    explicit named_pipe(boost::asio::io_service &io_service)
        : basic_io_object<named_pipe_service>(io_service)
    {
    }

    named_pipe(boost::asio::io_service &io_service, const char *name)
        : basic_io_object<named_pipe_service>(io_service)
    {
        boost::system::error_code ec;
        service.open(implementation, name, ec);
        boost::asio::detail::throw_error(ec);
    }

    named_pipe(boost::asio::io_service &io_service, const native_type &pipe)
        : basic_io_object<named_pipe_service>(io_service)
    {
        boost::system::error_code ec;
        service.assign(implementation, pipe, ec);
        boost::asio::detail::throw_error(ec);
    }

    lowest_layer_type &lowest_layer()
    {
        return *this;
    }

    const lowest_layer_type &lowest_layer() const
    {
        return *this;
    }

    void open(const char *name)
    {
        boost::system::error_code ec;
        service.open(implementation, name, ec);
        boost::asio::detail::throw_error(ec);
    }

    boost::system::error_code open(const char *name, boost::system::error_code &ec)
    {
        return service.open(implementation, name, ec);
    }

    void assign(const native_type &pipe)
    {
        boost::system::error_code ec;
        service.assign(implementation, pipe, ec);
        boost::asio::detail::throw_error(ec);
    }

    boost::system::error_code assign(const native_type &pipe, boost::system::error_code &ec)
    {
        return service.assign(implementation, pipe, ec);
    }

    bool is_open() const
    {
        return service.is_open(implementation);
    }

    void close()
    {
        boost::system::error_code ec;
        service.close(implementation, ec);
        boost::asio::detail::throw_error(ec);
    }

    boost::system::error_code close(boost::system::error_code &ec)
    {
        return service.close(implementation, ec);
    }

    native_type native()
    {
        return service.native(implementation);
    }

    void cancel()
    {
        boost::system::error_code ec;
        service.cancel(implementation, ec);
        boost::asio::detail::throw_error(ec);
    }

    boost::system::error_code cancel(boost::system::error_code &ec)
    {
        return service.cancel(implementation, ec);
    }

    void set_mode(DWORD mode)
    {
        boost::system::error_code ec;
        service.set_mode(implementation, mode, ec);
        boost::asio::detail::throw_error(ec);
    }

    boost::system::error_code set_mode(DWORD mode, boost::system::error_code &ec)
    {
        return service.set_mode(implementation, mode, ec);
    }

    template <typename ConstBufferSequence>
    std::size_t write_some(const ConstBufferSequence &buffers)
    {
        boost::system::error_code ec;
        std::size_t s = service.write_some(implementation, buffers, ec);
        boost::asio::detail::throw_error(ec);
        return s;
    }

    template <typename ConstBufferSequence>
    std::size_t write_some(const ConstBufferSequence &buffers, boost::system::error_code &ec)
    {
        return service.write_some(implementation, buffers, ec);
    }

    template <typename ConstBufferSequence, typename WriteHandler>
    void async_write_some(const ConstBufferSequence &buffers, WriteHandler handler)
    {
        service.async_write_some(implementation, buffers, handler);
    }

    template <typename MutableBufferSequence>
    std::size_t read_some(const MutableBufferSequence &buffers)
    {
        boost::system::error_code ec;
        std::size_t s = service.read_some(implementation, buffers, ec);
        boost::asio::detail::throw_error(ec);
        return s;
    }

    template <typename MutableBufferSequence>
    std::size_t read_some(const MutableBufferSequence &buffers, boost::system::error_code &ec)
    {
        return service.read_some(implementation, buffers, ec);
    }

    template <typename MutableBufferSequence, typename ReadHandler>
    void async_read_some(const MutableBufferSequence &buffers, ReadHandler handler)
    {
        service.async_read_some(implementation, buffers, handler);
    }
};

#endif