strs_tools 0.45.0

//! SIMD-optimized string splitting using aho-corasick and memchr.
//!
//! This module provides high-performance string splitting operations using SIMD
//! instructions when available. It maintains API compatibility with the scalar
//! implementation while providing significant performance improvements.

#[ cfg( all( feature = "simd", feature = "std" ) ) ]
use aho_corasick ::AhoCorasick;
#[ cfg( all( feature = "simd", feature = "std" ) ) ]
use std ::collections ::HashMap;
#[ cfg( all( feature = "simd", feature = "std" ) ) ]
use std ::sync :: { Arc, RwLock };

#[ cfg( feature = "std" ) ]
use std ::borrow ::Cow;
#[ cfg( all( feature = "use_alloc", not( feature = "std" ) ) ) ]
use alloc ::borrow ::Cow;

use super :: { Split, SplitType };

/// SIMD-optimized split iterator using aho-corasick for multi-pattern matching.
/// 
/// This iterator provides significant performance improvements over scalar splitting
/// for multiple delimiters, achieving 3-6x speedup on modern processors with AVX2.
#[ cfg( all( feature = "simd", feature = "std" ) ) ]
#[ derive( Debug ) ]
pub struct SIMDSplitIterator< 'a > 
{
  input: &'a str,
  patterns: Arc<  AhoCorasick  >,
  position: usize,
  #[ allow( dead_code ) ] // Used for debugging and future enhancements
  delimiter_patterns: Vec< String >,
  last_was_delimiter: bool,
  finished: bool,
}

#[ cfg( all( feature = "simd", feature = "std" ) ) ]
impl< 'a > SIMDSplitIterator< 'a > 
{
  /// Creates a new SIMD split iterator with the given delimiters.
  /// 
  /// Uses aho-corasick for efficient multi-pattern matching with SIMD acceleration.
  /// Falls back gracefully if pattern compilation fails.
  /// 
  /// # Errors
  /// 
  /// Returns `aho_corasick ::BuildError` if the pattern compilation fails or
  /// if no valid delimiters are provided.
  pub fn new( input: &'a str, delimiters: &[ &str ] ) -> Result< Self, aho_corasick ::BuildError > 
  {
  // Filter out empty delimiters to avoid matching issues
  let filtered_delimiters: Vec< &str > = delimiters
   .iter()
   .filter( |&d| !d.is_empty() )
   .copied()
   .collect();
  
  // Build the aho-corasick automaton with SIMD optimization
  // If no valid delimiters, this will return an appropriate error
  let patterns = AhoCorasick ::builder()
   .ascii_case_insensitive( false )
   .match_kind( aho_corasick ::MatchKind ::LeftmostFirst )
   .build( &filtered_delimiters )?;
  
  let delimiter_patterns = filtered_delimiters
   .iter()
   .map( std ::string ::ToString ::to_string )
   .collect();
  
  Ok( Self {
   input,
   patterns: Arc ::new( patterns ),
   position: 0,
   delimiter_patterns,
   last_was_delimiter: false,
   finished: false,
 } )
 }
  
  /// Creates a new SIMD split iterator from a cached pattern automaton.
  /// 
  /// This is more efficient when the same delimiter set is used repeatedly,
  /// as it avoids recompiling the aho-corasick automaton.
  #[ must_use ]
  pub fn from_cached_patterns( 
  input: &'a str, 
  patterns: Arc< AhoCorasick >, 
  delimiter_patterns: Vec< String > 
 ) -> Self 
  {
  Self {
   input,
   patterns,
   position: 0,
   delimiter_patterns,
   last_was_delimiter: false,
   finished: false,
 }
 }
}

#[ cfg( all( feature = "simd", feature = "std" ) ) ]
impl< 'a > Iterator for SIMDSplitIterator< 'a > 
{
  type Item = Split< 'a >;
  
