static-mapset 0.1.0

Maps and sets based on ordered array or slice
Documentation
#![feature(btree_cursors)]

use std::{
	collections::{BTreeMap, BTreeSet},
	convert::identity,
	ops::Bound
};

use quickcheck_macros::quickcheck;
use static_mapset::{OrderedArrayMap, OrderedArraySet, OrderedSliceMap, OrderedSliceMapMut, OrderedSliceSet};

#[quickcheck]
fn comparation_slice_map(mut xs: Vec<(i8, i64)>, keys: Vec<(i8, i8)>) -> bool {
	let reference = BTreeMap::from_iter(xs.clone().into_iter());
	let target = OrderedSliceMap::new(&mut xs);
	[
		keys.iter().all(|(key, key2)| {
			let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
			[
				reference.contains_key(key) == target.contains_key(key),
				reference.get(key) == target.get(key),
				reference.get_key_value(key) == target.get_key_value(key),
				reference.lower_bound(Bound::Included(key)).next() == target.lower_bound(Bound::Included(key)).next(),
				reference.lower_bound(Bound::Excluded(key)).next() == target.lower_bound(Bound::Excluded(key)).next(),
				reference
					.range((Bound::Included(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Included(start), Bound::Excluded(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Excluded(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Excluded(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Excluded(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				start == end
					|| reference
						.range((Bound::Excluded(start), Bound::Excluded(end)))
						.collect::<Vec<_>>()
						== target
							.range((Bound::Excluded(start), Bound::Excluded(end)))
							.collect::<Vec<_>>(),
				reference.upper_bound(Bound::Included(key)).next() == target.upper_bound(Bound::Included(key)).next(),
				reference.upper_bound(Bound::Excluded(key)).next() == target.upper_bound(Bound::Excluded(key)).next()
			]
			.into_iter()
			.all(identity)
		}),
		reference.first_key_value() == target.first_key_value(),
		reference.keys().collect::<Vec<_>>() == target.keys().collect::<Vec<_>>(),
		reference.last_key_value() == target.last_key_value(),
		reference.len() == target.len(),
		reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
		reference.values().collect::<Vec<_>>() == target.values().collect::<Vec<_>>()
	]
	.into_iter()
	.all(identity)
}

#[quickcheck]
fn comparation_slice_map_mut(mut xs: Vec<(i8, i64)>, keys: Vec<(i8, i8)>) -> bool {
	let reference = BTreeMap::from_iter(xs.clone().into_iter());
	let target = OrderedSliceMapMut::new(&mut xs);
	[
		keys.iter().all(|(key, key2)| {
			let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
			[
				reference.contains_key(key) == target.contains_key(key),
				reference.get(key) == target.get(key),
				reference.get_key_value(key) == target.get_key_value(key),
				reference.lower_bound(Bound::Included(key)).next() == target.lower_bound(Bound::Included(key)).next(),
				reference.lower_bound(Bound::Excluded(key)).next() == target.lower_bound(Bound::Excluded(key)).next(),
				reference
					.range((Bound::Included(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Included(start), Bound::Excluded(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Excluded(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Excluded(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Excluded(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				start == end
					|| reference
						.range((Bound::Excluded(start), Bound::Excluded(end)))
						.collect::<Vec<_>>()
						== target
							.range((Bound::Excluded(start), Bound::Excluded(end)))
							.collect::<Vec<_>>(),
				reference.upper_bound(Bound::Included(key)).next() == target.upper_bound(Bound::Included(key)).next(),
				reference.upper_bound(Bound::Excluded(key)).next() == target.upper_bound(Bound::Excluded(key)).next()
			]
			.into_iter()
			.all(identity)
		}),
		reference.first_key_value() == target.first_key_value(),
		reference.keys().collect::<Vec<_>>() == target.keys().collect::<Vec<_>>(),
		reference.last_key_value() == target.last_key_value(),
		reference.len() == target.len(),
		reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
		reference.values().collect::<Vec<_>>() == target.values().collect::<Vec<_>>()
	]
	.into_iter()
	.all(identity)
}

#[quickcheck]
fn comparation_array_map(xs: [(i8, i64); 100], keys: Vec<(i8, i8)>) -> bool {
	let reference = BTreeMap::from_iter(xs.clone().into_iter());
	let target = OrderedArrayMap::new(xs);
	[
		keys.iter().all(|(key, key2)| {
			let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
			[
				reference.contains_key(key) == target.contains_key(key),
				reference.get(key) == target.get(key),
				reference.get_key_value(key) == target.get_key_value(key),
				reference.lower_bound(Bound::Included(key)).next() == target.lower_bound(Bound::Included(key)).next(),
				reference.lower_bound(Bound::Excluded(key)).next() == target.lower_bound(Bound::Excluded(key)).next(),
				reference
					.range((Bound::Included(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Included(start), Bound::Excluded(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Excluded(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Excluded(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Excluded(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				start == end
					|| reference
						.range((Bound::Excluded(start), Bound::Excluded(end)))
						.collect::<Vec<_>>()
						== target
							.range((Bound::Excluded(start), Bound::Excluded(end)))
							.collect::<Vec<_>>(),
				reference.upper_bound(Bound::Included(key)).next() == target.upper_bound(Bound::Included(key)).next(),
				reference.upper_bound(Bound::Excluded(key)).next() == target.upper_bound(Bound::Excluded(key)).next()
			]
			.into_iter()
			.all(identity)
		}),
		reference.first_key_value() == target.first_key_value(),
		reference.keys().collect::<Vec<_>>() == target.keys().collect::<Vec<_>>(),
		reference.last_key_value() == target.last_key_value(),
		reference.len() == target.len(),
		reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
		reference.values().collect::<Vec<_>>() == target.values().collect::<Vec<_>>()
	]
	.into_iter()
	.all(identity)
}

#[quickcheck]
fn validation_of_new_slice_map(mut xs: Vec<(i8, i64)>) -> bool {
	let target = OrderedSliceMap::new(&mut xs);
	target.is_valid()
}

#[quickcheck]
fn validation_of_new_slice_map_mut(mut xs: Vec<(i8, i64)>) -> bool {
	let target = OrderedSliceMapMut::new(&mut xs);
	target.is_valid()
}

#[quickcheck]
fn validation_of_new_array_map(xs: [(i8, i64); 100]) -> bool {
	let target = OrderedArrayMap::new(xs);
	target.is_valid()
}

#[quickcheck]
fn comparation_array_set(xs: [i8; 100], ys: [i8; 100], keys: Vec<(i8, i8)>) -> bool {
	let reference = BTreeSet::from_iter(xs.clone().into_iter());
	let reference2 = BTreeSet::from_iter(ys.clone().into_iter());
	let target = OrderedArraySet::new(xs);
	let target2 = OrderedArraySet::new(ys);
	[
		keys.iter().all(|(key, key2)| {
			let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
			[
				reference.contains(key) == target.contains(key),
				reference.get(&key) == target.get(key),
				reference.lower_bound(Bound::Included(&key)).next() == target.lower_bound(Bound::Included(&key)).next(),
				reference.lower_bound(Bound::Excluded(&key)).next() == target.lower_bound(Bound::Excluded(&key)).next(),
				reference
					.range((Bound::Included(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Included(start), Bound::Excluded(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Excluded(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Excluded(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Excluded(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				start == end
					|| reference
						.range((Bound::Excluded(start), Bound::Excluded(end)))
						.collect::<Vec<_>>()
						== target
							.range((Bound::Excluded(start), Bound::Excluded(end)))
							.collect::<Vec<_>>(),
				reference.upper_bound(Bound::Included(&key)).next() == target.upper_bound(Bound::Included(&key)).next(),
				reference.upper_bound(Bound::Excluded(&key)).next() == target.upper_bound(Bound::Excluded(&key)).next()
			]
			.into_iter()
			.all(identity)
		}),
		reference.difference(&reference2).collect::<Vec<_>>() == target.difference(&target2).collect::<Vec<_>>(),
		reference.intersection(&reference2).collect::<Vec<_>>() == target.intersection(&target2).collect::<Vec<_>>(),
		reference.union(&reference2).collect::<Vec<_>>() == target.union(&target2).collect::<Vec<_>>(),
		reference.iter().collect::<Vec<_>>() == target.iter().collect::<Vec<_>>(),
		reference.first() == target.first(),
		reference.is_disjoint(&reference2) == target.is_disjoint(&target2),
		reference.is_empty() == target.is_empty(),
		reference.is_subset(&reference2) == target.is_subset(&target2),
		reference.is_superset(&reference2) == target.is_superset(&target2),
		reference.last() == target.last(),
		reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next(),
		reference.clone().into_iter().collect::<Vec<_>>() == target.clone().into_iter().collect::<Vec<_>>()
	]
	.into_iter()
	.all(identity)
}

#[quickcheck]
fn comparation_slice_set(mut xs: Vec<i8>, mut ys: Vec<i8>, keys: Vec<(i8, i8)>) -> bool {
	let reference = BTreeSet::from_iter(xs.clone().into_iter());
	let reference2 = BTreeSet::from_iter(ys.clone().into_iter());
	let target: OrderedSliceSet<'_, i8> = OrderedSliceSet::new(&mut xs);
	let target2 = OrderedSliceSet::new(&mut ys);
	[
		keys.iter().all(|(key, key2)| {
			let (start, end) = if key <= key2 { (key, key2) } else { (key2, key) };
			[
				reference.contains(key) == target.contains(key),
				reference.get(&key) == target.get(key),
				reference.lower_bound(Bound::Included(&key)).next() == target.lower_bound(Bound::Included(&key)).next(),
				reference.lower_bound(Bound::Excluded(&key)).next() == target.lower_bound(Bound::Excluded(&key)).next(),
				reference
					.range((Bound::Included(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Included(start), Bound::Excluded(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Included(start), Bound::Excluded(end)))
						.collect::<Vec<_>>(),
				reference
					.range((Bound::Excluded(start), Bound::Included(end)))
					.collect::<Vec<_>>()
					== target
						.range((Bound::Excluded(start), Bound::Included(end)))
						.collect::<Vec<_>>(),
				start == end
					|| reference
						.range((Bound::Excluded(start), Bound::Excluded(end)))
						.collect::<Vec<_>>()
						== target
							.range((Bound::Excluded(start), Bound::Excluded(end)))
							.collect::<Vec<_>>(),
				reference.upper_bound(Bound::Included(&key)).next() == target.upper_bound(Bound::Included(&key)).next(),
				reference.upper_bound(Bound::Excluded(&key)).next() == target.upper_bound(Bound::Excluded(&key)).next()
			]
			.into_iter()
			.all(identity)
		}),
		reference.difference(&reference2).collect::<Vec<_>>() == target.difference(&target2).collect::<Vec<_>>(),
		reference.intersection(&reference2).collect::<Vec<_>>() == target.intersection(&target2).collect::<Vec<_>>(),
		reference.union(&reference2).collect::<Vec<_>>() == target.union(&target2).collect::<Vec<_>>(),
		reference.iter().collect::<Vec<_>>() == target.iter().collect::<Vec<_>>(),
		reference.first() == target.first(),
		reference.is_disjoint(&reference2) == target.is_disjoint(&target2),
		reference.is_empty() == target.is_empty(),
		reference.is_subset(&reference2) == target.is_subset(&target2),
		reference.is_superset(&reference2) == target.is_superset(&target2),
		reference.last() == target.last(),
		reference.lower_bound(Bound::Unbounded).next() == target.lower_bound(Bound::Unbounded).next()
	]
	.into_iter()
	.all(identity)
}

#[quickcheck]
fn validation_of_new_array_set(xs: [i8; 100]) -> bool {
	let target = OrderedArraySet::new(xs);
	target.is_valid()
}

#[quickcheck]
fn validation_of_new_slice_set(mut xs: Vec<i8>) -> bool {
	let target = OrderedSliceSet::new(&mut xs);
	target.is_valid()
}