HttpResponse.h

/*
 * Copyright (C) 2019-2022 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.response.str());
    }
  }
 
  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(); }
 
  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_;
  }
 
  int status{static_cast<int>(olp::http::ErrorCode::UNKNOWN_ERROR)};
  std::stringstream response;
  http::Headers headers;
 
 private:
  NetworkStatistics network_statistics_;
};
 
}  // namespace client
}  // namespace olp