Struct Allocator 

pub struct Allocator { /* private fields */ }

Implementations

impl Allocator

pub fn new() -> Self

pub fn new_limited(heap_limit: usize) -> Self

pub fn checkpoint(&self) -> Checkpoint

create a checkpoint for the current state of the allocator. This can be used to go back to an earlier allocator state by passing the Checkpoint to restore_checkpoint().

pub fn restore_checkpoint(&mut self, cp: &Checkpoint)

pub fn transparent_checkpoint(&self) -> TransparentCheckpoint

create a checkpoint for the current state of the allocator. This is used to free all atoms and pairs allocated after this point, without affecting counters. i.e. as if they are still allocated

pub fn restore_transparent_checkpoint(&mut self, cp: &TransparentCheckpoint)

A transparent checkpoint works the same as a regular one but it doesn’t restore the counters. The atoms and pair being removed are still counted.

pub fn checkpoint_node_status( &self, checkpoint: &TransparentCheckpoint, node: NodePtr, ) -> NodeStatus

classify whether a node survives a restore to the checkpoint, and whether it references bytes allocated before or after that checkpoint.

pub fn maybe_restore_with_node( &mut self, checkpoint: &TransparentCheckpoint, ret: NodePtr, ) -> Result<MaybeRestore>

Attempt to restore the checkpoint, and preserve the value of the / specified node. If the node was allocated after the checkpoint, it will be invalidated. Fix up accounting and optionally produce a replacement node. Caller must replace the value stack top when Replace(node) is returned, If the node is a tree or too large to be restored, the allocator will not be restored to the checkpoint and Aborted will be returned.

pub fn new_atom(&mut self, v: &[u8]) -> Result<NodePtr>

pub fn new_small_number(&mut self, v: u32) -> Result<NodePtr>

pub fn new_u64(&mut self, val: u64) -> Result<NodePtr>

pub fn new_i64(&mut self, val: i64) -> Result<NodePtr>

pub fn new_number(&mut self, v: Number) -> Result<NodePtr>

pub fn new_malachite_number(&mut self, v: Malachite) -> Result<NodePtr>

pub fn new_g1(&mut self, g1: G1Element) -> Result<NodePtr>

pub fn new_g2(&mut self, g2: G2Element) -> Result<NodePtr>

pub fn new_pair(&mut self, first: NodePtr, rest: NodePtr) -> Result<NodePtr>

pub fn add_ghost_pair(&mut self, amount: usize) -> Result<()>

pub fn remove_ghost_pair(&mut self, amount: usize) -> Result<()>

pub fn add_ghost_atom(&mut self, amount: usize) -> Result<()>

pub fn new_substr( &mut self, node: NodePtr, start: u32, end: u32, ) -> Result<NodePtr>

pub fn new_concat( &mut self, new_size: usize, nodes: &[NodePtr], ) -> Result<NodePtr>

pub fn atom_eq(&self, lhs: NodePtr, rhs: NodePtr) -> bool

pub fn atom(&self, node: NodePtr) -> Atom<'_>

pub fn atom_len(&self, node: NodePtr) -> usize

pub fn small_number(&self, node: NodePtr) -> Option<u32>

pub fn number(&self, node: NodePtr) -> Number

pub fn malachite_number(&self, node: NodePtr) -> Malachite

pub fn g1(&self, node: NodePtr) -> Result<G1Element>

pub fn g2(&self, node: NodePtr) -> Result<G2Element>

pub fn node(&self, node: NodePtr) -> NodeVisitor<'_>

pub fn sexp(&self, node: NodePtr) -> SExp

pub fn next(&self, n: NodePtr) -> Option<(NodePtr, NodePtr)>

pub fn nil(&self) -> NodePtr

pub fn one(&self) -> NodePtr

pub fn atom_count(&self) -> usize

pub fn allocated_atom_count(&self) -> usize

pub fn pair_count(&self) -> usize

pub fn allocated_pair_count(&self) -> usize

pub fn heap_size(&self) -> usize

pub fn allocated_heap_size(&self) -> usize

pub fn validate_g1(&mut self, node: NodePtr, bytes: [u8; 48]) -> Result<()>

pub fn validate_g2(&mut self, node: NodePtr, bytes: [u8; 96]) -> Result<()>

pub fn add_validated_g1(&mut self, bytes: [u8; 48])

pub fn add_validated_g2(&mut self, bytes: [u8; 96])

pub fn clear_validation_caches(&mut self)

Trait Implementations

impl Debug for Allocator

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

Formats the value using the given formatter.

impl Default for Allocator

fn default() -> Self

Returns the “default value” for a type.