#![doc(html_root_url = "https://docs.rs/col_macros/0.1.93/")]
#[doc(hidden)]
pub use compile_ops::{add, sub};
#[doc(hidden)]
#[allow(deprecated)]
pub use high_mem_utils::{DontDrop, DontDropOpt, DropBy};
#[doc(hidden)]
pub use macro_helper::{expansion_bucle, expansion_bucle_counted};
#[doc(hidden)]
pub use std::mem::{transmute, transmute_copy, MaybeUninit};
#[doc(hidden)]
pub use std::hint::unreachable_unchecked;
pub mod types {
pub type Vector<T> = Vec<T>;
#[cfg(feature = "owned_slice")]
pub type OwnedSlice<T> = Box<[T]>;
pub type Deque<T> = std::collections::VecDeque<T>;
pub type Map<K, V> = std::collections::HashMap<K, V>;
pub type Set<K> = std::collections::HashSet<K>;
pub type BTMap<K, V> = std::collections::BTreeMap<K, V>;
pub type BTSet<K> = std::collections::BTreeSet<K>;
pub type BinHeap<T> = std::collections::BinaryHeap<T>;
}
#[macro_export]
macro_rules! vector {
(for $map:expr, ins $( $k:literal ),*) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<T>(map: &mut Vector<T>) -> &mut Vector<T> {
let mut actual_len = $crate::DontDrop(map.len());
let actual_ptr = &actual_len.0 as *const usize;
map.reserve($crate::add!(0 $(, 1!$k)*));
let mut map = $crate::DropBy::new(map, |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match map.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
$(
let k = $crate::transmute_copy(&$k);
map_ptr.add(actual_len.0).write(k);
actual_len.0 += 1;
)*
}
let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(actual_len.0) };
vec1
}
conflictless_large_name($map)
}
};
(for $map:expr, ins $( $k:expr ),*) => {
{
#[inline]
fn conflictless_large_name<T>(map: &mut Vector<T>, arr: [T; $crate::add!(0 $(, 1!$k)*)]) -> &mut Vector<T> {
map.reserve($crate::add!(0 $(, 1!$k)*));
unsafe {
let map_ptr: *mut T = map.as_mut_ptr().add(map.len());
let arr = $crate::DontDropOpt::new(arr);
let mut arr_ptr = match *arr {
Some(ref e) => e.as_ptr(),
None => unsafe { $crate::unreachable_unchecked() },
};
arr_ptr.copy_to(map_ptr, $crate::add!(0 $(, 1!$k)*));
}
unsafe { map.set_len(map.len() + $crate::add!(0 $(, 1!$k)*)); };
map
}
conflictless_large_name($map, [$( $k ),*])
}
};
(for $map:tt, ins $( $k:tt ,)*) => {
$crate::vector!(for $map, ins $( $k ),*)
};
( $( $k:literal ),*) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<T>() -> Vector<T> {
let mut actual_len = $crate::DontDrop(0);
let actual_ptr = &actual_len.0 as *const usize;
let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity($crate::add!(0 $(, 1!$k)*)),
|mut v| unsafe { v.set_len(actual_ptr.read()) });
unsafe {
let map_ptr: *mut T = match map.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
$(
let k = $crate::transmute_copy(&$k);
map_ptr.add(actual_len.0).write(k);
actual_len.0 += 1;
)*
}
let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(actual_len.0) };
vec1
}
conflictless_large_name()
}
};
( $( $k:expr ),*) => {
{
#[inline]
fn conflictless_large_name<T>(arr: [T; $crate::add!(0 $(, 1!$k)*)]) -> Vector<T> {
let mut map = <Vector<T>>::with_capacity($crate::add!(0 $(, 1!$k)*));
unsafe {
let map_ptr: *mut T = map.as_mut_ptr();
let arr = $crate::DontDropOpt::new(arr);
let arr_ptr = match *arr {
Some(ref e) => e.as_ptr(),
None => unsafe { $crate::unreachable_unchecked() },
};
arr_ptr.copy_to(map_ptr, $crate::add!(0 $(, 1!$k)*));
}
unsafe { map.set_len($crate::add!(0 $(, 1!$k)*)) };
map
}
conflictless_large_name([$( $k ),*])
}
};
( $e:literal; $n:literal) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<T>() -> Vector<T> {
let mut actual_len = $crate::DontDrop(0);
let actual_ptr = &actual_len.0 as *const usize;
let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity($n), |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match map.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
let t = $crate::transmute_copy;
let e: T = t(&$e);
map_ptr.write(e);
actual_len.0 += 1;
$crate::expansion_bucle!(let e: T = t(&$e); map_ptr.add(actual_len.0).write(e);
actual_len.0 += 1; => $n - 1);
}
let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(actual_len.0) };
vec1
}
conflictless_large_name()
}
};
( $e:expr; $n:literal) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<T: Clone>(e: T) -> Vector<T> {
let mut actual_len = $crate::DontDrop(0);
let actual_ptr = &actual_len.0 as *const usize;
let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity($n), |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match map.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
map_ptr.write(e.clone());
actual_len.0 += 1;
$crate::expansion_bucle!(map_ptr.add(actual_len.0).write(e.clone());
actual_len.0 += 1; => $n - 2);
map_ptr.add(actual_len.0).write(e);
actual_len.0 += 1;
}
let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(actual_len.0) };
vec1
}
conflictless_large_name($e)
}
};
( $e:literal; $n:expr) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<T>(n: usize) -> Vector<T> {
let mut actual_len = $crate::DontDrop(0);
let actual_ptr = &actual_len.0 as *const usize;
let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity(n), |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match map.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
let t = $crate::transmute_copy;
let e: T = t(&$e);
map_ptr.write(e);
actual_len.0 += 1;
for _ in 1..n {
let e: T = t(&$e);
map_ptr.add(actual_len.0).write(e);
actual_len.0 += 1;
}
}
let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(actual_len.0) };
vec1
}
conflictless_large_name($n)
}
};
( $e:expr; $n:expr) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<T: Clone>(e: T, n: usize) -> Vector<T> {
let mut actual_len = $crate::DontDrop(0);
let actual_ptr = &actual_len.0 as *const usize;
let mut map = $crate::DropBy::new(<Vector<T>>::with_capacity(n), |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match map.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
map_ptr.write(e.clone());
actual_len.0 += 1;
for _ in 2..n {
map_ptr.add(actual_len.0).write(e.clone());
actual_len.0 += 1;
}
map_ptr.add(actual_len.0).write(e);
actual_len.0 += 1;
}
let mut vec1 = map.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(actual_len.0) };
vec1
}
conflictless_large_name($e, $n)
}
};
(for $map:expr, ins $e:literal; $n:literal) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<'a, T>(mut mutable_ref: &'a mut Vector<T>) -> &'a mut Vector<T> {
let mut offset = $crate::DontDrop(mutable_ref.len());
let actual_ptr = &offset.0 as *const usize;
mutable_ref.reserve($n);
let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match mutable_ref.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
let t = $crate::transmute_copy;
$crate::expansion_bucle!(let e: T = t(&$e); map_ptr.add(offset.0).write(e);
offset.0 += 1; => $n);
}
let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(offset.0)};
vec1
}
conflictless_large_name($map)
}
};
(for $map:expr, ins $e:expr; $n:literal) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<'a, T: Clone>(mut mutable_ref: &'a mut Vector<T>, e: T) -> &'a mut Vector<T> {
let mut offset = $crate::DontDrop(mutable_ref.len());
let actual_ptr = &offset.0 as *const usize;
mutable_ref.reserve($n);
let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match mutable_ref.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
$crate::expansion_bucle!(map_ptr.add(offset.0).write(e.clone()); offset.0 += 1; => $n - 1);
map_ptr.add(offset.0).write(e);
offset.0 += 1;
}
let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(offset.0)};
vec1
}
conflictless_large_name($map, $e)
}
};
(for $map:expr, ins $e:literal; $n:expr) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<'a, T>(mut mutable_ref: &'a mut Vector<T>, n: usize) -> &'a mut Vector<T> {
let mut offset = $crate::DontDrop(mutable_ref.len());
let actual_ptr = &offset.0 as *const usize;
mutable_ref.reserve(n);
let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match mutable_ref.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
let t = $crate::transmute_copy;
for _ in 0..n {
let e: T = t(&$e);
map_ptr.add(offset.0).write(e);
offset.0 += 1;
}
}
let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(offset.0) };
vec1
}
conflictless_large_name($map, $n)
}
};
(for $map:expr, ins $e:expr; $n:expr) => {
{
#[inline]
#[allow(deprecated)]
fn conflictless_large_name<'a, T: Clone>(mut mutable_ref: &'a mut Vector<T>, e: T, n: usize) -> &'a mut Vector<T> {
let mut offset = $crate::DontDrop(mutable_ref.len());
let actual_ptr = &offset.0 as *const usize;
mutable_ref.reserve(n);
let mut mutable_ref = $crate::DropBy::new(mutable_ref, |mut v| unsafe {
v.set_len(actual_ptr.read())
});
unsafe {
let map_ptr: *mut T = match mutable_ref.value {
Some(ref mut a) => a.as_mut_ptr(),
None => $crate::unreachable_unchecked(),
};
for _ in 1..n {
map_ptr.add(offset.0).write(e.clone());
offset.0 += 1;
}
map_ptr.add(offset.0).write(e);
offset.0 += 1;
}
let mut vec1 = mutable_ref.value.take().unwrap_or_else(|| unsafe { $crate::unreachable_unchecked() });
unsafe { vec1.set_len(offset.0)};
vec1
}
conflictless_large_name($map, $e, $n)
}
};
( $( $k:tt ,)*) => {
$crate::vector!($( $k ),*)
};
}
#[cfg(feature = "owned_slice")]
#[macro_export]
macro_rules! own_slice {
($( $a:literal ),*) => {
unsafe {
#[inline]
unsafe fn conflictless_large_name<T>() -> OwnedSlice<T> {
let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = <OwnedSlice<_>>::new_uninit_slice(
$crate::add!(0 $(, 1!$a)* )
);
let t = $crate::transmute_copy;
$crate::expansion_bucle_counted!(
boxed.get_unchecked_mut(rep_count).as_mut_ptr()
.write(t(&meta_lit)); => 0 $(+ 1!$a)*$(:$a)*);
$crate::transmute(boxed)
}
conflictless_large_name()
}
};
($( $a:expr ),*) => {
unsafe {
#[inline]
unsafe fn conflictless_large_name<T>(arr: [T; $crate::add!(0 $(, 1!$a)*) ]) -> OwnedSlice<T> {
let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = <OwnedSlice<_>>::new_uninit_slice(
$crate::add!(0 $(, 1!$a)*)
);
let arr = $crate::DontDropOpt::new(arr);
let arr_ptr = match *arr {
Some(ref a) => a.as_ptr(),
None => $crate::unreachable_unchecked(),
};
$crate::expansion_bucle_counted!(
boxed.get_unchecked_mut(rep_count).as_mut_ptr().write(arr_ptr.add(rep_count).read());
=> 0 $(+ 1!$a)*
);
$crate::transmute(boxed)
}
conflictless_large_name([$( $a ),*])
}
};
($( $a:tt, )*) => {
own_slice!($( $a ,)*)
};
($a:literal; $n:literal) => {
unsafe {
#[inline]
unsafe fn conflictless_large_name<T: Clone>() -> OwnedSlice<T> {
let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = <OwnedSlice<_>>::new_uninit_slice($n);
let t = $crate::transmute_copy;
$crate::expansion_bucle_counted!(
boxed.get_unchecked_mut(rep_count).as_mut_ptr().write(t(&$a)); => $n - 1);
boxed.get_unchecked_mut($crate::sub!($n, 1)).as_mut_ptr().write(t(&$a));
$crate::transmute(boxed)
}
conflictless_large_name()
}
};
($a:literal; $n:expr) => {
unsafe {
#[inline]
unsafe fn conflictless_large_name<T>(a: T, n: usize) -> OwnedSlice<T> {
let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = <OwnedSlice<_>>::new_uninit_slice(n);
for i in 0..n {
boxed.get_unchecked_mut(i).as_mut_ptr().write($crate::transmute_copy(&$a));
}
$crate::transmute(boxed)
}
conflictless_large_name($a, $n)
}
};
($a:expr; $n:literal) => {
unsafe {
#[inline]
unsafe fn conflictless_large_name<T: Clone>(a: T) -> OwnedSlice<T> {
let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = <OwnedSlice<_>>::new_uninit_slice($n);
$crate::expansion_bucle_counted!(
boxed.get_unchecked_mut(rep_count).as_mut_ptr().write(a.clone()); => $n - 1);
boxed.get_unchecked_mut($crate::sub!($n, 1)).as_mut_ptr().write(a);
$crate::transmute(boxed)
}
conflictless_large_name($a)
}
};
($a:expr; $n:expr) => {
unsafe {
#[inline]
unsafe fn conflictless_large_name<T: Clone>(a: T, n: usize) -> OwnedSlice<T> {
let mut boxed: OwnedSlice<$crate::MaybeUninit<T>> = <OwnedSlice<_>>::new_uninit_slice(n);
for i in 1..n {
boxed.get_unchecked_mut(i).as_mut_ptr().write(a.clone());
}
boxed.get_unchecked_mut(0).as_mut_ptr().write(a);
$crate::transmute(boxed)
}
conflictless_large_name($a, $n)
}
};
}
#[macro_export]
macro_rules! vec_deque {
(for $vec:expr, ins $( $back:expr ),*) => {
{
let temp_vec_deque = $vec;
temp_vec_deque.reserve($crate::add!(0 $(, 1!$back)* ));
$(
temp_vec_deque.push_back($back);
)*
temp_vec_deque
}
};
(for $vec:tt, ins $( $back:tt ,)*) => {
vec_deque!(for $vec, ins $( $back ),*)
};
($($front:expr),* => $($back:expr),*) => {
{
let mut temp_vec_deque = <Deque<_>>::with_capacity($crate::add!(0 $(, 1!$front)*$(, 1!$back)* ) );
$(
temp_vec_deque.push_front($front);
)*
$(
temp_vec_deque.push_back($back);
)*
temp_vec_deque
}
};
($( $f:tt ,)* => $( $b:tt ,)*) => {
vec_deque!($( $f ),* => $( $b ),*)
};
($( $f:tt ,)* => $( $b:tt ),*) => {
vec_deque!($( $f ),* => $( $b ),*)
};
($( $f:tt ),* => $( $b:tt ,)*) => {
vec_deque!($( $f ),* => $( $b ),*)
};
($e:literal; $n:literal) => {
{
let mut temp_vec_deque = <Deque<_>>::with_capacity($n);
$crate::expansion_bucle(temp_vec_deque.push_back($e); => $n);
temp_vec_deque
}
};
($e:expr; $n:literal) => {
{
let mut temp_vec_deque = <Deque<_>>::with_capacity($n);
$crate::expansion_bucle(temp_vec_deque.push_back($e.clone()); => $n - 1);
temp_vec_deque.push_back($e);
temp_vec_deque
}
};
($e:literal; $n:expr) => {
{
let mut temp_vec_deque = <Deque<_>>::with_capacity($n);
for _ in 0..$n {
temp_vec_deque.push_back($e);
}
temp_vec_deque
}
};
($e:expr; $n:expr) => {
{
let mut temp_vec_deque = <Deque<_>>::with_capacity($n);
for _ in 1..$n {
temp_vec_deque.push_back($e.clone());
}
temp_vec_deque.push_back($e)
temp_vec_deque
}
};
}
#[macro_export]
macro_rules! bin_heap {
(for $vec:expr, ins $( $back:expr ),*) => {
{
let temp_vec_deque = $vec;
temp_vec_deque.reserve($crate::add!(0 $(, 1!$back)* ));
$(
temp_vec_deque.push($back);
)*
temp_vec_deque
}
};
(for $vec:tt ins, $( $back:tt ,)*) => {
bin_heap!(for $vec, ins $( $back ),*)
};
($($front:expr),*) => {
{
let mut temp_vec_deque = <BinHeap<_>>::with_capacity($crate::add!(0 $(, 1!$front)* ));
$(
temp_vec_deque.push($front);
)*
temp_vec_deque
}
};
($( $f:tt ,)*) => {
bin_heap!($( $f ),*)
};
($e:literal; $n:literal) => {
{
let mut temp_vec_deque = <BinHeap<_>>::with_capacity($n);
$crate::expansion_bucle(temp_vec_deque.push($e); => $n);
temp_vec_deque
}
};
($e:expr; $n:literal) => {
{
let mut temp_vec_deque = <BinHeap<_>>::with_capacity($n);
$crate::expansion_bucle(temp_vec_deque.push($e.clone()); => $n - 1);
temp_vec_deque.push($e);
temp_vec_deque
}
};
($e:literal; $n:expr) => {
{
let mut temp_vec_deque = <BinHeap<_>>::with_capacity($n);
for _ in 0..$n {
temp_vec_deque.push($e);
}
temp_vec_deque
}
};
($e:expr; $n:expr) => {
{
let mut temp_vec_deque = <BinHeap<_>>::with_capacity($n);
for _ in 1..$n {
temp_vec_deque.push($e.clone());
}
temp_vec_deque.push($e);
temp_vec_deque
}
};
}
#[macro_export]
macro_rules! hash_map {
(for $map:expr, ins $( $k:expr => $v:expr ),*) => {
{
let mut map = $map;
map.reserve($crate::add!(0 $(, 1!$k$v)* ));
$(
map.insert($k, $v);
)*
map
}
};
(for $map:tt, ins $( $k:tt => $v:tt ,)*) => {
$crate::hash_map!(for $map; $( $k => $v ),*)
};
( $( $k:expr => $v:expr ),*) => {
{
let mut map = <Map<_, _>>::with_capacity($crate::add!(0 $(, 1!$k$v)* ));
$(
map.insert($k, $v);
)*
map
}
};
( $( $k:tt => $v:tt ,)*) => {
$crate::hash_map!($( $k => $v ),*)
};
}
#[macro_export]
macro_rules! hash_set {
(for $map:expr, ins $( $k:expr ),*) => {
{
let mut map = $map;
map.reserve($crate::add!(0 $(, 1!$k$v)* ));
$(
map.insert($k);
)*
map
}
};
(for $map:tt, ins $( $k:tt ,)*) => {
$crate::hash_map!(for $map; $( $k ),*)
};
( $( $k:expr ),*) => {
{
let mut map = <Set<_>>::with_capacity($crate::add!(0 $(, 1!$k$v)* ));
$(
map.insert($k);
)*
map
}
};
( $( $k:tt ,)*) => {
$crate::hash_map!($( $k ),*)
};
}
#[macro_export]
macro_rules! btree_map {
(for $map:expr, ins $( $k:expr => $v:expr ),*) => {
{
let map = $map;
$(map.insert($k, $v);)*
map
}
};
(for $map:tt, ins $( $k:tt => $v:tt ,)*) => {
btree_map!(for $map, ins $( $k => $v ),*)
};
( $( $k:expr => $v:expr ),*) => {
{
let mut map = <BTMap<_, _>>::new();
$(map.insert($k, $v);)*
map
}
};
( $( $k:tt => $v:tt ,)*) => {
btree_map!($( $k => $v ),*)
};
}
#[macro_export]
macro_rules! btree_set {
(for $map:expr, ins $( $k:expr ),*) => {
{
let mut map = $map;
$(map.insert($k);)*
map
}
};
(for $map:tt, ins $( $k:tt ,)*) => {
$crate::btree_set!(for $map, ins $( $k ),*)
};
( $( $k:expr ),*) => {
{
let mut map = <BTSet<_>>::new();
$(map.insert($k);)*
map
}
};
( $( $k:tt ,)*) => {
$crate::btree_set!($( $k ),*)
};
}