consistent_hasher 0.1.5

An implementation of consistent hashing, a technique commonly used in distributed systems to map keys (such as data items or requests) to nodes (e.g., servers or storage units) in a way that minimizes disruptions when nodes are added or removed.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

use std::fmt;
use serde::{Serialize,Deserialize};

#[derive(Debug,Serialize,Deserialize)]
pub struct Transaction<T: fmt::Display + PartialEq>
{
    pub source:T,
    pub destination:T,
    pub min:T,
    pub max:T,
    exception: bool
}

impl<T:PartialOrd +  fmt::Display > Transaction<T>
{
    pub fn new(source: T , destination: T, min: T , max: T)-> Self
    {
        Self {exception:(min > max ), source, destination,min,max }
    }
    pub fn in_range(&self,num: T) -> bool
    {
        if !self.exception
        {
            return num>self.min && num<=self.max;
        }
        return num<= self.max || num > self.min;
    }
    
}
impl<T:PartialOrd +  fmt::Display > fmt::Display for Transaction<T>
{
    fn fmt(&self,f: &mut fmt::Formatter)->fmt::Result
    {
        let stringy = match self.exception
        {
            true =>
            {
                format!("[0,{}] u ]{},..[",self.max,self.min)
            }
            ,
            _=>
            {
                format!("]{},{}]",self.min,self.max)
            }

        };
        write!(f,"source: {}  -  destination: {}  -  range: {}",self.source,self.destination,stringy)

    }
}
impl<T: fmt::Display + PartialEq> PartialEq for Transaction<T> {
    fn eq(&self, other: &Self) -> bool {
        self.source == other.source
            && self.destination == other.destination
            && self.exception == other.exception
    }
}