Skip to content

A
abseil-cpp
Commit 2a5633fc by Xiaoyi Zhang Committed by Gerrit Code Review
Options

Merge "Export of internal Abseil changes"

parents f9b3d6e4 914ff445
Showing with 288 additions and 43 deletions
absl/container/CMakeLists.txt
...@@ -633,7 +633,7 @@ absl_cc_library( ...@@ -633,7 +633,7 @@ absl_cc_library(
NAME NAME
container_common container_common
HDRS HDRS
"internal/commom.h" "internal/common.h"
COPTS COPTS
${ABSL_DEFAULT_COPTS} ${ABSL_DEFAULT_COPTS}
DEPS DEPS
......
absl/flags/internal/flag.h
...@@ -43,10 +43,10 @@ template <typename T> ...@@ -43,10 +43,10 @@ template <typename T>
class Flag; class Flag;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Type-specific operations, eg., parsing, copying, etc. are provided // Flag value type operations, eg., parsing, copying, etc. are provided
// by function specific to that type with a signature matching FlagOpFn. // by function specific to that type with a signature matching FlagOpFn.
enum FlagOp { enum class FlagOp {
kDelete, kDelete,
kClone, kClone,
kCopy, kCopy,
...@@ -58,26 +58,26 @@ enum FlagOp { ...@@ -58,26 +58,26 @@ enum FlagOp {
}; };
using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*); using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
// The per-type function // Flag value specific operations routine.
template <typename T> template <typename T>
void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
switch (op) { switch (op) {
case flags_internal::kDelete: case FlagOp::kDelete:
delete static_cast<const T*>(v1); delete static_cast<const T*>(v1);
return nullptr; return nullptr;
case flags_internal::kClone: case FlagOp::kClone:
return new T(*static_cast<const T*>(v1)); return new T(*static_cast<const T*>(v1));
case flags_internal::kCopy: case FlagOp::kCopy:
*static_cast<T*>(v2) = *static_cast<const T*>(v1); *static_cast<T*>(v2) = *static_cast<const T*>(v1);
return nullptr; return nullptr;
case flags_internal::kCopyConstruct: case FlagOp::kCopyConstruct:
new (v2) T(*static_cast<const T*>(v1)); new (v2) T(*static_cast<const T*>(v1));
return nullptr; return nullptr;
case flags_internal::kSizeof: case FlagOp::kSizeof:
return reinterpret_cast<void*>(sizeof(T)); return reinterpret_cast<void*>(sizeof(T));
case flags_internal::kStaticTypeId: case FlagOp::kStaticTypeId:
return reinterpret_cast<void*>(&FlagStaticTypeIdGen<T>); return reinterpret_cast<void*>(&FlagStaticTypeIdGen<T>);
case flags_internal::kParse: { case FlagOp::kParse: {
// Initialize the temporary instance of type T based on current value in // Initialize the temporary instance of type T based on current value in
// destination (which is going to be flag's default value). // destination (which is going to be flag's default value).
T temp(*static_cast<T*>(v2)); T temp(*static_cast<T*>(v2));
...@@ -88,7 +88,7 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { ...@@ -88,7 +88,7 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
*static_cast<T*>(v2) = std::move(temp); *static_cast<T*>(v2) = std::move(temp);
return v2; return v2;
} }
case flags_internal::kUnparse: case FlagOp::kUnparse:
*static_cast<std::string*>(v2) = *static_cast<std::string*>(v2) =
absl::UnparseFlag<T>(*static_cast<const T*>(v1)); absl::UnparseFlag<T>(*static_cast<const T*>(v1));
return nullptr; return nullptr;
...@@ -97,37 +97,45 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { ...@@ -97,37 +97,45 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
} }
} }
// Functions that invoke flag-type-specific operations. // Deletes memory interpreting obj as flag value type pointer.
inline void Delete(FlagOpFn op, const void* obj) { inline void Delete(FlagOpFn op, const void* obj) {
op(flags_internal::kDelete, obj, nullptr, nullptr); op(FlagOp::kDelete, obj, nullptr, nullptr);
} }
// Makes a copy of flag value pointed by obj.
inline void* Clone(FlagOpFn op, const void* obj) { inline void* Clone(FlagOpFn op, const void* obj) {
return op(flags_internal::kClone, obj, nullptr, nullptr); return op(FlagOp::kClone, obj, nullptr, nullptr);
} }
// Copies src to dst interpreting as flag value type pointers.
inline void Copy(FlagOpFn op, const void* src, void* dst) { inline void Copy(FlagOpFn op, const void* src, void* dst) {
op(flags_internal::kCopy, src, dst, nullptr); op(FlagOp::kCopy, src, dst, nullptr);
} }
// Construct a copy of flag value in a location pointed by dst
// based on src - pointer to the flag's value.
inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) { inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
op(flags_internal::kCopyConstruct, src, dst, nullptr); op(FlagOp::kCopyConstruct, src, dst, nullptr);
} }
// Returns true if parsing of input text is successfull.
inline bool Parse(FlagOpFn op, absl::string_view text, void* dst, inline bool Parse(FlagOpFn op, absl::string_view text, void* dst,
std::string* error) { std::string* error) {
return op(flags_internal::kParse, &text, dst, error) != nullptr; return op(FlagOp::kParse, &text, dst, error) != nullptr;
} }
// Returns string representing supplied value.
inline std::string Unparse(FlagOpFn op, const void* val) { inline std::string Unparse(FlagOpFn op, const void* val) {
std::string result; std::string result;
op(flags_internal::kUnparse, val, &result, nullptr); op(FlagOp::kUnparse, val, &result, nullptr);
return result; return result;
} }
// Returns size of flag value type.
inline size_t Sizeof(FlagOpFn op) { inline size_t Sizeof(FlagOpFn op) {
// This sequence of casts reverses the sequence from // This sequence of casts reverses the sequence from
// `flags_internal::FlagOps()` // `flags_internal::FlagOps()`
return static_cast<size_t>(reinterpret_cast<intptr_t>( return static_cast<size_t>(reinterpret_cast<intptr_t>(
op(flags_internal::kSizeof, nullptr, nullptr, nullptr))); op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
} }
// Returns static type id coresponding to the value type.
inline FlagStaticTypeId StaticTypeId(FlagOpFn op) { inline FlagStaticTypeId StaticTypeId(FlagOpFn op) {
return reinterpret_cast<FlagStaticTypeId>( return reinterpret_cast<FlagStaticTypeId>(
op(flags_internal::kStaticTypeId, nullptr, nullptr, nullptr)); op(FlagOp::kStaticTypeId, nullptr, nullptr, nullptr));
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
......
absl/status/BUILD.bazel 0 → 100644
#
# Copyright 2017 The Abseil 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
#
# https://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.
# This package contains `absl::Status`.
# It will expand later to have utilities around `Status` like `StatusOr`,
# `StatusBuilder` and macros.
load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
load(
"//absl:copts/configure_copts.bzl",
"ABSL_DEFAULT_COPTS",
"ABSL_TEST_COPTS",
)
package(default_visibility = ["//visibility:public"])
licenses(["notice"]) # Apache 2.0
cc_library(
name = "status",
srcs = [
"status.cc",
"status_payload_printer.cc",
],
hdrs = [
"status.h",
"status_payload_printer.h",
],
copts = ABSL_DEFAULT_COPTS,
deps = [
"//absl/base:config",
"//absl/base:core_headers",
"//absl/base:raw_logging_internal",
"//absl/container:inlined_vector",
"//absl/debugging:stacktrace",
"//absl/debugging:symbolize",
"//absl/strings",
"//absl/strings:cord",
"//absl/strings:str_format",
"//absl/types:optional",
],
)
cc_test(
name = "status_test",
srcs = ["status_test.cc"],
copts = ABSL_TEST_COPTS,
deps = [
":status",
"//absl/strings",
"@com_google_googletest//:gtest_main",
],
)
absl/status/CMakeLists.txt 0 → 100644
#
# Copyright 2020 The Abseil 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
#
# https://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.
#
absl_cc_library(
NAME
status
HDRS
"status.h"
SRCS
"status.cc"
"status_payload_printer.h"
"status_payload_printer.cc"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::config
absl::core_headers
absl::raw_logging_internal
absl::inlined_vector
absl::stacktrace
absl::symbolize
absl::strings
absl::cord
absl::str_format
absl::optional
PUBLIC
)
absl_cc_test(
NAME
status_test
HDRS
"status_test.cc"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::status
absl::strings
gmock_main
)
absl/status/status_payload_printer.cc 0 → 100644
// Copyright 2019 The Abseil 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
//
// https://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 "absl/status/status_payload_printer.h"
#include <atomic>
#include "absl/base/attributes.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace status_internal {
namespace {
// Tried constant initialized global variable but it doesn't work with Lexan
// (MSVC's `std::atomic` has trouble constant initializing).
std::atomic<StatusPayloadPrinter>& GetStatusPayloadPrinterStorage() {
ABSL_CONST_INIT static std::atomic<StatusPayloadPrinter> instance{nullptr};
return instance;
}
} // namespace
void SetStatusPayloadPrinter(StatusPayloadPrinter printer) {
GetStatusPayloadPrinterStorage().store(printer, std::memory_order_relaxed);
}
StatusPayloadPrinter GetStatusPayloadPrinter() {
return GetStatusPayloadPrinterStorage().load(std::memory_order_relaxed);
}
} // namespace status_internal
ABSL_NAMESPACE_END
} // namespace absl
absl/status/status_payload_printer.h 0 → 100644
// Copyright 2019 The Abseil 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
//
// https://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.
#ifndef ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
#define ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
#include <string>
#include "absl/strings/cord.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace status_internal {
// By default, `Status::ToString` and `operator<<(Status)` print a payload by
// dumping the type URL and the raw bytes. To help debugging, we provide an
// extension point, which is a global printer function that can be set by users
// to specify how to print payloads. The function takes the type URL and the
// payload as input, and should return a valid human-readable string on success
// or `absl::nullopt` on failure (in which case it falls back to the default
// approach of printing the raw bytes).
// NOTE: This is an internal API and the design is subject to change in the
// future in a non-backward-compatible way. Since it's only meant for debugging
// purpose, you should not rely on it in any critical logic.
using StatusPayloadPrinter = absl::optional<std::string> (*)(absl::string_view,
const absl::Cord&);
// Sets the global payload printer. Only one printer should be set per process.
// If multiple printers are set, it's undefined which one will be used.
void SetStatusPayloadPrinter(StatusPayloadPrinter);
// Returns the global payload printer if previously set, otherwise `nullptr`.
StatusPayloadPrinter GetStatusPayloadPrinter();
} // namespace status_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
absl/strings/internal/str_format/arg_test.cc
...@@ -96,10 +96,10 @@ TEST_F(FormatArgImplTest, WorksWithCharArraysOfUnknownSize) { ...@@ -96,10 +96,10 @@ TEST_F(FormatArgImplTest, WorksWithCharArraysOfUnknownSize) {
std::string s; std::string s;
FormatSinkImpl sink(&s); FormatSinkImpl sink(&s);
ConversionSpec conv; ConversionSpec conv;
conv.set_conv(ConversionChar::s); FormatConversionSpecImplFriend::SetConversionChar(ConversionChar::s, &conv);
conv.set_flags(Flags()); FormatConversionSpecImplFriend::SetFlags(Flags(), &conv);
conv.set_width(-1); FormatConversionSpecImplFriend::SetWidth(-1, &conv);
conv.set_precision(-1); FormatConversionSpecImplFriend::SetPrecision(-1, &conv);
EXPECT_TRUE( EXPECT_TRUE(
FormatArgImplFriend::Convert(FormatArgImpl(kMyArray), conv, &sink)); FormatArgImplFriend::Convert(FormatArgImpl(kMyArray), conv, &sink));
sink.Flush(); sink.Flush();
......
absl/strings/internal/str_format/bind.cc
...@@ -66,18 +66,22 @@ inline bool ArgContext::Bind(const UnboundConversion* unbound, ...@@ -66,18 +66,22 @@ inline bool ArgContext::Bind(const UnboundConversion* unbound,
return false; return false;
} }
bound->set_width(width); FormatConversionSpecImplFriend::SetWidth(width, bound);
bound->set_precision(precision); FormatConversionSpecImplFriend::SetPrecision(precision, bound);
bound->set_flags(unbound->flags);
if (force_left) if (force_left) {
bound->set_left(true); Flags flags = unbound->flags;
flags.left = true;
FormatConversionSpecImplFriend::SetFlags(flags, bound);
} else { } else {
bound->set_flags(unbound->flags); FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
bound->set_width(-1);
bound->set_precision(-1);
} }
} else {
bound->set_conv(unbound->conv); FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
FormatConversionSpecImplFriend::SetWidth(-1, bound);
FormatConversionSpecImplFriend::SetPrecision(-1, bound);
}
FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
bound->set_arg(arg); bound->set_arg(arg);
return true; return true;
} }
...@@ -139,7 +143,8 @@ class SummarizingConverter { ...@@ -139,7 +143,8 @@ class SummarizingConverter {
UntypedFormatSpecImpl spec("%d"); UntypedFormatSpecImpl spec("%d");
std::ostringstream ss; std::ostringstream ss;
ss << "{" << Streamable(spec, {*bound.arg()}) << ":" << bound.flags(); ss << "{" << Streamable(spec, {*bound.arg()}) << ":"
<< FormatConversionSpecImplFriend::FlagsToString(bound);
if (bound.width() >= 0) ss << bound.width(); if (bound.width() >= 0) ss << bound.width();
if (bound.precision() >= 0) ss << "." << bound.precision(); if (bound.precision() >= 0) ss << "." << bound.precision();
ss << bound.conv() << "}"; ss << bound.conv() << "}";
......
absl/strings/internal/str_format/extension.h
...@@ -260,9 +260,21 @@ inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v) { ...@@ -260,9 +260,21 @@ inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v) {
return os << c; return os << c;
} }
struct FormatConversionSpecImplFriend;
class ConversionSpec { class ConversionSpec {
public: public:
// Deprecated (use has_x_flag() instead).
Flags flags() const { return flags_; } Flags flags() const { return flags_; }
// Width and precison are not specified, no flags are set.
bool is_basic() const { return flags_.basic; }
bool has_left_flag() const { return flags_.left; }
bool has_show_pos_flag() const { return flags_.show_pos; }
bool has_sign_col_flag() const { return flags_.sign_col; }
bool has_alt_flag() const { return flags_.alt; }
bool has_zero_flag() const { return flags_.zero; }
FormatConversionChar conv() const { FormatConversionChar conv() const {
// Keep this field first in the struct . It generates better code when // Keep this field first in the struct . It generates better code when
// accessing it when ConversionSpec is passed by value in registers. // accessing it when ConversionSpec is passed by value in registers.
...@@ -277,19 +289,28 @@ class ConversionSpec { ...@@ -277,19 +289,28 @@ class ConversionSpec {
// negative value. // negative value.
int precision() const { return precision_; } int precision() const { return precision_; }
void set_flags(Flags f) { flags_ = f; }
void set_conv(FormatConversionChar c) { conv_ = c; }
void set_width(int w) { width_ = w; }
void set_precision(int p) { precision_ = p; }
void set_left(bool b) { flags_.left = b; }
private: private:
friend struct str_format_internal::FormatConversionSpecImplFriend;
FormatConversionChar conv_ = FormatConversionChar::kNone; FormatConversionChar conv_ = FormatConversionChar::kNone;
Flags flags_; Flags flags_;
int width_; int width_;
int precision_; int precision_;
}; };
struct FormatConversionSpecImplFriend final {
static void SetFlags(Flags f, ConversionSpec* conv) { conv->flags_ = f; }
static void SetConversionChar(FormatConversionChar c, ConversionSpec* conv) {
conv->conv_ = c;
}
static void SetWidth(int w, ConversionSpec* conv) { conv->width_ = w; }
static void SetPrecision(int p, ConversionSpec* conv) {
conv->precision_ = p;
}
static std::string FlagsToString(const ConversionSpec& spec) {
return spec.flags_.ToString();
}
};
constexpr uint64_t FormatConversionCharToConvValue(char conv) { constexpr uint64_t FormatConversionCharToConvValue(char conv) {
return return
#define CONV_SET_CASE(c) \ #define CONV_SET_CASE(c) \
......
absl/strings/internal/str_format/float_conversion.cc
...@@ -28,7 +28,7 @@ bool FallbackToSnprintf(const Float v, const ConversionSpec &conv, ...@@ -28,7 +28,7 @@ bool FallbackToSnprintf(const Float v, const ConversionSpec &conv,
{ {
char *fp = fmt; char *fp = fmt;
*fp++ = '%'; *fp++ = '%';
fp = CopyStringTo(conv.flags().ToString(), fp); fp = CopyStringTo(FormatConversionSpecImplFriend::FlagsToString(conv), fp);
fp = CopyStringTo("*.*", fp); fp = CopyStringTo("*.*", fp);
if (std::is_same<long double, Float>()) { if (std::is_same<long double, Float>()) {
*fp++ = 'L'; *fp++ = 'L';
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment