Struct DiscontinuousSpan 

pub struct DiscontinuousSpan { /* private fields */ }

A discontinuous span representing non-contiguous entity mentions.

Some entities span multiple non-adjacent text regions:

• “severe [pain] in the [abdomen]” → “severe abdominal pain”
• “the [president] … [Obama]” → coreference

This is required for:

• Medical NER: Anatomical modifiers separated from findings
• Legal NER: Parties referenced across clauses
• W2NER: Word-word relation grids that detect discontinuous entities

Offset Unit (CRITICAL)

DiscontinuousSpan uses character offsets (Unicode scalar value indices), consistent with Entity::start / Entity::end and anno::core::grounded::Location.

This is intentionally not byte offsets. If you have byte offsets (from regex, str::find, tokenizers, etc.), convert them to character offsets first (see anno::offset::SpanConverter in the anno crate).

Example

use anno_core::DiscontinuousSpan;

// "severe pain in the abdomen" where "severe" modifies "pain"
// but they're separated by other words
let span = DiscontinuousSpan::new(vec![
    0..6,   // "severe"
    12..16, // "pain"
]);

assert_eq!(span.num_segments(), 2);
assert!(span.is_discontinuous());

Implementations

impl DiscontinuousSpan

pub fn new(segments: Vec<Range<usize>>) -> DiscontinuousSpan

Create a new discontinuous span from segments.

Segments are sorted and validated (no overlaps).

pub fn contiguous(start: usize, end: usize) -> DiscontinuousSpan

Create from a single contiguous span.

pub fn num_segments(&self) -> usize

Number of segments.

pub fn is_discontinuous(&self) -> bool

True if this spans multiple non-adjacent regions.

pub fn is_contiguous(&self) -> bool

True if this is a single contiguous span.

pub fn segments(&self) -> &[Range<usize>]

Get the segments.

pub fn bounding_range(&self) -> Option<Range<usize>>

Get the overall bounding range (start of first to end of last).

pub fn total_len(&self) -> usize

Total character length (sum of all segments).

pub fn extract_text(&self, text: &str, separator: &str) -> String

Extract text from each segment and join with separator.

pub fn contains(&self, pos: usize) -> bool

Check if a character position falls within any segment.

Arguments

• pos - Character offset to check (Unicode scalar value index)

Returns

true if the character position falls within any segment of this span.

pub fn to_span(&self) -> Option<Span>

Convert to a regular Span (uses bounding range, loses discontinuity info).

Trait Implementations

impl Clone for DiscontinuousSpan

fn clone(&self) -> DiscontinuousSpan

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DiscontinuousSpan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DiscontinuousSpan

fn deserialize<__D>( __deserializer: __D, ) -> Result<DiscontinuousSpan, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Range<usize>> for DiscontinuousSpan

fn from(range: Range<usize>) -> DiscontinuousSpan

Converts to this type from the input type.

impl PartialEq for DiscontinuousSpan

fn eq(&self, other: &DiscontinuousSpan) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DiscontinuousSpan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DiscontinuousSpan

impl StructuralPartialEq for DiscontinuousSpan