Chiebot-Mirror/protobuf - protobuf - Gitea: Git with a cup of tea

Author	SHA1	Message	Date
Jakob Buchgraber	991a2f4d54	#refactor Simplify maps through the new ProxiedInMapValue<K> trait This change is a pure refactoring and simplification of the code. We replace all MapsWith<TYPE>KeyOps traits through a single generic ProxiedInMapValue<K> trait. Through connecting the runtime maps implementation with Proxied the code gets a lot simpler e.g. we can use View<T> instead of hardcoding the concrete type behind it. I also expect this change to be beneficial for the gencode. In a subsequent CL we'll implement message values for maps. After this change we'll only have to implement a single trait, while before we had to implement num(key types) many traits. PiperOrigin-RevId: 596562909	11 months ago
Jakob Buchgraber	b539fa9c05	#cleanup Drop MapWithKeyOps::Value type in favor of Proxied::View. PiperOrigin-RevId: 592497727	11 months ago
Alyssa Haroldsen	1dd6a7d06e	Clean up some trivial lifetime usage - Rename most usage of `'a` to `'msg` - Remove a no-op unused lifetime param for `remove` in maps - Elide lifetimes recommended by clippy PiperOrigin-RevId: 589878364	12 months ago
Jakob Buchgraber	976029283f	Implement Maps for strings This change implements maps with keys and values of type string e.g. Map<ProtoStr, i32> and Map<ProtoStr, ProtoStr>. Implementing the Map type for ProtoStr has been different from scalar types because ProtoStr is an unsized type i.e. its size is not known at compile time. The existing Map implementation assumed sized types in many places. To make unsized types fit into the existing code architecture I have added an associated type 'Value' to the MapWith*KeyOps traits. The associated type needs to be sized and is the type returned by the Map::get(self, key) method e.g. for aProtoStr, the `type Value = &ProtoStr`. PiperOrigin-RevId: 588783751	12 months ago
Hong Shin	94ebf577e3	Squelch warning regarding map_view mut PiperOrigin-RevId: 586692967	1 year ago
Jakob Buchgraber	ab11a0d1a8	Name the lifetime in the signature of SettableValue.set_on() This change names the lifetime of Mut<'a, T> and requires that T outlives 'a. The motivation for this change came up while implementing `Map<K, ProtoStr>`. The Map implementation makes it so that `V` needs to implement the `MapWithKeyOps` trait which has an associated type with a lifetime (`Value<'a>`. The lifetime bound on `T` ensures that e.g. for `MapWithKeyOps<Value<'b>=&'b ProtoStr>` `'a` outlives `'b`. PiperOrigin-RevId: 585657154	1 year ago
Jakob Buchgraber	95073f8e78	Implement Proxied for Maps This change implements the Proxied trait for the Map type. It leaves a TODO to implement SettableValue. I haven't implemented SettableValue yet because I have not yet been able to verify that we get the right copy_from semantics for both kernels. I'll implement set_on in a follow up. PiperOrigin-RevId: 584285061	1 year ago
Jakob Buchgraber	245a6e692a	Remove the protobuf::__runtime::Map type Before this change the runtimes export a Map and MapInner. This change merges the Map and MapInner types into a single MapInner type, removing the Map type from the runtime (upb.rs, cpp.rs). The motivation for this change is twofold: 1) A separate Map type is not strictly needed by the runtime. I hope this reduces some complexity. 2) After this change we can introduce a runtime-agnostic protobuf::Map type that implements Proxied. PiperOrigin-RevId: 582978008	1 year ago
Jakob Buchgraber	001be3c655	Implement Maps for scalar types for the C++ kernel This CL implements Maps for scalar types for the C++ runtime. It's orthogonal to cl/580453646. This CL is constrained by having to force template instantiation of proto2::Map<K, V>. Put differently, a Rust protobuf::Map<K, V> implementation needs to call 'extern "C"' functions with both key and value type in the function name (e.g. __pb_rust_Map_i32_f64_get()). We use macros to generate a Map implementation for every (K,V)-pair. An alternative would have been to use vtables. Luckily a key in a protobuf map can only be integer types, bool and string. So the number of key types is bounded by the specification, while the number of value types is not i.e. any protobuf message can be a value in a map. Given these constraints we introduce one 'MapKeyOps' trait per key type e.g. MapKeyBOOLOps or MapKeyI32Ops. These traits need to be implemented for every value type e.g. 'impl MapKeyBOOLOps for i32' will implement 'Map::<bool, i32>'. In particular the MapKeyOps traits can also be implemented for generated messages without violating the orphan rule. This CL also contains significant changes to the UPB runtime so that both upb.rs and cpp.rs export a similar interface to simplify the implementation in map.rs and the generated code. This CL does not yet implement the Proxied trait. PiperOrigin-RevId: 582951914	1 year ago
Jakob Buchgraber	ac3f553073	This CL implements msg.<field>() and msg.<field_mut>() accessors for maps with primitive-typed keys and values for the UPB kernel only. Support for the CPP runtime and non-scalar value types will be implemented in follow up CLs. PiperOrigin-RevId: 580453646	1 year ago