raw_response.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/core/case_insensitive_containers.hpp"
#include "azure/core/http/http_status_code.hpp"
#include "azure/core/io/body_stream.hpp"
 
#include <memory>
#include <string>
#include <vector>
 
namespace Azure { namespace Core { namespace Http {
  class RawResponse final {
 
  private:
    int32_t m_majorVersion;
    int32_t m_minorVersion;
    HttpStatusCode m_statusCode;
    std::string m_reasonPhrase;
    CaseInsensitiveMap m_headers;
 
    std::unique_ptr<Azure::Core::IO::BodyStream> m_bodyStream;
    std::vector<uint8_t> m_body;
 
    explicit RawResponse(
        int32_t majorVersion,
        int32_t minorVersion,
        HttpStatusCode statusCode,
        std::string const& reasonPhrase,
        std::unique_ptr<Azure::Core::IO::BodyStream> BodyStream)
        : m_majorVersion(majorVersion), m_minorVersion(minorVersion), m_statusCode(statusCode),
          m_reasonPhrase(reasonPhrase), m_bodyStream(std::move(BodyStream))
    {
    }
 
  public:
    explicit RawResponse(
        int32_t majorVersion,
        int32_t minorVersion,
        HttpStatusCode statusCode,
        std::string const& reasonPhrase)
        : RawResponse(majorVersion, minorVersion, statusCode, reasonPhrase, nullptr)
    {
    }
 
    RawResponse(RawResponse const& response)
        : RawResponse(
            response.m_majorVersion,
            response.m_minorVersion,
            response.m_statusCode,
            response.m_reasonPhrase)
    {
      AZURE_ASSERT(m_bodyStream == nullptr);
      // Copy body
      m_body = response.GetBody();
    }
 
    RawResponse(RawResponse&& response) = default;
 
    RawResponse& operator=(RawResponse const&) = delete;
 
    RawResponse& operator=(RawResponse&&) = delete;
 
    ~RawResponse() = default;
 
    // ===== Methods used to build HTTP response =====
 
    void SetHeader(std::string const& name, std::string const& value);
 
    void SetBodyStream(std::unique_ptr<Azure::Core::IO::BodyStream> stream);
 
    void SetBody(std::vector<uint8_t> body) { this->m_body = std::move(body); }
 
    // adding getters for version and stream body. Clang will complain on macOS if we have unused
    // fields in a class
 
    int32_t GetMajorVersion() const { return m_majorVersion; }
 
    int32_t GetMinorVersion() const { return m_minorVersion; }
 
    HttpStatusCode GetStatusCode() const;
 
    std::string const& GetReasonPhrase() const;
 
    CaseInsensitiveMap const& GetHeaders() const;
 
    std::unique_ptr<Azure::Core::IO::BodyStream> ExtractBodyStream()
    {
      // If m_bodyStream was moved before. nullptr is returned
      return std::move(this->m_bodyStream);
    }
 
    std::vector<uint8_t>& GetBody() { return this->m_body; }
 
    std::vector<uint8_t> const& GetBody() const { return this->m_body; }
  };
}}} // namespace Azure::Core::Http