exceptions.hpp

/*
 *  Licensed under the MIT License <http://opensource.org/licenses/MIT>.
 *  SPDX-License-Identifier: MIT
 *
 *  Copyright (c) 2020-2022 Bhumit Attarde
 *
 *  Permission is hereby  granted, free of charge, to any  person obtaining a
 * copy of this software and associated  documentation files (the "Software"),
 * to deal in the Software  without restriction, including without  limitation
 * the rights to  use, copy,  modify, merge,  publish, distribute,  sublicense,
 * and/or  sell copies  of  the Software,  and  to  permit persons  to  whom the
 * Software  is furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS
 * OR IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN
 * NO EVENT  SHALL THE AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY
 * CLAIM,  DAMAGES OR  OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT
 * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
#pragma once
 
#include <exception>
#include <string>
#include <utility>
 
namespace kiteconnect {
 
using std::string;
 
class kiteppException : public std::exception {
 
  public:
    kiteppException(int Code_, string Message_)
        : Code(Code_), Message(std::move(Message_)) {};
 
    [[nodiscard]] const char* what() const noexcept override = 0;
 
    [[nodiscard]] int code() const noexcept { return Code; };
 
    [[nodiscard]] const char* message() const noexcept {
        return Message.c_str();
    };
 
  private:
    int Code = 0;
    string Message;
};
 
class tokenException : public kiteppException {
 
  public:
    tokenException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "TokenException was thrown by Kite";
    };
};
 
class userException : public kiteppException {
 
  public:
    userException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "UserException was thrown by Kite";
    };
};
 
class orderException : public kiteppException {
 
  public:
    orderException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "OrderException was thrown by Kite";
    };
};
 
class inputException : public kiteppException {
 
  public:
    inputException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "InputException was thrown by Kite";
    };
};
 
class networkException : public kiteppException {
 
  public:
    networkException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "NetworkException was thrown by Kite";
    };
};
 
class dataException : public kiteppException {
 
  public:
    dataException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "DataException was thrown by Kite";
    };
};
 
class generalException : public kiteppException {
 
  public:
    generalException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "GeneralException was thrown by Kite";
    };
};
 
class permissionException : public kiteppException {
 
  public:
    permissionException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "PermissionException was thrown by Kite";
    };
};
 
class unknownException : public kiteppException {
 
  public:
    unknownException(int code, string message)
        : kiteppException(code, std::move(message)) {};
 
    [[nodiscard]] const char* what() const noexcept override {
        return "unknown exception was thrown by Kite";
    };
};
 
class libException : public std::exception {
 
  public:
    explicit libException(string Message): message(std::move(Message)) {};
 
    const char* what() { return message.c_str(); };
 
  private:
    string message;
};
 
namespace internal {
inline void throwException(
    const string& exceptionString, int code, const string& msg) {
    // exception strings sent by API
    static const string tokenExceptionString = "TokenException";
    static const string userExceptionString = "UserException";
    static const string orderExcptionString = "OrderException";
    static const string inputExceptionString = "InputException";
    static const string networkExceptionString = "NetworkException";
    static const string dataExceptionString = "DataException";
    static const string generalExceptionString = "GeneralException";
    static const string permissionExceptionString = "PermissionException";
 
    // when rest api doesn't send an exception but http status code isn't 200
    // either
    static const string unknownExceptionString = "NoException";
 
    if (exceptionString == tokenExceptionString) {
        throw tokenException(code, msg);
    };
    if (exceptionString == userExceptionString) {
        throw userException(code, msg);
    };
    if (exceptionString == orderExcptionString) {
        throw orderException(code, msg);
    };
    if (exceptionString == inputExceptionString) {
        throw inputException(code, msg);
    };
    if (exceptionString == networkExceptionString) {
        throw networkException(code, msg);
    };
    if (exceptionString == dataExceptionString) {
        throw dataException(code, msg);
    };
    if (exceptionString == generalExceptionString) {
        throw generalException(code, msg);
    };
    if (exceptionString == permissionExceptionString) {
        throw permissionException(code, msg);
    };
    if (exceptionString == unknownExceptionString) {
        throw unknownException(code, msg);
    };
 
    throw libException("unknown exception was thrown by REST API");
};
} // namespace internal
 
} // namespace kiteconnect