/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	7.14k	void decodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream) override {
19	7.14k	if (end_stream) {
20	2.24k	onPreDecodeComplete();
21	2.24k	}
22	7.14k	inner_.decodeHeaders(std::move(headers), end_stream);
23	7.14k	if (end_stream) {
24	2.24k	onDecodeComplete();
25	2.24k	}
26	7.14k	}
27
28	12.4k	void decodeData(Buffer::Instance& data, bool end_stream) override {
29	12.4k	if (end_stream) {
30	2.35k	onPreDecodeComplete();
31	2.35k	}
32	12.4k	inner_.decodeData(data, end_stream);
33	12.4k	if (end_stream) {
34	2.35k	onDecodeComplete();
35	2.35k	}
36	12.4k	}
37
38	638	void decodeTrailers(ResponseTrailerMapPtr&& trailers) override {
39	638	onPreDecodeComplete();
40	638	inner_.decodeTrailers(std::move(trailers));
41	638	onDecodeComplete();
42	638	}
43
44	293	void decodeMetadata(MetadataMapPtr&& metadata_map) override {
45	293	inner_.decodeMetadata(std::move(metadata_map));
46	293	}
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	24.9k	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	24.9k	Status encodeHeaders(const RequestHeaderMap& headers, bool end_stream) override {
72	24.9k	ASSERT(inner_encoder_);
73	24.9k	RETURN_IF_ERROR(inner_encoder_->encodeHeaders(headers, end_stream));
74	24.9k	if (end_stream) {
75	4.83k	onEncodeComplete();
76	4.83k	}
77	24.9k	return okStatus();
78	24.9k	}
79
80	31.0k	void encodeData(Buffer::Instance& data, bool end_stream) override {
81	31.0k	ASSERT(inner_encoder_);
82	31.0k	inner_encoder_->encodeData(data, end_stream);
83	31.0k	if (end_stream) {
84	19.9k	onEncodeComplete();
85	19.9k	}
86	31.0k	}
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	23	void encodeMetadata(const MetadataMapVector& metadata_map_vector) override {
100	23	ASSERT(inner_encoder_);
101	23	inner_encoder_->encodeMetadata(metadata_map_vector);
102	23	}
103
104	51.7k	Stream& getStream() override {
105	51.7k	ASSERT(inner_encoder_);
106	51.7k	return inner_encoder_->getStream();
107	51.7k	}
108
109	0	Http1StreamEncoderOptionsOptRef http1StreamEncoderOptions() override {
110	0	ASSERT(inner_encoder_);
111	0	return inner_encoder_->http1StreamEncoderOptions();
112	0	}
113
114		protected:
115	24.9k	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: 2024-09-19 09:45