Struct hdk::prelude::holochain_serialized_bytes::SerializedBytes

source ·

pub struct SerializedBytes(/* private fields */);

Expand description

A Canonical Serialized Bytes representation for data If you have a data structure that needs a canonical byte representation use this Always round-trip through SerializedBytes via. a single TryFrom implementation. This ensures that the internal bytes of SerializedBytes are indeed canonical. The corrolary is that if bytes are NOT wrapped in SerializedBytes we can assume they are NOT canonical. Typically we need a canonical serialization when data is to be handled at the byte level by independently implemented and maintained systems.

Examples of times we need a canonical set of bytes to represent data:

cryptographic operations
moving across the host/guest wasm boundary
putting data on the network

Examples of times where we may not need a canonical representation and so may not need this:

round tripping data through a database that has its own serialization preferences
debug output or logging of data that is to be human readible
moving between data types within a single system that has no external facing representation

uses #[repr(transparent)] to maximise compatibility with ffi @see https://doc.rust-lang.org/1.26.2/unstable-book/language-features/repr-transparent.html#enter-reprtransparent

uses serde_bytes for efficient serialization and deserialization without this every byte will be individually round tripped through serde @see https://crates.io/crates/serde_bytes

Struct hdk::prelude::holochain_serialized_bytes::SerializedBytes

Implementations§

impl SerializedBytes

pub fn bytes(&self) -> &Vec<u8> ⓘ

Trait Implementations§

impl AsRef<SerializedBytes> for AppEntryBytes

fn as_ref(&self) -> &SerializedBytes

impl Borrow<SerializedBytes> for AppEntryBytes

fn borrow(&self) -> &SerializedBytes

impl Clone for SerializedBytes

fn clone(&self) -> SerializedBytes

fn clone_from(&mut self, source: &Self)

impl Debug for SerializedBytes

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Default for SerializedBytes

fn default() -> SerializedBytes

impl<'de> Deserialize<'de> for SerializedBytes

fn deserialize<__D>( __deserializer: __D ) -> Result<SerializedBytes, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

impl From<AppEntryBytes> for SerializedBytes

fn from(aeb: AppEntryBytes) -> SerializedBytes

impl From<SerializedBytes> for UnsafeBytes

fn from(sb: SerializedBytes) -> UnsafeBytes

impl From<UnsafeBytes> for SerializedBytes

fn from(b: UnsafeBytes) -> SerializedBytes

impl Hash for SerializedBytes

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl Ord for SerializedBytes

fn cmp(&self, other: &SerializedBytes) -> Ordering

fn max(self, other: Self) -> Selfwhere Self: Sized,

fn min(self, other: Self) -> Selfwhere Self: Sized,

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

impl PartialEq for SerializedBytes

fn eq(&self, other: &SerializedBytes) -> bool

fn ne(&self, other: &Rhs) -> bool

impl PartialOrd for SerializedBytes

fn partial_cmp(&self, other: &SerializedBytes) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl Serialize for SerializedBytes

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

impl TryFrom<&()> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &()) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&Action> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &Action) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&ActionType> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &ActionType) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&ActivityRequest> for SerializedBytes

type Error = SerializedBytesError

fn try_from( t: &ActivityRequest ) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&AgentActivity> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &AgentActivity) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&AgentInfo> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &AgentInfo) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&AgentValidationPkg> for SerializedBytes

type Error = SerializedBytesError

fn try_from( t: &AgentValidationPkg ) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&Anchor> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &Anchor) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&AnyDht> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &AnyDht) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&AnyLinkable> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &AnyLinkable) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&AppEntryDef> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &AppEntryDef) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&CapClaim> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &CapClaim) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&CapSecret> for SerializedBytes

fn deserialize<D>( deserializer: D ) -> Result<SerializedBytes, <D as Deserializer<'de>>::Error>
where __D: Deserializer<'de>,

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn max(self, other: Self) -> Self
where Self: Sized,

fn min(self, other: Self) -> Self
where Self: Sized,

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer,