Enum OwnedTerm 

pub enum OwnedTerm {
    Atom(Atom),
    Integer(i64),
    Float(f64),
    Pid(ExternalPid),
    Port(ExternalPort),
    Reference(ExternalReference),
    Binary(Vec<u8>),
    BitBinary {
        bytes: Vec<u8>,
        bits: u8,
    },
    String(String),
    List(Vec<OwnedTerm>),
    ImproperList {
        elements: Vec<OwnedTerm>,
        tail: Box<OwnedTerm>,
    },
    Map(BTreeMap<OwnedTerm, OwnedTerm>),
    Tuple(Vec<OwnedTerm>),
    BigInt(BigInt),
    ExternalFun(ExternalFun),
    InternalFun(Box<InternalFun>),
    Nil,
}

Variants

Atom(Atom)

Integer(i64)

Float(f64)

Pid(ExternalPid)

Port(ExternalPort)

Reference(ExternalReference)

Binary(Vec<u8>)

BitBinary

Fields

bytes: Vec<u8>

bits: u8

String(String)

List(Vec<OwnedTerm>)

ImproperList

Fields

elements: Vec<OwnedTerm>

tail: Box<OwnedTerm>

Map(BTreeMap<OwnedTerm, OwnedTerm>)

Tuple(Vec<OwnedTerm>)

BigInt(BigInt)

ExternalFun(ExternalFun)

InternalFun(Box<InternalFun>)

Nil

Implementations

impl OwnedTerm

pub fn atom<S>(name: S) -> OwnedTerm

where S: AsRef<str>,

pub fn integer(value: i64) -> OwnedTerm

pub fn float(value: f64) -> OwnedTerm

pub fn binary(data: Vec<u8>) -> OwnedTerm

pub fn string<S>(value: S) -> OwnedTerm

where S: Into<String>,

pub fn list(elements: Vec<OwnedTerm>) -> OwnedTerm

pub fn improper_list(elements: Vec<OwnedTerm>, tail: OwnedTerm) -> OwnedTerm

pub fn map(entries: BTreeMap<OwnedTerm, OwnedTerm>) -> OwnedTerm

pub fn tuple(elements: Vec<OwnedTerm>) -> OwnedTerm

pub fn boolean(value: bool) -> OwnedTerm

pub fn ok() -> OwnedTerm

pub fn error() -> OwnedTerm

pub fn ok_tuple(value: OwnedTerm) -> OwnedTerm

pub fn error_tuple(reason: OwnedTerm) -> OwnedTerm

pub fn nil() -> OwnedTerm

pub fn is_atom(&self) -> bool

pub fn is_integer(&self) -> bool

pub fn is_list(&self) -> bool

pub fn is_map(&self) -> bool

pub fn is_tuple(&self) -> bool

pub fn as_atom(&self) -> Option<&Atom>

pub fn as_integer(&self) -> Option<i64>

pub fn as_float(&self) -> Option<f64>

pub fn as_binary(&self) -> Option<&[u8]>

pub fn as_string(&self) -> Option<&str>

pub fn as_list(&self) -> Option<&[OwnedTerm]>

pub fn as_map(&self) -> Option<&BTreeMap<OwnedTerm, OwnedTerm>>

pub fn as_tuple(&self) -> Option<&[OwnedTerm]>

pub fn as_list_mut(&mut self) -> Option<&mut Vec<OwnedTerm>>

pub fn as_map_mut(&mut self) -> Option<&mut BTreeMap<OwnedTerm, OwnedTerm>>

pub fn as_tuple_mut(&mut self) -> Option<&mut Vec<OwnedTerm>>

pub fn as_binary_mut(&mut self) -> Option<&mut Vec<u8>>

pub fn try_as_integer(&self) -> Result<i64, TermConversionError>

pub fn try_as_float(&self) -> Result<f64, TermConversionError>

pub fn try_as_atom(&self) -> Result<&Atom, TermConversionError>

pub fn try_as_binary(&self) -> Result<&[u8], TermConversionError>

pub fn try_as_string(&self) -> Result<&str, TermConversionError>

pub fn try_as_list(&self) -> Result<&[OwnedTerm], TermConversionError>

pub fn try_as_tuple(&self) -> Result<&[OwnedTerm], TermConversionError>

pub fn try_as_map( &self, ) -> Result<&BTreeMap<OwnedTerm, OwnedTerm>, TermConversionError>

