exceptions.hpp

#ifndef EXC_TRFILE_H
#define EXC_TRFILE_H

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


class super_Matrix_Invalid_request: public std::exception{
    const char* msg;
public:
    explicit super_Matrix_Invalid_request(const char* m): msg(m){};
    const char* what()  const throw (){return msg;};
};

class E_invalid_pencil: public std::exception{
public:
    std::string name;
    std::string H_name;

    explicit E_invalid_pencil(const std::string& p,
                          const std::string& h): name(p), H_name(h){};
    ~E_invalid_pencil() throw() {};

    const char* what() const throw(){
    return "Hamiltonian does not accept his own pencil.\n";
    };
};

class E_dft_error{
public:
    const char* message;
    
    explicit E_dft_error(char* m):message(m){};    
    ~E_dft_error(){};

    const char* what() const throw() { return message;};
    
};

class E_invalid_param_value: public std::exception{
public:    
    const char* Object_name;
    std::string Param_name;

    explicit E_invalid_param_value(const std::string& pn, const char* on): 
    Object_name(on), Param_name(pn){};
    ~E_invalid_param_value() throw() {};
    const char* what() const throw(){
    return "Invalid Parameter value.\n";
    };
};

class E_invalid_dynamic_cast: public std::exception{
public:    
    const char* Object_name;
    std::string Param_name;

    explicit E_invalid_dynamic_cast(const std::string& s, const char* on): 
    Object_name(on), Param_name(s){};
    ~E_invalid_dynamic_cast() throw() {};
    const char* what() const throw(){
    return "Essential Parameter missing.\n";
    };
};

class E_missing_parameter: public std::exception{
public:
    const char* Object_name;
    std::string Param_name;

    explicit E_missing_parameter(const std::string& pn, const char* on): 
    Object_name(on), Param_name(pn){
        std::cerr << "Missing parameter : " << pn << ' ' << on << '\n';
    };
    ~E_missing_parameter() throw() {};
    const char* what() const throw(){
        std::cerr << "Parameter "<< Param_name <<" missing on " << Object_name << "\n";
    return "Essential Parameter missing.\n";
    };
};

class E_missing_XML_attribute: public std::exception{
public:
    const std::string key;

    explicit E_missing_XML_attribute(const std::string& k): 
    key(k) {};
    ~E_missing_XML_attribute() throw() {};
    const char* what() const throw(){
    return "XML attribute missing.\n";
    };
};

class E_double_XML_name: public std::exception{
public:
    const std::string name;

    explicit E_double_XML_name(const std::string& k): 
    name(k) {};
    ~E_double_XML_name() throw() {};
    const char* what() const throw(){
    return "Same XML object name used twice.\n";
    };
};

class E_XML_mixup: public std::exception{
public:
    const std::string section;
    explicit E_XML_mixup(const std::string& s): 
    section(s) {};
    ~E_XML_mixup() throw() {};
    const char* what() const throw(){
    return "XML Section \"object\" unexpected.\n";
    };
};

class E_XML_unknown: public std::exception{
public:
    const std::string section;
    explicit E_XML_unknown(const std::string& s): 
    section(s) {};
    ~E_XML_unknown() throw() {};
    const char* what() const throw(){
    return "XML object unknown.\n";
    };
};

class E_unknown_typename: public std::exception{
public:
    std::string type_name;
    explicit E_unknown_typename(const std::string& tn):type_name(tn){};
    ~E_unknown_typename() throw() {};
    const char* what() const throw(){
    return "Typename identifier not known!\n";
    };
};

class E_circular_reference: public std::exception{
public:
    std::string obj_class;
    explicit E_circular_reference(const std::string& tn):obj_class(tn){};
    ~E_circular_reference() throw() {};
    const char* what() const throw(){
    return "Circular reference in object dependencies!\n";
    };
};

class E_Bad_Size: public std::exception{
public:
    int index;
    explicit E_Bad_Size(const int i): index(i){};
    const char* what() const throw (){return "Size missmatch in Matrix operation!";};
};

class E_already_connected: public std::exception{
public:
    int index;
    explicit E_already_connected(const int i): index(i){};
    const char* what() const throw (){return "Tried to connect twice, module already connected!";};
};

class E_Is_Leaf: public std::exception{
public:
    explicit E_Is_Leaf(){};
    const char* what() const throw (){return "Rectangle does not contain Rectangle Parts!";};
};

class E_Is_No_Leaf: public std::exception{
public:
    explicit E_Is_No_Leaf(){};
    const char* what()  const throw (){return "Rectangle does not contain Hamiltonian!";};
};

class E_Not_ready: public std::exception{
public:
    const char* object;

