.. _program_listing_file_src_sparsebase_utils_exception.h:

Program Listing for File exception.h
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_sparsebase_utils_exception.h>` (``src/sparsebase/utils/exception.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*******************************************************
    * Copyright (c) 2022 SparCity, Amro Alabsi Aljundi, Taha Atahan Akyildiz, Arda
    *Sener All rights reserved.
    *
    * This file is distributed under MIT license.
    * The complete license agreement can be obtained at:
    * https://sparcityeu.github.io/sparsebase/pages/license.html
    ********************************************************/
   #ifndef SPARSEBASE_SPARSEBASE_UTILS_EXCEPTION_H_
   #define SPARSEBASE_SPARSEBASE_UTILS_EXCEPTION_H_
   
   #include <exception>
   #include <iostream>
   #include <typeindex>
   #include <vector>
   
   #include "sparsebase/config.h"
   
   namespace sparsebase {
   
   namespace utils {
   
   class Exception : public std::exception {};
   
   class InvalidDataMember : public Exception {
     std::string msg_;
   
    public:
     InvalidDataMember(const std::string &f, const std::string &dm)
         : msg_(std::string("Format ") + f + std::string(" does not have ") + dm +
                std::string(" as a data member.")) {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class DemangleException : public Exception {
     int status_;
   
    public:
     DemangleException(int status) : status_(status) {}
     virtual const char *what() const throw() {
       if (status_ == -1) {
         return "A memory allocation failiure occurred.";
       } else if (status_ == -2) {
         return "mangled_name is not a valid name under the C++ ABI mangling "
                "rules.";
       } else {
         return "Unknown failure in demangling.";
       }
     }
   };
   
   class ReorderException : public Exception {
     std::string msg_;
   
    public:
     ReorderException(const std::string &msg) : msg_(msg) {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class ReaderException : public Exception {
     std::string msg_;
   
    public:
     ReaderException(const std::string &msg) : msg_(msg) {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class WriterException : public Exception {
     std::string msg_;
   
    public:
     WriterException(const std::string &msg) : msg_(msg) {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class TypeException : public Exception {
     std::string msg_;
   
    public:
     TypeException(const std::string &msg) : msg_(msg) {}
     TypeException(const std::string &type1, const std::string &type2)
         : msg_("Object is of type " + type1 + " not " + type2) {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class ConversionException : public Exception {
     std::string msg_;
   
    public:
     ConversionException(const std::string &type1, const std::string &type2)
         : msg_("Can not convert type " + type1 + " to " + type2) {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   template <typename KeyType>
   std::string ListOfKeysToString(KeyType vec) {
     static_assert(
         std::is_same<KeyType, std::vector<std::type_index>>::value,
         "Cannot make a string of keys of other types than vector<type_index>");
     std::string output = "[";
     for (auto ti : vec) {
       output += std::string(ti.name()) + ", ";
     }
     output = output.substr(0, output.size() - 2);
     output += "]";
     return output;
   }
   
   template <typename T>
   class AttemptToReset : public Exception {
    public:
     std::string msg_;
     AttemptToReset() {
       msg_ = "Attempting to reset a variable of type " +
              std::string(std::type_index(typeid(T)).name()) +
              " that is only settable once";
     }
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   template <typename KeyType>
   class DirectExecutionNotAvailableException : public Exception {
    public:
     KeyType used_format_;
     std::vector<KeyType> available_formats_;
     std::string msg_;
     DirectExecutionNotAvailableException(
         const KeyType &used_format, const std::vector<KeyType> &available_formats)
         : used_format_(used_format), available_formats_(available_formats) {
       msg_ = "Preprocessing could not be used directly using input formats:\n " +
              ListOfKeysToString(used_format_) +
              "\nThis class can only be used with the following formats:\n ";
       for (auto format_ti : available_formats_) {
         msg_ += ListOfKeysToString(format_ti) + "\n ";
       }
     }
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class FunctionNotFoundException : public Exception {
     std::string msg_;
   
    public:
     FunctionNotFoundException(std::string message) : msg_(message) {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class NoConverterException : public Exception {
     std::string msg_;
   
    public:
     NoConverterException()
         : msg_(
               "Attempting to convert a format in a preprocessing object that "
               "does not have a Converter") {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class FeatureException : public Exception {
     std::string msg_;
   
    public:
     FeatureException(const std::string feature, const std::string extractor)
         : msg_("ERROR! " + feature + " is not registered in " + extractor + "!") {
     }
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class FeatureParamsException : public Exception {
     std::string msg_;
   
    public:
     FeatureParamsException(const std::string feature, const std::string type)
         : msg_("ERROR! " + feature + " do not store params for " + type + "!") {}
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class CUDADeviceException : public Exception {
     std::string msg_;
   
    public:
     CUDADeviceException(const int available_devices, const int requested_device) {
       msg_ = "Attempting to use CUDA device " + std::to_string(requested_device) +
              " when only " + std::to_string(available_devices) +
              " CUDA devices are available\n";
     }
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   class AllocationException : public Exception {
     std::string msg_;
   
    public:
     AllocationException() { msg_ = "Memory Allocation Operation Failed"; }
     virtual const char *what() const throw() { return msg_.c_str(); }
   };
   
   }  // namespace utils
   
   }  // namespace sparsebase
   
   #endif  // SPARSEBASE_SPARSEBASE_UTILS_EXCEPTION_H_