pub fn into_map_iter( self, ) -> Result<impl Iterator<Item = (OwnedTerm, OwnedTerm)>, TermConversionError>

pub fn type_name(&self) -> &'static str

pub fn atom_name(&self) -> Option<&str>

pub fn is_atom_with_name(&self, name: &str) -> bool

pub fn is_true(&self) -> bool

pub fn is_false(&self) -> bool

pub fn is_undefined(&self) -> bool

pub fn is_nil_atom(&self) -> bool

pub fn as_bool(&self) -> Option<bool>

pub fn into_ok_value(self) -> Option<OwnedTerm>

pub fn into_rex_response(self) -> Result<OwnedTerm, TermConversionError>

pub fn into_error_reason(self) -> Option<OwnedTerm>

pub fn map_get(&self, key: &OwnedTerm) -> Option<&OwnedTerm>

pub fn get<I>(&self, index: I) -> Option<&OwnedTerm>

where I: TermIndex,

pub fn iter(&self) -> OwnedTermIter<'_>

pub fn proplist_get_atom_key(&self, key: &str) -> Option<&OwnedTerm>

pub fn is_proplist(&self) -> bool

pub fn is_proplist_element(element: &OwnedTerm) -> bool

pub fn normalize_proplist(&self) -> Result<OwnedTerm, TermConversionError>

pub fn proplist_to_map(&self) -> Result<OwnedTerm, TermConversionError>

pub fn map_to_proplist(&self) -> Result<OwnedTerm, TermConversionError>

pub fn to_map_recursive(&self) -> Result<OwnedTerm, TermConversionError>

pub fn atomize_keys(&self) -> Result<OwnedTerm, TermConversionError>

pub fn as_list_wrapped(&self) -> OwnedTerm

pub fn proplist_iter(&self) -> Option<ProplistIter<'_>>

pub fn map_get_atom_key(&self, key: &str) -> Option<&OwnedTerm>

pub fn map_get_i64(&self, key: &str) -> Option<i64>

pub fn map_get_i64_or(&self, key: &str, default: i64) -> i64

pub fn map_get_bool(&self, key: &str) -> Option<bool>

pub fn map_get_bool_or(&self, key: &str, default: bool) -> bool

pub fn map_get_atom(&self, key: &str) -> Option<&Atom>

pub fn map_get_string(&self, key: &str) -> Option<String>

pub fn map_get_string_or(&self, key: &str, default: &str) -> String

pub fn map_get_pid(&self, key: &str) -> Option<&ExternalPid>

pub fn map_get_atom_string(&self, key: &str) -> Option<String>

pub fn map_get_atom_string_or(&self, key: &str, default: &str) -> String

pub fn map_get_pid_string(&self, key: &str) -> Option<String>

pub fn map_get_pid_string_or(&self, key: &str, default: &str) -> String

pub fn map_get_mfa_string(&self, key: &str) -> Option<String>

pub fn map_get_mfa_string_or(&self, key: &str, default: &str) -> String

pub fn as_erlang_string(&self) -> Option<String>

pub fn as_erlang_string_or(&self, default: &str) -> String

pub fn tuple_get(&self, index: usize) -> Option<&OwnedTerm>

pub fn tuple_get_string(&self, index: usize) -> Option<String>

pub fn tuple_get_string_or(&self, index: usize, default: &str) -> String

pub fn tuple_get_atom_string(&self, index: usize) -> Option<String>

pub fn tuple_get_atom_string_or(&self, index: usize, default: &str) -> String

pub fn charlist<S>(s: S) -> OwnedTerm

where S: AsRef<str>,

pub fn is_charlist(&self) -> bool

pub fn as_charlist_string(&self) -> Option<String>

pub fn as_list_or_empty(&self) -> &[OwnedTerm]

pub fn try_as_mfa(&self) -> Option<Mfa>

pub fn format_as_mfa(&self) -> Option<String>

pub fn as_pid(&self) -> Option<&ExternalPid>

pub fn try_as_pid(&self) -> Result<&ExternalPid, TermConversionError>

pub fn is_pid(&self) -> bool

pub fn format_as_pid(&self) -> Option<String>

pub fn proplist_get_i64(&self, key: &str) -> Option<i64>

pub fn proplist_get_i64_or(&self, key: &str, default: i64) -> i64

pub fn proplist_get_bool(&self, key: &str) -> Option<bool>

