Class Cb

boost-http/http.cpp:133–201

    }

    class Cb : public HttpRequestCallback {
     public:
      Cb(std::weak_ptr<HttpSession> self, asio::strand<asio::any_io_executor> strand)
          : self_(std::move(self)), strand_(std::move(strand)) {
      }

      void receive_answer(td::int32 status_code, std::string content_type,
                          std::vector<std::pair<std::string, std::string>> headers, std::string body_part = "",
                          bool is_completed = false) override {
        CHECK(!already_started_);
        CHECK(!already_completed_);
        already_started_ = true;
        asio::post(strand_, [weak = self_, status_code = (http::status)status_code,
                             content_type = std::move(content_type), headers = std::move(headers)]() mutable {
          if (auto self = weak.lock()) {
            self->send_headers(status_code, content_type, std::move(headers));
          }
        });
        receive_payload_part(std::move(body_part), is_completed);
      }
      void receive_payload_part(std::string body_part, bool is_completed) override {
        CHECK(already_started_);
        CHECK(!already_completed_);
        if (body_part.size() > 0) {
          asio::post(strand_, [weak = self_, body_part = std::move(body_part)]() mutable {
            if (auto self = weak.lock()) {
              self->enqueue_part(std::move(body_part));
            }
          });
        }
        if (is_completed) {
          already_completed_ = true;
          asio::post(strand_, [weak = self_, body_part = std::move(body_part)]() mutable {
            if (auto self = weak.lock()) {
              self->finish();
            }
          });
        }
      }

      ~Cb() {
        if (!already_started_) {
          already_started_ = true;
          already_completed_ = true;
          asio::post(strand_, [weak = self_]() mutable {
            if (auto self = weak.lock()) {
              self->send_headers(http::status::internal_server_error, "text/plain", {});
              self->enqueue_part(PSTRING() << "lost http callback");
              self->finish();
            }
          });
        }
        if (!already_completed_) {
          already_completed_ = true;
          asio::post(strand_, [weak = self_]() mutable {
            if (auto self = weak.lock()) {
              self->finish();
            }