Enum Value

pub enum Value {
    Int(i128),
    UInt(u128),
    Bool(bool),
    Sequence(SequenceData),
    Principal(PrincipalData),
    Tuple(TupleData),
    Optional(OptionalData),
    Response(ResponseData),
    CallableContract(CallableData),
}

Variants

Int(i128)

UInt(u128)

Bool(bool)

Sequence(SequenceData)

Principal(PrincipalData)

Tuple(TupleData)

Optional(OptionalData)

Response(ResponseData)

CallableContract(CallableData)

Implementations

impl Value

pub fn deserialize_read<R>( r: &mut R, expected_type: Option<&TypeSignature>, sanitize: bool, ) -> Result<Value, SerializationError>

where R: Read,

pub fn deserialize_read_count<R>( r: &mut R, expected_type: Option<&TypeSignature>, sanitize: bool, ) -> Result<(Value, u64), SerializationError>

where R: Read,

Deserialize just like deserialize_read but also return the bytes read. If sanitize argument is set to true and expected_type is supplied, this method will remove any extraneous tuple fields which may have been allowed by least_super_type.

pub fn serialize_write<W>(&self, w: &mut W) -> Result<(), SerializationError>

where W: Write,

pub fn try_deserialize_bytes( bytes: &Vec<u8>, expected: &TypeSignature, sanitize: bool, ) -> Result<Value, SerializationError>

This function attempts to deserialize a byte buffer into a Clarity Value. The expected_type parameter tells the deserializer to expect (and enforce) a particular type. ClarityDB uses this to ensure that lists, tuples, etc. loaded from the database have their max-length and other type information set by the type declarations in the contract.

pub fn try_deserialize_hex( hex: &str, expected: &TypeSignature, sanitize: bool, ) -> Result<Value, SerializationError>

This function attempts to deserialize a hex string into a Clarity Value. The expected_type parameter tells the deserializer to expect (and enforce) a particular type. ClarityDB uses this to ensure that lists, tuples, etc. loaded from the database have their max-length and other type information set by the type declarations in the contract.

pub fn try_deserialize_bytes_exact( bytes: &Vec<u8>, expected: &TypeSignature, sanitize: bool, ) -> Result<Value, SerializationError>

This function attempts to deserialize a byte buffer into a Clarity Value, while ensuring that the whole byte buffer is consumed by the deserialization, erroring if it is not. The expected_type parameter tells the deserializer to expect (and enforce) a particular type. ClarityDB uses this to ensure that lists, tuples, etc. loaded from the database have their max-length and other type information set by the type declarations in the contract.

pub fn try_deserialize_hex_untyped( hex: &str, ) -> Result<Value, SerializationError>

Try to deserialize a value from a hex string without type information. This does not perform sanitization.

pub fn serialized_size(&self) -> Result<u32, SerializationError>

impl Value

pub fn serialize_to_vec(&self) -> Result<Vec<u8>, InterpreterError>

pub fn serialize_to_hex(&self) -> Result<String, InterpreterError>

This does not perform any data sanitization

pub fn sanitize_value( epoch: &StacksEpochId, expected: &TypeSignature, value: Value, ) -> Option<(Value, bool)>

Sanitize value against pre-2.4 serialization

Returns Some if the sanitization is successful, or was not necessary. Returns None if the sanitization failed.

Returns the sanitized value and whether or not sanitization was required.

impl Value

pub fn some(data: Value) -> Result<Value, Error>

pub fn none() -> Value

pub fn okay_true() -> Value

pub fn err_uint(ecode: u128) -> Value

pub fn err_none() -> Value

pub fn okay(data: Value) -> Result<Value, Error>

pub fn error(data: Value) -> Result<Value, Error>

pub fn size(&self) -> Result<u32, Error>

pub fn depth(&self) -> Result<u8, Error>

pub fn list_with_type( epoch: &StacksEpochId, list_data: Vec<Value>, expected_type: ListTypeData, ) -> Result<Value, Error>

