Struct gulkana::DataStructure

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

Struct usd to store data Inorder to allow new fields in input struct to be added make all fields Optional e.g.

struct bar{
    foo:Option<String>,
    bar:Option<u32>,
}

this way the data structure is compatible with old versions of the database.

Methods

impl<KeyType: Ord + Clone + Serialize, DataType: Clone + Serialize, LinkLabel: Clone + Serialize> DataStructure<KeyType, DataType, LinkLabel>

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

Inserts data into datastructure

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

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

Used to insert a link into a datastructure

 let mut ds = gulkana::new_datastructure::<u32,u32,u32>();
 ds.insert(&10,5);
 ds.insert_link(&9,&vec![10],0);
 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>,
    link_type: LinkLabel
) -> Result<(), DBOperationError>

Overwrites Links with vec shown

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

 for (_key,data) in iter{
     assert!(*data==6);
 }
 let iter2 = ds.iter_links(&8).ok().unwrap();

 for (_key,data) in iter2{
     assert!(*data==5);
 }

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

sets data in database

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

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

Used to iterate through data

pub fn get_keys(&self) -> Vec<KeyType>

Gets All keys in database

let mut ds = gulkana::new_datastructure::<u32,u32,u32>();
ds.insert(&10,5);
let out = ds.get_keys();
assert!(out[0]==10);

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

gets key from database

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

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

Gets linked nodes

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

pub fn iter_links(
    &self,
    key: &KeyType
) -> Result<DataLinkIter<KeyType, DataType, LinkLabel>, 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,u32>();
ds.insert(&10,5);
assert!(ds.contains(&10));
assert!(!ds.contains(&20));

pub fn iter_link_type(
    &self,
    link_type: &LinkLabel
) -> DataLinkIterNoRef<KeyType, DataType, LinkLabel> where
    LinkLabel: PartialEq, 

Gets iterator of links with labels

let mut ds = gulkana::new_datastructure::<u32,u32,u32>();
ds.insert(&10,5);
ds.insert_link(&9,&vec![10],0);
for (link,linked_keys) in ds.iter_link_type(&0){
        assert!(link==9);
}

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

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

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

pub fn make_backed(
    &mut self,
    file_backing: &String
) -> Result<(), DBOperationError>

Makes the database backed

pub fn len(&self) -> usize

Gets number of elements in db

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

Trait Implementations

impl<KeyType: Clone + Ord + Serialize, DataType: Clone + Serialize, LinkLabel: Clone + Serialize> Clone for DataStructure<KeyType, DataType, LinkLabel>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de, KeyType: Ord + Clone + Serialize, DataType: Clone + Serialize, LinkLabel: Clone + Serialize> Deserialize<'de> for DataStructure<KeyType, DataType, LinkLabel> where
    KeyType: Deserialize<'de>,
    DataType: Deserialize<'de>,
    LinkLabel: 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, DataType: Clone + Serialize, I: Clone + Serialize> Display for DataStructure<K, DataType, I>

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

Formats the value using the given formatter.

impl<KeyType: Eq + Ord + Clone + Serialize, DataType: Eq + Clone + Serialize, LinkLabel: Eq + Clone + Serialize> Eq for DataStructure<KeyType, DataType, LinkLabel>

impl<KeyType: PartialEq + Ord + Clone + Serialize, DataType: PartialEq + Clone + Serialize, LinkLabel: PartialEq + Clone + Serialize> PartialEq<DataStructure<KeyType, DataType, LinkLabel>> for DataStructure<KeyType, DataType, LinkLabel>

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

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

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

This method tests for !=.

impl<KeyType: Ord + Clone + Serialize, DataType: Clone + Serialize, LinkLabel: Clone + Serialize> Serialize for DataStructure<KeyType, DataType, LinkLabel> where
    KeyType: Serialize,
    DataType: Serialize,
    LinkLabel: 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 + Serialize, DataType: Clone + Serialize, LinkLabel: Clone + Serialize> StructuralEq for DataStructure<KeyType, DataType, LinkLabel>

impl<KeyType: Ord + Clone + Serialize, DataType: Clone + Serialize, LinkLabel: Clone + Serialize> StructuralPartialEq for DataStructure<KeyType, DataType, LinkLabel>