Struct Index

pub struct Index {
    pub indexer: Indexer,
    /* private fields */
}

Fields

indexer: Indexer

Implementations

impl Index

pub fn from(v: &[u8]) -> Result<Self, ()>

pub fn to_vec(&self) -> Vec<u8>

impl<'a> Index

pub fn new(indexer: Indexer) -> Self

Creates a new Index

Example

use indexer::{Indexer, IndexString, IndexOrd};
let string_indexer = Indexer::String(IndexString {
    ordering: IndexOrd::ASC
});

pub fn insert<V>(&mut self, key: &str, value: V)

where V: Serialize + Deserialize<'a>,

Inserts a new entry or overrides a previous entry in the index

pub fn remove(&mut self, k: &str)

Removes an entry from the index

pub fn batch(&mut self, f: impl Fn(&mut Batch<'_>) + Sync + Send)

Batch transaction on the index. you can insert/update/delete multiple entries with one operation by commit the operation with b.commit() Example

use indexer::{Index, BatchTransaction};
use serde_json::Value;
let mut names_index = Index::new(string_indexer);
names_index.batch(|b| {
    b.delete("user.4");
    b.insert("user.1", "Kwadwo".to_string());
    b.insert("user.2", Value::String("Kwame".to_string()));
    b.update("user.3", Value::String("Joseph".to_string()));
    b.commit()
});

pub fn get_all_items(&self, f: impl Fn((&String, &Value)) + Sync + Send)

pub fn par_get_all_items(&self, f: impl Fn((&String, &Value)) + Sync + Send)

pub fn find_where<V>(&self, field: &str, op: Op, value: V) -> QueryResult

where V: Serialize + Deserialize<'a>,

Query on an index. by using conditional operators

• eq Equals
• lt Less than
• gt Greater than
• like Check for match using Glob style pattern matching

Example

 let query = students_index.find_where("state", Op::EQ, "CA");
 println!("Find all students in CA: {:?}", query());

pub fn count(&self) -> usize

👎Deprecated since 0.2.5: Please use the size() instead

pub fn size(&self) -> usize

pub fn get_items(&self) -> Vec<(String, Value)>

Trait Implementations

impl Clone for Index

fn clone(&self) -> Index

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Index

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Index

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

where __S: Serializer,

Serialize this value into the given Serde serializer.