Jie Luo
1 year ago
committed by
GitHub
commit
a077f68b1c
249 changed files with 9463 additions and 5376 deletions
File diff suppressed because it is too large
Load Diff
@ -1,20 +1,40 @@ |
||||
Recommended.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateFirstOnlyBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateFirstOnlyBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateFirstOnlyString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateFirstOnlyString |
||||
Recommended.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogatePairBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogatePairBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogatePairString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogatePairString |
||||
Recommended.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateSecondOnlyBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateSecondOnlyBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateSecondOnlyString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeSurrogateSecondOnlyString |
||||
Recommended.Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateFirstOnlyBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateFirstOnlyBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateFirstOnlyString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateFirstOnlyString |
||||
Recommended.Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogatePairBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogatePairBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogatePairString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogatePairString |
||||
Recommended.Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateSecondOnlyBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateSecondOnlyBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateSecondOnlyString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralShortUnicodeEscapeSurrogateSecondOnlyString |
||||
Recommended.Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairLongShortBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairLongShortBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairLongShortString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairLongShortString |
||||
Recommended.Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairShortLongBytes |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairShortLongBytes |
||||
Recommended.Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairShortLongString |
||||
Recommended.Editions_Proto3.TextFormatInput.StringLiteralUnicodeEscapeSurrogatePairShortLongString |
||||
Required.Proto3.TextFormatInput.StringFieldBadUTF8Hex |
||||
Required.Editions_Proto3.TextFormatInput.StringFieldBadUTF8Hex |
||||
Required.Proto3.TextFormatInput.StringFieldBadUTF8Octal |
||||
Required.Editions_Proto3.TextFormatInput.StringFieldBadUTF8Octal |
||||
Required.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeTooLargeBytes |
||||
Required.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeTooLargeBytes |
||||
Required.Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeTooLargeString |
||||
Required.Editions_Proto3.TextFormatInput.StringLiteralLongUnicodeEscapeTooLargeString |
||||
|
||||
@ -0,0 +1,150 @@ |
||||
# Editions: Feature Extension Layout |
||||
|
||||
**Author:** [@mkruskal-google](https://github.com/mkruskal-google), |
||||
[@zhangskz](https://github.com/zhangskz) |
||||
|
||||
**Approved:** 2023-08-23 |
||||
|
||||
## Background |
||||
|
||||
"[What are Protobuf Editions](what-are-protobuf-editions.md)" lays out a plan |
||||
for allowing for more targeted features not owned by the protobuf team. It uses |
||||
extensions of the global features proto to implement this. One thing that was |
||||
left a bit ambiguous was *who* should own these extensions. Language, code |
||||
generator, and runtime implementations are all similar but not identical |
||||
distinctions. |
||||
|
||||
"Editions Zero Feature: utf8_validation" (not available externally, though a |
||||
later version, |
||||
"[Editions Zero: utf8_validation Without Problematic Options](editions-zero-utf8_validation.md)" |
||||
is) is a recent plan to add a new set of generator features for utf8 validation. |
||||
While the sole feature we had originally created (`legacy_closed_enum` in Java |
||||
and C++) didn't have any ambiguity here, this one did. Specifically in Python, |
||||
the current behaviors across proto2/proto3 are distinct for all 3 |
||||
implementations: pure python, Python/C++, Python/upb. |
||||
|
||||
## Overview |
||||
|
||||
In meetings, we've discussed various alternatives, captured below. The original |
||||
plan was to make feature extensions runtime implementation-specific (e.g. C++, |
||||
Java, Python, upb). There are some notable complications that came up though: |
||||
|
||||
1. **Polyglot** - it's not clear how upb or C++ runtimes should behave in |
||||
multi-language situations. Which feature sets do they consider for runtime |
||||
behaviors? *Note: this is already a serious issue today, where all proto2 |
||||
strings and many proto3 strings are completely unsafe across languages.* |
||||
|
||||
2. **Shared Implementations** - Runtimes like upb and C++ are used as backing |
||||
implementations of multiple other languages (e.g. Python, Rust, Ruby, PHP). |
||||
If we have a single set of `upb` or `cpp` features, migrating to those |
||||
shared implementations would be more difficult (since there's no independent |
||||
switches per-language). *Note: this is already the situation we're in today, |
||||
where switching the runtime implementation can cause subtle and dangerous |
||||
behavior changes.* |
||||
|
||||
Given that we only have two behaviors, and one of them is unambiguous, it seems |
||||
reasonable to punt on this decision until we have more information. We may |
||||
encounter more edge cases that require feature extensions (and give us more |
||||
information) during the rollout of edition zero. We also have a lot of freedom |
||||
to re-model features in later editions, so keeping the initial implementation as |
||||
simple as possible seems best (i.e. Alternative 2). |
||||
|
||||
## Alternatives |
||||
|
||||
### Alternative 1: Runtime Implementation Features |
||||
|
||||
Features would be per-runtime implementation as originally described in |
||||
"Editions Zero Feature: utf8_validation." For example, Protobuf Python users |
||||
would set different features depending on the backing implementation (e.g. |
||||
`features.(pb.cpp).<feature>`, `features.(pb.upb).<feature>`). |
||||
|
||||
#### Pros |
||||
|
||||
* Most consistent with range of behaviors expressible pre-Editions |
||||
|
||||
#### Cons |
||||
|
||||
* Implementation may / should not be obvious to users. |
||||
* Lack of levers specifically for language / implementation combos. For |
||||
example, there is no way to set Python-C++ behavior independently of C++ |
||||
behavior which may make migration harder from other Python implementations. |
||||
|
||||
### Alternative 2: Generator Features |
||||
|
||||
Features would be per-generator only (i.e. each protoc plugin would own one set |
||||
of features). This was the second decision we made in later discussions, and |
||||
while very similar to the above alternative, it's more inline with our goal of |
||||
making features primarily for codegen. |
||||
|
||||
For example, all Python implementations would share the same set of features |
||||
(e.g. `features.(pb.python).<feature>`). However, certain features could be |
||||
targeted to specific implementations (e.g. |
||||
`features.(pb.python).upb_utf8_validation` would only be used by Python/upb). |
||||
|
||||
#### Pros |
||||
|
||||
* Allows independent controls of shared implementations in different target |
||||
languages (e.g. Python's upb feature won't affect PHP). |
||||
|
||||
#### Cons |
||||
|
||||
* Possible complexity in upb to understand which language's features to |
||||
respect. UPB is not currently aware of what language it is being used for. |
||||
* Limits in-process sharing across languages with shared implementations (e.g. |
||||
Python upb, PHP upb) in the case of conflicting behaviors. |
||||
* Additional checks may be needed. |
||||
|
||||
### Alternative 3: Migrate to bytes |
||||
|
||||
Since this whole discussion revolves around the utf8 validation feature, one |
||||
option would be to just remove it from edition zero. Instead of adding a new |
||||
toggle for UTF8 behavior, we could simply migrate everyone who doesn't enforce |
||||
utf8 today to `bytes`. This would likely need another new *codegen* feature for |
||||
generating byte getters/setters as strings, but that wouldn't have any of the |
||||
ambiguity we're seeing today. |
||||
|
||||
Unfortunately, this doesn't seem feasible because of all the different behaviors |
||||
laid out in "Editions Zero Feature: utf8_validation." UTF8 validation isn't |
||||
really a binary on/off decision, and it can vary widely between languages. There |
||||
are many cases where UTF8 is validated in **some** languages but not others, and |
||||
there's also the C++ "hint" behavior that logs errors but allows invalid UTF8. |
||||
|
||||
**Note:** This could still be partially done in a follow-up LSC by targeting |
||||
specific combinations of the new feature that disable validation in all relevant |
||||
languages. |
||||
|
||||
#### Pros |
||||
|
||||
* Punts on the issue, we wouldn't need any upb features and C++ features would |
||||
all be code-gen only |
||||
* Simplifies the situation, avoids adding a very complicated feature in |
||||
edition zero |
||||
|
||||
#### Cons |
||||
|
||||
* Not really possible given the current complexity |
||||
* There are O(10M) proto2 string fields that would be blindly changed to bytes |
||||
|
||||
### Alternative 4: Nested Features |
||||
|
||||
Another option is to allow for shared feature set messages. For example, upb |
||||
would define a feature message, but *not* make it an extension of the global |
||||
`FeatureSet`. Instead, languages with upb implementations would have a field of |
||||
this type to allow for finer-grained controls. C++ would both extend the global |
||||
`FeatureSet` and also be allowed as a field in other languages. |
||||
|
||||
For example, python utf8 validation could be specified as: |
||||
|
||||
We could have checks during feature validation that enforce that impossible |
||||
combinations aren't specified. For example, with our current implementation |
||||
`features.(pb.python).cpp` should always be identical to `features.(pb.cpp)`, |
||||
since we don't have any mechanism for distinguishing them. |
||||
|
||||
#### Pros |
||||
|
||||
* Much more explicit than options 1 and 2 |
||||
|
||||
#### Cons |
||||
|
||||
* Maybe too explicit? Proto owners would be forced to duplicate a lot of |
||||
features |
||||
@ -0,0 +1,144 @@ |
||||
# Legacy Syntax Editions |
||||
|
||||
**Author:** [@mkruskal-google](https://github.com/mkruskal-google) |
||||
|
||||
**Approved:** 2023-09-08 |
||||
|
||||
Should proto2/proto3 be treated as editions? |
||||
|
||||
## Background |
||||
|
||||
[Edition Zero Features](edition-zero-features.md) lays out our plan for edition |
||||
2023, which will unify proto2 and proto3. Since early in the design process, |
||||
we've discussed the possibility of making proto2 and proto3 "special" editions, |
||||
but never laid out what exactly it would look like or determined if it was |
||||
necessary. |
||||
|
||||
We recently redesigned editions to be represented as enums |
||||
([Edition Naming](edition-naming.md)), and also how edition defaults are |
||||
propagated to generators and runtimes |
||||
([Editions: Life of a FeatureSet](editions-life-of-a-featureset.md)). With these |
||||
changes, there could be an opportunity to special-case proto2 and proto3 in a |
||||
beneficial way. |
||||
|
||||
## Problem Description |
||||
|
||||
While the original plan was to keep editions and syntax orthogonal, that naively |
||||
means we'd be supporting two very different codebases. This has some serious |
||||
maintenance costs though, especially when it comes to test coverage. We could |
||||
expect to have sub-optimal test coverage of editions initially, which would |
||||
gradually become poor coverage of syntax later. Since we need to support both |
||||
syntax and editions long-term, this isn't ideal. |
||||
|
||||
In the implementation of editions in C++, we decided to unify a lot of the |
||||
infrastructure to avoid this issue. We define global feature sets for proto2 and |
||||
proto3, and try to use those internally instead of checking syntax directly. By |
||||
pushing the syntax/editions branch earlier in the stack, it gives us a lot of |
||||
indirect test coverage for editions much earlier. |
||||
|
||||
A separate issue is how Prototiller will support the conversion of syntax to |
||||
edition 2023. For features it knows about, we can hardcode defaults into the |
||||
transforms. However, third party feature owners will have no way of signaling |
||||
what the old proto2/proto3 behavior was, so Prototiller won't be able to provide |
||||
any transformations by default. They'd need to provide custom Prototiller |
||||
transforms hardcoding all of their features. |
||||
|
||||
## Recommended Solution |
||||
|
||||
We recommend adding two new special editions to our current set: |
||||
|
||||
``` |
||||
enum Edition { |
||||
EDITION_UNKNOWN = 0; |
||||
EDITION_PROTO2 = 998; |
||||
EDITION_PROTO3 = 999; |
||||
EDITION_2023 = 1000; |
||||
} |
||||
``` |
||||
|
||||
These will be treated the same as any other edition, except in our parser which |
||||
will reject `edition = "proto2"` and `edition = "proto3"` in proto files. The |
||||
real benefit here is that this allows features to specify what their |
||||
proto2/proto3 defaults are, making it easier for Prototiller to handle |
||||
migration. It also allows generators and runtimes to unify their internals more |
||||
completely, treating proto2/proto3 files exactly the same as editions. |
||||
|
||||
### Serialized Descriptors |
||||
|
||||
As we now know, there are a lot of serialized `descriptor.proto` descriptor sets |
||||
out there that need to continue working for O(months). In order to avoid |
||||
blocking edition zero for that long, we may need fallbacks in protoc for the |
||||
case where feature resolution *fails*. If the file is proto2/proto3, failure |
||||
should result in a fallback to the existing hardcoded defaults. We can remove |
||||
these later once we're willing to break stale `descriptor.proto` snapshots that |
||||
predate the changes in this doc. |
||||
|
||||
### Bootstrapping |
||||
|
||||
In order to get feature resolution running in proto2 and proto3, we need to be |
||||
able to support bootstrapped protos. For these builds, we can't use any |
||||
reflection without deadlocking, which means feature defaults can't be compiled |
||||
during runtime. We would have had to solve this problem anyway when it came time |
||||
to migrate these protos to editions, but this proposal forces our hand early. |
||||
Luckily, "Editions: Life of a FeatureSet" already set us up for this scenario, |
||||
and we have Blaze rules for embedding these defaults into code. For C++ |
||||
specifically, this will need to be checked in alongside the other bootstrapped |
||||
protos. Other languages will be able to do this more dynamically via genrules. |
||||
|
||||
### Feature Inference |
||||
|
||||
While we can calculate defaults using the same logic as in editions, actually |
||||
inferring "features" from proto2/proto3 needs some custom code. For example: |
||||
|
||||
* The `required` keyword sets `LEGACY_REQUIRED` feature |
||||
* The `optional` keyword in proto3 sets `EXPLICIT` presence |
||||
* The `group` keyword implies `DELIMITED` encoding |
||||
* The `enforce_utf8` options flips between `PACKED` and `EXPANDED` encoding |
||||
|
||||
This logic needs to be written in code, and will need to be duplicated in every |
||||
language we support. Any language-specific feature transformations will also |
||||
need to be included in that language. To make this as portable as possible, we |
||||
will define functions like: |
||||
|
||||
Each type of descriptor will have its own set of transformations that should be |
||||
applied to its features for legacy editions. |
||||
|
||||
#### Pros |
||||
|
||||
* Makes it clearer that proto2/proto3 are "like" editions |
||||
|
||||
* Gives Prototiller a little more information in the transformation from |
||||
proto2/proto3 to editions (not necessarily 2023) |
||||
|
||||
* Allows proto2/proto3 defaults to be specified in a single location |
||||
|
||||
* Makes unification of syntax/edition code easier to implement in runtimes |
||||
|
||||
* Allows cross-language proto2/proto3 testing with the conformance framework |
||||
mentioned in "Editions: Life of a FeatureSet" |
||||
|
||||
#### Cons |
||||
|
||||
* Adds special-case legacy editions, which may be somewhat confusing |
||||
|
||||
* We will need to port feature inference logic across all languages. This is |
||||
arguably cheaper than maintaining branched proto2/proto3 code in all |
||||
languages though |
||||
|
||||
## Considered Alternatives |
||||
|
||||
### Do Nothing |
||||
|
||||
If we do nothing, there will be no built-in unification of syntax and editions. |
||||
Runtimes could choose any point to split the logic. |
||||
|
||||
#### Pros |
||||
|
||||
* Requires no changes to editions code |
||||
|
||||
#### Cons |
||||
|
||||
* Likely results in lower test coverage |
||||
* May hide issues until we start rolling out edition 2023 |
||||
* Prototiller would have to hard-code proto2/proto3 defaults of features it |
||||
knows, and couldn't even try to migrate runtimes it doesn't |
||||
@ -0,0 +1,139 @@ |
||||
# Minimum Required Edition |
||||
|
||||
**Author:** [@mcy](https://github.com/mcy) |
||||
|
||||
**Approved:** 2022-11-15 |
||||
|
||||
A versioning mechanism for descriptors that ensures old runtimes do not load |
||||
descriptors that are "too new." |
||||
|
||||
## Background |
||||
|
||||
Suppose we decide to add a novel definition like |
||||
|
||||
``` |
||||
const int32 MY_CONSTANT = 42; |
||||
``` |
||||
|
||||
to the Protobuf language. This would entail a descriptor change to track the |
||||
values of constants, but they would not be loaded properly by older runtimes. |
||||
This document describes an addition to `descriptor.proto` that prevents this |
||||
version mismatch issue. |
||||
|
||||
[Protobuf Editions](what-are-protobuf-editions.md) intends to add the concept of |
||||
an edition to Protobuf, which will be an approximately-annually incrementing |
||||
value. Because of their annual nature, and because runtimes need to be updated |
||||
to handle new features they implement regardless, we can use them as a poison |
||||
pill for old runtimes that try to load descriptors that are "too new." |
||||
|
||||
## Overview |
||||
|
||||
We propose adding a new field to `FileDescriptorProto`: |
||||
|
||||
``` |
||||
optional string minimum_required_edition = ...; |
||||
``` |
||||
|
||||
This field would exist alongside the `edition` field, and would have the |
||||
following semantics: |
||||
|
||||
Every Protobuf runtime implementation must specify the newest edition whose |
||||
constructs it can handle (at a particular rev of that implementation). If that |
||||
edition is less than `minimum_required_edition`, loading the descriptor must |
||||
fail. |
||||
|
||||
"Less than" is defined per the edition total order given in |
||||
[Life of an Edition](life-of-an-edition.md). To restate it, it is the following |
||||
algorithm: |
||||
|
||||
``` |
||||
def edition_less_than(a, b): |
||||
parts_a = a.split(".") |
||||
parts_b = b.split(".") |
||||
for i in range(0, min(len(parts_a), len(parts_b))): |
||||
if int(parts_a[i]) < int(parts_b[i]): return True |
||||
return len(a) < len(b) |
||||
``` |
||||
|
||||
`protoc` should keep track of which constructions require which minimum edition. |
||||
For example, if constants are introduced in edition 2025, but they are not |
||||
present in a file, `protoc` should not require that runtimes understand |
||||
constants by picking a lower edition, like 2023 (assuming no other construct |
||||
requires a higher edition). |
||||
|
||||
In particular, the following changes should keep the minimum edition constant, |
||||
with all other things unchanged: |
||||
|
||||
* An upgrade of the proto compiler. |
||||
* Upgrading the specified edition of a file via Prototiller. |
||||
|
||||
### Bootstrapping Concerns |
||||
|
||||
"Epochs for `descriptor.proto`" (not available externally) describes a potential |
||||
issue with bootstrapping. It is not the case here: minimum edition is only |
||||
incremented once a particular file uses a new feature. Since `descriptor.proto` |
||||
and other schemas used by `protoc` and the backends would not use new features |
||||
immediately, introducing a new feature does not immediately stop the compiler |
||||
from being able to compile itself. |
||||
|
||||
### Concerns for Schema Producers |
||||
|
||||
Schema producers should consider changes to their schemas that increase the |
||||
minimum required edition to be breaking changes, since it will stop compiled |
||||
descriptors from being loaded at runtime. |
||||
|
||||
## Recommendation |
||||
|
||||
We recommend adding the aforementioned minimum required edition field, along |
||||
with the semantics it entails. This logic should be implemented entirely in the |
||||
protoc frontend. |
||||
|
||||
## Alternatives |
||||
|
||||
### Use a Non-Editions Version Number |
||||
|
||||
Rather than using the editions value, use some other version number. This number |
||||
would be incremented rarely (3-5 year horizon). This is the approach proposed |
||||
in "Epochs for `descriptor.proto`." |
||||
|
||||
#### Pros |
||||
|
||||
* Does not re-use the editions value for a semantically-different meaning; the |
||||
edition remains being "just" a key into a table of features defaults. |
||||
|
||||
#### Cons |
||||
|
||||
* Introduces another version number to Protobuf that increments at its own |
||||
cadence. |
||||
* Could potentially be confused with the edition value, even though they serve |
||||
distinct purposes. |
||||
|
||||
### Minimum Required Edition Should Not Be Minimal |
||||
|
||||
The proto compiler should not guarantee that the minimum required edition is as |
||||
small as it could possibly be. |
||||
|
||||
#### Pros |
||||
|
||||
* Reduces implementation burden. |
||||
|
||||
#### Cons |
||||
|
||||
* This introduces situations where an upgrade of the proto compiler, or an |
||||
innocuous change to a schema, can lead the the minimum required edition |
||||
being incremented. This is a problem for schema producers. |
||||
|
||||
### Do Nothing |
||||
|
||||
#### Pros |
||||
|
||||
* Reduces churn in runtimes, since they do not need to implement new handling |
||||
for new *editions* (as contrasted to just *features)* regularly. |
||||
* Avoids a situation where old software cannot load new descriptors at |
||||
runtime. |
||||
|
||||
#### Cons |
||||
|
||||
* Commits us to never changing the descriptor wire format in |
||||
backwards-incompatible ways, which has far-reaching effects on evolution. |
||||
These consequences are discussed in "Epochs for `descriptor.proto`." |
||||
@ -0,0 +1,597 @@ |
||||
<?php |
||||
|
||||
require_once('test_base.php'); |
||||
require_once('test_util.php'); |
||||
|
||||
use Google\Protobuf\Internal\RepeatedField; |
||||
use Google\Protobuf\Internal\GPBType; |
||||
use Foo\EmptyAnySerialization; |
||||
use Foo\TestInt32Value; |
||||
use Foo\TestStringValue; |
||||
use Foo\TestAny; |
||||
use Foo\TestEnum; |
||||
use Foo\TestLargeFieldNumber; |
||||
use Foo\TestMessage; |
||||
use Foo\TestMessage\Sub; |
||||
use Foo\TestPackedMessage; |
||||
use Foo\TestRandomFieldOrder; |
||||
use Foo\TestUnpackedMessage; |
||||
use Google\Protobuf\Any; |
||||
use Google\Protobuf\DoubleValue; |
||||
use Google\Protobuf\FieldMask; |
||||
use Google\Protobuf\FloatValue; |
||||
use Google\Protobuf\Int32Value; |
||||
use Google\Protobuf\UInt32Value; |
||||
use Google\Protobuf\Int64Value; |
||||
use Google\Protobuf\UInt64Value; |
||||
use Google\Protobuf\BoolValue; |
||||
use Google\Protobuf\StringValue; |
||||
use Google\Protobuf\BytesValue; |
||||
use Google\Protobuf\Value; |
||||
use Google\Protobuf\ListValue; |
||||
use Google\Protobuf\Struct; |
||||
use Google\Protobuf\GPBEmpty; |
||||
|
||||
class DebugInfoTest extends TestBase |
||||
{ |
||||
public function setUp(): void |
||||
{ |
||||
if (extension_loaded('protobuf')) { |
||||
$this->markTestSkipped('__debugInfo is not supported for the protobuf extension'); |
||||
} |
||||
} |
||||
|
||||
public function testVarDumpOutput() |
||||
{ |
||||
$m = new DoubleValue(); |
||||
$m->setValue(1.5); |
||||
var_dump($m); |
||||
$regex = <<<EOL |
||||
object(Google\Protobuf\DoubleValue)#%s (1) { |
||||
["value"]=> |
||||
float(1.5) |
||||
} |
||||
EOL; |
||||
$this->expectOutputRegex('/' . sprintf(preg_quote($regex), '\d+') . '/'); |
||||
} |
||||
|
||||
public function testTopLevelDoubleValue() |
||||
{ |
||||
$m = new DoubleValue(); |
||||
$m->setValue(1.5); |
||||
$this->assertSame(['value' => 1.5], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelFloatValue() |
||||
{ |
||||
$m = new FloatValue(); |
||||
$m->setValue(1.5); |
||||
$this->assertSame(['value' => 1.5], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelInt32Value() |
||||
{ |
||||
$m = new Int32Value(); |
||||
$m->setValue(1); |
||||
$this->assertSame(['value' => 1], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelUInt32Value() |
||||
{ |
||||
$m = new UInt32Value(); |
||||
$m->setValue(1); |
||||
$this->assertSame(['value' => 1], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelInt64Value() |
||||
{ |
||||
$m = new Int64Value(); |
||||
$m->setValue(1); |
||||
$this->assertSame(['value' => '1'], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelUInt64Value() |
||||
{ |
||||
$m = new UInt64Value(); |
||||
$m->setValue(1); |
||||
$this->assertSame(['value' => '1'], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelStringValue() |
||||
{ |
||||
$m = new StringValue(); |
||||
$m->setValue("a"); |
||||
$this->assertSame(['value' => 'a'], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelBoolValue() |
||||
{ |
||||
$m = new BoolValue(); |
||||
$m->setValue(true); |
||||
$this->assertSame(['value' => true], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelBytesValue() |
||||
{ |
||||
$m = new BytesValue(); |
||||
$m->setValue("a"); |
||||
$this->assertSame(['value' => 'YQ=='], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelLongBytesValue() |
||||
{ |
||||
$m = new BytesValue(); |
||||
$data = $this->generateRandomString(12007); |
||||
$m->setValue($data); |
||||
$expected = base64_encode($data); |
||||
$this->assertSame(['value' => $expected], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testJsonEncodeNullSubMessage() |
||||
{ |
||||
$from = new TestMessage(); |
||||
$from->setOptionalMessage(null); |
||||
$data = $from->__debugInfo(); |
||||
$this->assertEquals([], $data); |
||||
} |
||||
|
||||
public function testDuration() |
||||
{ |
||||
$m = new Google\Protobuf\Duration(); |
||||
$m->setSeconds(1234); |
||||
$m->setNanos(999999999); |
||||
$this->assertEquals([ |
||||
'seconds' => 1234, |
||||
'nanos' => 999999999, |
||||
], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTimestamp() |
||||
{ |
||||
$m = new Google\Protobuf\Timestamp(); |
||||
$m->setSeconds(946684800); |
||||
$m->setNanos(123456789); |
||||
$this->assertEquals([ |
||||
'seconds' => 946684800, |
||||
'nanos' => 123456789, |
||||
], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelValue() |
||||
{ |
||||
$m = new Value(); |
||||
$m->setStringValue("a"); |
||||
$this->assertSame(['stringValue' => 'a'], $m->__debugInfo()); |
||||
|
||||
$m = new Value(); |
||||
$m->setNumberValue(1.5); |
||||
$this->assertSame(['numberValue' => 1.5], $m->__debugInfo()); |
||||
|
||||
$m = new Value(); |
||||
$m->setBoolValue(true); |
||||
$this->assertSame(['boolValue' => true], $m->__debugInfo()); |
||||
|
||||
$m = new Value(); |
||||
$m->setNullValue(\Google\Protobuf\NullValue::NULL_VALUE); |
||||
$this->assertSame(['nullValue' => 0], $m->__debugInfo()); |
||||
|
||||
$m = new Value(); |
||||
$struct = new Struct(); |
||||
$map = $struct->getFields(); |
||||
$sub = new Value(); |
||||
$sub->setNumberValue(1.5); |
||||
$map["a"] = $sub; |
||||
$m->setStructValue($struct); |
||||
$this->assertSame(['structValue' => ['a' => 1.5]], $m->__debugInfo()); |
||||
|
||||
$m = new Value(); |
||||
$list = new ListValue(); |
||||
$arr = $list->getValues(); |
||||
$sub = new Value(); |
||||
$sub->setNumberValue(1.5); |
||||
$arr[] = $sub; |
||||
$m->setListValue($list); |
||||
$this->assertSame(['listValue' => [1.5]], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelListValue() |
||||
{ |
||||
$m = new ListValue(); |
||||
$arr = $m->getValues(); |
||||
$sub = new Value(); |
||||
$sub->setNumberValue(1.5); |
||||
$arr[] = $sub; |
||||
$this->assertSame([1.5], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testEmptyListValue() |
||||
{ |
||||
$m = new Struct(); |
||||
$m->setFields(['test' => (new Value())->setListValue(new ListValue())]); |
||||
$this->assertSame(['test' => []], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelStruct() |
||||
{ |
||||
$m = new Struct(); |
||||
$map = $m->getFields(); |
||||
$sub = new Value(); |
||||
$sub->setNumberValue(1.5); |
||||
$map["a"] = $sub; |
||||
$this->assertSame(['a' => 1.5], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testEmptyStruct() |
||||
{ |
||||
$m = new Struct(); |
||||
$m->setFields(['test' => (new Value())->setStructValue(new Struct())]); |
||||
$this->assertSame(['test' => []], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testEmptyValue() |
||||
{ |
||||
$m = new Value(); |
||||
$this->assertSame([], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelAny() |
||||
{ |
||||
// Test a normal message. |
||||
$packed = new TestMessage(); |
||||
$packed->setOptionalInt32(123); |
||||
$packed->setOptionalString("abc"); |
||||
|
||||
$m = new Any(); |
||||
$m->pack($packed); |
||||
$expected = [ |
||||
'@type' => 'type.googleapis.com/foo.TestMessage', |
||||
'optionalInt32' => 123, |
||||
'optionalString' => 'abc', |
||||
]; |
||||
$result = $m->__debugInfo(); |
||||
$this->assertSame($expected, $result); |
||||
|
||||
// Test a well known message. |
||||
$packed = new Int32Value(); |
||||
$packed->setValue(123); |
||||
|
||||
$m = new Any(); |
||||
$m->pack($packed); |
||||
$this->assertSame([ |
||||
'@type' => 'type.googleapis.com/google.protobuf.Int32Value', |
||||
'value' => 123 |
||||
], $m->__debugInfo()); |
||||
|
||||
// Test an Any message. |
||||
$outer = new Any(); |
||||
$outer->pack($m); |
||||
$this->assertSame([ |
||||
'@type' => 'type.googleapis.com/google.protobuf.Any', |
||||
'value' => [ |
||||
'@type' => 'type.googleapis.com/google.protobuf.Int32Value', |
||||
'value' => 123 |
||||
], |
||||
], $outer->__debugInfo()); |
||||
|
||||
// Test a Timestamp message. |
||||
$packed = new Google\Protobuf\Timestamp(); |
||||
$packed->setSeconds(946684800); |
||||
$packed->setNanos(123456789); |
||||
$m = new Any(); |
||||
$m->pack($packed); |
||||
$this->assertSame([ |
||||
'@type' => 'type.googleapis.com/google.protobuf.Timestamp', |
||||
'value' => '2000-01-01T00:00:00.123456789Z', |
||||
], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testAnyWithDefaultWrapperMessagePacked() |
||||
{ |
||||
$any = new Any(); |
||||
$any->pack(new TestInt32Value([ |
||||
'field' => new Int32Value(['value' => 0]), |
||||
])); |
||||
$this->assertSame( |
||||
['@type' => 'type.googleapis.com/foo.TestInt32Value', 'field' => 0], |
||||
$any->__debugInfo() |
||||
); |
||||
} |
||||
|
||||
public function testTopLevelFieldMask() |
||||
{ |
||||
$m = new FieldMask(); |
||||
$m->setPaths(["foo.bar_baz", "qux"]); |
||||
$this->assertSame(['paths' => ['foo.bar_baz', 'qux']], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testEmptyAnySerialization() |
||||
{ |
||||
$m = new EmptyAnySerialization(); |
||||
|
||||
$any = new Any(); |
||||
$any->pack($m); |
||||
|
||||
$data = $any->__debugInfo(); |
||||
$this->assertEquals(['@type' => 'type.googleapis.com/foo.EmptyAnySerialization'], $data); |
||||
} |
||||
|
||||
public function testRepeatedStringValue() |
||||
{ |
||||
$m = new TestStringValue(); |
||||
$r = [new StringValue(['value' => 'a'])]; |
||||
$m->setRepeatedField($r); |
||||
$this->assertSame(['repeatedField' => ['a']], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testMapStringValue() |
||||
{ |
||||
$m = new TestStringValue(); |
||||
$m->mergeFromJsonString("{\"map_field\":{\"1\": \"a\"}}"); |
||||
$this->assertSame(['mapField' => [1 => 'a']], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testNestedAny() |
||||
{ |
||||
// Make sure packed message has been created at least once. |
||||
$m = new TestAny(); |
||||
$m->mergeFromJsonString( |
||||
"{\"any\":{\"optionalInt32\": 1, " . |
||||
"\"@type\":\"type.googleapis.com/foo.TestMessage\", " . |
||||
"\"optionalInt64\": 2}}"); |
||||
$this->assertSame([ |
||||
'any' => [ |
||||
'@type' => 'type.googleapis.com/foo.TestMessage', |
||||
'optionalInt32' => 1, |
||||
'optionalInt64' => '2', |
||||
] |
||||
], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testEnum() |
||||
{ |
||||
$m = new TestMessage(); |
||||
$m->setOneofEnum(TestEnum::ZERO); |
||||
$this->assertSame(['oneofEnum' => 'ZERO'], $m->__debugInfo()); |
||||
} |
||||
|
||||
public function testTopLevelRepeatedField() |
||||
{ |
||||
$r1 = new RepeatedField(GPBType::class); |
||||
$r1[] = 'a'; |
||||
$this->assertSame(['a'], $r1->__debugInfo()); |
||||
|
||||
$r2 = new RepeatedField(TestMessage::class); |
||||
$r2[] = new TestMessage(['optional_int32' => -42]); |
||||
$r2[] = new TestMessage(['optional_int64' => 43]); |
||||
$this->assertSame([ |
||||
['optionalInt32' => -42], |
||||
['optionalInt64' => '43'], |
||||
], $r2->__debugInfo()); |
||||
|
||||
$r3 = new RepeatedField(RepeatedField::class); |
||||
$r3[] = $r1; |
||||
$r3[] = $r2; |
||||
|
||||
$this->assertSame([ |
||||
['a'], |
||||
[ |
||||
['optionalInt32' => -42], |
||||
['optionalInt64' => '43'], |
||||
], |
||||
], $r3->__debugInfo()); |
||||
} |
||||
|
||||
public function testEverything() |
||||
{ |
||||
$m = new TestMessage([ |
||||
'optional_int32' => -42, |
||||
'optional_int64' => -43, |
||||
'optional_uint32' => 42, |
||||
'optional_uint64' => 43, |
||||
'optional_sint32' => -44, |
||||
'optional_sint64' => -45, |
||||
'optional_fixed32' => 46, |
||||
'optional_fixed64' => 47, |
||||
'optional_sfixed32' => -46, |
||||
'optional_sfixed64' => -47, |
||||
'optional_float' => 1.5, |
||||
'optional_double' => 1.6, |
||||
'optional_bool' => true, |
||||
'optional_string' => 'a', |
||||
'optional_bytes' => 'bbbb', |
||||
'optional_enum' => TestEnum::ONE, |
||||
'optional_message' => new Sub([ |
||||
'a' => 33 |
||||
]), |
||||
'repeated_int32' => [-42, -52], |
||||
'repeated_int64' => [-43, -53], |
||||
'repeated_uint32' => [42, 52], |
||||
'repeated_uint64' => [43, 53], |
||||
'repeated_sint32' => [-44, -54], |
||||
'repeated_sint64' => [-45, -55], |
||||
'repeated_fixed32' => [46, 56], |
||||
'repeated_fixed64' => [47, 57], |
||||
'repeated_sfixed32' => [-46, -56], |
||||
'repeated_sfixed64' => [-47, -57], |
||||
'repeated_float' => [1.5, 2.5], |
||||
'repeated_double' => [1.6, 2.6], |
||||
'repeated_bool' => [true, false], |
||||
'repeated_string' => ['a', 'c'], |
||||
'repeated_bytes' => ['bbbb', 'dddd'], |
||||
'repeated_enum' => [TestEnum::ZERO, TestEnum::ONE], |
||||
'repeated_message' => [new Sub(['a' => 34]), |
||||
new Sub(['a' => 35])], |
||||
'map_int32_int32' => [-62 => -62], |
||||
'map_int64_int64' => [-63 => -63], |
||||
'map_uint32_uint32' => [62 => 62], |
||||
'map_uint64_uint64' => [63 => 63], |
||||
'map_sint32_sint32' => [-64 => -64], |
||||
'map_sint64_sint64' => [-65 => -65], |
||||
'map_fixed32_fixed32' => [66 => 66], |
||||
'map_fixed64_fixed64' => [67 => 67], |
||||
'map_sfixed32_sfixed32' => [-68 => -68], |
||||
'map_sfixed64_sfixed64' => [-69 => -69], |
||||
'map_int32_float' => [1 => 3.5], |
||||
'map_int32_double' => [1 => 3.6], |
||||
'map_bool_bool' => [true => true], |
||||
'map_string_string' => ['e' => 'e'], |
||||
'map_int32_bytes' => [1 => 'ffff'], |
||||
'map_int32_enum' => [1 => TestEnum::ONE], |
||||
'map_int32_message' => [1 => new Sub(['a' => 36])], |
||||
]); |
||||
|
||||
$this->assertSame([ |
||||
'optionalInt32' => -42, |
||||
'optionalInt64' => '-43', |
||||
'optionalUint32' => 42, |
||||
'optionalUint64' => '43', |
||||
'optionalSint32' => -44, |
||||
'optionalSint64' => '-45', |
||||
'optionalFixed32' => 46, |
||||
'optionalFixed64' => '47', |
||||
'optionalSfixed32' => -46, |
||||
'optionalSfixed64' => '-47', |
||||
'optionalFloat' => 1.5, |
||||
'optionalDouble' => 1.6, |
||||
'optionalBool' => true, |
||||
'optionalString' => 'a', |
||||
'optionalBytes' => 'YmJiYg==', |
||||
'optionalEnum' => 'ONE', |
||||
'optionalMessage' => [ |
||||
'a' => 33, |
||||
], |
||||
'repeatedInt32' => [ |
||||
-42, |
||||
-52, |
||||
], |
||||
'repeatedInt64' => [ |
||||
'-43', |
||||
'-53', |
||||
], |
||||
'repeatedUint32' => [ |
||||
42, |
||||
52, |
||||
], |
||||
'repeatedUint64' => [ |
||||
'43', |
||||
'53', |
||||
], |
||||
'repeatedSint32' => [ |
||||
-44, |
||||
-54, |
||||
], |
||||
'repeatedSint64' => [ |
||||
'-45', |
||||
'-55', |
||||
], |
||||
'repeatedFixed32' => [ |
||||
46, |
||||
56, |
||||
], |
||||
'repeatedFixed64' => [ |
||||
'47', |
||||
'57', |
||||
], |
||||
'repeatedSfixed32' => [ |
||||
-46, |
||||
-56, |
||||
], |
||||
'repeatedSfixed64' => [ |
||||
'-47', |
||||
'-57', |
||||
], |
||||
'repeatedFloat' => [ |
||||
1.5, |
||||
2.5, |
||||
], |
||||
'repeatedDouble' => [ |
||||
1.6, |
||||
2.6, |
||||
], |
||||
'repeatedBool' => [ |
||||
true, |
||||
false, |
||||
], |
||||
'repeatedString' => [ |
||||
'a', |
||||
'c', |
||||
], |
||||
'repeatedBytes' => [ |
||||
'YmJiYg==', |
||||
'ZGRkZA==', |
||||
], |
||||
'repeatedEnum' => [ |
||||
'ZERO', |
||||
'ONE', |
||||
], |
||||
'repeatedMessage' => [ |
||||
[ |
||||
'a' => 34, |
||||
], |
||||
[ |
||||
'a' => 35, |
||||
], |
||||
], |
||||
'mapInt32Int32' => [ |
||||
-62 => -62, |
||||
], |
||||
'mapInt64Int64' => [ |
||||
-63 => '-63', |
||||
], |
||||
'mapUint32Uint32' => [ |
||||
62 => 62, |
||||
], |
||||
'mapUint64Uint64' => [ |
||||
63 => '63', |
||||
], |
||||
'mapSint32Sint32' => [ |
||||
-64 => -64, |
||||
], |
||||
'mapSint64Sint64' => [ |
||||
-65 => '-65', |
||||
], |
||||
'mapFixed32Fixed32' => [ |
||||
66 => 66, |
||||
], |
||||
'mapFixed64Fixed64' => [ |
||||
67 => '67', |
||||
], |
||||
'mapSfixed32Sfixed32' => [ |
||||
-68 => -68, |
||||
], |
||||
'mapSfixed64Sfixed64' => [ |
||||
-69 => '-69', |
||||
], |
||||
'mapInt32Float' => [ |
||||
1 => 3.5, |
||||
], |
||||
'mapInt32Double' => [ |
||||
1 => 3.6, |
||||
], |
||||
'mapBoolBool' => [ |
||||
'true' => true, |
||||
], |
||||
'mapStringString' => [ |
||||
'e' => 'e', |
||||
], |
||||
'mapInt32Bytes' => [ |
||||
1 => 'ZmZmZg==', |
||||
], |
||||
'mapInt32Enum' => [ |
||||
1 => 'ONE', |
||||
], |
||||
'mapInt32Message' => [ |
||||
1 => ['a' => 36], |
||||
], |
||||
], $m->__debugInfo()); |
||||
} |
||||
|
||||
private function generateRandomString($length = 10) |
||||
{ |
||||
$randomString = str_repeat("+", $length); |
||||
for ($i = 0; $i < $length; $i++) { |
||||
$randomString[$i] = chr(rand(0, 255)); |
||||
} |
||||
return $randomString; |
||||
} |
||||
} |
||||
@ -0,0 +1,39 @@ |
||||
#include "google/protobuf/repeated_field.h" |
||||
|
||||
extern "C" { |
||||
|
||||
#define expose_repeated_field_methods(ty, rust_ty) \ |
||||
google::protobuf::RepeatedField<ty>* __pb_rust_RepeatedField_##rust_ty##_new() { \
|
||||
return new google::protobuf::RepeatedField<ty>(); \
|
||||
} \
|
||||
void __pb_rust_RepeatedField_##rust_ty##_add(google::protobuf::RepeatedField<ty>* r, \
|
||||
ty val) { \
|
||||
r->Add(val); \
|
||||
} \
|
||||
size_t __pb_rust_RepeatedField_##rust_ty##_size( \
|
||||
google::protobuf::RepeatedField<ty>* r) { \
|
||||
return r->size(); \
|
||||
} \
|
||||
ty __pb_rust_RepeatedField_##rust_ty##_get(google::protobuf::RepeatedField<ty>* r, \
|
||||
size_t index) { \
|
||||
return r->Get(index); \
|
||||
} \
|
||||
void __pb_rust_RepeatedField_##rust_ty##_set(google::protobuf::RepeatedField<ty>* r, \
|
||||
size_t index, ty val) { \
|
||||
return r->Set(index, val); \
|
||||
} \
|
||||
void __pb_rust_RepeatedField_##rust_ty##_copy_from( \
|
||||
google::protobuf::RepeatedField<ty> const& src, google::protobuf::RepeatedField<ty>& dst) { \
|
||||
dst.CopyFrom(src); \
|
||||
} |
||||
|
||||
expose_repeated_field_methods(int32_t, i32); |
||||
expose_repeated_field_methods(uint32_t, u32); |
||||
expose_repeated_field_methods(float, f32); |
||||
expose_repeated_field_methods(double, f64); |
||||
expose_repeated_field_methods(bool, bool); |
||||
expose_repeated_field_methods(uint64_t, u64); |
||||
expose_repeated_field_methods(int64_t, i64); |
||||
|
||||
#undef expose_repeated_field_methods |
||||
} |
||||
@ -0,0 +1,233 @@ |
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2023 Google LLC. All rights reserved.
|
||||
//
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file or at
|
||||
// https://developers.google.com/open-source/licenses/bsd
|
||||
|
||||
/// Repeated scalar fields are implemented around the runtime-specific
|
||||
/// `RepeatedField` struct. `RepeatedField` stores an opaque pointer to the
|
||||
/// runtime-specific representation of a repeated scalar (`upb_Array*` on upb,
|
||||
/// and `RepeatedField<T>*` on cpp).
|
||||
use std::marker::PhantomData; |
||||
|
||||
use crate::{ |
||||
Mut, MutProxy, Proxied, SettableValue, View, ViewProxy, |
||||
__internal::{Private, RawRepeatedField}, |
||||
__runtime::{RepeatedField, RepeatedFieldInner}, |
||||
primitive::PrimitiveMut, |
||||
vtable::ProxiedWithRawVTable, |
||||
}; |
||||
|
||||
#[derive(Clone, Copy)] |
||||
pub struct RepeatedFieldRef<'a> { |
||||
pub repeated_field: RawRepeatedField, |
||||
pub _phantom: PhantomData<&'a mut ()>, |
||||
} |
||||
|
||||
unsafe impl<'a> Send for RepeatedFieldRef<'a> {} |
||||
unsafe impl<'a> Sync for RepeatedFieldRef<'a> {} |
||||
|
||||
#[derive(Clone, Copy)] |
||||
#[repr(transparent)] |
||||
pub struct RepeatedView<'a, T: ?Sized> { |
||||
inner: RepeatedField<'a, T>, |
||||
} |
||||
|
||||
unsafe impl<'a, T: ProxiedWithRawVTable> Sync for RepeatedView<'a, T> {} |
||||
unsafe impl<'a, T: ProxiedWithRawVTable> Send for RepeatedView<'a, T> {} |
||||
|
||||
impl<'msg, T: ?Sized> RepeatedView<'msg, T> { |
||||
pub fn from_inner(_private: Private, inner: RepeatedFieldInner<'msg>) -> Self { |
||||
Self { inner: RepeatedField::<'msg>::from_inner(_private, inner) } |
||||
} |
||||
} |
||||
|
||||
pub struct RepeatedFieldIter<'a, T> { |
||||
inner: RepeatedField<'a, T>, |
||||
current_index: usize, |
||||
} |
||||
|
||||
impl<'a, T> std::fmt::Debug for RepeatedView<'a, T> { |
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
||||
f.debug_tuple("RepeatedView").finish() |
||||
} |
||||
} |
||||
|
||||
#[repr(transparent)] |
||||
#[derive(Debug)] |
||||
pub struct RepeatedMut<'a, T: ?Sized> { |
||||
inner: RepeatedField<'a, T>, |
||||
} |
||||
|
||||
unsafe impl<'a, T: ProxiedWithRawVTable> Sync for RepeatedMut<'a, T> {} |
||||
|
||||
impl<'msg, T: ?Sized> RepeatedMut<'msg, T> { |
||||
pub fn from_inner(_private: Private, inner: RepeatedFieldInner<'msg>) -> Self { |
||||
Self { inner: RepeatedField::from_inner(_private, inner) } |
||||
} |
||||
pub fn as_mut(&self) -> RepeatedMut<'_, T> { |
||||
Self { inner: self.inner } |
||||
} |
||||
} |
||||
|
||||
impl<'a, T> std::ops::Deref for RepeatedMut<'a, T> { |
||||
type Target = RepeatedView<'a, T>; |
||||
fn deref(&self) -> &Self::Target { |
||||
// SAFETY:
|
||||
// - `Repeated{View,Mut}<'a, T>` are both `#[repr(transparent)]` over
|
||||
// `RepeatedField<'a, T>`.
|
||||
// - `RepeatedField` is a type alias for `NonNull`.
|
||||
unsafe { &*(self as *const Self as *const RepeatedView<'a, T>) } |
||||
} |
||||
} |
||||
|
||||
pub struct RepeatedFieldIterMut<'a, T> { |
||||
inner: RepeatedMut<'a, T>, |
||||
current_index: usize, |
||||
} |
||||
|
||||
pub struct Repeated<T>(PhantomData<T>); |
||||
|
||||
macro_rules! impl_repeated_primitives { |
||||
($($t:ty),*) => { |
||||
$( |
||||
impl Proxied for Repeated<$t> { |
||||
type View<'a> = RepeatedView<'a, $t>; |
||||
type Mut<'a> = RepeatedMut<'a, $t>; |
||||
} |
||||
|
||||
impl<'a> ViewProxy<'a> for RepeatedView<'a, $t> { |
||||
type Proxied = Repeated<$t>; |
||||
|
||||
fn as_view(&self) -> View<'_, Self::Proxied> { |
||||
*self |
||||
} |
||||
|
||||
fn into_view<'shorter>(self) -> View<'shorter, Self::Proxied> |
||||
where 'a: 'shorter, |
||||
{ |
||||
RepeatedView { inner: self.inner } |
||||
} |
||||
} |
||||
|
||||
impl<'a> ViewProxy<'a> for RepeatedMut<'a, $t> { |
||||
type Proxied = Repeated<$t>; |
||||
|
||||
fn as_view(&self) -> View<'_, Self::Proxied> { |
||||
**self |
||||
} |
||||
|
||||
fn into_view<'shorter>(self) -> View<'shorter, Self::Proxied> |
||||
where 'a: 'shorter, |
||||
{ |
||||
*self.into_mut::<'shorter>() |
||||
} |
||||
} |
||||
|
||||
impl<'a> MutProxy<'a> for RepeatedMut<'a, $t> { |
||||
fn as_mut(&mut self) -> Mut<'_, Self::Proxied> { |
||||
RepeatedMut { inner: self.inner } |
||||
} |
||||
|
||||
fn into_mut<'shorter>(self) -> Mut<'shorter, Self::Proxied> |
||||
where 'a: 'shorter, |
||||
{ |
||||
RepeatedMut { inner: self.inner } |
||||
} |
||||
} |
||||
|
||||
impl <'a> SettableValue<Repeated<$t>> for RepeatedView<'a, $t> { |
||||
fn set_on(self, _private: Private, mut mutator: Mut<'_, Repeated<$t>>) { |
||||
mutator.copy_from(self); |
||||
} |
||||
} |
||||
|
||||
impl<'a> RepeatedView<'a, $t> { |
||||
pub fn len(&self) -> usize { |
||||
self.inner.len() |
||||
} |
||||
pub fn is_empty(&self) -> bool { |
||||
self.len() == 0 |
||||
} |
||||
pub fn get(&self, index: usize) -> Option<$t> { |
||||
self.inner.get(index) |
||||
} |
||||
pub fn iter(&self) -> RepeatedFieldIter<'_, $t> { |
||||
(*self).into_iter() |
||||
} |
||||
} |
||||
|
||||
impl<'a> RepeatedMut<'a, $t> { |
||||
pub fn push(&mut self, val: $t) { |
||||
self.inner.push(val) |
||||
} |
||||
pub fn set(&mut self, index: usize, val: $t) { |
||||
self.inner.set(index, val) |
||||
} |
||||
pub fn get_mut(&mut self, index: usize) -> Option<Mut<'_, $t>> { |
||||
if index >= self.len() { |
||||
return None; |
||||
} |
||||
Some(PrimitiveMut::Repeated(self.as_mut(), index)) |
||||
} |
||||
pub fn iter(&self) -> RepeatedFieldIter<'_, $t> { |
||||
self.as_view().into_iter() |
||||
} |
||||
pub fn iter_mut(&mut self) -> RepeatedFieldIterMut<'_, $t> { |
||||
self.as_mut().into_iter() |
||||
} |
||||
pub fn copy_from(&mut self, src: RepeatedView<'_, $t>) { |
||||
self.inner.copy_from(&src.inner); |
||||
} |
||||
} |
||||
|
||||
impl<'a> std::iter::Iterator for RepeatedFieldIter<'a, $t> { |
||||
type Item = $t; |
||||
fn next(&mut self) -> Option<Self::Item> { |
||||
let val = self.inner.get(self.current_index); |
||||
if val.is_some() { |
||||
self.current_index += 1; |
||||
} |
||||
val |
||||
} |
||||
} |
||||
|
||||
impl<'a> std::iter::IntoIterator for RepeatedView<'a, $t> { |
||||
type Item = $t; |
||||
type IntoIter = RepeatedFieldIter<'a, $t>; |
||||
fn into_iter(self) -> Self::IntoIter { |
||||
RepeatedFieldIter { inner: self.inner, current_index: 0 } |
||||
} |
||||
} |
||||
|
||||
impl <'a> std::iter::Iterator for RepeatedFieldIterMut<'a, $t> { |
||||
type Item = Mut<'a, $t>; |
||||
fn next(&mut self) -> Option<Self::Item> { |
||||
if self.current_index >= self.inner.len() { |
||||
return None; |
||||
} |
||||
let elem = PrimitiveMut::Repeated( |
||||
// While this appears to allow mutable aliasing
|
||||
// (multiple `Self::Item`s can co-exist), each `Item`
|
||||
// only references a specific unique index.
|
||||
RepeatedMut{ inner: self.inner.inner }, |
||||
self.current_index, |
||||
); |
||||
self.current_index += 1; |
||||
Some(elem) |
||||
} |
||||
} |
||||
|
||||
impl<'a> std::iter::IntoIterator for RepeatedMut<'a, $t> { |
||||
type Item = Mut<'a, $t>; |
||||
type IntoIter = RepeatedFieldIterMut<'a, $t>; |
||||
fn into_iter(self) -> Self::IntoIter { |
||||
RepeatedFieldIterMut { inner: self, current_index: 0 } |
||||
} |
||||
} |
||||
)* |
||||
} |
||||
} |
||||
|
||||
impl_repeated_primitives!(i32, u32, bool, f32, f64, i64, u64); |
||||
@ -1,29 +0,0 @@ |
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
//
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file or at
|
||||
// https://developers.google.com/open-source/licenses/bsd
|
||||
|
||||
#include "google/protobuf/compiler/allowlists/allowlists.h" |
||||
|
||||
#include "absl/strings/string_view.h" |
||||
#include "google/protobuf/compiler/allowlists/allowlist.h" |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
namespace compiler { |
||||
|
||||
// NOTE: Allowlists in this file are not accepting new entries unless otherwise
|
||||
// specified.
|
||||
|
||||
static constexpr auto kWeakImports = internal::MakeAllowlist({ |
||||
// Intentionally left blank.
|
||||
}); |
||||
|
||||
bool IsWeakImportFile(absl::string_view file) { |
||||
return kWeakImports.Allows(file); |
||||
} |
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue