Struct gulkana::DataStructure

pub struct DataStructure<KeyType: Ord + Clone, ItemData: Clone> { /* fields omitted */ }

Struct usd to store data

Methods

impl<KeyType: Ord + Clone, ItemData: Clone> DataStructure<KeyType, ItemData>

pub fn insert(
    &mut self,
    key: &KeyType,
    data: ItemData
) -> Result<(), DBOperationError>

Inserts data into datastructure

let mut ds = gulkana::new_datastructure::<u32,u32>();
ds.insert(&10,5);
assert!(ds.insert(&10,20).is_err());

pub fn insert_link(
    &mut self,
    key: &KeyType,
    children: &Vec<KeyType>
) -> Result<(), DBOperationError>

Used to insert a link into a datastructure

 let mut ds = gulkana::new_datastructure::<u32,u32>();
 ds.insert(&10,5);
 ds.insert_link(&9,&vec![10]);
 let iter = ds.iter_links(&9).ok().unwrap();
 
 for (i,j) in iter{
     assert!(*j==5);
 }

pub fn overwrite_link(
    &mut self,
    key: &KeyType,
    children: &Vec<KeyType>
) -> Result<(), DBOperationError>

Overwrites Links with vec shown

 let mut ds = gulkana::new_datastructure::<u32,u32>();
 ds.insert(&10,5);
 ds.insert(&11,6);
 ds.insert_link(&9,&vec![10]);
 ds.overwrite_link(&9,&vec![11]);
 let iter = ds.iter_links(&9).ok().unwrap();
 
 for (_key,data) in iter{
     assert!(*data==6);
 }

pub fn set_data(
    &mut self,
    key: &KeyType,
    data: &ItemData
) -> Result<(), DBOperationError>

sets data in database

let mut ds = gulkana::new_datastructure::<u32,u32>();
ds.insert(&10,3);
ds.set_data(&10,&5);
assert!(ds.get(&10).ok().unwrap()==&5);

Important traits for DataNodeIter<'a, KeyType, DataType>

impl<'a, KeyType: Ord + Clone, DataType: Clone> Iterator for DataNodeIter<'a, KeyType, DataType> type Item = (&'a KeyType, &'a DataType);

pub fn iter_data(&self) -> DataNodeIter<KeyType, ItemData>

Used to iterate through data

Important traits for DataMutIter<'a, KeyType, DataType>

impl<'a, KeyType: Ord + Clone, DataType: Clone> Iterator for DataMutIter<'a, KeyType, DataType> type Item = (&'a KeyType, &'a mut DataType);

pub fn iter_data_mut(&mut self) -> DataMutIter<KeyType, ItemData>

Iterates through data mutably

let mut ds = gulkana::new_datastructure::<u32,u32>();
ds.insert(&10,3);
for (k,n) in ds.iter_data_mut(){
    *n=5;
}
assert!(ds.get(&10).ok().unwrap()==&5);

pub fn get(&self, key: &KeyType) -> Result<&ItemData, DBOperationError> where
    KeyType: Ord, 

gets key from database

let mut ds = gulkana::new_datastructure::<u32,u32>();
ds.insert(&10,5);
let data = ds.get(&10);
assert!(*data.ok().unwrap()==5); 

pub fn get_mut(
    &mut self,
    key: &KeyType
) -> Result<&mut ItemData, DBOperationError>

Gets data associated with key mutably

let mut ds = gulkana::new_datastructure::<u32,u32>();
ds.insert(&10,5);
let data = ds.get_mut(&10).ok().unwrap();
*data=10;
assert!(ds.get(&10).ok().unwrap()==&10); 

pub fn get_links(
    &self,
    key: &KeyType
) -> Result<&Vec<KeyType>, DBOperationError>

Gets linked nodes

let mut ds = gulkana::new_datastructure::<u32,u32>();
ds.insert(&10,5);
ds.insert(&11,6);
ds.insert_link(&9,&vec![10]);
let v = ds.get_links(&9).ok().unwrap();
assert!(v[0]==10);

pub fn iter_links(
    &self,
    key: &KeyType
) -> Result<DataLinkIter<KeyType, ItemData>, DBOperationError>

Iterates through nodes attached to link

pub fn contains(&self, key: &KeyType) -> bool

Checks if database contains a given key

let mut ds = gulkana::new_datastructure::<u32,u32>();
ds.insert(&10,5);
assert!(ds.contains(&10));
assert!(!ds.contains(&20));

pub fn append_links(
    &mut self,
    key: &KeyType,
    key_append: &KeyType
) -> Result<(), DBOperationError>

pub fn right_join(
    &self,
    right: &DataStructure<KeyType, ItemData>
) -> Result<DataStructure<KeyType, ItemData>, DBOperationError>

pub fn to_string(&self) -> Result<String, SerializeError> where
    KeyType: Serialize,
    ItemData: Serialize, 

pub fn len(&self) -> usize

Gets number of elements in db

let mut ds = gulkana::new_datastructure::<u32,u32>();
assert!(ds.len()==0);
ds.insert(&20,20);
assert!(ds.len()==1);

Trait Implementations

impl<KeyType: Clone + Ord, ItemData: Clone> Clone for DataStructure<KeyType, ItemData>

fn clone(&self) -> DataStructure<KeyType, ItemData>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de, KeyType: Ord + Clone, ItemData: Clone> Deserialize<'de> for DataStructure<KeyType, ItemData> where
    KeyType: Deserialize<'de>,
    ItemData: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<K: Ord + Display + Clone + Serialize, I: Clone + Serialize> Display for DataStructure<K, I>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<KeyType: Eq + Ord + Clone, ItemData: Eq + Clone> Eq for DataStructure<KeyType, ItemData>

impl<KeyType: PartialEq + Ord + Clone, ItemData: PartialEq + Clone> PartialEq<DataStructure<KeyType, ItemData>> for DataStructure<KeyType, ItemData>

fn eq(&self, other: &DataStructure<KeyType, ItemData>) -> bool

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

fn ne(&self, other: &DataStructure<KeyType, ItemData>) -> bool

This method tests for !=.

impl<KeyType: Ord + Clone, ItemData: Clone> Serialize for DataStructure<KeyType, ItemData> where
    KeyType: Serialize,
    ItemData: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<KeyType: Ord + Clone, ItemData: Clone> StructuralEq for DataStructure<KeyType, ItemData>

impl<KeyType: Ord + Clone, ItemData: Clone> StructuralPartialEq for DataStructure<KeyType, ItemData>