HttpResponse.h

/*
 * Copyright (C) 2019-2024 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 <sstream>
#include <string>
#include <utility>
#include <vector>
 
#include <olp/core/CoreApi.h>
#include <olp/core/http/NetworkTypes.h>
 
namespace olp {
namespace client {
 
class NetworkStatistics {
 public:
  NetworkStatistics() = default;
 
  NetworkStatistics(uint64_t bytes_uploaded, uint64_t bytes_downloaded)
      : bytes_uploaded_{bytes_uploaded}, bytes_downloaded_{bytes_downloaded} {}
 
  uint64_t GetBytesUploaded() const { return bytes_uploaded_; }
 
  uint64_t GetBytesDownloaded() const { return bytes_downloaded_; }
 
  NetworkStatistics& operator+=(const NetworkStatistics& other) {
    bytes_uploaded_ += other.bytes_uploaded_;
    bytes_downloaded_ += other.bytes_downloaded_;
    return *this;
  }
 
  NetworkStatistics operator+(const NetworkStatistics& other) const {
    NetworkStatistics statistics(*this);
    statistics += other;
    return statistics;
  }
 
 private:
  uint64_t bytes_uploaded_{0};
  uint64_t bytes_downloaded_{0};
};
 
class CORE_API HttpResponse {
 public:
  HttpResponse() = default;
  virtual ~HttpResponse() = default;
 
  HttpResponse(int status, std::string response = {})  // NOLINT
      : status_(status), response_(std::move(response)) {}
 
  HttpResponse(int status, std::stringstream&& response)
      : status_(status), response_(std::move(response)) {}
 
  HttpResponse(int status, std::stringstream&& response, http::Headers headers)
      : status_(status),
        response_(std::move(response)),
        headers_(std::move(headers)) {}
 
  HttpResponse(const HttpResponse& other)
      : status_(other.status_), headers_(other.headers_) {
    response_ << other.response_.rdbuf();
    if (!response_.good()) {
      // Depending on the users handling of the stringstream it might be that
      // the read position is already at the end and thus operator<< cannot
      // read anything, so lets try with the safer but more memory intensive
      // solution as a second step.
      response_.str(other.GetResponseAsString());
    }
  }
 
  HttpResponse& operator=(const HttpResponse& other) {
    if (this != &other) {
      status_ = other.status_;
      response_ = std::stringstream{};
      response_ << other.response_.rdbuf();
      headers_ = other.headers_;
    }
 
    return *this;
  }
 
  HttpResponse(HttpResponse&&) = default;
 
  HttpResponse& operator=(HttpResponse&&) = default;
 
  void GetResponse(std::vector<unsigned char>& output) {
    response_.seekg(0, std::ios::end);
    const auto pos = response_.tellg();
    if (pos > 0) {
      output.resize(pos);
    }
    response_.seekg(0, std::ios::beg);
    response_.read(reinterpret_cast<char*>(output.data()), output.size());
    response_.seekg(0, std::ios::beg);
  }
 
  void GetResponse(std::string& output) const { output = response_.str(); }
 
  std::vector<unsigned char> GetResponseAsBytes() {
    std::vector<unsigned char> bytes;
    GetResponse(bytes);
    return bytes;
  }
 
  std::string GetResponseAsString() const {
    std::string result;
    GetResponse(result);
    return result;
  }
 
  std::stringstream& GetRawResponse() { return response_; }
 
  const http::Headers& GetHeaders() const { return headers_; }
 
  int GetStatus() const { return status_; }
 
  void SetNetworkStatistics(NetworkStatistics network_statistics) {
    network_statistics_ = network_statistics;
  }
 
  const NetworkStatistics& GetNetworkStatistics() const {
    return network_statistics_;
  }
 
 private:
  int status_{static_cast<int>(olp::http::ErrorCode::UNKNOWN_ERROR)};
  std::stringstream response_;
  http::Headers headers_;
  NetworkStatistics network_statistics_;
};
 
}  // namespace client
}  // namespace olp