Errno.hh

//********************************************************************
//*** Exceptions/Errno.hh
//*** Copyright (c) 2001 by Markus Winand <mws@fatalmind.com>
//*** $Id: Errno.hh,v 1.18 2003-05-29 20:49:34 mws Exp $
//********************************************************************

#ifndef INCLUDED_ERRNO_H
#define INCLUDED_ERRNO_H

#include <string>
//#include <memory>
#include "Exception.hh"
#include "OS_Errno.hh" // this is required to undef all the <errno.h> values

using std::string;

namespace fatalmind {

class Errno : public Exception {
    public:
        Errno(const int err=0);
        Errno(const int err, const string& fmt);
        int os_errno() const throw();
        virtual ~Errno();

        static void ThrowOnError(int err=0);
        static void Throw(int err=0);
        static void Throw(const string &fmt);
        virtual const std::string message() const throw();
        
    private:
        const int   _errno;


    public:
//  class Throw;
    /* POSIX Values */

    class E2BIG;
    class EACCES;
    class EAGAIN;
    class EBADF;
    class EBUSY;
    class ECHILD;
    class EDEADLK;
    class EDOM;
    class EEXIST;
    class EFAULT;
    class EFBIG;
    class EINTR;
    class EINVAL;
    class EIO;
    class EISDIR;
    class EMFILE;
    class EMLINK;
    class ENAMETOOLONG;
    class ENFILE;
    class ENODEV;
    class ENOENT;
    class ENOEXEC;
    class ENOLCK;
    class ENOMEM;
    class ENOSPC;
    class ENOSYS;
    class ENOTDIR;
    class ENOTEMPTY;
    class ENOTTY;
    class ENXIO;
    class EPERM;
    class EPIPE;
    class ERANGE;
    class EROFS;
    class ESPIPE;
    class ESRCH;
    class EXDEV;

    /* should be posix?? */
    class ETIMEDOUT;
};

/*
class Errno::Throw {
    public:
        Throw();
        Throw(int);
        Throw(const string&);
};
*/


class Errno::E2BIG: public Errno {
    public:
        E2BIG();
        E2BIG(const string &);
        virtual ~E2BIG();
};

class Errno::EACCES: public Errno {
    public:
        EACCES();
        EACCES(const string &);
        virtual ~EACCES();
};

class Errno::EAGAIN: public Errno {
    public:
        EAGAIN();
        EAGAIN(const string &);
        virtual ~EAGAIN();
};

class Errno::EBADF: public Errno {
    public:
        EBADF();
        EBADF(const string &);
        virtual ~EBADF();
};

class Errno::EBUSY: public Errno {
    public:
        EBUSY();
        EBUSY(const string &);
        virtual ~EBUSY();
};

class Errno::ECHILD: public Errno {
    public:
        ECHILD();
        ECHILD(const string &);
        virtual ~ECHILD();
};

class Errno::EDEADLK: public Errno {
    public:
        EDEADLK();
        EDEADLK(const string &);
        virtual ~EDEADLK();
};

class Errno::EDOM: public Errno {
    public:
        EDOM();
        EDOM(const string &);
        virtual ~EDOM();
};

class Errno::EEXIST: public Errno {
    public:
        EEXIST();
        EEXIST(const string &);
        virtual ~EEXIST();
};

class Errno::EFAULT: public Errno {
    public:
        EFAULT();
        EFAULT(const string &);
        virtual ~EFAULT();
};

class Errno::EFBIG: public Errno {
    public:
        EFBIG();
        EFBIG(const string &);
        virtual ~EFBIG();
};

class Errno::EINTR: public Errno {
    public:
        EINTR();
        EINTR(const string &);
        virtual ~EINTR();
};

class Errno::EINVAL: public Errno {
    public:
        EINVAL();
        EINVAL(const string &);
        virtual ~EINVAL();
};

class Errno::EIO: public Errno {
    public:
        EIO();
        EIO(const string &);
        virtual ~EIO();
};

class Errno::EISDIR: public Errno {
    public:
        EISDIR();
        EISDIR(const string &);
        virtual ~EISDIR();
};

class Errno::EMFILE: public Errno {
    public:
        EMFILE();
        EMFILE(const string &);
        virtual ~EMFILE();
};

class Errno::EMLINK: public Errno {
    public:
        EMLINK();
        EMLINK(const string &);
        virtual ~EMLINK();
};

class Errno::ENAMETOOLONG: public Errno {
    public:
        ENAMETOOLONG();
        ENAMETOOLONG(const string &);
        virtual ~ENAMETOOLONG();
};

class Errno::ENFILE: public Errno {
    public:
        ENFILE();
        ENFILE(const string &);
        virtual ~ENFILE();
};

class Errno::ENODEV: public Errno {
    public:
        ENODEV();
        ENODEV(const string &);
        virtual ~ENODEV();
};

class Errno::ENOENT: public Errno {
    public:
        ENOENT();
        ENOENT(const string &);
        virtual ~ENOENT();
};

class Errno::ENOEXEC: public Errno {
    public:
        ENOEXEC();
        ENOEXEC(const string &);
        virtual ~ENOEXEC();
};

class Errno::ENOLCK: public Errno {
    public:
        ENOLCK();
        ENOLCK(const string &);
        virtual ~ENOLCK();
};

class Errno::ENOMEM: public Errno {
    public:
        ENOMEM();
        ENOMEM(const string &);
        virtual ~ENOMEM();
};

class Errno::ENOSPC: public Errno {
    public:
        ENOSPC();
        ENOSPC(const string &);
        virtual ~ENOSPC();
};

class Errno::ENOSYS: public Errno {
    public:
        ENOSYS();
        ENOSYS(const string &);
        virtual ~ENOSYS();
};

class Errno::ENOTDIR: public Errno {
    public:
        ENOTDIR();
        ENOTDIR(const string &);
        virtual ~ENOTDIR();
};

class Errno::ENOTEMPTY: public Errno {
    public:
        ENOTEMPTY();
        ENOTEMPTY(const string &);
        virtual ~ENOTEMPTY();
};

class Errno::ENOTTY: public Errno {
    public:
        ENOTTY();
        ENOTTY(const string &);
        virtual ~ENOTTY();
};

class Errno::ENXIO: public Errno {
    public:
        ENXIO();
        ENXIO(const string &);
        virtual ~ENXIO();
};

class Errno::EPERM: public Errno {
    public:
        EPERM();
        EPERM(const string &);
        virtual ~EPERM();
};

class Errno::EPIPE: public Errno {
    public:
        EPIPE();
        EPIPE(const string &);
        virtual ~EPIPE();
};

class Errno::ERANGE: public Errno {
    public:
        ERANGE();
        ERANGE(const string &);
        virtual ~ERANGE();
};

class Errno::EROFS: public Errno {
    public:
        EROFS();
        EROFS(const string &);
        virtual ~EROFS();
};

class Errno::ESPIPE: public Errno {
    public:
        ESPIPE();
        ESPIPE(const string &);
        virtual ~ESPIPE();
};

class Errno::ESRCH: public Errno {
    public:
        ESRCH();
        ESRCH(const string &);
        virtual ~ESRCH();
};

class Errno::EXDEV: public Errno {
    public:
        EXDEV();
        EXDEV(const string &);
        virtual ~EXDEV();
};

class Errno::ETIMEDOUT: public Errno {
    public:
        ETIMEDOUT();
        ETIMEDOUT(const string &);
        virtual ~ETIMEDOUT();
};

}
#endif

---