/proc/self/cwd/source/common/http/codec_wrappers.h

Source (jump to first uncovered line)
#pragma once

#include "envoy/http/codec.h"

namespace Envoy {
namespace Http {

/**
 * Wrapper for ResponseDecoder that just forwards to an "inner" decoder.
 */
class ResponseDecoderWrapper : public ResponseDecoder {
public:
  // ResponseDecoder
  void decode1xxHeaders(ResponseHeaderMapPtr&& headers) override {
    inner_.decode1xxHeaders(std::move(headers));
  }

  void decodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream) override {
    if (end_stream) {
      onPreDecodeComplete();
    }
    inner_.decodeHeaders(std::move(headers), end_stream);
    if (end_stream) {
      onDecodeComplete();
    }
  }

  void decodeData(Buffer::Instance& data, bool end_stream) override {
    if (end_stream) {
      onPreDecodeComplete();
    }
    inner_.decodeData(data, end_stream);
    if (end_stream) {
      onDecodeComplete();
    }
  }

  void decodeTrailers(ResponseTrailerMapPtr&& trailers) override {
    onPreDecodeComplete();
    inner_.decodeTrailers(std::move(trailers));
    onDecodeComplete();
  }

  void decodeMetadata(MetadataMapPtr&& metadata_map) override {
    inner_.decodeMetadata(std::move(metadata_map));
  }

  void dumpState(std::ostream& os, int indent_level) const override {
    inner_.dumpState(os, indent_level);
  }

protected:
  ResponseDecoderWrapper(ResponseDecoder& inner) : inner_(inner) {}

  /**
   * Consumers of the wrapper generally want to know when a decode is complete. This is called
   * at that time and is implemented by derived classes.
   */
  virtual void onPreDecodeComplete() PURE;
  virtual void onDecodeComplete() PURE;

  ResponseDecoder& inner_;
};

/**
 * Wrapper for RequestEncoder that just forwards to an "inner" encoder.
 */
class RequestEncoderWrapper : public RequestEncoder {
public:
  // RequestEncoder
  Status encodeHeaders(const RequestHeaderMap& headers, bool end_stream) override {
    ASSERT(inner_encoder_);
    RETURN_IF_ERROR(inner_encoder_->encodeHeaders(headers, end_stream));
    if (end_stream) {
      onEncodeComplete();
    }
    return okStatus();
  }

  void encodeData(Buffer::Instance& data, bool end_stream) override {
    ASSERT(inner_encoder_);
    inner_encoder_->encodeData(data, end_stream);
    if (end_stream) {
      onEncodeComplete();
    }
  }

  void encodeTrailers(const RequestTrailerMap& trailers) override {
    ASSERT(inner_encoder_);
    inner_encoder_->encodeTrailers(trailers);
    onEncodeComplete();
  }

  void enableTcpTunneling() override {
    ASSERT(inner_encoder_);
    inner_encoder_->enableTcpTunneling();
  }

  void encodeMetadata(const MetadataMapVector& metadata_map_vector) override {
    ASSERT(inner_encoder_);
    inner_encoder_->encodeMetadata(metadata_map_vector);
  }

  Stream& getStream() override {
    ASSERT(inner_encoder_);
    return inner_encoder_->getStream();
  }

  Http1StreamEncoderOptionsOptRef http1StreamEncoderOptions() override {
    ASSERT(inner_encoder_);
    return inner_encoder_->http1StreamEncoderOptions();
  }

protected:
  RequestEncoderWrapper(RequestEncoder* inner) : inner_encoder_(inner) {}

  /**
   * Consumers of the wrapper generally want to know when an encode is complete. This is called at
   * that time and is implemented by derived classes.
   */
  virtual void onEncodeComplete() PURE;

  RequestEncoder* inner_encoder_;
};

} // namespace Http
} // namespace Envoy

Line	Count	Source (jump to first uncovered line)
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	2	void decode1xxHeaders(ResponseHeaderMapPtr&& headers) override {
15	2	inner_.decode1xxHeaders(std::move(headers));
16	2	}
17
18	9.79k	void decodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream) override {
19	9.79k	if (end_stream) {
20	2.10k	onPreDecodeComplete();
21	2.10k	}
22	9.79k	inner_.decodeHeaders(std::move(headers), end_stream);
23	9.79k	if (end_stream) {
24	2.10k	onDecodeComplete();
25	2.10k	}
26	9.79k	}
27
28	18.2k	void decodeData(Buffer::Instance& data, bool end_stream) override {
29	18.2k	if (end_stream) {
30	5.52k	onPreDecodeComplete();
31	5.52k	}
32	18.2k	inner_.decodeData(data, end_stream);
33	18.2k	if (end_stream) {
34	5.52k	onDecodeComplete();
35	5.52k	}
36	18.2k	}
37
38	516	void decodeTrailers(ResponseTrailerMapPtr&& trailers) override {
39	516	onPreDecodeComplete();
40	516	inner_.decodeTrailers(std::move(trailers));
41	516	onDecodeComplete();
42	516	}
43
44	181	void decodeMetadata(MetadataMapPtr&& metadata_map) override {
45	181	inner_.decodeMetadata(std::move(metadata_map));
46	181	}
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	28.5k	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	28.5k	Status encodeHeaders(const RequestHeaderMap& headers, bool end_stream) override {
72	28.5k	ASSERT(inner_encoder_);
73	28.5k	RETURN_IF_ERROR(inner_encoder_->encodeHeaders(headers, end_stream));
74	28.5k	if (end_stream) {
75	8.20k	onEncodeComplete();
76	8.20k	}
77	28.5k	return okStatus();
78	28.5k	}
79
80	33.4k	void encodeData(Buffer::Instance& data, bool end_stream) override {
81	33.4k	ASSERT(inner_encoder_);
82	33.4k	inner_encoder_->encodeData(data, end_stream);
83	33.4k	if (end_stream) {
84	20.1k	onEncodeComplete();
85	20.1k	}
86	33.4k	}
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	4	void encodeMetadata(const MetadataMapVector& metadata_map_vector) override {
100	4	ASSERT(inner_encoder_);
101	4	inner_encoder_->encodeMetadata(metadata_map_vector);
102	4	}
103
104	58.1k	Stream& getStream() override {
105	58.1k	ASSERT(inner_encoder_);
106	58.1k	return inner_encoder_->getStream();
107	58.1k	}
108
109	0	Http1StreamEncoderOptionsOptRef http1StreamEncoderOptions() override {
110	0	ASSERT(inner_encoder_);
111	0	return inner_encoder_->http1StreamEncoderOptions();
112	0	}
113
114		protected:
115	28.5k	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

Coverage Report

Created: 2023-11-12 09:30