routingkit-cch 0.1.4

Rust bindings for RoutingKit's Customizable Contraction Hierarchies (CCH)
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

#ifndef ROUTING_KIT_BIT_VECTOR_H
#define ROUTING_KIT_BIT_VECTOR_H


#include <stdint.h>
#include <assert.h>
#include <utility>

namespace RoutingKit{

class BitVector{
public:
	struct Uninitialized{};
	static constexpr Uninitialized uninitialized = {};

	BitVector();
	BitVector(uint64_t size, Uninitialized);
	explicit BitVector(uint64_t size, bool init_value = false);
	~BitVector();
	BitVector(const BitVector&);
	BitVector(BitVector&&);

	BitVector&operator=(BitVector);
	void swap(BitVector&);
	
	bool empty()const { return size() == 0; }
	uint64_t size()const { return size_; }
	
	void resize(uint64_t size, Uninitialized);
	void resize(uint64_t size, bool init_value = false);

	void make_large_enough_for(uint64_t x, Uninitialized);
	void make_large_enough_for(uint64_t x, bool init_value = false);

	bool is_set(uint64_t x)const{
		assert(x < size_ && "argument out of bounds");
		uint64_t a = x/64;
	    uint64_t b = x%64;
		uint64_t d = data_[a];
		return d & (1ull << b);
	}

	void set(uint64_t x){
		assert(x < size_ && "argument out of bounds");
		uint64_t a = x/64;
	    uint64_t b = x%64;
		uint64_t d = data_[a];
		d |= (1ull << b);
		data_[a] = d;
	}

	void set_if(uint64_t x, bool value){
		assert(x < size_ && "argument out of bounds");
		uint64_t a = x/64;
	    uint64_t b = x%64;
		uint64_t d = data_[a];
		d |= ((uint64_t)value << b);
		data_[a] = d;
	}

	void set(uint64_t x, bool value){
		assert(x < size_ && "argument out of bounds");
		uint64_t a = x/64;
	    uint64_t b = x%64;
		uint64_t d = data_[a];
		d &= ~(1ull << b);
		d |= ((uint64_t)value << b);
		data_[a] = d;
	}

	void reset(uint64_t x){
		assert(x < size_ && "argument out of bounds");
		uint64_t a = x/64;
	    uint64_t b = x%64;
		uint64_t d = data_[a];
		d &= ~(1ull << b);
		data_[a] = d;
	}

	void toggle(uint64_t x){
		assert(x < size_ && "argument out of bounds");
		uint64_t a = x/64;
	    uint64_t b = x%64;
		uint64_t d = data_[a];
		d ^= (1ull << b);
		data_[a] = d;
	}

	void set_all();
	void set_all(bool value);
	void reset_all();

	bool are_all_set()const;
	bool is_any_set()const;

	uint64_t population_count() const;

	uint64_t count_true() const {return population_count();}
	uint64_t count_false() const {return size()-population_count();}


	BitVector&operator|=(const BitVector&);
	BitVector&operator^=(const BitVector&);
	BitVector&operator&=(const BitVector&);

	void inplace_not();
	BitVector operator~() const { BitVector v = *this; v.inplace_not(); return v; }

	friend bool operator==(const BitVector&l, const BitVector&r);
	friend bool operator<(const BitVector&l, const BitVector&r);

	uint64_t*data(){return data_;}
	const uint64_t*data()const{return data_;}

	uint64_t uint512_count()const{ return (size_+511) / 512; }

	void reset_all_padding_bits();
private:
	uint64_t*data_;
	uint64_t size_;
};

template<class F>
inline BitVector make_bit_vector(uint64_t size, const F&f){
	BitVector v(size, BitVector::uninitialized);
	for(uint64_t x=0; x<size; ++x)
		v.set(x, f(x));
	return v;
}

// I envy the day where C++ finally gets rid of this error prone boilerplate.

inline BitVector operator|(BitVector&&l, BitVector&&r) { l |= r; return std::move(l); }
inline BitVector operator|(BitVector&&l, const BitVector&r) { l |= r; return std::move(l); }
inline BitVector operator|(const BitVector&l, BitVector&&r) { r |= l; return std::move(r); }
inline BitVector operator|(const BitVector&l, const BitVector&r) { BitVector x = l; x |= r; return x; }

inline BitVector operator&(BitVector&&l, BitVector&&r) { l &= r; return std::move(l); }
inline BitVector operator&(BitVector&&l, const BitVector&r) { l &= r; return std::move(l); }
inline BitVector operator&(const BitVector&l, BitVector&&r) { r &= l; return std::move(r); }
inline BitVector operator&(const BitVector&l, const BitVector&r) { BitVector x = l; x &= r; return x; }

inline BitVector operator^(BitVector&&l, BitVector&&r) { l ^= r; return std::move(l); }
inline BitVector operator^(BitVector&&l, const BitVector&r) { l ^= r; return std::move(l); }
inline BitVector operator^(const BitVector&l, BitVector&&r) { r ^= l; return std::move(r); }
inline BitVector operator^(const BitVector&l, const BitVector&r) { BitVector x = l; x ^= r; return x; }

inline bool operator!=(const BitVector&l, const BitVector&r){ return !(l == r); }
inline bool operator>(const BitVector&l, const BitVector&r){ return r < l; }
inline bool operator<=(const BitVector&l, const BitVector&r){ return !(l > r); }
inline bool operator>=(const BitVector&l, const BitVector&r){ return !(l < r); }

} // namespace RoutingKit

#endif