response.h

Go to the documentation of this file.

#ifndef FASTLY_HTTP_RESPONSE_H
#define FASTLY_HTTP_RESPONSE_H
 
#include <chrono>
#include <fastly/backend.h>
#include <fastly/detail/access_bridge_internals.h>
#include <fastly/error.h>
#include <fastly/http/body.h>
#include <fastly/http/header.h>
#include <fastly/http/http.h>
#include <fastly/http/request.h>
#include <fastly/http/status_code.h>
#include <fastly/sdk-sys.h>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace fastly::backend {
class Backend;
}
 
namespace fastly::http {
 
class Body;
class StreamingBody;
class Response;
class Request;
namespace request {
class PendingRequest;
std::pair<fastly::expected<Response>, std::vector<PendingRequest>>
select(std::vector<PendingRequest> &reqs);
} // namespace request

class Response {
  friend detail::AccessBridgeInternals;
  friend Request;
  friend request::PendingRequest;
  friend std::pair<fastly::expected<Response>,
                   std::vector<request::PendingRequest>>
  request::select(std::vector<request::PendingRequest> &reqs);
 
public:
  Response();
  // TODO(@zkat): Make this a "friend"?
  bool is_from_backend();

  Response clone_without_body();

  Response clone_with_body();

  static Response from_body(Body body);

  static Response from_status(StatusCode status);

  static Response see_other(std::string_view destination);

  static Response redirect(std::string_view destination);

  static Response temporary_redirect(std::string_view destination);

  Response with_body(Body body) &&;

  bool has_body();

  void set_body(Body body);

  Body take_body();

  void append_body(Body body);

  std::vector<uint8_t> into_body_bytes();

  std::string into_body_string();

  Body into_body();

  fastly::expected<Response> with_body_text_plain(std::string_view body) &&;

  fastly::expected<void> set_body_text_plain(std::string_view body);

  fastly::expected<Response> with_body_text_html(std::string_view body) &&;

  fastly::expected<void> set_body_text_html(std::string_view body);

  std::string take_body_string();

  Response with_body_octet_stream(std::vector<uint8_t> body) &&;

  void set_body_octet_stream(std::vector<uint8_t> body);

  std::vector<uint8_t> take_body_bytes();

  std::optional<std::string> get_content_type();

  Response with_content_type(std::string_view mime) &&;

  void set_content_type(std::string_view mime);

  std::optional<size_t> get_content_length();

  fastly::expected<bool> contains_header(std::string_view name);

  fastly::expected<Response> with_header(std::string_view name,
                                         std::string_view value) &&;

  fastly::expected<Response> with_set_header(std::string_view name,
                                             std::string_view value) &&;

  fastly::expected<std::optional<HeaderValue>>
  get_header(std::string_view name);

  fastly::expected<HeaderValuesRange> get_header_all(std::string_view name);
  fastly::expected<HeadersRange> get_headers();
  fastly::expected<HeaderNamesRange> get_header_names();

  fastly::expected<void> set_header(std::string_view name,
                                    std::string_view value);

  fastly::expected<void> append_header(std::string_view name,
                                       std::string_view value);

  fastly::expected<std::optional<std::string>>
  remove_header(std::string_view name);

  Response with_status(StatusCode status) &&;

  void set_status(StatusCode status);

  Response with_version(Version version) &&;

  Version get_version();

  void set_version(Version version);
 
  // TODO(@zkat): needs enum
  // void set_framing_headers_mode(FramingHeadersMode mode);
  // Response set_framing_headers_mode(FramingHeadersMode mode);

  std::optional<std::string> get_backend_name();

  std::optional<fastly::backend::Backend> get_backend();

  std::optional<std::string> get_backend_addr();

  std::optional<Request> take_backend_request();

  void send_to_client();

  StreamingBody stream_to_client();

  std::optional<std::chrono::milliseconds> get_ttl();

  std::optional<std::chrono::milliseconds> get_age();

  std::optional<std::chrono::milliseconds> get_stale_while_revalidate();
 
private:
  auto &inner() { return res; }
  Response(rust::Box<fastly::sys::http::Response> response)
      : res(std::move(response)) {};
  rust::Box<fastly::sys::http::Response> res;
};
 
} // namespace fastly::http
 
namespace fastly {
using fastly::http::Response;
}
 
#endif