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;
#[derive(Debug, Clone)]
pub(crate) enum DynamicRepeated {
U32(Vec<u32>),
U64(Vec<u64>),
I32(Vec<i32>),
I64(Vec<i64>),
F32(Vec<f32>),
F64(Vec<f64>),
Bool(Vec<bool>),
String(Vec<String>),
Bytes(Vec<Vec<u8>>),
Enum(EnumDescriptor, Vec<i32>),
Message(MessageDescriptor, Vec<Box<dyn MessageDyn>>),
}
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()),
_ => {
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())
}
}
}
}