Exceptions.h

Go to the documentation of this file.

//
// C++ Interface: Audio::Codec
//
#ifndef __AUDIO_EXCEPTIONS_H__INCLUDED__
#define __AUDIO_EXCEPTIONS_H__INCLUDED__

#include <string>
#include <exception>
#include "Format.h"

namespace Audio {

    class Exception : public std::exception
    {
    private:
        std::string _message;
        
    public:
        Exception() {};
        Exception(const Exception &other) : _message(other._message) {}
        explicit Exception(const std::string &message) : _message(message) {}
        virtual ~Exception() throw() {}
        virtual const char* what() const throw() { return _message.c_str(); }
    };
    
    class FileOpenException : public Exception {
    public:
        FileOpenException() {}
        FileOpenException(const FileOpenException &other) : Exception(other) {}
        explicit FileOpenException(const std::string &message) : Exception(message) {}
    };
    
    class CodecNotFoundException : public Exception {
    public:
        CodecNotFoundException() {}
        CodecNotFoundException(const CodecNotFoundException &other) : Exception(other) {}
        explicit CodecNotFoundException(const std::string &message) : Exception(message) {}
    };
    
    class FileFormatException : public Exception {
    public:
        FileFormatException() {}
        FileFormatException(const FileFormatException &other) : Exception(other) {}
        explicit FileFormatException(const std::string &message) : Exception(message) {}
    };
    
    class EndOfStreamException : public Exception {
    public:
        EndOfStreamException() {}
        EndOfStreamException(const EndOfStreamException &other) : Exception(other) {}
        explicit EndOfStreamException(const std::string &message) : Exception(message) {}
    };
    
    class CorruptStreamException : public Exception {
        bool fatal;
    public:
        CorruptStreamException(const CorruptStreamException &other) : Exception(other) {}
        explicit CorruptStreamException(bool _fatal) 
            : Exception(fatal ? "Fatal corruption on stream" : "Recoverable corruption on stream"),
              fatal(_fatal) 
        {}
        
        bool isFatal() const { return fatal; }
    };
    
    class ResourceNotLoadedException : public Exception {
    public:
        ResourceNotLoadedException() {}
        ResourceNotLoadedException(const ResourceNotLoadedException &other) : Exception(other) {}
        explicit ResourceNotLoadedException(const std::string &message) : Exception(message) {}
    };
    
    class ResourceAlreadyLoadedException : public Exception {
    public:
        ResourceAlreadyLoadedException() {}
        ResourceAlreadyLoadedException(const ResourceAlreadyLoadedException &other) : Exception(other) {}
        explicit ResourceAlreadyLoadedException(const std::string &message) : Exception(message) {}
    };
    
    class InvalidParametersException : public Exception {
    public:
        InvalidParametersException() {}
        InvalidParametersException(const InvalidParametersException &other) : Exception(other) {}
        explicit InvalidParametersException(const std::string &message) : Exception(message) {}
    };
    
    class DuplicateObjectException : public Exception {
    public:
        explicit DuplicateObjectException(const std::string &name) : 
            Exception(std::string("Object with name \"") + name + "\" already existed") {}
    };
    
    class NotFoundException : public Exception {
    public:
        explicit NotFoundException(const std::string &name) : 
            Exception(std::string("Object with name \"") + name + "\" does not exist") {}
    };
    
    class NotImplementedException : public Exception {
    public:
        explicit NotImplementedException(const std::string &name) : 
            Exception(name + " has not been implemented yet") {}
    };
    
    class UnsupportedFormatException : public Exception {
        Format format;
    public:
        explicit UnsupportedFormatException(const std::string &where, const Format &fmt) : 
            Exception(std::string("Unsupported format (" + where + ")")),
            format(fmt)
        {}
        
        const Format& getFormat() const throw() { return format; }
    };

    class OutOfMemoryException : public Exception {
    public:
        OutOfMemoryException() {}
    };

};

#endif//__AUDIO_EXCEPTIONS_H__INCLUDED__