Protocol Buffers - Google's data interchange format (grpc依赖)
https://developers.google.com/protocol-buffers/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
137 lines
4.2 KiB
137 lines
4.2 KiB
// Protocol Buffers - Google's data interchange format |
|
// Copyright 2023 Google LLC. All rights reserved. |
|
// |
|
// Use of this source code is governed by a BSD-style |
|
// license that can be found in the LICENSE file or at |
|
// https://developers.google.com/open-source/licenses/bsd |
|
|
|
use crate::__internal::Private; |
|
use crate::__runtime::InnerPrimitiveMut; |
|
use crate::vtable::{ |
|
PrimitiveOptionalMutVTable, PrimitiveVTable, ProxiedWithRawOptionalVTable, |
|
ProxiedWithRawVTable, RawVTableOptionalMutatorData, |
|
}; |
|
use crate::{Mut, MutProxy, Proxied, ProxiedWithPresence, SettableValue, View, ViewProxy}; |
|
|
|
#[derive(Debug)] |
|
pub struct PrimitiveMut<'a, T: ProxiedWithRawVTable> { |
|
inner: InnerPrimitiveMut<'a, T>, |
|
} |
|
|
|
impl<'a, T: ProxiedWithRawVTable> PrimitiveMut<'a, T> { |
|
#[doc(hidden)] |
|
pub fn from_inner(_private: Private, inner: InnerPrimitiveMut<'a, T>) -> Self { |
|
Self { inner } |
|
} |
|
} |
|
|
|
unsafe impl<'a, T: ProxiedWithRawVTable> Sync for PrimitiveMut<'a, T> {} |
|
|
|
macro_rules! impl_singular_primitives { |
|
($($t:ty),*) => { |
|
$( |
|
impl Proxied for $t { |
|
type View<'a> = $t; |
|
type Mut<'a> = PrimitiveMut<'a, $t>; |
|
} |
|
|
|
impl<'a> ViewProxy<'a> for $t { |
|
type Proxied = $t; |
|
|
|
fn as_view(&self) -> View<'_, Self::Proxied> { |
|
*self |
|
} |
|
|
|
fn into_view<'shorter>(self) -> View<'shorter, Self::Proxied> { |
|
self |
|
} |
|
} |
|
|
|
impl<'a> PrimitiveMut<'a, $t> { |
|
pub fn get(&self) -> View<'_, $t> { |
|
self.inner.get() |
|
} |
|
|
|
pub fn set(&mut self, val: impl SettableValue<$t>) { |
|
val.set_on(Private, self.as_mut()); |
|
} |
|
} |
|
|
|
impl<'a> ViewProxy<'a> for PrimitiveMut<'a, $t> { |
|
type Proxied = $t; |
|
|
|
fn as_view(&self) -> View<'_, Self::Proxied> { |
|
self.get() |
|
} |
|
|
|
fn into_view<'shorter>(self) -> View<'shorter, Self::Proxied> { |
|
self.get() |
|
} |
|
} |
|
|
|
impl<'a> MutProxy<'a> for PrimitiveMut<'a, $t> { |
|
fn as_mut(&mut self) -> Mut<'_, Self::Proxied> { |
|
PrimitiveMut { inner: self.inner } |
|
} |
|
|
|
fn into_mut<'shorter>(self) -> Mut<'shorter, Self::Proxied> |
|
where 'a: 'shorter, |
|
{ |
|
self |
|
} |
|
} |
|
|
|
impl SettableValue<$t> for $t { |
|
fn set_on<'a>(self, _private: Private, mutator: Mut<'a, $t>) where $t: 'a { |
|
// SAFETY: the raw mutator is valid for `'a` as enforced by `Mut` |
|
unsafe { mutator.inner.set(self) } |
|
} |
|
} |
|
|
|
impl ProxiedWithRawVTable for $t { |
|
type VTable = PrimitiveVTable<$t>; |
|
|
|
fn make_view( |
|
_private: Private, |
|
mut_inner: InnerPrimitiveMut<'_, Self> |
|
) -> View<'_, Self> { |
|
mut_inner.get() |
|
} |
|
|
|
fn make_mut(_private: Private, inner: InnerPrimitiveMut<'_, Self>) -> Mut<'_, Self> { |
|
PrimitiveMut::from_inner(Private, inner) |
|
} |
|
} |
|
|
|
impl ProxiedWithPresence for $t { |
|
type PresentMutData<'a> = RawVTableOptionalMutatorData<'a, $t>; |
|
type AbsentMutData<'a> = RawVTableOptionalMutatorData<'a, $t>; |
|
|
|
fn clear_present_field( |
|
present_mutator: Self::PresentMutData<'_>, |
|
) -> Self::AbsentMutData<'_> { |
|
present_mutator.clear() |
|
} |
|
|
|
fn set_absent_to_default( |
|
absent_mutator: Self::AbsentMutData<'_>, |
|
) -> Self::PresentMutData<'_> { |
|
absent_mutator.set_absent_to_default() |
|
} |
|
} |
|
|
|
impl ProxiedWithRawOptionalVTable for $t { |
|
type OptionalVTable = PrimitiveOptionalMutVTable<$t>; |
|
|
|
fn upcast_vtable( |
|
_private: Private, |
|
optional_vtable: &'static Self::OptionalVTable, |
|
) -> &'static Self::VTable { |
|
&optional_vtable.base |
|
} |
|
} |
|
)* |
|
} |
|
} |
|
|
|
impl_singular_primitives!(bool, f32, f64, i32, i64, u32, u64);
|
|
|