UAPException.hpp

/*
 * UAP Exception
 * Universal Accelerator Parser
 * Copyright (C) 2005, 2006 Daniel Bates, David Sagan
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version. 
 * 
 * This 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 Lesser General Public License
 * for more details. 
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc., 
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * 
 * Direct questions, comments, etc to:
 * Daniel Bates (dbates@lbl.gov)
 * David Sagan (dcs16@cornell.edu)
 */

#ifndef UAPException_hpp
#define UAPException_hpp 1

#include <iostream>
#include <sstream>
#include <string>
#include <exception>

class UAPNode;

class UAPException : public std::exception {
    
public:
    
    UAPException(const std::string& _message = "Unspecified exception");
    
    UAPException(const std::string& _message, const UAPException& _cause);
    
    virtual ~UAPException() throw();
    
    std::string getMessage() const;
    
    UAPException* getCause() const;
    
    void printStackTrace(std::ostream& _file = std::cerr);
    
    virtual std::string toString() const;
    
    friend std::ostream& operator << (std::ostream& os, const UAPException& except);
    friend std::ostream& operator << (std::ostream& os, const UAPException* except);
    
private:
    
    std::string message;
    
    UAPException* cause;

};

class UAPIOException : public UAPException {
    
public:
    
    UAPIOException(const std::string& _message = "Unspecified exception", 
                   const std::string& _file = "Unspecified file name", 
                   int _line = 0);
    
    UAPIOException(const std::string& _message, 
                   const std::string& _file, 
                   int _line, const UAPException& _cause);
    
    ~UAPIOException() throw();
    
    std::string getFile() const;
    
    int getLineNumber() const;
    
    std::string toString() const;
    
private:
        
    std::string file;
    
    int line;
};

class UAPNodeException : public UAPException {
    
public:
    
    UAPNodeException(const std::string& _message = "Unspecified exception", UAPNode* _node = NULL);
    
    UAPNodeException(const std::string& _message, UAPNode* _node, const UAPException& _cause);

    ~UAPNodeException() throw();
    
    UAPNode* getNode();
    
    std::string toString() const;
    
private:
    
    UAPNode* node;
    
};

class UAPParserException : public UAPException {
    
public:
    
    UAPParserException(const std::string& _message = "Unspecified exception");
    
    UAPParserException(const std::string& _message, const UAPException& _cause);
    
    ~UAPParserException() throw();

};

class UAPNotRecognizedException : public UAPParserException {

public:
    
    UAPNotRecognizedException(const std::string& _message = "Unspecified exception");
    
    UAPNotRecognizedException(const std::string& _message, const UAPException& _cause);
    
    ~UAPNotRecognizedException() throw();

};

class UAPBeamlineExpansionFailedException : public UAPException {
    
public:
    
    UAPBeamlineExpansionFailedException(const std::string& _message = "Unspecified exception");
    
    UAPBeamlineExpansionFailedException(const std::string& _message, const UAPException& _cause);
    
    ~UAPBeamlineExpansionFailedException() throw();

};

class UAPInvalidExpressionException : public UAPParserException {
    
public:

    UAPInvalidExpressionException(const std::string& _message = "Unspecified exception");
    
    UAPInvalidExpressionException(const std::string& _message, const UAPException& _cause);
    
    ~UAPInvalidExpressionException() throw();

};

class UAPParameterNotFoundException : public UAPException {

public:

    UAPParameterNotFoundException(const std::string& _message = "Unspecified exception");
    
    UAPParameterNotFoundException(const std::string& _message, const UAPException& _cause);
    
    ~UAPParameterNotFoundException() throw();

};

class UAPNotSupportedException: public UAPException {

public:
    
    UAPNotSupportedException(const std::string& _message = "Unspecified exception");
    
    UAPNotSupportedException(const std::string& _message, const UAPException& _cause);
    
    ~UAPNotSupportedException() throw();
    
};

class UAPFileCouldNotBeOpened: public UAPIOException {
    
public:
    
    UAPFileCouldNotBeOpened(const std::string& _message = "Unspecified exception", 
                            const std::string& _file = "Unspecified file name", 
                            int _line = 0);
    
    UAPFileCouldNotBeOpened(const std::string& _message, 
                            const std::string& _file, int _line, const UAPException& _cause);
    
    ~UAPFileCouldNotBeOpened() throw();
    
};

class UAPAttributeNotFound: public UAPNodeException {

public:

    UAPAttributeNotFound(const std::string& _message = "Unspecified exception", UAPNode* _node = NULL);
    
    UAPAttributeNotFound(const std::string& _message, UAPNode* _node, const UAPException& _cause);    
    
    ~UAPAttributeNotFound() throw();

};

class UAPAttributeConfusion: public UAPNodeException {

public:
    
    UAPAttributeConfusion(const std::string& _message = "Unspecified exception", UAPNode* _node = NULL);
    
    UAPAttributeConfusion(const std::string& _message, UAPNode* _node, const UAPException& _cause);
    
    ~UAPAttributeConfusion() throw();

};

class UAPBadAttributeValue: public UAPNodeException {
    
public:
    
    UAPBadAttributeValue(const std::string& _message = "Unspecified exception", UAPNode* _node = NULL);
    
    UAPBadAttributeValue(const std::string& _message, UAPNode* _node, const UAPException& _cause);
    
    ~UAPBadAttributeValue() throw();

};

class UAPNodeNotFound: public UAPNodeException {

public:

    UAPNodeNotFound(const std::string& _message = "Unspecified exception", UAPNode* _node = NULL);
    
    UAPNodeNotFound(const std::string& _message, UAPNode* _node, const UAPException& _cause);
    
    ~UAPNodeNotFound() throw();

};


#endif

---