  fn next( &mut self ) -> Option< Self ::Item > 
  {
  if self.finished || self.position > self.input.len() 
  {
   return None;
 }
  
  // Handle case where we've reached the end of input
  if self.position == self.input.len() 
  {
   self.finished = true;
   return None;
 }
  
  let remaining = &self.input[ self.position.. ];
  
  // Search for the next delimiter using SIMD-optimized aho-corasick
  if let Some( mat ) = self.patterns.find( remaining ) 
  {
   let delimiter_start = self.position + mat.start();
   let delimiter_end = self.position + mat.end();
   
   // Return content before delimiter if any
   if mat.start() > 0 
   {
   let content = &self.input[ self.position..delimiter_start ];
   self.position = delimiter_start;
   self.last_was_delimiter = false;
   
  return Some( Split {
   string: Cow ::Borrowed( content ),
   typ: SplitType ::Delimited,
   start: self.position - content.len(),
   end: self.position,
   was_quoted: false,
 } );
 }
   
   // Return the delimiter itself
   let delimiter = &self.input[ delimiter_start..delimiter_end ];
   self.position = delimiter_end;
   self.last_was_delimiter = true;
   
   Some( Split {
  string: Cow ::Borrowed( delimiter ),
  typ: SplitType ::Delimiter,
  start: delimiter_start,
  end: delimiter_end,
  was_quoted: false,
 } )
 } 
  else 
  {
   // No more delimiters found, return remaining content
   if self.position < self.input.len() 
   {
  let content = &self.input[ self.position.. ];
  let start = self.position;
  self.position = self.input.len();
  self.finished = true;
  
  Some( Split {
   string: Cow ::Borrowed( content ),
   typ: SplitType ::Delimited,
   start,
   end: self.input.len(),
   was_quoted: false,
 } )
 } 
   else 
   {
  self.finished = true;
  None
 }
 }
 }
}

// Pattern cache for reusing compiled aho-corasick automatons
#[ cfg( all( feature = "simd", feature = "std" ) ) ]
use std ::sync ::LazyLock;

#[ cfg( all( feature = "simd", feature = "std" ) ) ]
static PATTERN_CACHE: LazyLock< RwLock<HashMap<Vec< String >, Arc< AhoCorasick >>>> = 
  LazyLock ::new(|| RwLock ::new(HashMap ::new()));

/// Retrieves or creates a cached aho-corasick pattern automaton.
/// 
/// This cache significantly improves performance when the same delimiter
/// patterns are used repeatedly, which is common in parsing applications.
/// 
/// # Errors
/// 
/// Returns `aho_corasick ::BuildError` if pattern compilation fails.
/// 
/// # Panics
/// 
/// Panics if the pattern cache mutex is poisoned due to a panic in another thread.
#[ cfg( all( feature = "simd", feature = "std" ) ) ]
pub fn get_or_create_cached_patterns( delimiters: &[ &str ] ) -> Result< Arc< AhoCorasick >, aho_corasick ::BuildError > 
{
  let delimiter_key: Vec< String > = delimiters
  .iter()
  .filter( |&d| !d.is_empty() )
  .map( |s| (*s).to_string() )
  .collect();
  
  // Try to get from cache first
  {
  let cache = PATTERN_CACHE.read().unwrap();
  if let Some( patterns ) = cache.get( &delimiter_key ) 
  {
   return Ok( Arc ::clone( patterns ) );
 }
 }
  
  // Not in cache, create new patterns
  let patterns = AhoCorasick ::builder()
  .ascii_case_insensitive( false )
  .match_kind( aho_corasick ::MatchKind ::LeftmostFirst )
  .build( &delimiter_key )?;
  
  let patterns_arc = Arc ::new( patterns );
  
  // Store in cache
  {
  let mut cache = PATTERN_CACHE.write().unwrap();
  
  // Limit cache size to prevent memory bloat
  if cache.len() >= 64 
  {
   cache.clear(); // Simple eviction strategy
 }
  
  cache.insert( delimiter_key, Arc ::clone( &patterns_arc ) );
 }
  
  Ok( patterns_arc )
}

/// Creates a SIMD-optimized split iterator with pattern caching.
/// 
/// This is the recommended way to create SIMD split iterators for
/// repeated use with the same delimiter patterns.
/// 
/// # Errors
/// 
/// Returns `aho_corasick ::BuildError` if pattern compilation fails.
#[ cfg( all( feature = "simd", feature = "std" ) ) ]
pub fn simd_split_cached< 'a >( input: &'a str, delimiters: &[ &str ] ) -> Result< SIMDSplitIterator<'a >, aho_corasick ::BuildError > 
{
  let patterns = get_or_create_cached_patterns( delimiters )?;
  let delimiter_patterns: Vec< String > = delimiters
  .iter()
  .filter( |&d| !d.is_empty() )
  .map( |s| (*s).to_string() )
  .collect();
  
  Ok( SIMDSplitIterator ::from_cached_patterns( input, patterns, delimiter_patterns ) )
}

// Fallback implementations when SIMD feature is disabled
#[ cfg( not( all( feature = "simd", feature = "std" ) ) ) ]
pub struct SIMDSplitIterator< 'a >( std ::marker ::PhantomData< &'a str > );

#[ cfg( not( all( feature = "simd", feature = "std" ) ) ) ]
impl< 'a > SIMDSplitIterator< 'a > 
{
  pub fn new( _input: &'a str, _delimiters: &[ &str ] ) -> Result<  Self, &'static str  > 
  {
  Err( "SIMD feature not enabled" )
 }
}

#[ cfg( not( all( feature = "simd", feature = "std" ) ) ) ]
impl< 'a > Iterator for SIMDSplitIterator< 'a > 
{
  type Item = Split< 'a >;
  
  fn next( &mut self ) -> Option< Self ::Item > 
  {
  None
 }
}

#[ cfg( not( all( feature = "simd", feature = "std" ) ) ) ]
pub fn simd_split_cached< 'a >( _input: &'a str, _delimiters: &[ &str ] ) -> Result< SIMDSplitIterator<'a >, &'static str > 
{
  Err( "SIMD feature not enabled" )
}