ApiError.h

/*
 * Copyright (C) 2019-2025 HERE Europe B.V.
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */
 
#pragma once
 
#include <string>
#include <utility>
 
#include "ErrorCode.h"
 
#include <olp/core/CoreApi.h>
#include "olp/core/client/HttpResponse.h"
#include "olp/core/http/HttpStatusCode.h"
 
namespace olp {
namespace client {
 
class CORE_API ApiError {
 public:
  static ApiError Cancelled(const char* message = "Cancelled") {
    return {ErrorCode::Cancelled, message};
  }
 
  static ApiError NetworkConnection(const char* message = "Offline") {
    return {ErrorCode::NetworkConnection, message};
  }
 
  static ApiError PreconditionFailed(
      const char* message = "Precondition failed") {
    return {ErrorCode::PreconditionFailed, message};
  }
 
  static ApiError InvalidArgument(const char* message = "Invalid argument") {
    return {ErrorCode::InvalidArgument, message};
  }
 
  static ApiError NotFound(const char* message = "Resource not found") {
    return {ErrorCode::NotFound, message};
  }
 
  static ApiError CacheIO(const char* description = "Cache IO") {
    return {ErrorCode::CacheIO, description};
  }
 
  static ApiError Offline(const char* description = "Offline") {
    return {ErrorCode::Offline, description};
  }
 
  static ApiError Unknown(const char* message = "Unknown") {
    return {ErrorCode::Unknown, message};
  }
 
  ApiError() = default;
 
  ApiError(ErrorCode error_code, std::string message, bool is_retryable = false)
      : error_code_(error_code),
        message_(std::move(message)),
        is_retryable_(is_retryable) {
    if (error_code == ErrorCode::Cancelled) {
      http_status_code_ =
          static_cast<int>(olp::http::ErrorCode::CANCELLED_ERROR);
    }
  }
 
  ApiError(int http_status_code, std::string message = "")  // NOLINT
      : error_code_(http::HttpStatusCode::GetErrorCode(http_status_code)),
        http_status_code_(http_status_code),
        message_(std::move(message)),
        is_retryable_(http::HttpStatusCode::IsRetryable(http_status_code)) {}
 
  inline ErrorCode GetErrorCode() const { return error_code_; }
 
  inline int GetHttpStatusCode() const { return http_status_code_; }
 
  inline const std::string& GetMessage() const { return message_; }
 
  inline bool ShouldRetry() const { return is_retryable_; }
 
 private:
  // TODO: merge error_code_ and http_status_code_ by shifting ErrorCode values
  // to negatives
  ErrorCode error_code_{ErrorCode::Unknown};
  int http_status_code_{static_cast<int>(http::ErrorCode::UNKNOWN_ERROR)};
  std::string message_;
  bool is_retryable_{false};
};
 
}  // namespace client
}  // namespace olp