pub fn proplist_get_bool_or(&self, key: &str, default: bool) -> bool

pub fn proplist_get_atom(&self, key: &str) -> Option<&Atom>

pub fn proplist_get_string(&self, key: &str) -> Option<String>

pub fn proplist_get_string_or(&self, key: &str, default: &str) -> String

pub fn proplist_get_pid(&self, key: &str) -> Option<&ExternalPid>

pub fn proplist_get_atom_string(&self, key: &str) -> Option<String>

pub fn proplist_get_atom_string_or(&self, key: &str, default: &str) -> String

pub fn proplist_get_pid_string(&self, key: &str) -> Option<String>

pub fn proplist_get_pid_string_or(&self, key: &str, default: &str) -> String

pub fn proplist_get_mfa_string(&self, key: &str) -> Option<String>

pub fn proplist_get_mfa_string_or(&self, key: &str, default: &str) -> String

pub fn atom_list(names: &[&str]) -> OwnedTerm

pub fn map_iter(&self) -> Option<impl Iterator<Item = (&OwnedTerm, &OwnedTerm)>>

pub fn try_into_list(self) -> Result<Vec<OwnedTerm>, TermConversionError>

pub fn try_into_tuple(self) -> Result<Vec<OwnedTerm>, TermConversionError>

pub fn try_into_map( self, ) -> Result<BTreeMap<OwnedTerm, OwnedTerm>, TermConversionError>

pub fn try_into_binary(self) -> Result<Vec<u8>, TermConversionError>

pub fn try_into_string(self) -> Result<String, TermConversionError>

pub fn try_into_atom(self) -> Result<Arc<str>, TermConversionError>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn estimated_encoded_size(&self) -> usize

pub fn as_2_tuple(&self) -> Option<(&OwnedTerm, &OwnedTerm)>

Returns the elements of a 2-tuple, or None if not a 2-tuple.

Example

use erltf::OwnedTerm;
let term = OwnedTerm::Tuple(vec![OwnedTerm::atom("ok"), OwnedTerm::integer(42)]);
if let Some((first, second)) = term.as_2_tuple() {
    assert!(first.is_atom_with_name("ok"));
    assert_eq!(second.as_integer(), Some(42));
}

pub fn as_3_tuple(&self) -> Option<(&OwnedTerm, &OwnedTerm, &OwnedTerm)>

Returns the elements of a 3-tuple, or None if not a 3-tuple.

pub fn as_4_tuple( &self, ) -> Option<(&OwnedTerm, &OwnedTerm, &OwnedTerm, &OwnedTerm)>

Returns the elements of a 4-tuple, or None if not a 4-tuple.

pub fn as_ok_tuple(&self) -> Option<&OwnedTerm>

Returns the value from an {:ok, value} tuple, or None if not in that format.

Example

use erltf::OwnedTerm;
let term = OwnedTerm::ok_tuple(OwnedTerm::integer(42));
assert_eq!(term.as_ok_tuple().and_then(|v| v.as_integer()), Some(42));

pub fn as_error_tuple(&self) -> Option<&OwnedTerm>

Returns the reason from an {:error, reason} tuple, or None if not in that format.

pub fn as_ok_error(&self) -> Result<&OwnedTerm, &OwnedTerm>

Converts an {:ok, value} or {:error, reason} tuple to a Result.

Example

use erltf::OwnedTerm;
let ok_term = OwnedTerm::ok_tuple(OwnedTerm::integer(42));
assert!(ok_term.as_ok_error().is_ok());

let err_term = OwnedTerm::error_tuple(OwnedTerm::atom("not_found"));
assert!(err_term.as_ok_error().is_err());

pub fn is_elixir_nil(&self) -> bool

Returns true if this is the Elixir nil atom.

pub fn is_erlang_undefined(&self) -> bool

Returns true if this is the Erlang undefined atom.

pub fn is_nil_like(&self) -> bool

Returns true if this is either nil or undefined.

pub fn elixir_nil() -> OwnedTerm

Creates the Elixir nil atom.

pub fn erlang_undefined() -> OwnedTerm

Creates the Erlang undefined atom.

pub fn is_atom_one_of(&self, names: &[&str]) -> bool

Returns true if this is an atom matching one of the provided names.

Example

