Exception.h

/* 
 *  Copyright 2011 Matthias Fuchs
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

#ifndef STROMX_RUNTIME_EXCEPTION_H
#define STROMX_RUNTIME_EXCEPTION_H

#include <exception>
#include <string>
#include "stromx/runtime/Config.h"

namespace stromx
{
    namespace runtime
    {
        class Data;
        
        class STROMX_RUNTIME_API Exception : public std::exception
        {
        public:
            explicit Exception(const std::string & message);
            
            virtual ~Exception() throw() {}
            
            virtual const char* what() const throw() { return m_message.c_str(); }
            
            virtual const std::string & message() const { return m_message; }
            
            virtual const std::string & callStack() const { return m_callStack; }
                        
        private:
            std::string m_message;
            std::string m_callStack;
        };  
        
        class WrongArgument : public Exception
        {
        public:
            WrongArgument(const std::string & message = "WrongArgument")
              : Exception(message)
            {}
        };  
        
        class WrongId : public WrongArgument
        {
        public:
            WrongId(const std::string & message = "WrongId")
              : WrongArgument(message)
            {}
        };  
        
        class WrongState : public Exception
        {
        public:
            WrongState(const std::string & message = "WrongState")
              : Exception(message)
            {}
        };
        
        class InternalError : public Exception
        {
        public:
            InternalError(const std::string & message = "InternalError")
              : Exception(message)
            {}
        };
        
        class Interrupt : public Exception
        {
        public:
            Interrupt(const std::string & message = "Interrupt")
            : Exception(message)
            {}
        };
        
        class FileException : public Exception
        {
        public:
            FileException(const std::string & filename, const std::string & container, 
                          const std::string & message)
              : Exception(message),
                m_filename(filename),
                m_container(container)
            {}
            
            virtual ~FileException() throw() {}
            
            const std::string & filename() const { return m_filename; }
            const std::string & container() const { return m_container; }
            
            void setContainer(const std::string & container) { m_container = container; }
            
        private:
            const std::string m_filename;
            std::string m_container;
        };
        
        class FileAccessFailed : public FileException
        {
        public:
            
            FileAccessFailed(const std::string & filename,
                             const std::string & container,
                             const std::string & message = "")
              : FileException(filename, container, message)
            {}
        };
        
        class InvalidFileFormat : public FileException
        {
        public:
            InvalidFileFormat(const std::string & filename,
                             const std::string & message)
              : FileException(filename, "", message)
            {}
            
            InvalidFileFormat(const std::string & filename,
                             const std::string & container,
                             const std::string & message)
              : FileException(filename, container, message)
            {}
        };
        
        class InconsistentFileContent : public FileException
        {
        public:
            InconsistentFileContent(const std::string & filename,
                             const std::string & message)
              : FileException(filename, "", message)
            {}
            
            InconsistentFileContent(const std::string & filename,
                             const std::string & container,
                             const std::string & message)
              : FileException(filename, container, message)
            {}
        };
        
        class OutOfMemory : public Exception
        {
        public:
            OutOfMemory(const std::string & message = "OutOfMemory")
              : Exception(message)
            {}
        };
        
        class Timeout : public Exception
        {
        public:
            Timeout(const std::string & message = "Timeout")
              : Exception(message)
            {}
        };
        
        class BadCast : public Exception
        {
        public:
            BadCast(const std::string & message = "BadCast")
              : Exception(message)
            {}
        };
        
        class NotImplemented : public Exception
        {
        public:
            NotImplemented(const std::string & message = "NotImplemented")
              : Exception(message)
            {}
        };
        
        class AccessEmpty : public Exception
        {
        public:
            AccessEmpty(const std::string & message = "AccessEmpty")
              : Exception(message)
            {}
        };
        
        class DataException : public Exception
        {
        public:
            
            virtual ~DataException() throw() {}
            
            const std::string & package() const { return m_package; }
            const std::string & type() const { return m_package; }
            
        protected:
            DataException(const std::string & package, const std::string & type,
                               const std::string & message = "DataException")
              : Exception(message),
                m_package(package),
                m_type(type)
            {}
            
        private:
            const std::string m_package;
            const std::string m_type;
        };
        
        class SerializationError : public DataException
        {
        public:
            SerializationError(const std::string & package, const std::string & type,
                               const std::string & message = "SerializationError")
              : DataException(package, type, message)
            {}
        };
        
        class DeserializationError : public DataException
        {
        public:
            DeserializationError(const std::string & package, const std::string & type,
                                 const std::string & message = "DeserializationError")
              : DataException(package, type, message)
            {}
        };
        
        class FactoryException : public Exception
        {
        public:
            
            virtual ~FactoryException() throw() {}
            
            const std::string & package() const { return m_package; }
            const std::string & type() const { return m_type; }
            
        protected:
            FactoryException(const std::string & package, const std::string & type,
                               const std::string & message = "SerializationError")
              : Exception(message),
                m_package(package),
                m_type(type)
            {}
            
        private:
            const std::string m_package;
            const std::string m_type;
        };
        
        class OperatorAllocationFailed : public FactoryException
        {
        public:
            OperatorAllocationFailed(const std::string & package, const std::string & type,
                                     const std::string & message = "OperatorAllocationFailed")
              : FactoryException(package, type, message)
            {}
        };
        
        class DataAllocationFailed : public FactoryException
        {
        public:
            DataAllocationFailed(const std::string & package, const std::string & type,
                                 const std::string & message = "DataAllocationFailed")
              : FactoryException(package, type, message)
            {}
        };
        
        class NoInputFile : public Exception
        {
        public:
            NoInputFile(const std::string & message = "NoInputFile")
              : Exception(message)
            {}
        };     
    }
}

#endif // STROMX_RUNTIME_EXCEPTION_H