use crate::reflect::repeated::drain_iter::ReflectRepeatedDrainIter; use crate::reflect::repeated::iter::ReflectRepeatedIter; use crate::reflect::repeated::ReflectRepeated; use crate::reflect::EnumDescriptor; use crate::reflect::MessageDescriptor; use crate::reflect::MessageRef; use crate::reflect::ReflectRepeatedMut; use crate::reflect::ReflectValueBox; use crate::reflect::ReflectValueRef; use crate::reflect::RuntimeType; use crate::MessageDyn; /// Container of repeated values for dynamic messages. /// /// It is logically similar to `Vec`, but: /// * more efficient /// * asserts all the elements are of the same type, the type which is specified at construction #[derive(Debug, Clone)] pub(crate) enum DynamicRepeated { U32(Vec), U64(Vec), I32(Vec), I64(Vec), F32(Vec), F64(Vec), Bool(Vec), String(Vec), Bytes(Vec>), Enum(EnumDescriptor, Vec), Message(MessageDescriptor, Vec>), } impl ReflectRepeated for DynamicRepeated { fn reflect_iter(&self) -> ReflectRepeatedIter { match self { DynamicRepeated::U32(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::U64(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::I32(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::I64(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::F32(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::F64(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::Bool(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::String(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::Bytes(v) => ReflectRepeatedIter::new_slice(&v), DynamicRepeated::Enum(descriptor, v) => ReflectRepeatedIter::new( v.iter() .map(|v| ReflectValueRef::Enum(descriptor.clone(), *v)), ), DynamicRepeated::Message(_descriptor, v) => ReflectRepeatedIter::new( v.iter() .map(|v| ReflectValueRef::Message(MessageRef::new(&**v))), ), } } fn reflect_drain_iter(&mut self) -> ReflectRepeatedDrainIter { match self { DynamicRepeated::U32(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::U64(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::I32(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::I64(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::F32(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::F64(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::Bool(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::String(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::Bytes(v) => ReflectRepeatedDrainIter::new_vec(v), DynamicRepeated::Enum(descriptor, v) => ReflectRepeatedDrainIter::new( v.drain(..) .map(|v| ReflectValueBox::Enum(descriptor.clone(), v)), ), DynamicRepeated::Message(_descriptor, v) => { ReflectRepeatedDrainIter::new(v.drain(..).map(|v| ReflectValueBox::Message(v))) } } } fn len(&self) -> usize { match self { DynamicRepeated::U32(v) => v.len(), DynamicRepeated::U64(v) => v.len(), DynamicRepeated::I32(v) => v.len(), DynamicRepeated::I64(v) => v.len(), DynamicRepeated::F32(v) => v.len(), DynamicRepeated::F64(v) => v.len(), DynamicRepeated::Bool(v) => v.len(), DynamicRepeated::String(v) => v.len(), DynamicRepeated::Bytes(v) => v.len(), DynamicRepeated::Enum(.., v) => v.len(), DynamicRepeated::Message(.., v) => v.len(), } } fn get(&self, index: usize) -> ReflectValueRef { match self { DynamicRepeated::U32(v) => ReflectValueRef::U32(v[index]), DynamicRepeated::U64(v) => ReflectValueRef::U64(v[index]), DynamicRepeated::I32(v) => ReflectValueRef::I32(v[index]), DynamicRepeated::I64(v) => ReflectValueRef::I64(v[index]), DynamicRepeated::F32(v) => ReflectValueRef::F32(v[index]), DynamicRepeated::F64(v) => ReflectValueRef::F64(v[index]), DynamicRepeated::Bool(v) => ReflectValueRef::Bool(v[index]), DynamicRepeated::String(v) => ReflectValueRef::String(&v[index]), DynamicRepeated::Bytes(v) => ReflectValueRef::Bytes(&v[index]), DynamicRepeated::Enum(descriptor, v) => { ReflectValueRef::Enum(descriptor.clone(), v[index]) } DynamicRepeated::Message(_descriptor, v) => { ReflectValueRef::Message(MessageRef::from(&*v[index])) } } } fn set(&mut self, index: usize, value: ReflectValueBox) { match self { DynamicRepeated::U32(v) => v.set(index, value), DynamicRepeated::U64(v) => v.set(index, value), DynamicRepeated::I32(v) => v.set(index, value), DynamicRepeated::I64(v) => v.set(index, value), DynamicRepeated::F32(v) => v.set(index, value), DynamicRepeated::F64(v) => v.set(index, value), DynamicRepeated::Bool(v) => v.set(index, value), DynamicRepeated::String(v) => v.set(index, value), DynamicRepeated::Bytes(v) => v.set(index, value), DynamicRepeated::Enum(descriptor, vs) => match value { ReflectValueBox::Enum(value_description, v) => { assert_eq!(*descriptor, value_description); vs[index] = v; } _ => panic!("Expected enum value"), }, DynamicRepeated::Message(descriptor, vs) => match value { ReflectValueBox::Message(message) => { assert_eq!(*descriptor, message.descriptor_dyn()); vs[index] = message; } _ => panic!("Expected message value"), }, } } fn push(&mut self, value: ReflectValueBox) { match self { DynamicRepeated::U32(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::U64(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::I32(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::I64(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::F32(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::F64(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::Bool(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::String(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::Bytes(vs) => ReflectRepeated::push(vs, value), DynamicRepeated::Enum(descriptor, vs) => match value { ReflectValueBox::Enum(value_description, v) => { assert_eq!(*descriptor, value_description); vs.push(v); } _ => panic!("Expected enum value"), }, DynamicRepeated::Message(descriptor, vs) => match value { ReflectValueBox::Message(message) => { assert_eq!(*descriptor, message.descriptor_dyn()); vs.push(message); } _ => panic!("Expected message value"), }, } } fn reflect_extend(&mut self, values: ReflectRepeatedMut) { match self { DynamicRepeated::U32(vs) => vs.extend(values.repeated.data_u32()), DynamicRepeated::U64(vs) => vs.extend(values.repeated.data_u64()), DynamicRepeated::I32(vs) => vs.extend(values.repeated.data_i32()), DynamicRepeated::I64(vs) => vs.extend(values.repeated.data_i64()), DynamicRepeated::F32(vs) => vs.extend(values.repeated.data_f32()), DynamicRepeated::F64(vs) => vs.extend(values.repeated.data_f64()), DynamicRepeated::Bool(vs) => vs.extend(values.repeated.data_bool()), _ => { // Default less efficient implementation. for value in values.repeated.reflect_drain_iter() { self.push(value); } } } } fn clear(&mut self) { match self { DynamicRepeated::U32(vs) => vs.clear(), DynamicRepeated::U64(vs) => vs.clear(), DynamicRepeated::I32(vs) => vs.clear(), DynamicRepeated::I64(vs) => vs.clear(), DynamicRepeated::F32(vs) => vs.clear(), DynamicRepeated::F64(vs) => vs.clear(), DynamicRepeated::Bool(vs) => vs.clear(), DynamicRepeated::String(vs) => vs.clear(), DynamicRepeated::Bytes(vs) => vs.clear(), DynamicRepeated::Enum(_descriptor, vs) => vs.clear(), DynamicRepeated::Message(_descriptor, vs) => vs.clear(), } } fn element_type(&self) -> RuntimeType { match self { DynamicRepeated::U32(..) => RuntimeType::U32, DynamicRepeated::U64(..) => RuntimeType::U64, DynamicRepeated::I32(..) => RuntimeType::I32, DynamicRepeated::I64(..) => RuntimeType::I64, DynamicRepeated::F32(..) => RuntimeType::F32, DynamicRepeated::F64(..) => RuntimeType::F64, DynamicRepeated::Bool(..) => RuntimeType::Bool, DynamicRepeated::String(..) => RuntimeType::String, DynamicRepeated::Bytes(..) => RuntimeType::VecU8, DynamicRepeated::Enum(descriptor, _vs) => RuntimeType::Enum(descriptor.clone()), DynamicRepeated::Message(descriptor, _vs) => RuntimeType::Message(descriptor.clone()), } } fn data_enum_values(&self) -> &[i32] { match self { DynamicRepeated::Enum(_descriptor, vs) => &vs, _ => panic!("Expected enum value"), } } fn data_bool(&self) -> &[bool] { match self { DynamicRepeated::Bool(vs) => &vs, _ => panic!("Expected bool value"), } } fn data_u32(&self) -> &[u32] { match self { DynamicRepeated::U32(vs) => &vs, _ => panic!("Expected u32 value"), } } fn data_u64(&self) -> &[u64] { match self { DynamicRepeated::U64(vs) => &vs, _ => panic!("Expected u64 value"), } } fn data_i32(&self) -> &[i32] { match self { DynamicRepeated::I32(vs) => &vs, _ => panic!("Expected i32 value"), } } fn data_i64(&self) -> &[i64] { match self { DynamicRepeated::I64(vs) => &vs, _ => panic!("Expected i64 value"), } } fn data_f32(&self) -> &[f32] { match self { DynamicRepeated::F32(vs) => &vs, _ => panic!("Expected f32 value"), } } fn data_f64(&self) -> &[f64] { match self { DynamicRepeated::F64(vs) => &vs, _ => panic!("Expected f64 value"), } } } impl DynamicRepeated { pub fn new(elem: RuntimeType) -> DynamicRepeated { match elem { RuntimeType::U32 => DynamicRepeated::U32(Vec::new()), RuntimeType::U64 => DynamicRepeated::U64(Vec::new()), RuntimeType::I32 => DynamicRepeated::I32(Vec::new()), RuntimeType::I64 => DynamicRepeated::I64(Vec::new()), RuntimeType::F32 => DynamicRepeated::F32(Vec::new()), RuntimeType::F64 => DynamicRepeated::F64(Vec::new()), RuntimeType::Bool => DynamicRepeated::Bool(Vec::new()), RuntimeType::String => DynamicRepeated::String(Vec::new()), RuntimeType::VecU8 => DynamicRepeated::Bytes(Vec::new()), RuntimeType::Enum(enum_descriptor) => { DynamicRepeated::Enum(enum_descriptor, Vec::new()) } RuntimeType::Message(message_descriptor) => { DynamicRepeated::Message(message_descriptor, Vec::new()) } } } }