use erltf::OwnedTerm;
let term = OwnedTerm::atom("ok");
assert!(term.is_atom_one_of(&["ok", "error", "noreply"]));
assert!(!term.is_atom_one_of(&["stop", "continue"]));

pub fn is_elixir_struct(&self) -> bool

Returns true if this term is an Elixir struct (a map with __struct__ key).

Example

use erltf::OwnedTerm;
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(OwnedTerm::atom("__struct__"), OwnedTerm::atom("Elixir.MyApp.User"));
map.insert(OwnedTerm::atom("name"), OwnedTerm::string("Alice".to_string()));
let term = OwnedTerm::Map(map);

assert!(term.is_elixir_struct());
assert_eq!(term.elixir_struct_module(), Some("Elixir.MyApp.User"));

pub fn elixir_struct_module(&self) -> Option<&str>

Returns the module name if this is an Elixir struct.

pub fn is_elixir_exception(&self) -> bool

Returns true if this is an Elixir exception (has both __struct__ and __exception__ keys).

pub fn inspect(&self) -> String

Formats the term in Elixir inspect style for debugging.

Example

use erltf::OwnedTerm;
assert_eq!(OwnedTerm::atom("ok").inspect(), ":ok");
assert_eq!(OwnedTerm::integer(42).inspect(), "42");

impl OwnedTerm

pub fn map_builder() -> MapBuilder

pub fn list_builder() -> ListBuilder

Trait Implementations

impl Clone for OwnedTerm

fn clone(&self) -> OwnedTerm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OwnedTerm

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

Formats the value using the given formatter.

impl Default for OwnedTerm

fn default() -> OwnedTerm

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OwnedTerm

Available on crate feature serde only.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OwnedTerm

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

Formats the value using the given formatter.

impl<T> From<&[T]> for OwnedTerm

where T: Into<OwnedTerm> + Clone,

fn from(slice: &[T]) -> OwnedTerm

Converts to this type from the input type.

impl From<&str> for OwnedTerm

fn from(s: &str) -> OwnedTerm

Converts to this type from the input type.

impl From<Atom> for OwnedTerm

fn from(a: Atom) -> OwnedTerm

Converts to this type from the input type.

impl From<BTreeMap<OwnedTerm, OwnedTerm>> for OwnedTerm

fn from(m: BTreeMap<OwnedTerm, OwnedTerm>) -> OwnedTerm

Converts to this type from the input type.

impl<K, V, S> From<HashMap<K, V, S>> for OwnedTerm

where K: Into<OwnedTerm>, V: Into<OwnedTerm>, S: BuildHasher,

fn from(m: HashMap<K, V, S>) -> OwnedTerm

Converts to this type from the input type.

impl From<String> for OwnedTerm

fn from(s: String) -> OwnedTerm

Converts to this type from the input type.

impl From<Vec<OwnedTerm>> for OwnedTerm

fn from(v: Vec<OwnedTerm>) -> OwnedTerm

Converts to this type from the input type.

impl From<Vec<i32>> for OwnedTerm

fn from(v: Vec<i32>) -> OwnedTerm

Converts to this type from the input type.

impl From<Vec<i64>> for OwnedTerm

fn from(v: Vec<i64>) -> OwnedTerm

Converts to this type from the input type.

impl From<Vec<u8>> for OwnedTerm

fn from(b: Vec<u8>) -> OwnedTerm

Converts to this type from the input type.

impl From<bool> for OwnedTerm

fn from(b: bool) -> OwnedTerm

Converts to this type from the input type.

impl From<f32> for OwnedTerm

fn from(f: f32) -> OwnedTerm

Converts to this type from the input type.

impl From<f64> for OwnedTerm

fn from(f: f64) -> OwnedTerm

Converts to this type from the input type.

impl From<i16> for OwnedTerm

fn from(i: i16) -> OwnedTerm

Converts to this type from the input type.

impl From<i32> for OwnedTerm

fn from(i: i32) -> OwnedTerm

Converts to this type from the input type.

impl From<i64> for OwnedTerm

fn from(i: i64) -> OwnedTerm

Converts to this type from the input type.

impl From<i8> for OwnedTerm

fn from(i: i8) -> OwnedTerm

Converts to this type from the input type.

impl From<u16> for OwnedTerm

fn from(i: u16) -> OwnedTerm

Converts to this type from the input type.

impl From<u32> for OwnedTerm

fn from(i: u32) -> OwnedTerm

Converts to this type from the input type.

