Struct RegexBuilder 

pub struct RegexBuilder {
    pub lookahead_context_max: u32,
    /* private fields */
}

Fields

lookahead_context_max: u32

maximum lookahead context distance before returning AnchorLimit.

Implementations

impl RegexBuilder

pub fn new() -> RegexBuilder

pub fn solver_ref(&self) -> &Solver

pub fn solver(&mut self) -> &mut Solver

pub fn get_tregex(&self, inst: TRegexId) -> &TRegex<TSetId>

pub fn get_nulls( &mut self, pending_rel: u32, mask: Nullability, acc: &mut BTreeSet<NullState>, node_id: NodeId, )

pub fn contains_look(&mut self, node_id: NodeId) -> bool

pub fn contains_anchors(&self, node_id: NodeId) -> bool

whether node contains ^, $, \A, \z anchors.

pub fn is_infinite(&self, node_id: NodeId) -> bool

pub fn get_min_max_length(&self, node_id: NodeId) -> (u32, u32)

returns (min_length, max_length). max = u32::MAX means unbounded.

pub fn get_fixed_length(&self, node_id: NodeId) -> Option<u32>

pub fn der( &mut self, node_id: NodeId, mask: Nullability, ) -> Result<TRegexId, AlgebraError>

pub fn num_nodes(&self) -> u32

pub fn get_extra(&self, node_id: NodeId) -> u32

pub fn get_lookbehind_inner(&self, lookbehind_node_id: NodeId) -> NodeId

pub fn get_kind(&self, node_id: NodeId) -> Kind

pub fn get_node(&self, node_id: NodeId) -> &NodeKey

pub fn get_nulls_id(&self, node_id: NodeId) -> NullsId

pub fn nulls_as_vecs(&self) -> Vec<Vec<NullState>>

pub fn nulls_count(&self) -> usize

pub fn nulls_entry_vec(&self, id: u32) -> Vec<NullState>

pub fn strip_lb(&mut self, node_id: NodeId) -> Result<NodeId, AlgebraError>

pub fn reverse(&mut self, node_id: NodeId) -> Result<NodeId, AlgebraError>

pub fn mk_compl(&mut self, body: NodeId) -> NodeId

pub fn mk_concat(&mut self, head: NodeId, tail: NodeId) -> NodeId

pub fn mk_lookbehind(&mut self, lb_body: NodeId, lb_prev: NodeId) -> NodeId

pub fn mk_lookahead( &mut self, la_body: NodeId, la_tail: NodeId, rel: u32, ) -> NodeId

pub fn mk_lookahead_internal( &mut self, la_body: NodeId, la_tail: NodeId, rel: u32, ) -> NodeId

pub fn mk_counted(&mut self, body: NodeId, chain: NodeId, packed: u32) -> NodeId

pub fn mk_neg_lookahead(&mut self, body: NodeId, rel: u32) -> NodeId

pub fn mk_neg_lookbehind(&mut self, body: NodeId) -> NodeId

pub fn mk_union(&mut self, left: NodeId, right: NodeId) -> NodeId

pub fn mk_plus(&mut self, body_id: NodeId) -> NodeId

pub fn mk_repeat(&mut self, body_id: NodeId, lower: u32, upper: u32) -> NodeId

pub fn mk_opt(&mut self, body_id: NodeId) -> NodeId

pub fn mk_star(&mut self, body_id: NodeId) -> NodeId

pub fn nullability_emptystring(&self, node_id: NodeId) -> Nullability

it’s cheaper to check this once as an edge-case than to compute a 4th nullability bit for every node

pub fn any_nonbegin_nullable(&self, node_id: NodeId) -> bool

pub fn nullability(&self, node_id: NodeId) -> Nullability

pub fn pp(&self, node_id: NodeId) -> String

pub fn mk_not_begins_with(&mut self, node: NodeId) -> NodeId

pub fn mk_pred_not(&mut self, set: TSetId) -> NodeId

pub fn mk_u8(&mut self, char: u8) -> NodeId

pub fn mk_range_u8(&mut self, start: u8, end_inclusive: u8) -> NodeId

pub fn mk_ranges_u8(&mut self, ranges: &[(u8, u8)]) -> NodeId

pub fn extract_literal_prefix(&self, node: NodeId) -> (Vec<u8>, bool)

pub fn mk_string(&mut self, raw_str: &str) -> NodeId

pub fn mk_unions( &mut self, nodes: impl DoubleEndedIterator<Item = NodeId>, ) -> NodeId

pub fn mk_inters( &mut self, nodes: impl DoubleEndedIterator<Item = NodeId>, ) -> NodeId

pub fn mk_concats( &mut self, nodes: impl DoubleEndedIterator<Item = NodeId>, ) -> NodeId

impl RegexBuilder

pub fn subsumes( &mut self, larger_lang: NodeId, smaller_lang: NodeId, ) -> Option<bool>

check if larger_lang subsumes smaller_lang (i.e. L(smaller) ⊆ L(larger)).