Grcov report - delegating_route

1

#include "source/common/router/delegating_route_impl.h"

2

3

namespace Envoy {

4

namespace Router {

5

6

// Router:DelegatingRouteEntry

7

void DelegatingRouteEntry::finalizeResponseHeaders(

8

    Http::ResponseHeaderMap& headers, const Formatter::Context& context,

9

298

    const StreamInfo::StreamInfo& stream_info) const {

10

298

  return base_route_entry_->finalizeResponseHeaders(headers, context, stream_info);

11

298

12

13

Http::HeaderTransforms

14

DelegatingRouteEntry::responseHeaderTransforms(const StreamInfo::StreamInfo& stream_info,

15

2

                                               bool do_formatting) const {

16

2

  return base_route_entry_->responseHeaderTransforms(stream_info, do_formatting);

17

2

18

19

1

const std::string& DelegatingRouteEntry::clusterName() const {

20

1

  return base_route_entry_->clusterName();

21

1

22

23

53

Http::Code DelegatingRouteEntry::clusterNotFoundResponseCode() const {

24

53

  return base_route_entry_->clusterNotFoundResponseCode();

25

53

26

27

3

const CorsPolicy* DelegatingRouteEntry::corsPolicy() const {

28

3

  return base_route_entry_->corsPolicy();

29

3

30

31

std::string

32

DelegatingRouteEntry::currentUrlPathAfterRewrite(const Http::RequestHeaderMap& headers,

33

                                                 const Formatter::Context& context,

34

2

                                                 const StreamInfo::StreamInfo& stream_info) const {

35

2

  return base_route_entry_->currentUrlPathAfterRewrite(headers, context, stream_info);

36

2

37

38

void DelegatingRouteEntry::finalizeRequestHeaders(Http::RequestHeaderMap& headers,

39

                                                  const Formatter::Context& context,

40

                                                  const StreamInfo::StreamInfo& stream_info,

41

248

                                                  bool insert_envoy_original_path) const {

42

248

  return base_route_entry_->finalizeRequestHeaders(headers, context, stream_info,

43

248

                                                   insert_envoy_original_path);

44

248

45

46

Http::HeaderTransforms

47

DelegatingRouteEntry::requestHeaderTransforms(const StreamInfo::StreamInfo& stream_info,

48

2

                                              bool do_formatting) const {

49

2

  return base_route_entry_->requestHeaderTransforms(stream_info, do_formatting);

50

2

51

52

3

const Http::HashPolicy* DelegatingRouteEntry::hashPolicy() const {

53

3

  return base_route_entry_->hashPolicy();

54

3

55

56

246

const HedgePolicy& DelegatingRouteEntry::hedgePolicy() const {

57

246

  return base_route_entry_->hedgePolicy();

58

246

59

60

487

Upstream::ResourcePriority DelegatingRouteEntry::priority() const {

61

487

  return base_route_entry_->priority();

62

487

63

64

4

const RateLimitPolicy& DelegatingRouteEntry::rateLimitPolicy() const {

65

4

  return base_route_entry_->rateLimitPolicy();

66

4

67

68

730

const RetryPolicyConstSharedPtr& DelegatingRouteEntry::retryPolicy() const {

69

730

  return base_route_entry_->retryPolicy();

70

730

71

72

1

const PathMatcherSharedPtr& DelegatingRouteEntry::pathMatcher() const {

73

1

  return base_route_entry_->pathMatcher();

74

1

75

76

1

const PathRewriterSharedPtr& DelegatingRouteEntry::pathRewriter() const {

77

1

  return base_route_entry_->pathRewriter();

78

1

79

80

246

const InternalRedirectPolicy& DelegatingRouteEntry::internalRedirectPolicy() const {

81

246

  return base_route_entry_->internalRedirectPolicy();

82

246

83

84

642

uint64_t DelegatingRouteEntry::requestBodyBufferLimit() const {

85

642

  return base_route_entry_->requestBodyBufferLimit();

86

642

87

88

245

const std::vector<Router::ShadowPolicyPtr>& DelegatingRouteEntry::shadowPolicies() const {

89

245

  return base_route_entry_->shadowPolicies();

90

245

91

92

245

std::chrono::milliseconds DelegatingRouteEntry::timeout() const {

93

245

  return base_route_entry_->timeout();

94

245

95

96

341

absl::optional<std::chrono::milliseconds> DelegatingRouteEntry::idleTimeout() const {

97

341

  return base_route_entry_->idleTimeout();

98

341

99

100

348

absl::optional<std::chrono::milliseconds> DelegatingRouteEntry::flushTimeout() const {

101

348

  return base_route_entry_->flushTimeout();

102

348

103

104

244

bool DelegatingRouteEntry::usingNewTimeouts() const {

105

244

  return base_route_entry_->usingNewTimeouts();

106

244

107

108

350

absl::optional<std::chrono::milliseconds> DelegatingRouteEntry::maxStreamDuration() const {

109

350

  return base_route_entry_->maxStreamDuration();

110

350

111

112

2

absl::optional<std::chrono::milliseconds> DelegatingRouteEntry::grpcTimeoutHeaderMax() const {

113

2

  return base_route_entry_->grpcTimeoutHeaderMax();

114

2

115

116

2

absl::optional<std::chrono::milliseconds> DelegatingRouteEntry::grpcTimeoutHeaderOffset() const {

117

2

  return base_route_entry_->grpcTimeoutHeaderOffset();

118

2

119

120

4

absl::optional<std::chrono::milliseconds> DelegatingRouteEntry::maxGrpcTimeout() const {

121

4

  return base_route_entry_->maxGrpcTimeout();

122

4

123

124

4

absl::optional<std::chrono::milliseconds> DelegatingRouteEntry::grpcTimeoutOffset() const {

125

4

  return base_route_entry_->grpcTimeoutOffset();

126

4

127

128

245

bool DelegatingRouteEntry::autoHostRewrite() const { return base_route_entry_->autoHostRewrite(); }

129

130

1

bool DelegatingRouteEntry::appendXfh() const { return base_route_entry_->appendXfh(); }

131

132

3

const MetadataMatchCriteria* DelegatingRouteEntry::metadataMatchCriteria() const {

133

3

  return base_route_entry_->metadataMatchCriteria();

134

3

135

136

3

const std::multimap<std::string, std::string>& DelegatingRouteEntry::opaqueConfig() const {

137

3

  return base_route_entry_->opaqueConfig();

138

3

139

140

3

bool DelegatingRouteEntry::includeVirtualHostRateLimits() const {

141

3

  return base_route_entry_->includeVirtualHostRateLimits();

142

3

143

144

2

const TlsContextMatchCriteria* DelegatingRouteEntry::tlsContextMatchCriteria() const {

145

2

  return base_route_entry_->tlsContextMatchCriteria();

146

2

147

148

4

const PathMatchCriterion& DelegatingRouteEntry::pathMatchCriterion() const {

149

4

  return base_route_entry_->pathMatchCriterion();

150

4

151

152

244

bool DelegatingRouteEntry::includeAttemptCountInRequest() const {

153

244

  return base_route_entry_->includeAttemptCountInRequest();

154

244

155

156

244

bool DelegatingRouteEntry::includeAttemptCountInResponse() const {

157

244

  return base_route_entry_->includeAttemptCountInResponse();

158

244

159

160

using UpgradeMap = std::map<std::string, bool>;

161

3

const UpgradeMap& DelegatingRouteEntry::upgradeMap() const {

162

3

  return base_route_entry_->upgradeMap();

163

3

164

165

using ConnectConfig = envoy::config::route::v3::RouteAction::UpgradeConfig::ConnectConfig;

166

using ConnectConfigOptRef = OptRef<ConnectConfig>;

167

244

const ConnectConfigOptRef DelegatingRouteEntry::connectConfig() const {

168

244

  return base_route_entry_->connectConfig();

169

244

170

171

243

const EarlyDataPolicy& DelegatingRouteEntry::earlyDataPolicy() const {

172

243

  return base_route_entry_->earlyDataPolicy();

173

243

174

175

231

const RouteStatsContextOptRef DelegatingRouteEntry::routeStatsContext() const {

176

231

  return base_route_entry_->routeStatsContext();

177

231

178

179

void DelegatingRouteEntry::refreshRouteCluster(const Http::RequestHeaderMap& headers,

180

                                               const StreamInfo::StreamInfo& stream_info) const {

181

  base_route_entry_->refreshRouteCluster(headers, stream_info);

182

183

184

} // namespace Router

185

} // namespace Envoy