basic_iosocketstream.h

Go to the documentation of this file.

// -*- Socket Streams -*-

// Copyright (C) 2003, 2004, 2005 Pedro Lamarão <pedro.lamarao@mndfck.org>

// This file is part of the Socket Streams Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License as published by the
// Free Software Foundation; either version 2.1 of the License
// or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
// USA

#ifndef SOCKETSTREAM_BASIC_IOSOCKETSTREAM_H
#define SOCKETSTREAM_BASIC_IOSOCKETSTREAM_H 1

#include <socketstream/config.h>

#include <iostream>
#include <socketstream/basic_socketbuf.h>

namespace ss {

  template <typename _CharT, typename _Traits>
  class basic_socketstream
  : public std::basic_iostream<_CharT, _Traits>,
    public sockets_base
  {
  public:


    typedef _CharT     char_type;
    typedef _Traits  traits_type;

    typedef typename traits_type::int_type int_type;
    typedef typename traits_type::pos_type pos_type;
    typedef typename traits_type::off_type off_type;

    typedef basic_socketbuf<char_type, traits_type>   __streambuf_type;
    typedef std::basic_iostream<char_type, traits_type>  __stream_type;
    
    template <typename C, typename T>
    friend class basic_listener;

    basic_socketstream()
    : __stream_type(&_M_buffer), _M_buffer()
    { }

    basic_socketstream(family __f, style __s)
    : __stream_type(&_M_buffer), _M_buffer(__f, __s)
    { }

    virtual ~basic_socketstream()
    { }

    bool
    is_open ()
    { return _M_buffer.is_open(); }

        template <typename AddressT>
    void
    connect (AddressT& __addr)
    {
      if (!_M_buffer.connect(__addr))
        this->setstate(std::ios_base::failbit);
    }

    void
    shutdown (shutmode __mode = sockets_base::rw)
    {
      if (!_M_buffer.shutdown(__mode))
        this->setstate(std::ios_base::failbit);
    }

    __streambuf_type*
    rdbuf () const
    { return const_cast<__streambuf_type*>(&_M_buffer); }

    __stream_type&
    operator>> (flag& __flag)
    {
      _M_buffer.setf(__flag);
      return *this;
    }

    __stream_type&
    operator<< (flag& __flag)
    {
      _M_buffer.setf(__flag);
      return *this;
    }

  protected:

    basic_socketstream(basic_socket::descriptor_t descriptor)
    : __stream_type(&_M_buffer), _M_buffer(descriptor)
    { }

    __streambuf_type _M_buffer;

  };

  typedef basic_socketstream<char, std::char_traits<char> > socketstream;

}

#endif  // SOCKETSTREAM_BASIC_IOSOCKETSTREAM_H

---