metadata_batch.cc | Explore in Territory

// Copyright 2021 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <grpc/support/port_platform.h>

#include "src/core/lib/transport/metadata_batch.h"

#include <string.h>

#include <algorithm>

#include "absl/strings/escaping.h"
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"

#include "src/core/lib/transport/timeout_encoding.h"

namespace grpc_core {
namespace metadata_detail {

void DebugStringBuilder::Add(absl::string_view key, absl::string_view value) { … }

void UnknownMap::Append(absl::string_view key, Slice value) { … }

void UnknownMap::Remove(absl::string_view key) { … }

absl::optional<absl::string_view> UnknownMap::GetStringValue(
    absl::string_view key, std::string* backing) const { … }

}  // namespace metadata_detail

ContentTypeMetadata::MementoType ContentTypeMetadata::ParseMemento(
    Slice value, MetadataParseErrorFn on_error) { … }

StaticSlice ContentTypeMetadata::Encode(ValueType x) { … }

const char* ContentTypeMetadata::DisplayValue(ValueType content_type) { … }

GrpcTimeoutMetadata::MementoType GrpcTimeoutMetadata::ParseMemento(
    Slice value, MetadataParseErrorFn on_error) { … }

GrpcTimeoutMetadata::ValueType GrpcTimeoutMetadata::MementoToValue(
    MementoType timeout) { … }

Slice GrpcTimeoutMetadata::Encode(ValueType x) { … }

TeMetadata::MementoType TeMetadata::ParseMemento(
    Slice value, MetadataParseErrorFn on_error) { … }

const char* TeMetadata::DisplayValue(ValueType te) { … }

HttpSchemeMetadata::ValueType HttpSchemeMetadata::Parse(
    absl::string_view value, MetadataParseErrorFn on_error) { … }

StaticSlice HttpSchemeMetadata::Encode(ValueType x) { … }

size_t EncodedSizeOfKey(HttpSchemeMetadata, HttpSchemeMetadata::ValueType x) { … }

const char* HttpSchemeMetadata::DisplayValue(ValueType content_type) { … }

HttpMethodMetadata::MementoType HttpMethodMetadata::ParseMemento(
    Slice value, MetadataParseErrorFn on_error) { … }

StaticSlice HttpMethodMetadata::Encode(ValueType x) { … }

const char* HttpMethodMetadata::DisplayValue(ValueType content_type) { … }

CompressionAlgorithmBasedMetadata::MementoType
CompressionAlgorithmBasedMetadata::ParseMemento(Slice value,
                                                MetadataParseErrorFn on_error) { … }

Duration GrpcRetryPushbackMsMetadata::ParseMemento(
    Slice value, MetadataParseErrorFn on_error) { … }

Slice LbCostBinMetadata::Encode(const ValueType& x) { … }

std::string LbCostBinMetadata::DisplayValue(ValueType x) { … }

LbCostBinMetadata::MementoType LbCostBinMetadata::ParseMemento(
    Slice value, MetadataParseErrorFn on_error) { … }

std::string GrpcStreamNetworkState::DisplayValue(ValueType x) { … }

std::string PeerString::DisplayValue(const ValueType& x) { … }

const std::string& GrpcStatusContext::DisplayValue(const std::string& x) { … }

std::string WaitForReady::DisplayValue(ValueType x) { … }

}  // namespace grpc_core
chromium/third_party/grpc/src/src/core/lib/transport/metadata_batch.cc
