key-node-list

Doubly-linked list that stores key-node pairs.

KeyNodeList is a doubly-linked list, it uses a hash map to maintain correspondence between keys and nodes, and records the previous key and the next key of the current node in the node itself. There is no pointer operations during this process, so key_node_list is all implemented in safe Rust.

You can complete key lookups, key-node pair updates, key-node pair deletions and other operations of KeyNodeList in O(1)~ time. You can also use cursor-based interface to traverse or edit the linked list.

Usage

key_node_list is available on crates.io, so:

[dependencies]
key-node-list = "0.0.2"

Example

use key_node_list::KeyValueList;

// construct key-value list from tuple array
let mut list = KeyValueList::from([(1, "Reimu"), (2, "Marisa")]);

// or pushing other key-value pairs to the front/back of list
list.push_front(0, "Alice").unwrap();
list.push_back(3, "Patchouli").unwrap();

// query nodes by key
assert_eq!(list[&1].value(), &"Reimu");
assert_eq!(list[&0].value(), &"Alice");

// also you can update nodes by key
*list.node_mut(&3).unwrap().value_mut() = "Youmu";
*list.front_node_mut().unwrap().value_mut() = "Mokou";
assert_eq!(list[&3].value(), &"Youmu");
assert_eq!(list[&0].value(), &"Mokou");
assert_eq!(list.front_node().unwrap().value(), &"Mokou");

// remove some key-node pairs
assert!(list.pop_front().is_some());
assert!(list.remove(&2).is_some());

// all key-node pairs are in order
list.push_back(5, "Yuyuko");
let vec: Vec<_> = list.into_iter().map(|(k, n)| (k, n.into_value())).collect();
assert_eq!(vec, [(1, "Reimu"), (3, "Youmu"), (5, "Yuyuko")]);

For more details, visit key_node_list on docs.rs.

Changelog

See CHANGELOG.md.

License

An implementation of the OPAQUE password-authenticated key exchange protocol

The OPAQUE key exchange protocol OPAQUE is an asymmetric password-authenticated key exchange protocol. It allows a client to authenticate to a server

178 Jan 9, 2023

A safe implementation of the secure remote password authentication and key-exchange protocol (SRP), SRP6a and legacy are as features available.

Secure Remote Password (SRP 6 / 6a) A safe implementation of the secure remote password authentication and key-exchange protocol (SRP version 6a). Ver

10 Nov 3, 2022

Comments

Is it possible to concatenate two KeyNodeLists in constant time?

Double linked lists can be concatenated in constant time. Is it possible with this crate? If not, I would like that feature. I'd also like to contribute if possible.

opened by azriel1rf 2

Releases(v0.0.4)

v0.0.4(Jan 9, 2022)
Added

Implemented Clone trait for all list iterators.

Source code(tar.gz)
Source code(zip)
v0.0.3(Jan 5, 2022)
Added

Implemented Extend<&K>, Extend<K>, FromIterator<K> trait for KeyNodeList.

Source code(tar.gz)
Source code(zip)
v0.0.2(Dec 24, 2021)
Added

More provided methods to Map trait.

Method KeyNodeList::push_key_front and KeyNodeList::push_key_back.

Method CursorMut::insert_key_after and CursorMut::insert_key_before.

Changed

Signature of trait method Map::insert.

Relexed generic type bound of KeyNodeList::new.

Fixed

Problem about generic type bound of Index trait of KeyNodeList.

Source code(tar.gz)
Source code(zip)
v0.0.1(Dec 22, 2021)

Source code(tar.gz)
Source code(zip)