Struct Node 

pub struct Node {
    pub id: u64,
    /* private fields */
}

A node holds multiple Worker structures and has a, ideally, unique ID given.

Fields

id: u64

The ID of the node, ideally it should be unique and not be used multiple times within an application.

Implementations

impl Node

The default implementation of a node.

pub fn new(id: u64) -> Self

Create a new node for the given ID.

Examples found in repository

examples/basic.rs (line 4)

fn main() {
    let mut node = spaceflake::Node::new(1);
    let worker = node.new_worker();
    let sf = worker.generate();
    match sf {
        Ok(value) => {
            println!("Generated Spaceflake: {:#?}", value.decompose())
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }
}

examples/bulk.rs (line 16)

fn main() {
    let settings = spaceflake::BulkGeneratorSettings::new(2_000_000);
    let mut spaceflakes = spaceflake::bulk_generate(settings);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[1337331].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }

    let node_one = spaceflake::Node::new(1);
    spaceflakes = node_one.bulk_generate(1_000_000);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[7331].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }

    let mut node_two = spaceflake::Node::new(2);
    let worker = node_two.new_worker();
    spaceflakes = worker.bulk_generate(500_000);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[1337].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }
}

pub fn new_worker(&mut self) -> Worker

Create a new worker and push it to the list of workers of the node to generate Spaceflakes.

Examples found in repository

examples/basic.rs (line 5)

fn main() {
    let mut node = spaceflake::Node::new(1);
    let worker = node.new_worker();
    let sf = worker.generate();
    match sf {
        Ok(value) => {
            println!("Generated Spaceflake: {:#?}", value.decompose())
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }
}

examples/bulk.rs (line 29)

fn main() {
    let settings = spaceflake::BulkGeneratorSettings::new(2_000_000);
    let mut spaceflakes = spaceflake::bulk_generate(settings);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[1337331].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }

    let node_one = spaceflake::Node::new(1);
    spaceflakes = node_one.bulk_generate(1_000_000);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[7331].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }

    let mut node_two = spaceflake::Node::new(2);
    let worker = node_two.new_worker();
    spaceflakes = worker.bulk_generate(500_000);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[1337].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }
}

pub fn remove_worker(&mut self, id: u64)

Remove a worker given its ID from the list of workers.

pub fn get_workers(&self) -> Vec<Worker>

Returns the list of workers the node is currently holding.

pub fn bulk_generate(&self, amount: usize) -> Result<Vec<Spaceflake>, String>

Generate an amount of Spaceflakes on the node.

The workers will automatically scale, so there is no need to add new workers to the node.

Examples found in repository

examples/bulk.rs (line 17)

fn main() {
    let settings = spaceflake::BulkGeneratorSettings::new(2_000_000);
    let mut spaceflakes = spaceflake::bulk_generate(settings);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[1337331].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }

    let node_one = spaceflake::Node::new(1);
    spaceflakes = node_one.bulk_generate(1_000_000);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[7331].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }

    let mut node_two = spaceflake::Node::new(2);
    let worker = node_two.new_worker();
    spaceflakes = worker.bulk_generate(500_000);
    match spaceflakes {
        Ok(value) => {
            println!("Successfully generated {} Spaceflakes", value.len());
            println!("{:#?}", value[1337].decompose());
        }
        Err(error) => {
            println!("Error: {}", error)
        }
    }
}

Trait Implementations

impl Debug for Node

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

Formats the value using the given formatter.