use std::any::Any;
use std::any::TypeId;
use std::fmt;
use crate::descriptor::field_descriptor_proto::Type;
use crate::message_dyn::MessageDyn;
use crate::reflect::dynamic::map::DynamicMap;
use crate::reflect::dynamic::optional::DynamicOptional;
use crate::reflect::dynamic::repeated::DynamicRepeated;
use crate::reflect::map::ReflectMap;
use crate::reflect::protobuf_type_box::ProtobufType;
use crate::reflect::repeated::ReflectRepeated;
use crate::reflect::value::value_ref::ReflectValueMut;
use crate::reflect::FieldDescriptor;
use crate::reflect::MessageDescriptor;
use crate::reflect::ReflectFieldRef;
use crate::reflect::ReflectMapMut;
use crate::reflect::ReflectMapRef;
use crate::reflect::ReflectRepeatedMut;
use crate::reflect::ReflectRepeatedRef;
use crate::reflect::ReflectValueBox;
use crate::reflect::ReflectValueRef;
use crate::reflect::RuntimeFieldType;
use crate::reflect::Syntax;
use crate::rt::bytes_size;
use crate::rt::compute_raw_varint32_size;
use crate::rt::compute_raw_varint64_size;
use crate::rt::int32_size;
use crate::rt::int64_size;
use crate::rt::map::read_map_template;
use crate::rt::sint32_size;
use crate::rt::sint64_size;
use crate::rt::string_size;
use crate::rt::tag_size;
use crate::rt::uint32_size;
use crate::rt::uint64_size;
use crate::rt::unknown_fields_size;
use crate::rt::unknown_or_group::read_unknown_or_skip_group_with_tag_unpacked;
use crate::rt::vec_packed_bool_size;
use crate::rt::vec_packed_double_size;
use crate::rt::vec_packed_fixed32_size;
use crate::rt::vec_packed_fixed64_size;
use crate::rt::vec_packed_float_size;
use crate::rt::vec_packed_int32_size;
use crate::rt::vec_packed_int64_size;
use crate::rt::vec_packed_sfixed32_size;
use crate::rt::vec_packed_sfixed64_size;
use crate::rt::vec_packed_sint32_size;
use crate::rt::vec_packed_sint64_size;
use crate::rt::vec_packed_uint32_size;
use crate::rt::vec_packed_uint64_size;
use crate::text_format;
use crate::wire_format::WireType;
use crate::CodedInputStream;
use crate::CodedOutputStream;
use crate::SpecialFields;
use crate::UnknownFields;
pub(crate) mod map;
pub(crate) mod optional;
pub(crate) mod repeated;
#[derive(Debug, Clone)]
enum DynamicFieldValue {
Singular(DynamicOptional),
Repeated(DynamicRepeated),
Map(DynamicMap),
}
impl DynamicFieldValue {
fn as_ref(&self) -> ReflectFieldRef {
match self {
DynamicFieldValue::Singular(v) => ReflectFieldRef::Optional(v.reflect_singlar_ref()),
DynamicFieldValue::Repeated(r) => ReflectFieldRef::Repeated(ReflectRepeatedRef::new(r)),
DynamicFieldValue::Map(m) => ReflectFieldRef::Map(ReflectMapRef::new(m)),
}
}
fn clear(&mut self) {
match self {
DynamicFieldValue::Singular(o) => o.clear(),
DynamicFieldValue::Repeated(r) => r.clear(),
DynamicFieldValue::Map(m) => m.clear(),
}
}
}
impl DynamicFieldValue {
fn default_for_field(field: &FieldDescriptor) -> DynamicFieldValue {
match field.runtime_field_type() {
RuntimeFieldType::Singular(s) => DynamicFieldValue::Singular(DynamicOptional::none(s)),
RuntimeFieldType::Repeated(r) => DynamicFieldValue::Repeated(DynamicRepeated::new(r)),
RuntimeFieldType::Map(k, v) => DynamicFieldValue::Map(DynamicMap::new(k, v)),
}
}
}
#[derive(Debug, Clone)]
pub(crate) struct DynamicMessage {
descriptor: MessageDescriptor,
fields: Box<[DynamicFieldValue]>,
special_fields: SpecialFields,
}
impl DynamicMessage {
pub(crate) fn new(descriptor: MessageDescriptor) -> DynamicMessage {
DynamicMessage {
descriptor,
fields: Vec::new().into_boxed_slice(),
special_fields: SpecialFields::new(),
}
}
pub(crate) fn descriptor(&self) -> &MessageDescriptor {
&self.descriptor
}
fn init_fields(&mut self) {
if self.fields.is_empty() {
self.fields = self
.descriptor
.fields()
.map(|f| DynamicFieldValue::default_for_field(&f))
.collect();
}
}
pub(crate) fn get_reflect<'a>(&'a self, field: &FieldDescriptor) -> ReflectFieldRef<'a> {
let (descriptor, index) = field.regular();
assert_eq!(self.descriptor, descriptor);
if self.fields.is_empty() {
ReflectFieldRef::default_for_field(field)
} else {
self.fields[index].as_ref()
}
}
pub fn clear_field(&mut self, field: &FieldDescriptor) {
let (descriptor, index) = field.regular();
assert_eq!(self.descriptor, descriptor);
if self.fields.is_empty() {
return;
}
self.fields[index].clear();
}
fn clear_oneof_group_fields_except(&mut self, field: &FieldDescriptor) {
if let Some(oneof) = field.containing_oneof_including_synthetic() {
for next in oneof.fields() {
if &next == field {
continue;
}
self.clear_field(&next);
}
}
}
pub(crate) fn mut_singular_field_or_default<'a>(
&'a mut self,
field: &FieldDescriptor,
) -> ReflectValueMut<'a> {
let (descriptor, index) = field.regular();
assert_eq!(self.descriptor, descriptor);
self.init_fields();
self.clear_oneof_group_fields_except(field);
match &mut self.fields[index] {
DynamicFieldValue::Singular(f) => f.mut_or_default(),
_ => panic!("Not a singular field"),
}
}
pub(crate) fn mut_repeated<'a>(
&'a mut self,
field: &FieldDescriptor,
) -> ReflectRepeatedMut<'a> {
let (descriptor, index) = field.regular();
assert_eq!(self.descriptor, descriptor);
self.init_fields();
self.clear_oneof_group_fields_except(field);
match &mut self.fields[index] {
DynamicFieldValue::Repeated(r) => ReflectRepeatedMut::new(r),
_ => panic!("Not a repeated field: {}", field),
}
}
pub(crate) fn mut_map<'a>(&'a mut self, field: &FieldDescriptor) -> ReflectMapMut<'a> {
let (descriptor, index) = field.regular();
assert_eq!(self.descriptor, descriptor);
self.init_fields();
self.clear_oneof_group_fields_except(field);
match &mut self.fields[index] {
DynamicFieldValue::Map(m) => ReflectMapMut::new(m),
_ => panic!("Not a map field: {}", field),
}
}
pub(crate) fn set_field(&mut self, field: &FieldDescriptor, value: ReflectValueBox) {
let (descriptor, index) = field.regular();
assert_eq!(self.descriptor, descriptor);
self.init_fields();
self.clear_oneof_group_fields_except(field);
match &mut self.fields[index] {
DynamicFieldValue::Singular(s) => s.set(value),
_ => panic!("Not a singular field: {}", field),
}
}
pub(crate) fn downcast_ref(message: &dyn MessageDyn) -> &DynamicMessage {
assert!(Any::type_id(&*message) == TypeId::of::<DynamicMessage>());
unsafe { &*(message as *const dyn MessageDyn as *const DynamicMessage) }
}
pub(crate) fn downcast_mut(message: &mut dyn MessageDyn) -> &mut DynamicMessage {
assert!(Any::type_id(&*message) == TypeId::of::<DynamicMessage>());
unsafe { &mut *(message as *mut dyn MessageDyn as *mut DynamicMessage) }
}
fn for_each_field_to_write(
&self,
handler: &mut impl ForEachSingularFieldToWrite,
) -> crate::Result<()> {
let is_proto3 = self.descriptor.file_descriptor().syntax() == Syntax::Proto3;
for field_desc in self.descriptor.fields() {
let field_number = field_desc.proto().number() as u32;
match field_desc.runtime_field_type() {
RuntimeFieldType::Singular(..) => {
if let Some(v) = field_desc.get_singular(self) {
if !is_proto3 || v.is_non_zero() {
handler.field(field_desc.proto().type_(), field_number, &v)?;
}
}
}
RuntimeFieldType::Repeated(..) => {
let repeated = field_desc.get_repeated(self);
if field_desc.proto().options.get_or_default().packed() {
handler.repeated_packed(
field_desc.proto().type_(),
field_number,
&repeated,
)?;
} else {
for i in 0..repeated.len() {
let v = repeated.get(i);
handler.field(field_desc.proto().type_(), field_number, &v)?;
}
}
}
RuntimeFieldType::Map(_, _) => {
let map = field_desc.get_map(self);
let (key_type, value_type) = field_desc.map_proto_type();
for (k, v) in &map {
handler.map_field_entry(
field_number,
&k,
key_type.t(),
&v,
value_type.t(),
)?;
}
}
}
}
handler.unknown_fields(&self.special_fields.unknown_fields())?;
Ok(())
}
}
trait ForEachSingularFieldToWrite {
fn field(&mut self, t: Type, number: u32, value: &ReflectValueRef) -> crate::Result<()>;
fn repeated_packed(
&mut self,
t: Type,
number: u32,
value: &ReflectRepeatedRef,
) -> crate::Result<()>;
fn map_field_entry(
&mut self,
number: u32,
key: &ReflectValueRef,
kt: Type,
value: &ReflectValueRef,
vt: Type,
) -> crate::Result<()>;
fn unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()>;
}
impl fmt::Display for DynamicMessage {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
text_format::fmt(self, f)
}
}
impl MessageDyn for DynamicMessage {
fn descriptor_dyn(&self) -> MessageDescriptor {
self.descriptor.clone()
}
fn is_initialized_dyn(&self) -> bool {
if self.descriptor.is_initialized_is_always_true() {
return true;
}
for f in self.descriptor.fields() {
let fv = self.get_reflect(&f);
match fv {
ReflectFieldRef::Optional(s) => match s.value() {
None => {
if f.is_required() {
return false;
}
}
Some(v) => {
if !v.is_initialized() {
return false;
}
}
},
ReflectFieldRef::Repeated(r) => {
for v in &r {
if !v.is_initialized() {
return false;
}
}
}
ReflectFieldRef::Map(m) => {
for (_k, v) in &m {
if !v.is_initialized() {
return false;
}
}
}
}
}
true
}
fn merge_from_dyn(&mut self, is: &mut CodedInputStream) -> crate::Result<()> {
while !is.eof()? {
let (field, wire_type) = is.read_tag_unpack()?;
let field_desc = match self.descriptor.field_by_number(field) {
Some(f) => f,
None => {
read_unknown_or_skip_group_with_tag_unpacked(
field,
wire_type,
is,
&mut self.special_fields.mut_unknown_fields(),
)?;
continue;
}
};
match field_desc.runtime_field_type() {
RuntimeFieldType::Singular(rtb) => {
let pt = ProtobufType::new(rtb, field_desc.proto().type_())?;
let value = pt.read(is, wire_type)?;
self.set_field(&field_desc, value);
}
RuntimeFieldType::Repeated(rtb) => {
let pt = ProtobufType::new(rtb, field_desc.proto().type_())?;
let mut repeated = self.mut_repeated(&field_desc);
pt.read_repeated_into(is, wire_type, &mut repeated)?;
}
RuntimeFieldType::Map(..) => {
let (key_type, value_type) = field_desc.map_proto_type();
let mut map = self.mut_map(&field_desc);
let mut key = key_type.runtime().default_value_box();
let mut value = value_type.runtime().default_value_box();
read_map_template(
wire_type,
is,
|wire_type, is| {
key = key_type.read(is, wire_type)?;
Ok(())
},
|wire_type, is| {
value = value_type.read(is, wire_type)?;
Ok(())
},
)?;
map.insert(key, value);
}
}
}
Ok(())
}
fn write_to_with_cached_sizes_dyn(&self, os: &mut CodedOutputStream) -> crate::Result<()> {
struct Handler<'a, 'o> {
os: &'a mut CodedOutputStream<'o>,
}
impl<'a, 'o> ForEachSingularFieldToWrite for Handler<'a, 'o> {
fn field(
&mut self,
t: Type,
number: u32,
value: &ReflectValueRef,
) -> crate::Result<()> {
singular_write_to(t, number, value, self.os)
}
fn repeated_packed(
&mut self,
t: Type,
number: u32,
value: &ReflectRepeatedRef,
) -> crate::Result<()> {
repeated_write_to(t, number, value, self.os)
}
fn map_field_entry(
&mut self,
number: u32,
key: &ReflectValueRef,
kt: Type,
value: &ReflectValueRef,
vt: Type,
) -> crate::Result<()> {
let entry_data_size = compute_map_entry_field_data_size(key, kt, value, vt);
self.os.write_tag(number, WireType::LengthDelimited)?;
self.os.write_raw_varint32(entry_data_size as u32)?;
singular_write_to(kt, 1, key, self.os)?;
singular_write_to(vt, 2, value, self.os)?;
Ok(())
}
fn unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()> {
self.os.write_unknown_fields(unknown_fields)
}
}
let mut handler = Handler { os };
self.for_each_field_to_write(&mut handler)
}
fn compute_size_dyn(&self) -> u64 {
struct Handler {
m_size: u64,
}
impl ForEachSingularFieldToWrite for Handler {
fn field(
&mut self,
t: Type,
number: u32,
value: &ReflectValueRef,
) -> crate::Result<()> {
self.m_size += compute_singular_size(t, number, value);
Ok(())
}
fn repeated_packed(
&mut self,
t: Type,
number: u32,
value: &ReflectRepeatedRef,
) -> crate::Result<()> {
self.m_size += compute_repeated_packed_size(t, number, value);
Ok(())
}
fn map_field_entry(
&mut self,
number: u32,
key: &ReflectValueRef,
kt: Type,
value: &ReflectValueRef,
vt: Type,
) -> crate::Result<()> {
let entry_data_size = compute_map_entry_field_data_size(key, kt, value, vt);
self.m_size += tag_size(number)
+ compute_raw_varint32_size(entry_data_size as u32)
+ entry_data_size;
Ok(())
}
fn unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()> {
self.m_size += unknown_fields_size(unknown_fields);
Ok(())
}
}
let mut handler = Handler { m_size: 0 };
self.for_each_field_to_write(&mut handler)
.expect("compute_size should not fail");
handler.m_size
}
fn special_fields_dyn(&self) -> &SpecialFields {
&self.special_fields
}
fn mut_special_fields_dyn(&mut self) -> &mut SpecialFields {
&mut self.special_fields
}
}
fn singular_write_to(
proto_type: Type,
field_number: u32,
v: &ReflectValueRef,
os: &mut CodedOutputStream,
) -> crate::Result<()> {
match proto_type {
Type::TYPE_ENUM => {
let enum_v = v.to_enum_value().unwrap();
os.write_enum(field_number, enum_v)
}
Type::TYPE_MESSAGE => {
let msg_v = v.to_message().unwrap();
os.write_message_dyn(field_number, &*msg_v)
}
Type::TYPE_GROUP => {
unimplemented!()
}
Type::TYPE_UINT32 => os.write_uint32(field_number, v.to_u32().unwrap()),
Type::TYPE_UINT64 => os.write_uint64(field_number, v.to_u64().unwrap()),
Type::TYPE_INT32 => os.write_int32(field_number, v.to_i32().unwrap()),
Type::TYPE_INT64 => os.write_int64(field_number, v.to_i64().unwrap()),
Type::TYPE_SINT32 => os.write_sint32(field_number, v.to_i32().unwrap()),
Type::TYPE_SINT64 => os.write_sint64(field_number, v.to_i64().unwrap()),
Type::TYPE_FIXED32 => os.write_fixed32(field_number, v.to_u32().unwrap()),
Type::TYPE_FIXED64 => os.write_fixed64(field_number, v.to_u64().unwrap()),
Type::TYPE_SFIXED64 => os.write_sfixed64(field_number, v.to_i64().unwrap()),
Type::TYPE_SFIXED32 => os.write_sfixed32(field_number, v.to_i32().unwrap()),
Type::TYPE_BOOL => os.write_bool(field_number, v.to_bool().unwrap()),
Type::TYPE_STRING => os.write_string(field_number, v.to_str().unwrap()),
Type::TYPE_BYTES => os.write_bytes(field_number, v.to_bytes().unwrap()),
Type::TYPE_FLOAT => os.write_float(field_number, v.to_f32().unwrap()),
Type::TYPE_DOUBLE => os.write_double(field_number, v.to_f64().unwrap()),
}
}
fn compute_singular_size(proto_type: Type, field_number: u32, v: &ReflectValueRef) -> u64 {
match proto_type {
Type::TYPE_ENUM => {
let enum_v = v.to_enum_value().unwrap();
int32_size(field_number, enum_v)
}
Type::TYPE_MESSAGE => {
let msg_v = v.to_message().unwrap();
let len = msg_v.compute_size_dyn();
tag_size(field_number) + compute_raw_varint64_size(len) + len
}
Type::TYPE_GROUP => {
unimplemented!()
}
Type::TYPE_UINT32 => {
let typed_v = v.to_u32().unwrap();
uint32_size(field_number, typed_v)
}
Type::TYPE_UINT64 => {
let typed_v = v.to_u64().unwrap();
uint64_size(field_number, typed_v)
}
Type::TYPE_INT32 => {
let typed_v = v.to_i32().unwrap();
int32_size(field_number, typed_v)
}
Type::TYPE_INT64 => {
let typed_v = v.to_i64().unwrap();
int64_size(field_number, typed_v)
}
Type::TYPE_SINT32 => {
let typed_v = v.to_i32().unwrap();
sint32_size(field_number, typed_v)
}
Type::TYPE_SINT64 => {
let typed_v = v.to_i64().unwrap();
sint64_size(field_number, typed_v)
}
Type::TYPE_FIXED32 => tag_size(field_number) + 4,
Type::TYPE_FIXED64 => tag_size(field_number) + 8,
Type::TYPE_SFIXED32 => tag_size(field_number) + 4,
Type::TYPE_SFIXED64 => tag_size(field_number) + 8,
Type::TYPE_BOOL => tag_size(field_number) + 1,
Type::TYPE_STRING => {
let typed_v = v.to_str().unwrap();
string_size(field_number, typed_v)
}
Type::TYPE_BYTES => {
let typed_v = v.to_bytes().unwrap();
bytes_size(field_number, typed_v)
}
Type::TYPE_FLOAT => tag_size(field_number) + 4,
Type::TYPE_DOUBLE => tag_size(field_number) + 8,
}
}
fn compute_repeated_packed_size(
proto_type: Type,
field_number: u32,
v: &ReflectRepeatedRef,
) -> u64 {
match proto_type {
Type::TYPE_INT32 => vec_packed_int32_size(field_number, v.data_i32()),
Type::TYPE_INT64 => vec_packed_int64_size(field_number, v.data_i64()),
Type::TYPE_UINT32 => vec_packed_uint32_size(field_number, v.data_u32()),
Type::TYPE_UINT64 => vec_packed_uint64_size(field_number, v.data_u64()),
Type::TYPE_SINT32 => vec_packed_sint32_size(field_number, v.data_i32()),
Type::TYPE_SINT64 => vec_packed_sint64_size(field_number, v.data_i64()),
Type::TYPE_FIXED32 => vec_packed_fixed32_size(field_number, v.data_u32()),
Type::TYPE_FIXED64 => vec_packed_fixed64_size(field_number, v.data_u64()),
Type::TYPE_SFIXED32 => vec_packed_sfixed32_size(field_number, v.data_i32()),
Type::TYPE_SFIXED64 => vec_packed_sfixed64_size(field_number, v.data_i64()),
Type::TYPE_FLOAT => vec_packed_float_size(field_number, v.data_f32()),
Type::TYPE_DOUBLE => vec_packed_double_size(field_number, v.data_f64()),
Type::TYPE_BOOL => vec_packed_bool_size(field_number, v.data_bool()),
Type::TYPE_STRING => panic!("strings cannot be packed"),
Type::TYPE_BYTES => panic!("bytes cannot be packed"),
Type::TYPE_ENUM => vec_packed_int32_size(field_number, v.data_enum_values()),
Type::TYPE_MESSAGE => panic!("messages cannot be packed"),
Type::TYPE_GROUP => panic!("groups cannot be packed"),
}
}
fn repeated_write_to(
proto_type: Type,
field_number: u32,
v: &ReflectRepeatedRef,
os: &mut CodedOutputStream,
) -> crate::Result<()> {
match proto_type {
Type::TYPE_INT32 => os.write_repeated_packed_int32(field_number, v.data_i32()),
Type::TYPE_INT64 => os.write_repeated_packed_int64(field_number, v.data_i64()),
Type::TYPE_UINT64 => os.write_repeated_packed_uint64(field_number, v.data_u64()),
Type::TYPE_FIXED64 => os.write_repeated_packed_fixed64(field_number, v.data_u64()),
Type::TYPE_FIXED32 => os.write_repeated_packed_fixed32(field_number, v.data_u32()),
Type::TYPE_UINT32 => os.write_repeated_packed_uint32(field_number, v.data_u32()),
Type::TYPE_SINT32 => os.write_repeated_packed_sint32(field_number, v.data_i32()),
Type::TYPE_SINT64 => os.write_repeated_packed_sint64(field_number, v.data_i64()),
Type::TYPE_SFIXED32 => os.write_repeated_packed_sfixed32(field_number, v.data_i32()),
Type::TYPE_SFIXED64 => os.write_repeated_packed_sfixed64(field_number, v.data_i64()),
Type::TYPE_BOOL => os.write_repeated_packed_bool(field_number, v.data_bool()),
Type::TYPE_FLOAT => os.write_repeated_packed_float(field_number, v.data_f32()),
Type::TYPE_DOUBLE => os.write_repeated_packed_double(field_number, v.data_f64()),
Type::TYPE_ENUM => os.write_repeated_packed_int32(field_number, v.data_enum_values()),
Type::TYPE_STRING => panic!("strings cannot be packed"),
Type::TYPE_BYTES => panic!("bytes cannot be packed"),
Type::TYPE_GROUP => panic!("groups cannot be packed"),
Type::TYPE_MESSAGE => panic!("messages cannot be packed"),
}
}
fn compute_map_entry_field_data_size(
key: &ReflectValueRef,
kt: Type,
value: &ReflectValueRef,
vt: Type,
) -> u64 {
let key_size = compute_singular_size(kt, 1, key);
let value_size = compute_singular_size(vt, 2, value);
key_size + value_size
}