varinteger 1.0.2

Rust module for encoding/decoding varints that doesn't do any IO. Inspired by the Node.js varint module
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

#![crate_type = "lib"]
#![crate_name = "varinteger"]

pub fn length (value: u64) -> usize {
  if value < 128 {
    return 1;
  } else if value < 16384 {
    return 2;
  } else if value < 2097152 {
    return 3;
  } else if value < 268435456 {
    return 4;
  } else if value < 34359738368 {
    return 5;
  } else if value < 4398046511104 {
    return 6;
  } else if value < 562949953421312 {
    return 7;
  } else if value < 72057594037927936 {
    return 8;
  } else if value < 9223372036854775808 {
    return 9;
  } else {
    return 10;
  }
}

pub fn encode (value: u64, buf: &mut [u8]) -> usize {
  return encode_with_offset(value, buf, 0);
}

pub fn encode_with_offset (value: u64, buf: &mut [u8], offset: usize) -> usize {
  let mut off = offset;
  let mut val = value;

  while val > 127 {
    buf[off] = (val as u8) | 128;
    off += 1;
    val >>= 7;
  }
  buf[off] = val as u8;

  return off + 1 - offset;
}

pub fn decode (buf: &[u8], value: &mut u64) -> usize {
  return decode_with_offset(buf, 0, value);
}

pub fn decode_with_offset (buf: &[u8], offset: usize, value: &mut u64) -> usize {
  let mut val = 0 as u64;
  let mut fac = 1 as u64;
  let mut off = offset;

  loop {
    let byte = buf[off];
    off += 1;
    val += fac * ((byte & 127) as u64);
    fac <<= 7;
    if byte & 128 == 0 {
      break;
    }
  }

  *value = val;

  return off - offset;
}

pub fn signed_length (value: i64) -> usize {
  return length(unsign(value));
}

pub fn signed_encode (value: i64, buf: &mut [u8]) -> usize {
  return encode_with_offset(unsign(value), buf, 0);
}

pub fn signed_encode_with_offset (value: i64, buf: &mut [u8], offset: usize) -> usize {
  return encode_with_offset(unsign(value), buf, offset);
}

pub fn signed_decode (buf: &[u8], value: &mut i64) -> usize {
  return signed_decode_with_offset(buf, 0, value);
}

pub fn signed_decode_with_offset (buf: &[u8], offset: usize, value: &mut i64) -> usize {
  let mut val = 0;
  let off = decode_with_offset(buf, offset, &mut val);
  *value = sign(val);
  return off;
}

fn unsign (value: i64) -> u64 {
  if value >= 0 {
    return (value * 2) as u64;
  } else {
    return (value * -2 - 1) as u64;
  }
}

fn sign (value: u64) -> i64 {
  if value & 1 != 0 {
    return -(((value + 1) / 2) as i64);
  } else {
    return (value / 2) as i64;
  }
}

// TODO: how do move these to a different file?

#[test]
fn test_encode () {
  let mut buf = [0; 512];
  assert_eq!(encode(100, &mut buf), 1);
  assert_eq!(buf[0], 100);

  assert_eq!(encode(1000, &mut buf), 2);
  assert_eq!(buf[0], 232);
  assert_eq!(buf[1], 7);
}

#[test]
fn test_decode () {
  let mut value = 0 as u64;
  assert_eq!(decode(&[100], &mut value), 1);
  assert_eq!(value, 100);

  assert_eq!(decode(&[232, 7], &mut value), 2);
  assert_eq!(value, 1000);
}

#[test]
fn test_length () {
  assert_eq!(length(100), 1);
  assert_eq!(length(1000), 2);
}

#[test]
fn test_signed_encode () {
  let mut buf = [0; 512];
  assert_eq!(signed_encode(100, &mut buf), 2);
  assert_eq!(buf[0], 200);
  assert_eq!(buf[1], 1);

  assert_eq!(signed_encode(-100, &mut buf), 2);
  assert_eq!(buf[0], 199);
  assert_eq!(buf[1], 1);
}

#[test]
fn test_signed_decode () {
  let mut value = 0 as i64;
  assert_eq!(signed_decode(&[200, 1], &mut value), 2);
  assert_eq!(value, 100);

  assert_eq!(signed_decode(&[199, 1], &mut value), 2);
  assert_eq!(value, -100);
}

#[test]
fn test_signed_length () {
  assert_eq!(signed_length(100), 2);
  assert_eq!(signed_length(-100), 2);
}