exceptions.h

/* Copyright (C) 2019-2020 IBM Corp.
 * This program is 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. See accompanying LICENSE file.
 */
 
// Header guard
#ifndef HELIB_EXCEPTIONS_H
#define HELIB_EXCEPTIONS_H
 
#include <exception>
#include <stdexcept>
#include <sstream>
 
/* @namespace helib*/
namespace helib {
 
class Exception
{
public:
  virtual ~Exception() = default;
  virtual const char* what() const noexcept = 0;
 
protected:
  Exception() = default;
};
 
class LogicError : public std::logic_error, public ::helib::Exception
{
public:
  explicit LogicError(const std::string& what_arg) :
      std::logic_error(what_arg){};
  explicit LogicError(const char* what_arg) : std::logic_error(what_arg){};
  virtual ~LogicError(){};
  virtual const char* what() const noexcept override
  {
    return std::logic_error::what();
  };
};
 
class OutOfRangeError : public std::out_of_range, public ::helib::Exception
{
public:
  explicit OutOfRangeError(const std::string& what_arg) :
      std::out_of_range(what_arg){};
  explicit OutOfRangeError(const char* what_arg) :
      std::out_of_range(what_arg){};
  virtual ~OutOfRangeError(){};
  virtual const char* what() const noexcept override
  {
    return std::out_of_range::what();
  };
};
 
class RuntimeError : public std::runtime_error, public ::helib::Exception
{
public:
  explicit RuntimeError(const std::string& what_arg) :
      std::runtime_error(what_arg){};
  explicit RuntimeError(const char* what_arg) : std::runtime_error(what_arg){};
  virtual ~RuntimeError(){};
  virtual const char* what() const noexcept override
  {
    return std::runtime_error::what();
  };
};
 
class IOError : public helib::RuntimeError
{
public:
  explicit IOError(const std::string& what_arg) : RuntimeError(what_arg){};
  explicit IOError(const char* what_arg) : RuntimeError(what_arg){};
  virtual ~IOError(){};
  virtual const char* what() const noexcept override
  {
    return std::runtime_error::what();
  };
};
 
class InvalidArgument : public std::invalid_argument, public ::helib::Exception
{
public:
  explicit InvalidArgument(const std::string& what_arg) :
      std::invalid_argument(what_arg){};
  explicit InvalidArgument(const char* what_arg) :
      std::invalid_argument(what_arg){};
  virtual ~InvalidArgument(){};
  virtual const char* what() const noexcept override
  {
    return std::invalid_argument::what();
  };
};
 
} // namespace helib
#endif // End of header guard