src/reflect/acc/v1.rs - platform/external/rust/crates/protobuf - Git at Google

 #![doc(hidden)]

 //! Version 1 reflection accessors.

 use std::collections::HashMap;
 use std::fmt;
 use std::hash::Hash;

 use crate::enums::ProtobufEnum;
 use crate::message::message_down_cast;
 use crate::message::Message;
 use crate::reflect::EnumValueDescriptor;
 use crate::reflect::ProtobufValue;
 use crate::reflect::ReflectFieldRef;
 use crate::reflect::ReflectValueRef;
 use crate::types::*;

 use crate::reflect::map::ReflectMap;
 use crate::reflect::optional::ReflectOptional;
 use crate::reflect::repeated::ReflectRepeated;
 use crate::reflect::repeated::ReflectRepeatedEnum;
 use crate::reflect::repeated::ReflectRepeatedMessage;
 use crate::reflect::rt::FieldAccessor;
 use crate::repeated::RepeatedField;
 use crate::singular::SingularField;
 use crate::singular::SingularPtrField;

 /// this trait should not be used directly, use `FieldDescriptor` instead
 pub trait FieldAccessorTrait: Sync + 'static {
     fn has_field_generic(&self, m: &dyn Message) -> bool;
     fn len_field_generic(&self, m: &dyn Message) -> usize;
     // TODO: should it return default value or panic on unset field?
     fn get_message_generic<'a>(&self, m: &'a dyn Message) -> &'a dyn Message;
     fn get_enum_generic(&self, m: &dyn Message) -> &'static EnumValueDescriptor;
     fn get_str_generic<'a>(&self, m: &'a dyn Message) -> &'a str;
     fn get_bytes_generic<'a>(&self, m: &'a dyn Message) -> &'a [u8];
     fn get_u32_generic(&self, m: &dyn Message) -> u32;
     fn get_u64_generic(&self, m: &dyn Message) -> u64;
     fn get_i32_generic(&self, m: &dyn Message) -> i32;
     fn get_i64_generic(&self, m: &dyn Message) -> i64;
     fn get_bool_generic(&self, m: &dyn Message) -> bool;
     fn get_f32_generic(&self, m: &dyn Message) -> f32;
     fn get_f64_generic(&self, m: &dyn Message) -> f64;

     fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a>;
 }

 pub(crate) trait GetSingularMessage<M>: Sync {
     fn get_message<'a>(&self, m: &'a M) -> &'a dyn Message;
 }

 struct GetSingularMessageImpl<M, N> {
     get: for<'a> fn(&'a M) -> &'a N,
 }

 impl<M: Message, N: Message + 'static> GetSingularMessage<M> for GetSingularMessageImpl<M, N> {
     fn get_message<'a>(&self, m: &'a M) -> &'a dyn Message {
         (self.get)(m)
     }
 }

 pub(crate) trait GetSingularEnum<M>: Sync {
     fn get_enum(&self, m: &M) -> &'static EnumValueDescriptor;
 }

 struct GetSingularEnumImpl<M, E> {
     get: fn(&M) -> E,
 }

 impl<M: Message, E: ProtobufEnum> GetSingularEnum<M> for GetSingularEnumImpl<M, E> {
     fn get_enum(&self, m: &M) -> &'static EnumValueDescriptor {
         (self.get)(m).descriptor()
     }
 }

 trait GetRepeatedMessage<M>: Sync {
     fn len_field(&self, m: &M) -> usize;
     fn get_message_item<'a>(&self, m: &'a M, index: usize) -> &'a dyn Message;
     fn reflect_repeated_message<'a>(&self, m: &'a M) -> Box<dyn ReflectRepeatedMessage<'a> + 'a>;
 }

 trait GetRepeatedEnum<M: Message + 'static>: Sync {
     fn len_field(&self, m: &M) -> usize;
     fn get_enum_item(&self, m: &M, index: usize) -> &'static EnumValueDescriptor;
     fn reflect_repeated_enum<'a>(&self, m: &'a M) -> Box<dyn ReflectRepeatedEnum<'a> + 'a>;
 }

 pub(crate) trait GetSetCopyFns<M>: Sync {
     fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a>;
 }

 struct GetSetCopyFnsImpl<M, V: ProtobufValue + Copy> {
     get: fn(&M) -> V,
     _set: fn(&mut M, V),
 }

 impl<M, V: ProtobufValue + Copy> GetSetCopyFns<M> for GetSetCopyFnsImpl<M, V> {
     fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a> {
         (&(self.get)(m) as &dyn ProtobufValue).as_ref_copy()
     }
 }

 pub(crate) enum SingularGetSet<M> {
     Copy(Box<dyn GetSetCopyFns<M>>),
     String(for<'a> fn(&'a M) -> &'a str, fn(&mut M, String)),
     Bytes(for<'a> fn(&'a M) -> &'a [u8], fn(&mut M, Vec<u8>)),
     Enum(Box<dyn GetSingularEnum<M> + 'static>),
     Message(Box<dyn GetSingularMessage<M> + 'static>),
 }

 impl<M: Message + 'static> SingularGetSet<M> {
     fn get_ref<'a>(&self, m: &'a M) -> ReflectValueRef<'a> {
         match self {
             &SingularGetSet::Copy(ref copy) => copy.get_field(m),
             &SingularGetSet::String(get, _) => ReflectValueRef::String(get(m)),
             &SingularGetSet::Bytes(get, _) => ReflectValueRef::Bytes(get(m)),
             &SingularGetSet::Enum(ref get) => ReflectValueRef::Enum(get.get_enum(m)),
             &SingularGetSet::Message(ref get) => ReflectValueRef::Message(get.get_message(m)),
         }
     }
 }

 pub(crate) trait FieldAccessor2<M, R: ?Sized>: Sync
 where
     M: Message + 'static,
 {
     fn get_field<'a>(&self, _: &'a M) -> &'a R;
     fn mut_field<'a>(&self, _: &'a mut M) -> &'a mut R;
 }

 struct MessageGetMut<M, L>
 where
     M: Message + 'static,
 {
     get_field: for<'a> fn(&'a M) -> &'a L,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut L,
 }

 pub(crate) enum FieldAccessorFunctions<M> {
     // up to 1.0.24 optional or required
     SingularHasGetSet {
         has: fn(&M) -> bool,
         get_set: SingularGetSet<M>,
     },
     // protobuf 3 simple field
     Simple(Box<dyn FieldAccessor2<M, dyn ProtobufValue>>),
     // optional, required or message
     Optional(Box<dyn FieldAccessor2<M, dyn ReflectOptional>>),
     // repeated
     Repeated(Box<dyn FieldAccessor2<M, dyn ReflectRepeated>>),
     // protobuf 3 map
     Map(Box<dyn FieldAccessor2<M, dyn ReflectMap>>),
 }

 impl<M> fmt::Debug for FieldAccessorFunctions<M> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             &FieldAccessorFunctions::SingularHasGetSet { .. } => {
                 write!(f, "SingularHasGetSet {{ .. }}")
             }
             &FieldAccessorFunctions::Simple(..) => write!(f, "Simple(..)"),
             &FieldAccessorFunctions::Optional(..) => write!(f, "Optional(..)"),
             &FieldAccessorFunctions::Repeated(..) => write!(f, "Repeated(..)"),
             &FieldAccessorFunctions::Map(..) => write!(f, "Map(..)"),
         }
     }
 }

 pub(crate) struct FieldAccessorImpl<M> {
     pub(crate) fns: FieldAccessorFunctions<M>,
 }

 impl<M: Message> FieldAccessorImpl<M> {
     fn get_value_option<'a>(&self, m: &'a M) -> Option<ReflectValueRef<'a>> {
         match self.fns {
             FieldAccessorFunctions::Repeated(..) | FieldAccessorFunctions::Map(..) => {
                 panic!("repeated")
             }
             FieldAccessorFunctions::Simple(ref a) => Some(a.get_field(m).as_ref()),
             FieldAccessorFunctions::Optional(ref a) => {
                 a.get_field(m).to_option().map(|v| v.as_ref())
             }
             FieldAccessorFunctions::SingularHasGetSet {
                 ref has,
                 ref get_set,
             } => {
                 if !has(m) {
                     None
                 } else {
                     Some(get_set.get_ref(m))
                 }
             }
         }
     }
 }

 impl<M: Message + 'static> FieldAccessorTrait for FieldAccessorImpl<M> {
     fn has_field_generic(&self, m: &dyn Message) -> bool {
         match self.fns {
             FieldAccessorFunctions::SingularHasGetSet { has, .. } => has(message_down_cast(m)),
             FieldAccessorFunctions::Optional(ref a) => {
                 a.get_field(message_down_cast(m)).to_option().is_some()
             }
             FieldAccessorFunctions::Simple(ref a) => {
                 a.get_field(message_down_cast(m)).is_non_zero()
             }
             FieldAccessorFunctions::Map(..) | FieldAccessorFunctions::Repeated(..) => {
                 panic!("has_xxx is not implemented for repeated");
             }
         }
     }

     fn len_field_generic(&self, m: &dyn Message) -> usize {
         match self.fns {
             FieldAccessorFunctions::Repeated(ref a) => a.get_field(message_down_cast(m)).len(),
             FieldAccessorFunctions::Map(ref a) => a.get_field(message_down_cast(m)).len(),
             FieldAccessorFunctions::Simple(..)
             | FieldAccessorFunctions::SingularHasGetSet { .. }
             | FieldAccessorFunctions::Optional(..) => {
                 panic!("not a repeated field");
             }
         }
     }

     fn get_message_generic<'a>(&self, m: &'a dyn Message) -> &'a dyn Message {
         match self.fns {
             FieldAccessorFunctions::SingularHasGetSet {
                 get_set: SingularGetSet::Message(ref get),
                 ..
             } => get.get_message(message_down_cast(m)),
             FieldAccessorFunctions::Optional(ref t) => {
                 match t
                     .get_field(message_down_cast(m))
                     .to_option()
                     .expect("field unset")
                     .as_ref()
                 {
                     ReflectValueRef::Message(m) => m,
                     _ => panic!("not a message"),
                 }
             }
             ref fns => panic!("unknown accessor type: {:?}", fns),
         }
     }

     fn get_enum_generic(&self, m: &dyn Message) -> &'static EnumValueDescriptor {
         match self.fns {
             FieldAccessorFunctions::SingularHasGetSet {
                 get_set: SingularGetSet::Enum(ref get),
                 ..
             } => get.get_enum(message_down_cast(m)),
             _ => panic!(),
         }
     }

     fn get_str_generic<'a>(&self, m: &'a dyn Message) -> &'a str {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::String(v)) => v,
             Some(_) => panic!("wrong type"),
             None => "", // TODO: check type
         }
     }

     fn get_bytes_generic<'a>(&self, m: &'a dyn Message) -> &'a [u8] {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::Bytes(v)) => v,
             Some(_) => panic!("wrong type"),
             None => b"", // TODO: check type
         }
     }

     fn get_u32_generic(&self, m: &dyn Message) -> u32 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::U32(v)) => v,
             Some(_) => panic!("wrong type"),
             None => 0, // TODO: check type
         }
     }

     fn get_u64_generic(&self, m: &dyn Message) -> u64 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::U64(v)) => v,
             Some(_) => panic!("wrong type"),
             None => 0, // TODO: check type
         }
     }

     fn get_i32_generic(&self, m: &dyn Message) -> i32 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::I32(v)) => v,
             Some(_) => panic!("wrong type"),
             None => 0, // TODO: check type
         }
     }

     fn get_i64_generic(&self, m: &dyn Message) -> i64 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::I64(v)) => v,
             Some(_) => panic!("wrong type"),
             None => 0, // TODO: check type
         }
     }

     fn get_bool_generic(&self, m: &dyn Message) -> bool {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::Bool(v)) => v,
             Some(_) => panic!("wrong type"),
             None => false, // TODO: check type
         }
     }

     fn get_f32_generic(&self, m: &dyn Message) -> f32 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::F32(v)) => v,
             Some(_) => panic!("wrong type"),
             None => 0.0, // TODO: check type
         }
     }

     fn get_f64_generic(&self, m: &dyn Message) -> f64 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::F64(v)) => v,
             Some(_) => panic!("wrong type"),
             None => 0.0, // TODO: check type
         }
     }

     fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a> {
         match self.fns {
             FieldAccessorFunctions::Repeated(ref accessor2) => {
                 ReflectFieldRef::Repeated(accessor2.get_field(message_down_cast(m)))
             }
             FieldAccessorFunctions::Map(ref accessor2) => {
                 ReflectFieldRef::Map(accessor2.get_field(message_down_cast(m)))
             }
             FieldAccessorFunctions::Optional(ref accessor2) => ReflectFieldRef::Optional(
                 accessor2
                     .get_field(message_down_cast(m))
                     .to_option()
                     .map(|v| v.as_ref()),
             ),
             FieldAccessorFunctions::Simple(ref accessor2) => ReflectFieldRef::Optional({
                 let v = accessor2.get_field(message_down_cast(m));
                 if v.is_non_zero() {
                     Some(v.as_ref())
                 } else {
                     None
                 }
             }),
             FieldAccessorFunctions::SingularHasGetSet {
                 ref has,
                 ref get_set,
             } => ReflectFieldRef::Optional(if has(message_down_cast(m)) {
                 Some(get_set.get_ref(message_down_cast(m)))
             } else {
                 None
             }),
         }
     }
 }

 // singular

 fn set_panic<A, B>(_: &mut A, _: B) {
     panic!()
 }

 // TODO: make_singular_xxx_accessor are used only for oneof fields
 // oneof codegen should be changed

 pub fn make_singular_u32_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> u32,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
                 get,
                 _set: set_panic,
             })),
         },
     )
 }

 pub fn make_singular_i32_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> i32,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
                 get,
                 _set: set_panic,
             })),
         },
     )
 }

 pub fn make_singular_u64_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> u64,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
                 get,
                 _set: set_panic,
             })),
         },
     )
 }

 pub fn make_singular_i64_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> i64,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
                 get,
                 _set: set_panic,
             })),
         },
     )
 }

 pub fn make_singular_f32_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> f32,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
                 get,
                 _set: set_panic,
             })),
         },
     )
 }

 pub fn make_singular_f64_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> f64,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
                 get,
                 _set: set_panic,
             })),
         },
     )
 }

 pub fn make_singular_bool_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> bool,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
                 get,
                 _set: set_panic,
             })),
         },
     )
 }

 pub fn make_singular_enum_accessor<M: Message + 'static, E: ProtobufEnum + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> E,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Enum(Box::new(GetSingularEnumImpl { get })),
         },
     )
 }

 pub fn make_singular_string_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: for<'a> fn(&'a M) -> &'a str,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::String(get, set_panic),
         },
     )
 }

 pub fn make_singular_bytes_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: for<'a> fn(&'a M) -> &'a [u8],
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Bytes(get, set_panic),
         },
     )
 }

 pub fn make_singular_message_accessor<M: Message + 'static, F: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: for<'a> fn(&'a M) -> &'a F,
 ) -> FieldAccessor {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::SingularHasGetSet {
             has,
             get_set: SingularGetSet::Message(Box::new(GetSingularMessageImpl { get })),
         },
     )
 }

 // repeated

 impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, Vec<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + 'static,
 {
     fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
         (self.get_field)(m) as &dyn ReflectRepeated
     }

     fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
         (self.mut_field)(m) as &mut dyn ReflectRepeated
     }
 }

 pub fn make_vec_accessor<M, V>(
     name: &'static str,
     get_vec: for<'a> fn(&'a M) -> &'a Vec<V::Value>,
     mut_vec: for<'a> fn(&'a mut M) -> &'a mut Vec<V::Value>,
 ) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, Vec<V::Value>> {
             get_field: get_vec,
             mut_field: mut_vec,
         })),
     )
 }

 impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, RepeatedField<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + 'static,
 {
     fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
         (self.get_field)(m) as &dyn ReflectRepeated
     }

     fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
         (self.mut_field)(m) as &mut dyn ReflectRepeated
     }
 }

 pub fn make_repeated_field_accessor<M, V>(
     name: &'static str,
     get_vec: for<'a> fn(&'a M) -> &'a RepeatedField<V::Value>,
     mut_vec: for<'a> fn(&'a mut M) -> &'a mut RepeatedField<V::Value>,
 ) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, RepeatedField<V::Value>> {
             get_field: get_vec,
             mut_field: mut_vec,
         })),
     )
 }

 impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, Option<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
     fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
         (self.get_field)(m) as &dyn ReflectOptional
     }

     fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
         (self.mut_field)(m) as &mut dyn ReflectOptional
     }
 }

 pub fn make_option_accessor<M, V>(
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a Option<V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut Option<V::Value>,
 ) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, Option<V::Value>> {
             get_field,
             mut_field,
         })),
     )
 }

 impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularField<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
     fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
         (self.get_field)(m) as &dyn ReflectOptional
     }

     fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
         (self.mut_field)(m) as &mut dyn ReflectOptional
     }
 }

 pub fn make_singular_field_accessor<M, V>(
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a SingularField<V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularField<V::Value>,
 ) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, SingularField<V::Value>> {
             get_field,
             mut_field,
         })),
     )
 }

 impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularPtrField<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
     fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
         (self.get_field)(m) as &dyn ReflectOptional
     }

     fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
         (self.mut_field)(m) as &mut dyn ReflectOptional
     }
 }

 pub fn make_singular_ptr_field_accessor<M, V>(
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a SingularPtrField<V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularPtrField<V::Value>,
 ) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::Optional(Box::new(
             MessageGetMut::<M, SingularPtrField<V::Value>> {
                 get_field,
                 mut_field,
             },
         )),
     )
 }

 impl<M, V> FieldAccessor2<M, dyn ProtobufValue> for MessageGetMut<M, V>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
     fn get_field<'a>(&self, m: &'a M) -> &'a dyn ProtobufValue {
         (self.get_field)(m) as &dyn ProtobufValue
     }

     fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ProtobufValue {
         (self.mut_field)(m) as &mut dyn ProtobufValue
     }
 }

 pub fn make_simple_field_accessor<M, V>(
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a V::Value,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut V::Value,
 ) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::Simple(Box::new(MessageGetMut::<M, V::Value> {
             get_field,
             mut_field,
         })),
     )
 }

 impl<M, K, V> FieldAccessor2<M, dyn ReflectMap> for MessageGetMut<M, HashMap<K, V>>
 where
     M: Message + 'static,
     K: ProtobufValue + 'static,
     V: ProtobufValue + 'static,
     K: Hash + Eq,
 {
     fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectMap {
         (self.get_field)(m) as &dyn ReflectMap
     }

     fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectMap {
         (self.mut_field)(m) as &mut dyn ReflectMap
     }
 }

 pub fn make_map_accessor<M, K, V>(
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a HashMap<K::Value, V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut HashMap<K::Value, V::Value>,
 ) -> FieldAccessor
 where
     M: Message + 'static,
     K: ProtobufType + 'static,
     V: ProtobufType + 'static,
     <K as ProtobufType>::Value: Hash + Eq,
 {
     FieldAccessor::new_v1(
         name,
         FieldAccessorFunctions::Map(Box::new(MessageGetMut::<M, HashMap<K::Value, V::Value>> {
             get_field,
             mut_field,
         })),
     )
 }
	#![doc(hidden)]

	//! Version 1 reflection accessors.

	use std::collections::HashMap;
	use std::fmt;
	use std::hash::Hash;

	use crate::enums::ProtobufEnum;
	use crate::message::message_down_cast;
	use crate::message::Message;
	use crate::reflect::EnumValueDescriptor;
	use crate::reflect::ProtobufValue;
	use crate::reflect::ReflectFieldRef;
	use crate::reflect::ReflectValueRef;
	use crate::types::*;

	use crate::reflect::map::ReflectMap;
	use crate::reflect::optional::ReflectOptional;
	use crate::reflect::repeated::ReflectRepeated;
	use crate::reflect::repeated::ReflectRepeatedEnum;
	use crate::reflect::repeated::ReflectRepeatedMessage;
	use crate::reflect::rt::FieldAccessor;
	use crate::repeated::RepeatedField;
	use crate::singular::SingularField;
	use crate::singular::SingularPtrField;

	/// this trait should not be used directly, use `FieldDescriptor` instead
	pub trait FieldAccessorTrait: Sync + 'static {
	fn has_field_generic(&self, m: &dyn Message) -> bool;
	fn len_field_generic(&self, m: &dyn Message) -> usize;
	// TODO: should it return default value or panic on unset field?
	fn get_message_generic<'a>(&self, m: &'a dyn Message) -> &'a dyn Message;
	fn get_enum_generic(&self, m: &dyn Message) -> &'static EnumValueDescriptor;
	fn get_str_generic<'a>(&self, m: &'a dyn Message) -> &'a str;
	fn get_bytes_generic<'a>(&self, m: &'a dyn Message) -> &'a [u8];
	fn get_u32_generic(&self, m: &dyn Message) -> u32;
	fn get_u64_generic(&self, m: &dyn Message) -> u64;
	fn get_i32_generic(&self, m: &dyn Message) -> i32;
	fn get_i64_generic(&self, m: &dyn Message) -> i64;
	fn get_bool_generic(&self, m: &dyn Message) -> bool;
	fn get_f32_generic(&self, m: &dyn Message) -> f32;
	fn get_f64_generic(&self, m: &dyn Message) -> f64;

	fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a>;
	}

	pub(crate) trait GetSingularMessage<M>: Sync {
	fn get_message<'a>(&self, m: &'a M) -> &'a dyn Message;
	}

	struct GetSingularMessageImpl<M, N> {
	get: for<'a> fn(&'a M) -> &'a N,
	}

	impl<M: Message, N: Message + 'static> GetSingularMessage<M> for GetSingularMessageImpl<M, N> {
	fn get_message<'a>(&self, m: &'a M) -> &'a dyn Message {
	(self.get)(m)
	}
	}

	pub(crate) trait GetSingularEnum<M>: Sync {
	fn get_enum(&self, m: &M) -> &'static EnumValueDescriptor;
	}

	struct GetSingularEnumImpl<M, E> {
	get: fn(&M) -> E,
	}

	impl<M: Message, E: ProtobufEnum> GetSingularEnum<M> for GetSingularEnumImpl<M, E> {
	fn get_enum(&self, m: &M) -> &'static EnumValueDescriptor {
	(self.get)(m).descriptor()
	}
	}

	trait GetRepeatedMessage<M>: Sync {
	fn len_field(&self, m: &M) -> usize;
	fn get_message_item<'a>(&self, m: &'a M, index: usize) -> &'a dyn Message;
	fn reflect_repeated_message<'a>(&self, m: &'a M) -> Box<dyn ReflectRepeatedMessage<'a> + 'a>;
	}

	trait GetRepeatedEnum<M: Message + 'static>: Sync {
	fn len_field(&self, m: &M) -> usize;
	fn get_enum_item(&self, m: &M, index: usize) -> &'static EnumValueDescriptor;
	fn reflect_repeated_enum<'a>(&self, m: &'a M) -> Box<dyn ReflectRepeatedEnum<'a> + 'a>;
	}

	pub(crate) trait GetSetCopyFns<M>: Sync {
	fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a>;
	}

	struct GetSetCopyFnsImpl<M, V: ProtobufValue + Copy> {
	get: fn(&M) -> V,
	_set: fn(&mut M, V),
	}

	impl<M, V: ProtobufValue + Copy> GetSetCopyFns<M> for GetSetCopyFnsImpl<M, V> {
	fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a> {
	(&(self.get)(m) as &dyn ProtobufValue).as_ref_copy()
	}
	}

	pub(crate) enum SingularGetSet<M> {
	Copy(Box<dyn GetSetCopyFns<M>>),
	String(for<'a> fn(&'a M) -> &'a str, fn(&mut M, String)),
	Bytes(for<'a> fn(&'a M) -> &'a [u8], fn(&mut M, Vec<u8>)),
	Enum(Box<dyn GetSingularEnum<M> + 'static>),
	Message(Box<dyn GetSingularMessage<M> + 'static>),
	}

	impl<M: Message + 'static> SingularGetSet<M> {
	fn get_ref<'a>(&self, m: &'a M) -> ReflectValueRef<'a> {
	match self {
	&SingularGetSet::Copy(ref copy) => copy.get_field(m),
	&SingularGetSet::String(get, _) => ReflectValueRef::String(get(m)),
	&SingularGetSet::Bytes(get, _) => ReflectValueRef::Bytes(get(m)),
	&SingularGetSet::Enum(ref get) => ReflectValueRef::Enum(get.get_enum(m)),
	&SingularGetSet::Message(ref get) => ReflectValueRef::Message(get.get_message(m)),
	}
	}
	}

	pub(crate) trait FieldAccessor2<M, R: ?Sized>: Sync
	where
	M: Message + 'static,
	{
	fn get_field<'a>(&self, _: &'a M) -> &'a R;
	fn mut_field<'a>(&self, _: &'a mut M) -> &'a mut R;
	}

	struct MessageGetMut<M, L>
	where
	M: Message + 'static,
	{
	get_field: for<'a> fn(&'a M) -> &'a L,
	mut_field: for<'a> fn(&'a mut M) -> &'a mut L,
	}

	pub(crate) enum FieldAccessorFunctions<M> {
	// up to 1.0.24 optional or required
	SingularHasGetSet {
	has: fn(&M) -> bool,
	get_set: SingularGetSet<M>,
	},
	// protobuf 3 simple field
	Simple(Box<dyn FieldAccessor2<M, dyn ProtobufValue>>),
	// optional, required or message
	Optional(Box<dyn FieldAccessor2<M, dyn ReflectOptional>>),
	// repeated
	Repeated(Box<dyn FieldAccessor2<M, dyn ReflectRepeated>>),
	// protobuf 3 map
	Map(Box<dyn FieldAccessor2<M, dyn ReflectMap>>),
	}

	impl<M> fmt::Debug for FieldAccessorFunctions<M> {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	match self {
	&FieldAccessorFunctions::SingularHasGetSet { .. } => {
	write!(f, "SingularHasGetSet {{ .. }}")
	}
	&FieldAccessorFunctions::Simple(..) => write!(f, "Simple(..)"),
	&FieldAccessorFunctions::Optional(..) => write!(f, "Optional(..)"),
	&FieldAccessorFunctions::Repeated(..) => write!(f, "Repeated(..)"),
	&FieldAccessorFunctions::Map(..) => write!(f, "Map(..)"),
	}
	}
	}

	pub(crate) struct FieldAccessorImpl<M> {
	pub(crate) fns: FieldAccessorFunctions<M>,
	}

	impl<M: Message> FieldAccessorImpl<M> {
	fn get_value_option<'a>(&self, m: &'a M) -> Option<ReflectValueRef<'a>> {
	match self.fns {
	FieldAccessorFunctions::Repeated(..) \| FieldAccessorFunctions::Map(..) => {
	panic!("repeated")
	}
	FieldAccessorFunctions::Simple(ref a) => Some(a.get_field(m).as_ref()),
	FieldAccessorFunctions::Optional(ref a) => {
	a.get_field(m).to_option().map(\|v\| v.as_ref())
	}
	FieldAccessorFunctions::SingularHasGetSet {
	ref has,
	ref get_set,
	} => {
	if !has(m) {
	None
	} else {
	Some(get_set.get_ref(m))
	}
	}
	}
	}
	}

	impl<M: Message + 'static> FieldAccessorTrait for FieldAccessorImpl<M> {
	fn has_field_generic(&self, m: &dyn Message) -> bool {
	match self.fns {
	FieldAccessorFunctions::SingularHasGetSet { has, .. } => has(message_down_cast(m)),
	FieldAccessorFunctions::Optional(ref a) => {
	a.get_field(message_down_cast(m)).to_option().is_some()
	}
	FieldAccessorFunctions::Simple(ref a) => {
	a.get_field(message_down_cast(m)).is_non_zero()
	}
	FieldAccessorFunctions::Map(..) \| FieldAccessorFunctions::Repeated(..) => {
	panic!("has_xxx is not implemented for repeated");
	}
	}
	}

	fn len_field_generic(&self, m: &dyn Message) -> usize {
	match self.fns {
	FieldAccessorFunctions::Repeated(ref a) => a.get_field(message_down_cast(m)).len(),
	FieldAccessorFunctions::Map(ref a) => a.get_field(message_down_cast(m)).len(),
	FieldAccessorFunctions::Simple(..)
	\| FieldAccessorFunctions::SingularHasGetSet { .. }
	\| FieldAccessorFunctions::Optional(..) => {
	panic!("not a repeated field");
	}
	}
	}

	fn get_message_generic<'a>(&self, m: &'a dyn Message) -> &'a dyn Message {
	match self.fns {
	FieldAccessorFunctions::SingularHasGetSet {
	get_set: SingularGetSet::Message(ref get),
	..
	} => get.get_message(message_down_cast(m)),
	FieldAccessorFunctions::Optional(ref t) => {
	match t
	.get_field(message_down_cast(m))
	.to_option()
	.expect("field unset")
	.as_ref()
	{
	ReflectValueRef::Message(m) => m,
	_ => panic!("not a message"),
	}
	}
	ref fns => panic!("unknown accessor type: {:?}", fns),
	}
	}

	fn get_enum_generic(&self, m: &dyn Message) -> &'static EnumValueDescriptor {
	match self.fns {
	FieldAccessorFunctions::SingularHasGetSet {
	get_set: SingularGetSet::Enum(ref get),
	..
	} => get.get_enum(message_down_cast(m)),
	_ => panic!(),
	}
	}

	fn get_str_generic<'a>(&self, m: &'a dyn Message) -> &'a str {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::String(v)) => v,
	Some(_) => panic!("wrong type"),
	None => "", // TODO: check type
	}
	}

	fn get_bytes_generic<'a>(&self, m: &'a dyn Message) -> &'a [u8] {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::Bytes(v)) => v,
	Some(_) => panic!("wrong type"),
	None => b"", // TODO: check type
	}
	}

	fn get_u32_generic(&self, m: &dyn Message) -> u32 {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::U32(v)) => v,
	Some(_) => panic!("wrong type"),
	None => 0, // TODO: check type
	}
	}

	fn get_u64_generic(&self, m: &dyn Message) -> u64 {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::U64(v)) => v,
	Some(_) => panic!("wrong type"),
	None => 0, // TODO: check type
	}
	}

	fn get_i32_generic(&self, m: &dyn Message) -> i32 {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::I32(v)) => v,
	Some(_) => panic!("wrong type"),
	None => 0, // TODO: check type
	}
	}

	fn get_i64_generic(&self, m: &dyn Message) -> i64 {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::I64(v)) => v,
	Some(_) => panic!("wrong type"),
	None => 0, // TODO: check type
	}
	}

	fn get_bool_generic(&self, m: &dyn Message) -> bool {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::Bool(v)) => v,
	Some(_) => panic!("wrong type"),
	None => false, // TODO: check type
	}
	}

	fn get_f32_generic(&self, m: &dyn Message) -> f32 {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::F32(v)) => v,
	Some(_) => panic!("wrong type"),
	None => 0.0, // TODO: check type
	}
	}

	fn get_f64_generic(&self, m: &dyn Message) -> f64 {
	match self.get_value_option(message_down_cast(m)) {
	Some(ReflectValueRef::F64(v)) => v,
	Some(_) => panic!("wrong type"),
	None => 0.0, // TODO: check type
	}
	}

	fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a> {
	match self.fns {
	FieldAccessorFunctions::Repeated(ref accessor2) => {
	ReflectFieldRef::Repeated(accessor2.get_field(message_down_cast(m)))
	}
	FieldAccessorFunctions::Map(ref accessor2) => {
	ReflectFieldRef::Map(accessor2.get_field(message_down_cast(m)))
	}
	FieldAccessorFunctions::Optional(ref accessor2) => ReflectFieldRef::Optional(
	accessor2
	.get_field(message_down_cast(m))
	.to_option()
	.map(\|v\| v.as_ref()),
	),
	FieldAccessorFunctions::Simple(ref accessor2) => ReflectFieldRef::Optional({
	let v = accessor2.get_field(message_down_cast(m));
	if v.is_non_zero() {
	Some(v.as_ref())
	} else {
	None
	}
	}),
	FieldAccessorFunctions::SingularHasGetSet {
	ref has,
	ref get_set,
	} => ReflectFieldRef::Optional(if has(message_down_cast(m)) {
	Some(get_set.get_ref(message_down_cast(m)))
	} else {
	None
	}),
	}
	}
	}

	// singular

	fn set_panic<A, B>(_: &mut A, _: B) {
	panic!()
	}

	// TODO: make_singular_xxx_accessor are used only for oneof fields
	// oneof codegen should be changed

	pub fn make_singular_u32_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> u32,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
	get,
	_set: set_panic,
	})),
	},
	)
	}

	pub fn make_singular_i32_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> i32,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
	get,
	_set: set_panic,
	})),
	},
	)
	}

	pub fn make_singular_u64_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> u64,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
	get,
	_set: set_panic,
	})),
	},
	)
	}

	pub fn make_singular_i64_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> i64,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
	get,
	_set: set_panic,
	})),
	},
	)
	}

	pub fn make_singular_f32_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> f32,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
	get,
	_set: set_panic,
	})),
	},
	)
	}

	pub fn make_singular_f64_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> f64,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
	get,
	_set: set_panic,
	})),
	},
	)
	}

	pub fn make_singular_bool_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> bool,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
	get,
	_set: set_panic,
	})),
	},
	)
	}

	pub fn make_singular_enum_accessor<M: Message + 'static, E: ProtobufEnum + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: fn(&M) -> E,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Enum(Box::new(GetSingularEnumImpl { get })),
	},
	)
	}

	pub fn make_singular_string_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: for<'a> fn(&'a M) -> &'a str,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::String(get, set_panic),
	},
	)
	}

	pub fn make_singular_bytes_accessor<M: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: for<'a> fn(&'a M) -> &'a [u8],
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Bytes(get, set_panic),
	},
	)
	}

	pub fn make_singular_message_accessor<M: Message + 'static, F: Message + 'static>(
	name: &'static str,
	has: fn(&M) -> bool,
	get: for<'a> fn(&'a M) -> &'a F,
	) -> FieldAccessor {
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::SingularHasGetSet {
	has,
	get_set: SingularGetSet::Message(Box::new(GetSingularMessageImpl { get })),
	},
	)
	}

	// repeated

	impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, Vec<V>>
	where
	M: Message + 'static,
	V: ProtobufValue + 'static,
	{
	fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
	(self.get_field)(m) as &dyn ReflectRepeated
	}

	fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
	(self.mut_field)(m) as &mut dyn ReflectRepeated
	}
	}

	pub fn make_vec_accessor<M, V>(
	name: &'static str,
	get_vec: for<'a> fn(&'a M) -> &'a Vec<V::Value>,
	mut_vec: for<'a> fn(&'a mut M) -> &'a mut Vec<V::Value>,
	) -> FieldAccessor
	where
	M: Message + 'static,
	V: ProtobufType + 'static,
	{
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, Vec<V::Value>> {
	get_field: get_vec,
	mut_field: mut_vec,
	})),
	)
	}

	impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, RepeatedField<V>>
	where
	M: Message + 'static,
	V: ProtobufValue + 'static,
	{
	fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
	(self.get_field)(m) as &dyn ReflectRepeated
	}

	fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
	(self.mut_field)(m) as &mut dyn ReflectRepeated
	}
	}

	pub fn make_repeated_field_accessor<M, V>(
	name: &'static str,
	get_vec: for<'a> fn(&'a M) -> &'a RepeatedField<V::Value>,
	mut_vec: for<'a> fn(&'a mut M) -> &'a mut RepeatedField<V::Value>,
	) -> FieldAccessor
	where
	M: Message + 'static,
	V: ProtobufType + 'static,
	{
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, RepeatedField<V::Value>> {
	get_field: get_vec,
	mut_field: mut_vec,
	})),
	)
	}

	impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, Option<V>>
	where
	M: Message + 'static,
	V: ProtobufValue + Clone + 'static,
	{
	fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
	(self.get_field)(m) as &dyn ReflectOptional
	}

	fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
	(self.mut_field)(m) as &mut dyn ReflectOptional
	}
	}

	pub fn make_option_accessor<M, V>(
	name: &'static str,
	get_field: for<'a> fn(&'a M) -> &'a Option<V::Value>,
	mut_field: for<'a> fn(&'a mut M) -> &'a mut Option<V::Value>,
	) -> FieldAccessor
	where
	M: Message + 'static,
	V: ProtobufType + 'static,
	{
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, Option<V::Value>> {
	get_field,
	mut_field,
	})),
	)
	}

	impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularField<V>>
	where
	M: Message + 'static,
	V: ProtobufValue + Clone + 'static,
	{
	fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
	(self.get_field)(m) as &dyn ReflectOptional
	}

	fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
	(self.mut_field)(m) as &mut dyn ReflectOptional
	}
	}

	pub fn make_singular_field_accessor<M, V>(
	name: &'static str,
	get_field: for<'a> fn(&'a M) -> &'a SingularField<V::Value>,
	mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularField<V::Value>,
	) -> FieldAccessor
	where
	M: Message + 'static,
	V: ProtobufType + 'static,
	{
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, SingularField<V::Value>> {
	get_field,
	mut_field,
	})),
	)
	}

	impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularPtrField<V>>
	where
	M: Message + 'static,
	V: ProtobufValue + Clone + 'static,
	{
	fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
	(self.get_field)(m) as &dyn ReflectOptional
	}

	fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
	(self.mut_field)(m) as &mut dyn ReflectOptional
	}
	}

	pub fn make_singular_ptr_field_accessor<M, V>(
	name: &'static str,
	get_field: for<'a> fn(&'a M) -> &'a SingularPtrField<V::Value>,
	mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularPtrField<V::Value>,
	) -> FieldAccessor
	where
	M: Message + 'static,
	V: ProtobufType + 'static,
	{
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::Optional(Box::new(
	MessageGetMut::<M, SingularPtrField<V::Value>> {
	get_field,
	mut_field,
	},
	)),
	)
	}

	impl<M, V> FieldAccessor2<M, dyn ProtobufValue> for MessageGetMut<M, V>
	where
	M: Message + 'static,
	V: ProtobufValue + Clone + 'static,
	{
	fn get_field<'a>(&self, m: &'a M) -> &'a dyn ProtobufValue {
	(self.get_field)(m) as &dyn ProtobufValue
	}

	fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ProtobufValue {
	(self.mut_field)(m) as &mut dyn ProtobufValue
	}
	}

	pub fn make_simple_field_accessor<M, V>(
	name: &'static str,
	get_field: for<'a> fn(&'a M) -> &'a V::Value,
	mut_field: for<'a> fn(&'a mut M) -> &'a mut V::Value,
	) -> FieldAccessor
	where
	M: Message + 'static,
	V: ProtobufType + 'static,
	{
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::Simple(Box::new(MessageGetMut::<M, V::Value> {
	get_field,
	mut_field,
	})),
	)
	}

	impl<M, K, V> FieldAccessor2<M, dyn ReflectMap> for MessageGetMut<M, HashMap<K, V>>
	where
	M: Message + 'static,
	K: ProtobufValue + 'static,
	V: ProtobufValue + 'static,
	K: Hash + Eq,
	{
	fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectMap {
	(self.get_field)(m) as &dyn ReflectMap
	}

	fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectMap {
	(self.mut_field)(m) as &mut dyn ReflectMap
	}
	}

	pub fn make_map_accessor<M, K, V>(
	name: &'static str,
	get_field: for<'a> fn(&'a M) -> &'a HashMap<K::Value, V::Value>,
	mut_field: for<'a> fn(&'a mut M) -> &'a mut HashMap<K::Value, V::Value>,
	) -> FieldAccessor
	where
	M: Message + 'static,
	K: ProtobufType + 'static,
	V: ProtobufType + 'static,
	<K as ProtobufType>::Value: Hash + Eq,
	{
	FieldAccessor::new_v1(
	name,
	FieldAccessorFunctions::Map(Box::new(MessageGetMut::<M, HashMap<K::Value, V::Value>> {
	get_field,
	mut_field,
	})),
	)
	}