except_open.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_OPEN_H
#define CONEXUSEXCEPT_OPEN_H

#include <conexus/except.h>

namespace Conexus
{

  class open_exception: public conexus_exception
  {
    public:
      open_exception ( int e = 0 ) : conexus_exception ( ::strerror ( e ), e, "open" )
      { }
      open_exception ( const std::string s, int e = 0 ) : conexus_exception ( ::strerror ( e ), e, "open" )
      { }
  };

  namespace exception
  {


    namespace open
    {

      class protocol_not_supported: public open_exception
      {
        public:
          protocol_not_supported() : open_exception ( "The protocol type or the specified protocol is not supported within this domain.", EPROTONOSUPPORT )
          { }
      };

      class af_not_supported: public open_exception
      {
        public:
          af_not_supported() : open_exception ( "The implementation does not support the specified address family.", EAFNOSUPPORT )
          { }
      };

      class system_file: public open_exception
      {
        public:
          system_file() : open_exception ( "The system limit on the total number of open files has been reached.", ENFILE )
          { }
      };

      class process_file: public open_exception
      {
        public:
          process_file() : open_exception ( "The process already has the maximum number of files open.", EMFILE )
          { }
      };

      class access: public open_exception
      {
        public:
          access() : open_exception ( "Permission to access the file or create a socket of the specified type and/or protocol is denied.", EACCES )
          { }
      };

      class no_memory: public open_exception
      {
        public:
          no_memory() : open_exception ( "Insufficient memory is available. The socket cannot be created until sufficient resources are freed.", ENOBUFS )
          { }
      };

      class invalid_protocol: public open_exception
      {
        public:
          invalid_protocol() : open_exception ( "Unknown protocol, or protocol family not available.", EINVAL )
          { }
      };

      class exists: public open_exception
      {
        public:
          exists() : open_exception ( "File already exists and O_CREAT and O_EXCL were used.", EEXIST )
          { }
      };

      class fault: public open_exception
      {
        public:
          fault() : open_exception ( "File path points outside your accessible address space.", EFAULT )
          { }
      };

      class is_directory: public open_exception
      {
        public:
          is_directory() : open_exception ( "Pathname refers to a directory and the access requested involved writing (that is, O_WRONLY or O_RDWR is set).", EISDIR )
          { }
      };

      class loop: public open_exception
      {
        public:
          loop() : open_exception ( "Too many symbolic links were encountered in resolving pathname, or O_NOFOLLOW was specified but pathname was a symbolic link.", ELOOP )
          { }
      };

      class name_too_long: public open_exception
      {
        public:
          name_too_long() : open_exception ( "Pathname was too long.", ENAMETOOLONG )
          { }
      };

      class no_device: public open_exception
      {
        public:
          no_device() : open_exception ( "pathname refers to a device special file and no corresponding device exists.", ENODEV )
          { }
      };

      class no_exist: public open_exception
      {
        public:
          no_exist() : open_exception ( "O_CREAT  is  not  set and the named file does not exist.  Or, a directory component in pathname does not exist or is a dangling symbolic link.", ENOENT )
          { }
      };

      class no_space: public open_exception
      {
        public:
          no_space() : open_exception ( "pathname was to be created but the device containing pathname has no room for the new file.", ENOSPC )
          { }
      };

      class not_directory: public open_exception
      {
        public:
          not_directory() : open_exception ( "A component used as a directory in pathname is not, in fact, a directory, or O_DIRECTORY was specified and pathname was  not  a directory.", ENOTDIR )
          { }
      };

      class no_io: public open_exception
      {
        public:
          no_io() : open_exception ( "O_NONBLOCK  | O_WRONLY is set, the named file is a FIFO and no process has the file open for reading.  Or, the file is a device special file and no corresponding device exists.", ENXIO )
          { }
      };

      class file_too_large: public open_exception
      {
        public:
          file_too_large() : open_exception ( "pathname refers to a regular file, too large to be opened; see O_LARGEFILE above.", EOVERFLOW )
          { }
      };

      class no_permission: public open_exception
      {
        public:
          no_permission() : open_exception ( "The O_NOATIME flag was specified, but the effective user ID of the caller did not match the owner of the file  and  the  caller was not privileged (CAP_FOWNER).", EPERM )
          { }
      };

      class read_only: public open_exception
      {
        public:
          read_only() : open_exception ( "pathname refers to a file on a read-only filesystem and write access was requested.", EROFS )
          { }
      };

      class executable_busy: public open_exception
      {
        public:
          executable_busy() : open_exception ( "pathname refers to an executable image which is currently being executed and write access was requested.", ETXTBSY )
          { }
      };

      class would_block: public open_exception
      {
        public:
          would_block() : open_exception ( "The O_NONBLOCK flag was specified, and an incompatible lease was held on the file.", EWOULDBLOCK )
          { }
      };

      class no_device_set: public open_exception
      {
        public:
          no_device_set() : open_exception ( "open requested and device not available or not set.", -1 )
          { }
      };

      class no_filename: public open_exception
      {
        public:
          no_filename() : open_exception ( "open requested on file, but filename not set or file not found.", -1 )
          { }
      };

      class invalid_file_mode: public open_exception
      {
        public:
          invalid_file_mode() : open_exception ( "open requested on file, but the file's mode is invalid. It should at least be either Conexus::FILE_READ or Conexus::FILE_WRITE.", -1 )
          { }
      };

      class no_rd_wr_rdwr: public open_exception
      {
        public:
          no_rd_wr_rdwr() : open_exception ( "open requires read, write or read/write mode, but none was given", -1 )
          { }
      };

      class set_nonblock_failed: public open_exception
      {
        public:
          set_nonblock_failed() : open_exception ( "File or socket requires non-blocking I/O and setting non-block mode failed", -1 )
          { }
      };

    }


  }
}

#endif // CONEXUSCREATE_ERROR_H