Invariant: the supplied Values have already been “checked”, i.e., it’s a valid Value object this invariant is enforced through the Value constructors, each of which checks to ensure that any typing data is correct.

pub fn cons_list_unsanitized(list_data: Vec<Value>) -> Result<Value, Error>

pub fn cons_list( list_data: Vec<Value>, epoch: &StacksEpochId, ) -> Result<Value, Error>

pub fn buff_from(buff_data: Vec<u8>) -> Result<Value, Error>

Errors

• CheckErrors::ValueTooLarge if buff_data is too large.

pub fn buff_from_byte(byte: u8) -> Value

pub fn string_ascii_from_bytes(bytes: Vec<u8>) -> Result<Value, Error>

pub fn string_utf8_from_string_utf8_literal( tokenized_str: String, ) -> Result<Value, Error>

pub fn string_utf8_from_bytes(bytes: Vec<u8>) -> Result<Value, Error>

pub fn string_utf8_from_unicode_scalars( scalars: Vec<u8>, ) -> Result<Value, Error>

pub fn expect_ascii(self) -> Result<String, Error>

pub fn expect_u128(self) -> Result<u128, Error>

pub fn expect_i128(self) -> Result<i128, Error>

pub fn expect_buff(self, sz: usize) -> Result<Vec<u8>, Error>

pub fn expect_list(self) -> Result<Vec<Value>, Error>

pub fn expect_buff_padded(self, sz: usize, pad: u8) -> Result<Vec<u8>, Error>

pub fn expect_bool(self) -> Result<bool, Error>

pub fn expect_tuple(self) -> Result<TupleData, Error>

pub fn expect_optional(self) -> Result<Option<Value>, Error>

pub fn expect_principal(self) -> Result<PrincipalData, Error>

pub fn expect_callable(self) -> Result<CallableData, Error>

pub fn expect_result(self) -> Result<Result<Value, Value>, Error>

pub fn expect_result_ok(self) -> Result<Value, Error>

pub fn expect_result_err(self) -> Result<Value, Error>

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Value

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Value

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

Formats the value using the given formatter.

impl From<&Value> for TypePrefix

fn from(v: &Value) -> TypePrefix

Converts to this type from the input type.

impl From<ASCIIData> for Value

fn from(ascii: ASCIIData) -> Value

Converts to this type from the input type.

impl From<PrincipalData> for Value

fn from(p: PrincipalData) -> Value

Converts to this type from the input type.

impl From<QualifiedContractIdentifier> for Value

fn from(principal: QualifiedContractIdentifier) -> Value

Converts to this type from the input type.

impl From<StandardPrincipalData> for Value

fn from(principal: StandardPrincipalData) -> Value

Converts to this type from the input type.

impl From<TupleData> for Value

fn from(t: TupleData) -> Value

Converts to this type from the input type.

impl Into<Value> for ShortReturnType

fn into(self) -> Value

Converts this type into the (usually inferred) input type.

impl MemoryConsumer for Value

fn get_memory_use(&self) -> Result<u64, CostErrors>

impl PartialEq for Value

fn eq(&self, other: &Value) -> 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 SequencedValue<Value> for ListData

fn items(&self) -> &Vec<Value>

fn drained_items(&mut self) -> Vec<Value>

fn type_signature(&self) -> Result<TypeSignature, CheckErrors>

fn to_value(v: &Value) -> Result<Value, Error>

fn atom_values(&mut self) -> Result<Vec<SymbolicExpression>, Error>

impl Serialize for Value

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 StacksMessageCodec for Value

Note: the StacksMessageCodec implementation for Clarity values does not sanitize its serialization or deserialization.

fn consensus_serialize<W>(&self, fd: &mut W) -> Result<(), Error>

where W: Write,

serialize implementors should never error unless there is an underlying failure in writing to the fd

fn consensus_deserialize<R>(fd: &mut R) -> Result<Value, Error>

where R: Read,

fn serialize_to_vec(&self) -> Vec<u8>

where Self: Sized,

Convenience for serialization to a vec. this function unwraps any underlying serialization error

impl Eq for Value

impl StructuralPartialEq for Value