diff --git a/pdl-compiler/src/backends/rust/preamble.rs b/pdl-compiler/src/backends/rust/preamble.rs index 92356f7..e9af398 100644 --- a/pdl-compiler/src/backends/rust/preamble.rs +++ b/pdl-compiler/src/backends/rust/preamble.rs @@ -55,9 +55,23 @@ pub fn generate(path: &Path) -> proc_macro2::TokenStream { use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; - use pdl_runtime::{Error, Packet, Private}; + use pdl_runtime::{Error, Packet}; type Result = std::result::Result; + + /// Private prevents users from creating arbitrary scalar values + /// in situations where the value needs to be validated. + /// Users can freely deref the value, but only the backend + /// may create it. + #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] + pub struct Private(T); + + impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } + } } } diff --git a/pdl-compiler/tests/generated/custom_field_declaration_big_endian.rs b/pdl-compiler/tests/generated/custom_field_declaration_big_endian.rs index e2cd295..eb70e2f 100644 --- a/pdl-compiler/tests/generated/custom_field_declaration_big_endian.rs +++ b/pdl-compiler/tests/generated/custom_field_declaration_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(from = "u32", into = "u32"))] diff --git a/pdl-compiler/tests/generated/custom_field_declaration_little_endian.rs b/pdl-compiler/tests/generated/custom_field_declaration_little_endian.rs index e2cd295..eb70e2f 100644 --- a/pdl-compiler/tests/generated/custom_field_declaration_little_endian.rs +++ b/pdl-compiler/tests/generated/custom_field_declaration_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(from = "u32", into = "u32"))] diff --git a/pdl-compiler/tests/generated/enum_declaration_big_endian.rs b/pdl-compiler/tests/generated/enum_declaration_big_endian.rs index 8986680..bd90591 100644 --- a/pdl-compiler/tests/generated/enum_declaration_big_endian.rs +++ b/pdl-compiler/tests/generated/enum_declaration_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/enum_declaration_little_endian.rs b/pdl-compiler/tests/generated/enum_declaration_little_endian.rs index 8986680..bd90591 100644 --- a/pdl-compiler/tests/generated/enum_declaration_little_endian.rs +++ b/pdl-compiler/tests/generated/enum_declaration_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_big_endian.rs index a67c1af..d1bba97 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_little_endian.rs index ff01127..9a48b4b 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_enum_array_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_big_endian.rs index 70403ef..64b6a81 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_enum_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_enum_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_enum_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_enum_little_endian.rs index b7918ec..cd916a7 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_enum_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_enum_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs index 10a741a..a0a810a 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs index 0727057..adbdff4 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_array_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_big_endian.rs index 62e3358..2bbdde0 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_little_endian.rs index 1be3c88..fce2122 100644 --- a/pdl-compiler/tests/generated/packet_decl_24bit_scalar_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_24bit_scalar_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_big_endian.rs index 1e44edb..fce2ae1 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_little_endian.rs index 261ed1d..8d7c2a1 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_enum_array_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_big_endian.rs index 9a5fdb7..2a0c784 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_enum_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_enum_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_enum_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_enum_little_endian.rs index e5bc122..0fcaa48 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_enum_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_enum_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs index 8318a46..261e4dd 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs index fa1f71e..f60c64c 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_array_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_big_endian.rs index 076fb20..e067fac 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_little_endian.rs index b76199f..815d0b1 100644 --- a/pdl-compiler/tests/generated/packet_decl_64bit_scalar_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_64bit_scalar_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_big_endian.rs index a21f8ca..ba959a6 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_little_endian.rs index a21f8ca..ba959a6 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_enum_array_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_enum_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_enum_big_endian.rs index 66faf4f..03bec5d 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_enum_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_enum_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_enum_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_enum_little_endian.rs index 66faf4f..03bec5d 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_enum_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_enum_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs index dbc8980..74099b0 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs index dbc8980..74099b0 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_array_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_big_endian.rs index 7eb26bd..de13f31 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_little_endian.rs index 7eb26bd..de13f31 100644 --- a/pdl-compiler/tests/generated/packet_decl_8bit_scalar_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_8bit_scalar_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_big_endian.rs index b24e60b..074443c 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_little_endian.rs index 29aa7bc..e6429b4 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_dynamic_count_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_big_endian.rs index 901adbd..a4899a1 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_little_endian.rs index 5b2e8e3..d048bfc 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_dynamic_size_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs index d52e402..d542792 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs index 6338480..767671f 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs index fb9205d..63d2dc2 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs index adef94a..30ef3ba 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-compiler/tests/generated/packet_decl_array_with_padding_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_with_padding_big_endian.rs index 4ce57b1..0231b64 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_with_padding_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_with_padding_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-compiler/tests/generated/packet_decl_array_with_padding_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_array_with_padding_little_endian.rs index 6adbf8e..6aee602 100644 --- a/pdl-compiler/tests/generated/packet_decl_array_with_padding_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_array_with_padding_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-compiler/tests/generated/packet_decl_child_packets_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_child_packets_big_endian.rs index 884aaff..3498cae 100644 --- a/pdl-compiler/tests/generated/packet_decl_child_packets_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_child_packets_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_child_packets_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_child_packets_little_endian.rs index f3645d3..cebc67e 100644 --- a/pdl-compiler/tests/generated/packet_decl_child_packets_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_child_packets_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_complex_scalars_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_complex_scalars_big_endian.rs index c96156e..4c3de07 100644 --- a/pdl-compiler/tests/generated/packet_decl_complex_scalars_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_complex_scalars_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_complex_scalars_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_complex_scalars_little_endian.rs index 3d794e4..4bd1a80 100644 --- a/pdl-compiler/tests/generated/packet_decl_complex_scalars_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_complex_scalars_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_custom_field_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_custom_field_big_endian.rs index a956187..43b2237 100644 --- a/pdl-compiler/tests/generated/packet_decl_custom_field_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_custom_field_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(try_from = "u32", into = "u32"))] diff --git a/pdl-compiler/tests/generated/packet_decl_custom_field_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_custom_field_little_endian.rs index 481ae12..f1b9d0a 100644 --- a/pdl-compiler/tests/generated/packet_decl_custom_field_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_custom_field_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", serde(try_from = "u32", into = "u32"))] diff --git a/pdl-compiler/tests/generated/packet_decl_empty_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_empty_big_endian.rs index 87cffeb..49f14b8 100644 --- a/pdl-compiler/tests/generated/packet_decl_empty_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_empty_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData {} diff --git a/pdl-compiler/tests/generated/packet_decl_empty_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_empty_little_endian.rs index 87cffeb..49f14b8 100644 --- a/pdl-compiler/tests/generated/packet_decl_empty_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_empty_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData {} diff --git a/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_big_endian.rs index 31307fe..78b2b99 100644 --- a/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_little_endian.rs index c4511d7..dfb4c25 100644 --- a/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_fixed_enum_field_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs index ed70df0..2c5ad70 100644 --- a/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs index 8156167..b37bce0 100644 --- a/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_fixed_scalar_field_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_grand_children_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_grand_children_big_endian.rs index 2b4e88c..64ca83f 100644 --- a/pdl-compiler/tests/generated/packet_decl_grand_children_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_grand_children_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_grand_children_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_grand_children_little_endian.rs index 38ffa3d..9c03220 100644 --- a/pdl-compiler/tests/generated/packet_decl_grand_children_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_grand_children_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_big_endian.rs index 4bc7eee..dddbc0b 100644 --- a/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_little_endian.rs index 420fdc5..57bcb51 100644 --- a/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_mask_scalar_value_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs index 4ce954c..1bf676b 100644 --- a/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs index 1293eba..baa27e3 100644 --- a/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_mixed_scalars_enums_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs index aa244b1..c0a1cf1 100644 --- a/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs index aa244b1..c0a1cf1 100644 --- a/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_parent_with_alias_child_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs index 4421543..4bb083b 100644 --- a/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs index 4421543..4bb083b 100644 --- a/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_parent_with_no_payload_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[repr(u64)] #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] diff --git a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs index 588b337..bfbffe7 100644 --- a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub enum FooDataChild { diff --git a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs index dc1a1b2..e473774 100644 --- a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub enum FooDataChild { diff --git a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs index a736393..c37ff2b 100644 --- a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub enum FooDataChild { diff --git a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs index 011b231..2e22410 100644 --- a/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_payload_field_unknown_size_terminal_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub enum FooDataChild { diff --git a/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs index 2e0bf8e..5df7232 100644 --- a/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub enum FooDataChild { diff --git a/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs index 35f3881..477c8b6 100644 --- a/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_payload_field_variable_size_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub enum FooDataChild { diff --git a/pdl-compiler/tests/generated/packet_decl_reserved_field_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_reserved_field_big_endian.rs index 7b964e1..b296e58 100644 --- a/pdl-compiler/tests/generated/packet_decl_reserved_field_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_reserved_field_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData {} diff --git a/pdl-compiler/tests/generated/packet_decl_reserved_field_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_reserved_field_little_endian.rs index 7b964e1..b296e58 100644 --- a/pdl-compiler/tests/generated/packet_decl_reserved_field_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_reserved_field_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData {} diff --git a/pdl-compiler/tests/generated/packet_decl_simple_scalars_big_endian.rs b/pdl-compiler/tests/generated/packet_decl_simple_scalars_big_endian.rs index 88eac0d..8c31583 100644 --- a/pdl-compiler/tests/generated/packet_decl_simple_scalars_big_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_simple_scalars_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/packet_decl_simple_scalars_little_endian.rs b/pdl-compiler/tests/generated/packet_decl_simple_scalars_little_endian.rs index 30bc6a1..d1c3655 100644 --- a/pdl-compiler/tests/generated/packet_decl_simple_scalars_little_endian.rs +++ b/pdl-compiler/tests/generated/packet_decl_simple_scalars_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct FooData { diff --git a/pdl-compiler/tests/generated/preamble.rs b/pdl-compiler/tests/generated/preamble.rs index a97324e..dd11680 100644 --- a/pdl-compiler/tests/generated/preamble.rs +++ b/pdl-compiler/tests/generated/preamble.rs @@ -4,5 +4,17 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} diff --git a/pdl-compiler/tests/generated/reserved_identifier_big_endian.rs b/pdl-compiler/tests/generated/reserved_identifier_big_endian.rs index 032b29e..f346dd1 100644 --- a/pdl-compiler/tests/generated/reserved_identifier_big_endian.rs +++ b/pdl-compiler/tests/generated/reserved_identifier_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct TestData { diff --git a/pdl-compiler/tests/generated/reserved_identifier_little_endian.rs b/pdl-compiler/tests/generated/reserved_identifier_little_endian.rs index 032b29e..f346dd1 100644 --- a/pdl-compiler/tests/generated/reserved_identifier_little_endian.rs +++ b/pdl-compiler/tests/generated/reserved_identifier_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct TestData { diff --git a/pdl-compiler/tests/generated/struct_decl_complex_scalars_big_endian.rs b/pdl-compiler/tests/generated/struct_decl_complex_scalars_big_endian.rs index 356d000..5fa18cd 100644 --- a/pdl-compiler/tests/generated/struct_decl_complex_scalars_big_endian.rs +++ b/pdl-compiler/tests/generated/struct_decl_complex_scalars_big_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-compiler/tests/generated/struct_decl_complex_scalars_little_endian.rs b/pdl-compiler/tests/generated/struct_decl_complex_scalars_little_endian.rs index a59711d..dbd7b69 100644 --- a/pdl-compiler/tests/generated/struct_decl_complex_scalars_little_endian.rs +++ b/pdl-compiler/tests/generated/struct_decl_complex_scalars_little_endian.rs @@ -4,8 +4,20 @@ use bytes::{Buf, BufMut, Bytes, BytesMut}; use std::convert::{TryFrom, TryInto}; use std::cell::Cell; use std::fmt; -use pdl_runtime::{Error, Packet, Private}; +use pdl_runtime::{Error, Packet}; type Result = std::result::Result; +/// Private prevents users from creating arbitrary scalar values +/// in situations where the value needs to be validated. +/// Users can freely deref the value, but only the backend +/// may create it. +#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] +pub struct Private(T); +impl std::ops::Deref for Private { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Foo { diff --git a/pdl-runtime/src/lib.rs b/pdl-runtime/src/lib.rs index 728a7c2..4e78bf9 100644 --- a/pdl-runtime/src/lib.rs +++ b/pdl-runtime/src/lib.rs @@ -43,17 +43,3 @@ pub trait Packet { fn to_bytes(self) -> Bytes; fn to_vec(self) -> Vec; } - -/// Private prevents users from creating arbitrary scalar values -/// in situations where the value needs to be validated. -/// Users can freely deref the value, but only the backend -/// may create it. -#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] -pub struct Private(T); - -impl std::ops::Deref for Private { - type Target = T; - fn deref(&self) -> &Self::Target { - &self.0 - } -}