impl From<u8> for OwnedTerm

fn from(i: u8) -> OwnedTerm

Converts to this type from the input type.

impl<K, V> FromIterator<(K, V)> for OwnedTerm

where K: Into<OwnedTerm>, V: Into<OwnedTerm>,

fn from_iter<I>(iter: I) -> OwnedTerm

where I: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<T> FromIterator<T> for OwnedTerm

where T: Into<OwnedTerm>,

fn from_iter<I>(iter: I) -> OwnedTerm

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl Hash for OwnedTerm

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

where H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<&OwnedTerm> for OwnedTerm

type Output = OwnedTerm

The returned type after indexing.

fn index(&self, key: &OwnedTerm) -> &<OwnedTerm as Index<&OwnedTerm>>::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for OwnedTerm

type Output = OwnedTerm

The returned type after indexing.

fn index(&self, index: usize) -> &<OwnedTerm as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IntoIterator for OwnedTerm

type Item = OwnedTerm

The type of the elements being iterated over.

type IntoIter = OwnedTermIntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <OwnedTerm as IntoIterator>::IntoIter

Creates an iterator from a value.

impl KeyValueAccess for OwnedTerm

fn kv_get(&self, key: &str) -> Option<&OwnedTerm>

Retrieve the value associated with an atom key, returning the raw term

fn kv_get_i64(&self, key: &str) -> Option<i64>

Retrieve an i64 value by key

fn kv_get_i64_or(&self, key: &str, default: i64) -> i64

Retrieve an i64 value by key or return the default if the key is missing

fn kv_get_bool(&self, key: &str) -> Option<bool>

Retrieve a boolean value by key

fn kv_get_bool_or(&self, key: &str, default: bool) -> bool

Retrieve a boolean value by key, or return the default if the key is missing

fn kv_get_atom(&self, key: &str) -> Option<&Atom>

Retrieve an atom value by key

fn kv_get_atom_string(&self, key: &str) -> Option<String>

Retrieve an atom value as a string by key

fn kv_get_atom_string_or(&self, key: &str, default: &str) -> String

Retrieve an atom value as a string by key or return the default if the key is missing

fn kv_get_string(&self, key: &str) -> Option<String>

Retrieve a string value by key

fn kv_get_string_or(&self, key: &str, default: &str) -> String

Retrieve a string value by key or return the default if the key is missing

fn kv_get_pid(&self, key: &str) -> Option<&ExternalPid>

Retrieve a PID value by key

fn kv_get_pid_string(&self, key: &str) -> Option<String>

Retrieve a PID value as a formatted string by key

fn kv_get_pid_string_or(&self, key: &str, default: &str) -> String

Retrieve a PID value as a formatted string by key or return the default if the key is missing

fn kv_get_mfa_string(&self, key: &str) -> Option<String>

Retrieve an MFA value as a formatted string by key

fn kv_get_mfa_string_or(&self, key: &str, default: &str) -> String

Retrieve an MFA value as a formatted string by key or return the default if the key is missing

impl Ord for OwnedTerm

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl OwnedTermExt for OwnedTerm

fn try_deserialize<T>(&self) -> Result<T, Error>

where T: DeserializeOwned,

fn try_deserialize_proplist<T>(&self) -> Result<T, Error>

where T: DeserializeOwned,

impl PartialEq for OwnedTerm

fn eq(&self, other: &OwnedTerm) -> 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 PartialOrd for OwnedTerm

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for OwnedTerm

Available on crate feature serde only.

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 TermIndex for &OwnedTerm

fn get_from_term<'a>(&self, term: &'a OwnedTerm) -> Option<&'a OwnedTerm>

impl TryFrom<OwnedTerm> for Vec<OwnedTerm>

type Error = TermConversionError

The type returned in the event of a conversion error.

fn try_from( term: OwnedTerm, ) -> Result<Vec<OwnedTerm>, <Vec<OwnedTerm> as TryFrom<OwnedTerm>>::Error>

Performs the conversion.

impl TryFrom<OwnedTerm> for Vec<u8>

type Error = TermConversionError

The type returned in the event of a conversion error.

fn try_from( term: OwnedTerm, ) -> Result<Vec<u8>, <Vec<u8> as TryFrom<OwnedTerm>>::Error>

Performs the conversion.

impl Eq for OwnedTerm

impl StructuralPartialEq for OwnedTerm