    explicit E_Not_ready(const char* c):object(c){};
    const char* what()  const throw (){return "Object not initialized!";};
};

class E_unknown_command: public std::exception{
    std::string k;
 public:
    E_unknown_command(const std::string& s):k(s){};
    ~E_unknown_command() throw() {};
    char const *what() const throw() {return "The provided command is unknown.";};
    const std::string& Command_name() const throw() {return k;};
};

class E_syntax_error: public std::exception{
 public:
    E_syntax_error(){};
    ~E_syntax_error() throw() {};
    char const *what() const throw() {return "Syntax error!";};
};

class E_incompatible_average: public std::exception{
    std::string k;
 public:
    E_incompatible_average(const std::string& s):k(s){};
    ~E_incompatible_average() throw() {};
    char const *what() const throw() {return "The average over these two datasets is impossible.";};
    const std::string& H_name() const throw() {return k;};
};

class E_unknown_H: public std::exception{
    std::string k;
 public:
    E_unknown_H(const std::string& s):k(s){};
    ~E_unknown_H() throw() {};
    char const *what() const throw() {return "The provided Hamiltonian is unknown.";};
    const std::string& H_name() const throw() {return k;};
};

class E_key_not_found: public std::exception{
    std::string k;
 public:
    E_key_not_found(const std::string& s):k(s){};
    ~E_key_not_found() throw() {};
    char const *what() const throw() {return "The provided key was not found.";};
    const std::string& key_name() const throw() {return k;};
};

class E_invalid_filename: public std::exception{
    std::string k;
 public:
    E_invalid_filename(const std::string& s):k(s){};
    ~E_invalid_filename() throw() {};
    char const *what() const throw() {return "The provided filename is invalid.";};
    const std::string& filename() const throw() {return k;};
};

class E_uninintialized_Rect: public std::exception{
    int k;
 public:
    E_uninintialized_Rect(const int i):k(i){};
    ~E_uninintialized_Rect() throw() {};
    char const *what() const throw() {return "The Rectangle is uninizialised.";};
    int Rect_Nr() const throw() {return k;};
};

class E_invalid_TRfile: public std::exception{
 public:
    E_invalid_TRfile(){};
    ~E_invalid_TRfile() throw() {};
    char const *what() const throw() {return "The provided TRfile could not be loaded.";};
};

class E_bad_index: public std::exception{
 public:
    int index;
    E_bad_index():index(0){};
    E_bad_index(const int i):index(i){};
    ~E_bad_index() throw() {};
    char const *what() const throw() {return "The provided index is out of range.";};
};

class E_bad_range_string: public std::exception{
    std::string k;
 public:
    E_bad_range_string(const std::string& s):k(s){};
    ~E_bad_range_string() throw() {};
    char const *what() const throw() {return "The provided range string "
                      "could not be parsed.";};
    const std::string& parse_string() const throw() {return k;};
};

class E_index_out_of_range: public std::exception{
    size_t val;
    size_t max;
public:
    E_index_out_of_range(size_t v, size_t m):val(v), max(m){};
    ~E_index_out_of_range() throw() {};
    char const *what() const throw() {return "The provided index was out of range.";};
    size_t get_val(){return val;};
    size_t get_max(){return max;};
};
    
class E_low_function_value: public std::exception{
public:
    const char* Object_name;
    std::string Param_name;

    explicit E_low_function_value(const std::string& pn, const char* on): 
    Object_name(on), Param_name(pn){};
    ~E_low_function_value() throw() {};
    const char* what() const throw(){
    return "all values are to low for this calculation.\n";
    };
};

class E_wrong_parameter_number: public std::exception{
public:
    
    explicit E_wrong_parameter_number() {};
    ~E_wrong_parameter_number() throw() {};
    const char* what() const throw(){
    return "The number of parameters in  multi_slice_hamiltonian type is badly choosen. \n\
The number of nn parameters should never exceed 15 \n\
also certain nn parameter numbers lead to a highly degenerate interaction Hamiltonian and lead to errors for greensfunction calculations \n\
for eigenstate calculation set higher nn parameters to zero \n";
    };
};

#ifndef USE_ABSTRACT_FUNCTIONS
class E_real_virtual_function: public std::exception{
public:
    const char* Object_name;
    const std::string function_name;

    explicit E_real_virtual_function(const std::string& pn, const char* on): 
    Object_name(on), function_name(pn){};
    ~E_real_virtual_function() throw() {};
    const char* what() const throw(){
    std::cerr << "The function:\n"<< function_name << "\nis not defined in \n" <<Object_name<<"\n explicitly declare it in derived class";
    return "explicitly declare it in derived class";

    };
};
#endif
#endif