except_write.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2001 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus 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   *
 *   General Public License for more details.                              *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUSEXCEPT_WRITE_H
#define CONEXUSEXCEPT_WRITE_H

#include <conexus/except.h>
#include <cstring>

namespace Conexus
{

  class write_exception: public conexus_exception
  {
    public:
      write_exception() : conexus_exception ( "Unknown exception, write failed.",0,"write" )
      { }
      write_exception ( int e ) : conexus_exception ( strerror ( e ),e,"write" )
      { }
      write_exception ( const std::string s ) : conexus_exception ( s,0,"write" )
      { }
  };

  namespace exception
  {

    namespace write
    {

      class retry: public write_exception
      {
        public:
          retry() : write_exception ( "Unknown exception, write failed but should be retried." )
          { }
          retry ( int e ) : write_exception ( e )
          { }
          retry ( const std::string s ) : write_exception ( s )
          { }
      };

      class would_block: public retry
      {
        public:
          would_block() : retry ( EAGAIN )
          { }
      }
      ;

      class bad_fd: public write_exception
      {
        public:
          bad_fd() : write_exception ( EBADF )
          { }
      };

      class connection_reset: public write_exception
      {
        public:
          connection_reset() : write_exception ( ECONNRESET )
          { }
      };

      class destination_address_required: public write_exception
      {
        public:
          destination_address_required() : write_exception ( EDESTADDRREQ )
          { }
      };


      class invalid_user_space_address: public write_exception
      {
        public:
          invalid_user_space_address() : write_exception ( EFAULT )
          { }
      };

      class interrupted: public retry
      {
        public:
          interrupted() : retry ( EINTR )
          { }
      };


      class invalid_argument: public write_exception
      {
        public:
          invalid_argument() : write_exception ( EINVAL )
          { }
      };

      class is_connected: public write_exception
      {
        public:
          is_connected() : write_exception ( EISCONN )
          { }
      };


      class message_size: public write_exception
      {
        public:
          message_size() : write_exception ( EMSGSIZE )
          { }
      };

      class no_buffers: public retry
      {
        public:
          no_buffers() : retry ( ENOBUFS )
          { }
      };


      class no_memory: public write_exception
      {
        public:
          no_memory() : write_exception ( ENOMEM )
          { }
      };

      class permission_denied: public write_exception
      {
        public:
          permission_denied() : write_exception ( EACCES )
          { }
      };

      class not_connected: public write_exception
      {
        public:
          not_connected() : write_exception ( ENOTCONN )
          { }
      };

      class not_socket: public write_exception
      {
        public:
          not_socket() : write_exception ( ENOTSOCK )
          { }
      };


      class operation_not_supported: public write_exception
      {
        public:
          operation_not_supported() : write_exception ( EOPNOTSUPP )
          { }
      };


      class pipe: public write_exception
      {
        public:
          pipe() : write_exception ( EPIPE )
          { }
      };

      class connection_refused: public write_exception
      {
        public:
          connection_refused() : write_exception ( ECONNREFUSED )
          { }
      };

      class no_default_remote_address: public write_exception
      {
        public:
          no_default_remote_address() : write_exception ( "Socket cannot send because a default remote address has not been set." )
          { }
      };

      class no_sendto_without_address: public write_exception
      {
        public:
          no_sendto_without_address() : write_exception ( "Socket is not capable of sendto without an address." )
          { }
      };

      class not_opened: public write_exception
      {
        public:
          not_opened() : write_exception ( "Trying to write on I/O that cannot open." )
          { }
      };

      class read_only: public write_exception
      {
        public:
          read_only() : write_exception ( "Trying to write to a read only I/O." )
          { }
      };

      class timeout: public retry
      {
        public:
          timeout() : retry ( ETIMEDOUT )
          { }
      };

      class disconnected: public write_exception
      {
        public:
          disconnected() : write_exception ( "Trying to write from a socket where the peer has performed an orderly shutdown." )
          { }
      };




    }

  }

}

#endif // CONEXUSSEND_ERROR_H