Struct Record

pub struct Record<A = SignedHashed<Action>> {
    pub signed_action: A,
    pub entry: RecordEntry,
}

a chain record containing the signed action along with the entry if the action type has one.

Fields

signed_action: A

The signed action for this record

entry: RecordEntry

If there is an entry associated with this action it will be here. If not, there will be an enum variant explaining the reason.

Implementations

impl Record

pub fn new( signed_action: SignedHashed<Action>, maybe_entry: Option<Entry>, ) -> Record

Raw record constructor. Used only when we know that the values are valid. NOTE: this will NOT hide private entry data if present!

pub fn signature(&self) -> &Signature

Access the signature from this record’s signed action

pub fn privatized(self) -> (Record, Option<Entry>)

If the Record contains private entry data, set the RecordEntry to Hidden so that it cannot be leaked. If the entry was hidden, return it separately.

pub fn action_address(&self) -> &HoloHash<Action>

Access the action address from this record’s signed action

pub fn action(&self) -> &Action

Access the Action from this record’s signed action

pub fn action_hashed(&self) -> &HoloHashed<Action>

Access the ActionHashed from this record’s signed action portion

pub fn entry(&self) -> &RecordEntry

Access the Entry portion of this record as a RecordEntry, which includes the context around the presence or absence of the entry.

impl<A> Record<A>

pub fn into_inner(self) -> (A, RecordEntry)

Break this record into its components

pub fn signed_action(&self) -> &A

The inner signed-action

Trait Implementations

impl ActionHashedContainer for Record

fn action(&self) -> &Action

fn action_hash(&self) -> &HoloHash<Action>

impl ActionSequenceAndHash for Record

fn action_seq(&self) -> u32

fn address(&self) -> &HoloHash<Action>

impl<A> AsRef<A> for Record<A>

fn as_ref(&self) -> &A

Converts this type into a shared reference of the (usually inferred) input type.

impl<A> Clone for Record<A>

where A: Clone,

fn clone(&self) -> Record<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A> Debug for Record<A>

where A: Debug,

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for Record<A>

where A: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> PartialEq for Record<A>

where A: PartialEq,

fn eq(&self, other: &Record<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A> Serialize for Record<A>

where A: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&Record> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Record> for CreateLink

type Error = WrongActionError

The type returned in the event of a conversion error.

fn try_from( value: Record, ) -> Result<CreateLink, <CreateLink as TryFrom<Record>>::Error>

Performs the conversion.

impl TryFrom<Record> for DeleteLink

type Error = WrongActionError

The type returned in the event of a conversion error.

fn try_from( value: Record, ) -> Result<DeleteLink, <DeleteLink as TryFrom<Record>>::Error>

Performs the conversion.

impl TryFrom<Record> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<SerializedBytes> for Record

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(sb: SerializedBytes) -> Result<Record, SerializedBytesError>

Performs the conversion.

impl<A> Eq for Record<A>

where A: Eq,

impl<A> StructuralPartialEq for Record<A>