Struct OrdAllocator 

pub struct OrdAllocator<K, T, O>
where
    K: Id,
    O: Collexetable<T>,
    T: FieldValue,
{
    pub id_map: IdMap<K, T>,
    pub collex: FieldCollex<Pair<K, O>, T>,
}

Fields

id_map: IdMap<K, T>

collex: FieldCollex<Pair<K, O>, T>

Implementations

impl<K, V, E> OrdAllocator<K, V, E>

where K: Id, E: Collexetable<V>, V: FieldValue,

pub fn new(span: Span<V>, unit: V) -> Result<Self, NewFieldCollexError<V>>

pub fn with_capacity( span: Span<V>, unit: V, capacity: usize, ) -> Result<Self, WithCapacityFieldCollexError<V>>

pub fn with_elements( span: Span<V>, unit: V, vec: Vec<E>, ) -> Result<Self, WithElementsFieldCollexError<V>>

pub fn extend(&mut self, vec: Vec<E>)

pub fn try_extend(&mut self, vec: Vec<E>) -> TryExtendResult<Pair<K, E>>

pub fn insert(&mut self, elem: E) -> Result<K, InsertFieldCollexError<E>>

pub fn remove(&mut self, id: K) -> Option<E>

pub fn modify<F, R>( &mut self, id: K, f: F, ) -> Result<R, ModifyFieldCollexError<(R, E)>>

where F: Fn(&mut E) -> R,

pub fn try_modify<F, R>( &mut self, id: K, f: F, ) -> Result<R, ModifyFieldCollexError<R>>

where F: Fn(&mut E) -> R,

pub fn get_with_id(&self, id: K) -> Option<&E>

pub fn into_raw_parts(self) -> (IdMap<K, V>, FieldCollex<Pair<K, E>, V>)

pub fn from_raw_parts( id_map: IdMap<K, V>, collex: FieldCollex<Pair<K, E>, V>, ) -> Self

Methods from Deref<Target = FieldCollex<Pair<K, E>, V>>

pub fn iter(&self) -> Iter<'_, E, V>

获取不可变迭代器

pub fn span(&self) -> &Span<V>

pub fn unit(&self) -> &V

pub fn size(&self) -> Option<usize>

返回最大块数量

若Span是无限区间，返回None

pub fn len(&self) -> usize

返回已存在的块的数量

此值应小于等于最大块数量

pub fn capacity(&self) -> usize

Returns the total number of elements the inner vector can hold without reallocating.

此值应小于等于最大块数量

pub fn contains(&self, elem: &E) -> bool

查找对应是否存在与其collexate()值相同的元素

pub fn contains_value(&self, value: V) -> bool

查找对应值是否存在

pub fn first(&self) -> Option<&E>

找到第一个值的引用

pub fn last(&self) -> Option<&E>

找最后一个值的引用

pub fn extend(&mut self, vec: Vec<E>)

批量插入元素，忽略错误值。

pub fn try_extend(&mut self, vec: Vec<E>) -> TryExtendResult<E>

批量插入元素，返回插入的情况。

pub fn insert(&mut self, value: E) -> Result<(), InsertFieldCollexError<E>>

插入值

pub fn remove(&mut self, target: V) -> Result<E, RemoveFieldCollexError>

删除对应值

pub fn find_gt(&self, target: V) -> Option<&E>

pub fn find_ge(&self, target: V) -> Option<&E>

pub fn find_lt(&self, target: V) -> Option<&E>

pub fn find_le(&self, target: V) -> Option<&E>

pub fn find_closest(&self, target: V) -> Option<&E>

找到最近的

两边距离相等时返回更小的

pub fn is_empty(&self) -> bool

判断本容器是否为空

为空不意味着内存占用为0。

pub fn get(&self, value: V) -> Option<&E>

pub fn unchecked_get(&self, value: V) -> &E

Panics

找不到panic

pub fn try_modify<F, R>( &mut self, value: V, op: F, ) -> Result<R, ModifyFieldCollexError<R>>

where F: Fn(&mut E) -> R,

闭包结束后，会根据Value是否发生变化来决定是否更新其在Collex中的位置

若更新后的值(仅指collexate值)无法容纳于本Collex，将报错并重置值。

pub fn modify<F, R>( &mut self, value: V, op: F, ) -> Result<R, ModifyFieldCollexError<(R, E)>>

where F: Fn(&mut E) -> R,

闭包结束后，会根据Value是否发生变化来决定是否更新其在Collex中的位置

若更新后的值(仅指collexate值)无法容纳于本Collex，将直接通过错误类型的变体返还

pub fn unchecked_modify<F, R>(&mut self, value: V, op: F) -> R

where F: Fn(&mut E) -> R,

闭包结束后，会根据Value是否发生变化来决定是否更新其在Collex中的位置

Panics

若无法找到对应的元素，panic

若更新后的值(仅指collexate值)无法容纳于本Collex，将直接Panic

Trait Implementations

impl<K, T, O> Debug for OrdAllocator<K, T, O>

where K: Id + Debug, O: Collexetable<T> + Debug, T: FieldValue + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V, E> Deref for OrdAllocator<K, V, E>

where K: Id, E: Collexetable<V>, V: FieldValue,

type Target = FieldCollex<Pair<K, E>, V>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<K, V, E> DerefMut for OrdAllocator<K, V, E>

where K: Id, E: Collexetable<V>, V: FieldValue,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, K, T, O> Deserialize<'de> for OrdAllocator<K, T, O>

where O: Collexetable<T> + Deserialize<'de>, T: FieldValue + Deserialize<'de>, K: Id + Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, T, O> Serialize for OrdAllocator<K, T, O>

where K: Id + Serialize, O: Collexetable<T> + Serialize, T: FieldValue + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.