Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include "envoy/http/codec.h"
       4             : 
       5             : namespace Envoy {
       6             : namespace Http {
       7             : 
       8             : /**
       9             :  * Wrapper for ResponseDecoder that just forwards to an "inner" decoder.
      10             :  */
      11             : class ResponseDecoderWrapper : public ResponseDecoder {
      12             : public:
      13             :   // ResponseDecoder
      14           0 :   void decode1xxHeaders(ResponseHeaderMapPtr&& headers) override {
      15           0 :     inner_.decode1xxHeaders(std::move(headers));
      16           0 :   }
      17             : 
      18         338 :   void decodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream) override {
      19         338 :     if (end_stream) {
      20          40 :       onPreDecodeComplete();
      21          40 :     }
      22         338 :     inner_.decodeHeaders(std::move(headers), end_stream);
      23         338 :     if (end_stream) {
      24          40 :       onDecodeComplete();
      25          40 :     }
      26         338 :   }
      27             : 
      28         755 :   void decodeData(Buffer::Instance& data, bool end_stream) override {
      29         755 :     if (end_stream) {
      30         244 :       onPreDecodeComplete();
      31         244 :     }
      32         755 :     inner_.decodeData(data, end_stream);
      33         755 :     if (end_stream) {
      34         244 :       onDecodeComplete();
      35         244 :     }
      36         755 :   }
      37             : 
      38           9 :   void decodeTrailers(ResponseTrailerMapPtr&& trailers) override {
      39           9 :     onPreDecodeComplete();
      40           9 :     inner_.decodeTrailers(std::move(trailers));
      41           9 :     onDecodeComplete();
      42           9 :   }
      43             : 
      44           2 :   void decodeMetadata(MetadataMapPtr&& metadata_map) override {
      45           2 :     inner_.decodeMetadata(std::move(metadata_map));
      46           2 :   }
      47             : 
      48           0 :   void dumpState(std::ostream& os, int indent_level) const override {
      49           0 :     inner_.dumpState(os, indent_level);
      50           0 :   }
      51             : 
      52             : protected:
      53         452 :   ResponseDecoderWrapper(ResponseDecoder& inner) : inner_(inner) {}
      54             : 
      55             :   /**
      56             :    * Consumers of the wrapper generally want to know when a decode is complete. This is called
      57             :    * at that time and is implemented by derived classes.
      58             :    */
      59             :   virtual void onPreDecodeComplete() PURE;
      60             :   virtual void onDecodeComplete() PURE;
      61             : 
      62             :   ResponseDecoder& inner_;
      63             : };
      64             : 
      65             : /**
      66             :  * Wrapper for RequestEncoder that just forwards to an "inner" encoder.
      67             :  */
      68             : class RequestEncoderWrapper : public RequestEncoder {
      69             : public:
      70             :   // RequestEncoder
      71         452 :   Status encodeHeaders(const RequestHeaderMap& headers, bool end_stream) override {
      72         452 :     ASSERT(inner_encoder_);
      73         452 :     RETURN_IF_ERROR(inner_encoder_->encodeHeaders(headers, end_stream));
      74         452 :     if (end_stream) {
      75         214 :       onEncodeComplete();
      76         214 :     }
      77         452 :     return okStatus();
      78         452 :   }
      79             : 
      80         613 :   void encodeData(Buffer::Instance& data, bool end_stream) override {
      81         613 :     ASSERT(inner_encoder_);
      82         613 :     inner_encoder_->encodeData(data, end_stream);
      83         613 :     if (end_stream) {
      84         181 :       onEncodeComplete();
      85         181 :     }
      86         613 :   }
      87             : 
      88           0 :   void encodeTrailers(const RequestTrailerMap& trailers) override {
      89           0 :     ASSERT(inner_encoder_);
      90           0 :     inner_encoder_->encodeTrailers(trailers);
      91           0 :     onEncodeComplete();
      92           0 :   }
      93             : 
      94           0 :   void enableTcpTunneling() override {
      95           0 :     ASSERT(inner_encoder_);
      96           0 :     inner_encoder_->enableTcpTunneling();
      97           0 :   }
      98             : 
      99           0 :   void encodeMetadata(const MetadataMapVector& metadata_map_vector) override {
     100           0 :     ASSERT(inner_encoder_);
     101           0 :     inner_encoder_->encodeMetadata(metadata_map_vector);
     102           0 :   }
     103             : 
     104        1473 :   Stream& getStream() override {
     105        1473 :     ASSERT(inner_encoder_);
     106        1473 :     return inner_encoder_->getStream();
     107        1473 :   }
     108             : 
     109           0 :   Http1StreamEncoderOptionsOptRef http1StreamEncoderOptions() override {
     110           0 :     ASSERT(inner_encoder_);
     111           0 :     return inner_encoder_->http1StreamEncoderOptions();
     112           0 :   }
     113             : 
     114             : protected:
     115         452 :   RequestEncoderWrapper(RequestEncoder* inner) : inner_encoder_(inner) {}
     116             : 
     117             :   /**
     118             :    * Consumers of the wrapper generally want to know when an encode is complete. This is called at
     119             :    * that time and is implemented by derived classes.
     120             :    */
     121             :   virtual void onEncodeComplete() PURE;
     122             : 
     123             :   RequestEncoder* inner_encoder_;
     124             : };
     125             : 
     126             : } // namespace Http
     127             : } // namespace Envoy