Struct janetrs::JanetTable[−][src]

#[repr(transparent)]
pub struct JanetTable<'data> { /* fields omitted */ }

Expand description

Janet tables are mutable data structures that map keys to values. Values are put into a Janet table with a key, and can be looked up later with the same key. Tables are implemented with an underlying open hash table, so they are quite fast and cache friendly.

Any Janet value except Janet nil and Janet number that is NaN can be a key or a value in a Janet table, and a single Janet table can have any mixture of Janet types as keys and values.

To facilitate the creation of this structure, you can use the macro table.

Examples

use janetrs::{Janet, JanetTable};
let mut table = JanetTable::new();

table.insert("key", 10.0);
table.insert(10, 20.3);

println!("{}", Janet::table(table));

Implementations

impl<'data> JanetTable<'data>[src]

pub fn new() -> Self[src]

Create a empty JanetTable.

It is initially created with capacity 1, so it will not allocate until it is second inserted into.

Examples

use janetrs::JanetTable;

let table = JanetTable::new();

pub fn with_capacity(capacity: i32) -> Self[src]

Create a empty JanetTable given to Janet the specified capacity.

Examples

use janetrs::JanetTable;

let table = JanetTable::with_capacity(20);

pub fn with_prototype(proto: JanetTable<'data>) -> Self[src]

Create a empty JanetTable with a prototype table set to proto.

It is initially created with capacity 1, so it will not allocate until it is second inserted into.

Examples

use janetrs::{JanetTable, table};

let table = JanetTable::with_prototype(table!(":_name" => "MyClass"));

pub const unsafe fn from_raw(raw: *mut CJanetTable) -> Self[src]

Create a new JanetTable with a raw_table.

Safety

This function do not check if the given raw_table is NULL or not. Use at your own risk.

pub fn capacity(&self) -> i32[src]

Returns the number of elements the table can hold without reallocating.

This number is a lower bound; the JanetTable might be able to hold more, but is guaranteed to be able to hold at least this many.

Examples

use janetrs::JanetTable;

let mut table = JanetTable::with_capacity(20);
assert!(table.capacity() >= 20);

pub fn removed(&self) -> i32[src]

Returns the number of elements that was removed from the table.

Examples

use janetrs::JanetTable;

let mut table = JanetTable::with_capacity(2);
table.insert(10, "ten");
table.insert(20, "twenty");

assert!(table.removed() == 0);
table.remove(20);
assert!(table.removed() == 1);

pub fn clear(&mut self)[src]

Clears the table, removing all key-value pairs. Keeps the allocated memory for reuse.

Examples

use janetrs::JanetTable;

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

table.clear();
assert!(table.is_empty());

pub fn len(&self) -> i32[src]

Returns the number of elements of the table, also refered to as its ‘length’.

Examples

use janetrs::JanetTable;

let mut table = JanetTable::with_capacity(20);

assert_eq!(table.len(), 0);
table.insert(10, "ten");
assert_eq!(table.len(), 1);

pub fn is_empty(&self) -> bool[src]

Returns true if the table contains no elements.

Examples

use janetrs::JanetTable;

let mut table = JanetTable::with_capacity(20);

assert!(table.is_empty());
table.insert(10, "ten");
assert!(!table.is_empty());

pub fn prototype(&self) -> Option<Self>[src]

Get the prototype table of the table.

pub fn set_prototype(&mut self, proto: &JanetTable<'_>)[src]

Set the prototype of the table with the values of proto.

Examples

use janetrs::{table, Janet, JanetTable};

let mut table = table! {1 => "a", 2 => "b"};
let proto = table! {":_name" => "MyClass"};

table.set_prototype(&proto);

assert_eq!(table.prototype(), Some(proto));

pub fn get(&self, key: impl Into<Janet>) -> Option<&Janet>[src]

Returns the value corresponding to the supplied key.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

assert_eq!(table.get(10), Some(&Janet::from("ten")));
assert_eq!(table.get(11), None);

pub fn get_key_value(&self, key: impl Into<Janet>) -> Option<(&Janet, &Janet)>[src]

Returns the key-value pair corresponding to the supplied key.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

assert_eq!(
    table.get_key_value(10),
    Some((&Janet::integer(10), &Janet::from("ten")))
);
assert_eq!(table.get_key_value(11), None);

pub fn get_mut(&mut self, key: impl Into<Janet>) -> Option<&'data mut Janet>[src]

Returns a mutable reference to the value corresponding to the key.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

if let Some(val) = table.get_mut(10) {
    *val = Janet::boolean(true);
}

assert_eq!(table.get(10), Some(&Janet::boolean(true)));

pub fn get_key_value_mut(
    &mut self, 
    key: impl Into<Janet>
) -> Option<(&Janet, &'data mut Janet)>

Returns the key-value pair corresponding to the supplied key, with a mutable reference to value.

Examples

use janetrs::{Janet, JanetString, JanetTable};

let mut table = JanetTable::with_capacity(2);
table.insert(10, "ten");

let (k, v) = table.get_key_value_mut(10).unwrap();

assert_eq!(&Janet::integer(10), k);
assert_eq!(&mut Janet::from("ten"), v);

*v = Janet::string(JanetString::new("ten but modified"));

assert_eq!(
    table.get_key_value_mut(10),
    Some((&Janet::integer(10), &mut Janet::from("ten but modified")))
);
assert_eq!(table.get_key_value_mut(11), None);

pub fn get_proto(&self, key: impl Into<Janet>) -> Option<&Janet>[src]

Returns the reference to the value corresponding to the supplied key, with prototype lookup.

Examples

use janetrs::{table, Janet, JanetTable};

let mut table = table! {1 => "a", 2 => "b"};
let proto = table! {3 => "c"};

table.set_prototype(&proto);

assert_eq!(table.get_proto(3), Some(&Janet::from("c")));
assert_eq!(table.get_proto(11), None);

pub fn get_proto_mut(&mut self, key: impl Into<Janet>) -> Option<&mut Janet>[src]

Returns the exclusivereference to the value corresponding to the supplied key, with prototype lookup.

Examples

use janetrs::{table, Janet, JanetTable};

let mut table = table! {1 => "a", 2 => "b"};
let proto = table! {3 => "c"};

table.set_prototype(&proto);

assert_eq!(table.get_proto_mut(3), Some(&mut Janet::from("c")));
assert_eq!(table.get_proto_mut(11), None);

pub fn get_key_value_proto_mut(
    &mut self, 
    key: impl Into<Janet>
) -> Option<(&Janet, &mut Janet)>

Returns the key-value pair corresponding to the supplied key with a mutable reference to value, with prototype lookup.

Examples

use janetrs::{table, Janet, JanetTable};

let mut table = table! {1 => "a", 2 => "b"};
let proto = table! {3 => "c"};

table.set_prototype(&proto);

assert_eq!(
    table.get_key_value_proto_mut(3),
    Some((&Janet::integer(3), &mut Janet::from("c")))
);
assert_eq!(table.get_key_value_proto_mut(11), None);

pub fn get_key_value_proto(
    &self, 
    key: impl Into<Janet>
) -> Option<(&Janet, &Janet)>

Returns the key-value pair corresponding to the supplied key with prototype lookup.

Examples

use janetrs::{table, Janet, JanetTable};

let mut table = table! {1 => "a", 2 => "b"};
let proto = table! {3 => "c"};

table.set_prototype(&proto);

assert_eq!(
    table.get_key_value_proto(3),
    Some((&Janet::integer(3), &Janet::from("c")))
);
assert_eq!(table.get_key_value_proto(11), None);

pub fn get_owned(&self, key: impl Into<Janet>) -> Option<Janet>[src]

Returns the value corresponding to the supplied key checking prototype tables.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

assert_eq!(table.get_owned(10), Some(Janet::from("ten")));
assert_eq!(table.get_owned(11), None);

pub fn get_owned_key_value(
    &self, 
    key: impl Into<Janet>
) -> Option<(Janet, Janet)>

Returns the key-value pair corresponding to the supplied key checking prototype tables.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

assert_eq!(
    table.get_owned_key_value(10),
    Some((Janet::integer(10), Janet::from("ten")))
);
assert_eq!(table.get_owned_key_value(11), None);

pub fn raw_get_owned(&self, key: impl Into<Janet>) -> Option<Janet>[src]

Returns the value corresponding to the supplied key without checking prototype tables.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

assert_eq!(table.raw_get_owned(10), Some(Janet::from("ten")));
assert_eq!(table.raw_get_owned(11), None);

pub fn raw_get_owned_key_value(
    &self, 
    key: impl Into<Janet>
) -> Option<(Janet, Janet)>

Returns the key-value pair corresponding to the supplied key without checking prototype tables.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

assert_eq!(
    table.raw_get_owned_key_value(10),
    Some((Janet::integer(10), Janet::from("ten")))
);
assert_eq!(table.raw_get_owned_key_value(11), None);

pub fn remove(&mut self, key: impl Into<Janet>) -> Option<Janet>[src]

Removes key from the table, returning the value of the key.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::with_capacity(20);
table.insert(10, "ten");

assert_eq!(table.remove(10), Some(Janet::from("ten")));
assert_eq!(table.remove(10), None);

pub fn insert(
    &mut self, 
    key: impl Into<Janet>, 
    value: impl Into<Janet>
) -> Option<Janet>

Inserts a key-value pair into the table.

If the table did not have this key present or if the key is a Janet nil, None is returned.

If the map did have this key present, the value is updated, and the old value is returned.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::new();

assert!(table.is_empty());
assert_eq!(table.insert(37, "a"), None);
assert!(!table.is_empty());

table.insert(37, "b");
assert_eq!(table.insert(37, "c"), Some(Janet::from("b")));
assert_eq!(table.get(37), Some(&Janet::from("c")));

pub fn contains_key(&self, key: impl Into<Janet>) -> bool[src]

Returns true if the table contains a value for the specified key.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::new();
table.insert(10, "ten");

assert!(table.contains_key(10));
assert!(!table.contains_key(11));

pub fn contains(&self, value: impl Into<Janet>) -> bool[src]

Returns true if the table contais a given value.

Examples

use janetrs::{Janet, JanetTable};

let mut table = JanetTable::new();
table.insert(10, "ten");

assert!(table.contains("ten"));
assert!(!table.contains(11));

pub fn keys(&self) -> Keys<'_, '_>ⓘNotable traits for Keys<'a, '_>
impl<'a> Iterator for Keys<'a, '_>    type Item = &'a Janet;

Creates a iterator over the refernece of the table keys.

Examples

use janetrs::table;

let table = table! { 1 => "10", true => 10.0};

for key in table.keys() {
    println!("Key: {}", key);
}

pub fn values(&self) -> Values<'_, '_>ⓘNotable traits for Values<'a, '_>
impl<'a> Iterator for Values<'a, '_>    type Item = &'a Janet;

Creates a iterator over the refernece of the table values.

Examples

use janetrs::table;

let table = table! { 1 => "10", true => 10.0};

for val in table.values() {
    println!("Value: {}", val);
}

pub fn values_mut(&mut self) -> ValuesMut<'_, '_>ⓘNotable traits for ValuesMut<'_, 'data>
impl<'data> Iterator for ValuesMut<'_, 'data>    type Item = &'data mut Janet;

Creates a iterator over the mutable refernece of the table values.

Examples

use janetrs::{table, Janet};

let mut table = table! { 1 => "10", true => 10.0};

for val in table.values_mut() {
    *val = Janet::number(100.0);
}

assert!(table.values().all(|v| *v == Janet::number(100.0)));

pub fn iter(&self) -> Iter<'_, '_>ⓘNotable traits for Iter<'a, 'data>
impl<'a, 'data> Iterator for Iter<'a, 'data>    type Item = (&'a Janet, &'a Janet);

Creates a iterator over the reference of the table key-value pairs.

Examples

use janetrs::table;

let table = table! { 1 => "10", true => 10.0};

for (k, v) in table.iter() {
    println!("Key: {}\tValue: {}", k, v);
}

pub fn iter_mut(&mut self) -> IterMut<'_, '_>ⓘNotable traits for IterMut<'a, 'data>
impl<'a, 'data> Iterator for IterMut<'a, 'data>    type Item = (&'a Janet, &'data mut Janet);

Creates a iterator over the reference of the table keys and mutable reference of the table values.

Examples

use janetrs::{table, Janet};

let mut table = table! { 1 => "10", true => 10.0};

for (k, val) in table.iter_mut() {
    *val = Janet::number(100.0);
}

assert!(table.values().all(|v| *v == Janet::number(100.0)));

pub const fn as_raw(&self) -> *const CJanetTable[src]

Return a raw pointer to the buffer raw structure.

The caller must ensure that the buffer outlives the pointer this function returns, or else it will end up pointing to garbage.

If you need to mutate the contents of the slice, use as_mut_ptr.

pub fn as_mut_raw(&mut self) -> *mut CJanetTable[src]

Return a raw mutable pointer to the buffer raw structure.

The caller must ensure that the buffer outlives the pointer this function returns, or else it will end up pointing to garbage.

impl<'data> JanetTable<'data>[src]

pub fn entry(&mut self, key: impl Into<Janet>) -> Entry<'_, 'data>[src]

Gets the given key’s corresponding entry in the table for in-place manipulation.

Trait Implementations

impl Clone for JanetTable<'_>[src]

fn clone(&self) -> Self[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0 [src]

Performs copy-assignment from source. Read more

impl Debug for JanetTable<'_>[src]

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

Formats the value using the given formatter. Read more

impl DeepEq<JanetStruct<'_>> for JanetTable<'_>[src]

fn deep_eq(&self, other: &JanetStruct<'_>) -> bool[src]

impl DeepEq<JanetTable<'_>> for JanetStruct<'_>[src]

fn deep_eq(&self, other: &JanetTable<'_>) -> bool[src]

impl DeepEq<JanetTable<'_>> for JanetTable<'_>[src]

fn deep_eq(&self, other: &Self) -> bool[src]

impl Default for JanetTable<'_>[src]

fn default() -> Self[src]

Returns the “default value” for a type. Read more

impl<'a> Extend<(&'a Janet, &'a Janet)> for JanetTable<'_>[src]

fn extend<T: IntoIterator<Item = (&'a Janet, &'a Janet)>>(&mut self, iter: T)[src]

Extends a collection with the contents of an iterator. Read more

fn extend_one(&mut self, item: A)[src]

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)[src]

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements. Read more

impl Extend<(Janet, Janet)> for JanetTable<'_>[src]

fn extend<T: IntoIterator<Item = (Janet, Janet)>>(&mut self, iter: T)[src]

Extends a collection with the contents of an iterator. Read more

fn extend_one(&mut self, item: A)[src]

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)[src]

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements. Read more

impl From<&'_ JanetStruct<'_>> for JanetTable<'_>[src]

fn from(val: &JanetStruct<'_>) -> Self[src]

Performs the conversion.

impl From<&'_ JanetTable<'_>> for JanetStruct<'_>[src]

fn from(table: &JanetTable<'_>) -> Self[src]

Performs the conversion.

impl From<&'_ JanetTable<'_>> for Janet[src]

fn from(val: &JanetTable<'_>) -> Self[src]

Performs the conversion.

impl From<JanetStruct<'_>> for JanetTable<'_>[src]

fn from(val: JanetStruct<'_>) -> Self[src]

Performs the conversion.

impl From<JanetTable<'_>> for JanetStruct<'_>[src]

fn from(table: JanetTable<'_>) -> Self[src]

Performs the conversion.

impl From<JanetTable<'_>> for Janet[src]

fn from(val: JanetTable<'_>) -> Self[src]

Performs the conversion.

impl<U, J> FromIterator<(U, J)> for JanetTable<'_> where
    U: Into<Janet>,
    J: Into<Janet>,

fn from_iter<T: IntoIterator<Item = (U, J)>>(iter: T) -> Self[src]

Creates a value from an iterator. Read more

impl<T: Into<Janet>> Index<T> for JanetTable<'_>[src]

fn index(&self, key: T) -> &Self::Output[src]

Get a reference to the value of a given key.

It is recommended to use get method or the entry API.

Janet Panics

Panics if the table does not have the key.

type Output = Janet

The returned type after indexing.

impl<'data> IntoIterator for JanetTable<'data>[src]

type IntoIter = IntoIter<'data>

Which kind of iterator are we turning this into?

type Item = (Janet, Janet)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter[src]

Creates an iterator from a value. Read more

impl<'a, 'data> IntoIterator for &'a JanetTable<'data>[src]

type IntoIter = Iter<'a, 'data>

Which kind of iterator are we turning this into?

type Item = (&'a Janet, &'a Janet)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter[src]

Creates an iterator from a value. Read more

impl<'a, 'data> IntoIterator for &'a mut JanetTable<'data>[src]

type IntoIter = IterMut<'a, 'data>

Which kind of iterator are we turning this into?

type Item = (&'a Janet, &'data mut Janet)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter[src]

Creates an iterator from a value. Read more

impl JanetExtend<JanetTable<'_>> for JanetTable<'_>[src]

fn extend(&mut self, other: JanetTable<'_>)[src]

Extend the table with all key-value pairs of the other table.

impl Ord for JanetTable<'_>[src]

fn cmp(&self, other: &Self) -> Ordering[src]

This method returns an Ordering between self and other. Read more

#[must_use]
fn max(self, other: Self) -> Self

1.21.0 [src]

Compares and returns the maximum of two values. Read more

#[must_use]
fn min(self, other: Self) -> Self

1.21.0 [src]

Compares and returns the minimum of two values. Read more

#[must_use]
fn clamp(self, min: Self, max: Self) -> Self

1.50.0 [src]

Restrict a value to a certain interval. Read more

impl PartialEq<JanetTable<'_>> for JanetTable<'_>[src]

fn eq(&self, other: &Self) -> bool[src]

This method tests for self and other values to be equal, and is used by ==. Read more

#[must_use]
fn ne(&self, other: &Rhs) -> bool

1.0.0 [src]

This method tests for !=.

impl PartialOrd<JanetTable<'_>> for JanetTable<'_>[src]

fn partial_cmp(&self, other: &Self) -> Option<Ordering>[src]

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

#[must_use]
fn lt(&self, other: &Rhs) -> bool

1.0.0 [src]

This method tests less than (for self and other) and is used by the < operator. Read more

#[must_use]
fn le(&self, other: &Rhs) -> bool

1.0.0 [src]

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

#[must_use]
fn gt(&self, other: &Rhs) -> bool

1.0.0 [src]

This method tests greater than (for self and other) and is used by the > operator. Read more

#[must_use]
fn ge(&self, other: &Rhs) -> bool

1.0.0 [src]

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl TryFrom<Janet> for JanetTable<'_>[src]

type Error = JanetConversionError

The type returned in the event of a conversion error.

fn try_from(value: Janet) -> Result<Self, Self::Error>[src]

Performs the conversion.

impl Eq for JanetTable<'_>[src]

Auto Trait Implementations

impl<'data> RefUnwindSafe for JanetTable<'data>

impl<'data> !Send for JanetTable<'data>

impl<'data> !Sync for JanetTable<'data>

impl<'data> Unpin for JanetTable<'data>

impl<'data> UnwindSafe for JanetTable<'data>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized,

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>,

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> ToOwned for T where
    T: Clone,

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.