Restituisce tutti gli indici di una particolare sottostringa

Question

Esiste un metodo API della libreria Scala (e in caso contrario, un modo idiomatico) per ottenere un elenco di tutti gli indici per una sottostringa (destinazione) all'interno di una stringa più grande (origine)? Ho provato a guardare attraverso ScalaDoc, ma non sono riuscito a trovare nulla di ovvio. Ci sono così tanti metodi che fanno tante cose utili, suppongo che non stia semplicemente sottomettendo i termini di ricerca giusti.

Per esempio, se ho una stringa di origine di "Nome: Yo, nome: Jim, nome: nome, il nome: bozo" e io uso una stringa di destinazione di "Nome:" Mi piacerebbe tornare un Elenco [Int] di List (0, 8, 17, 27).

Ecco il mio trucco veloce per risolvere il problema:

def indexesOf(source: String, target: String, index: Int = 0, withinOverlaps: Boolean = false): List[Int] = { 
    def recursive(index: Int, accumulator: List[Int]): List[Int] = { 
     if (!(index < source.size)) accumulator 
     else { 
     val position = source.indexOf(target, index) 
     if (position == -1) accumulator 
     else { 
      recursive(position + (if (withinOverlaps) 1 else target.size), position :: accumulator) 
     } 
     } 
    } 

    if (target.size <= source.size) { 
     if (!source.equals(target)) { 
     recursive(0, Nil).reverse 
     } 
     else List(0) 
    } 
    else Nil 
    } 

Qualsiasi orientamento è possibile darmi sostituzione di questo con un adeguato punto di ingresso della libreria standard sarebbe molto apprezzato.

AGGIORNAMENTO 2014/Lug/22:

Ispirato dalla risposta di Siddhartha Dutta, ho tighted il mio codice. E ora si presenta così:

def indexesOf(source: String, target: String, index: Int = 0, withinOverlaps: Boolean = false): List[Int] = { 
    @tailrec def recursive(indexTarget: Int, accumulator: List[Int]): List[Int] = { 
     val position = source.indexOf(target, indexTarget) 
     if (position == -1) accumulator 
     else 
     recursive(position + (if (withinOverlaps) 1 else target.size), position :: accumulator) 
    } 
    recursive(index, Nil).reverse 
    } 

Inoltre, se ho una stringa di origine di "aaaaaaaa" e io uso una stringa di destinazione di "aa", vorrei per difetto di tornare un elenco [Int] di Elenco (0, 2, 4, 6) che salta una ricerca iniziando all'interno di una sottostringa trovata. L'impostazione predefinita può essere sovrascritta passando "true" per il parametro withinOverlaps che nel caso "aaaaaaaa"/"aa" restituirà List (0, 1, 2, 3, 4, 5, 6).

Answer 1

Sono sempre incline a raggiungere il sacco di trucchi regex con problemi come questo. Non direi che è corretto, ma è un codice infernale. :)

val r = "\\Qname\\E".r 
val ex = "name:Yo,name:Jim,name:name,name:bozo" 

val is = r.findAllMatchIn(ex).map(_.start).toList 

Le citazioni \\Q e \\E non sono necessari per questo caso, ma se la stringa che state cercando ha alcun carattere speciale, allora sarà.

Answer 2

un piccolo codice per ottenere tutti gli indici
chiamare il metodo seguito come getAllIndexes (origine, destinazione)

def getAllIndexes(source: String, target: String, index: Int = 0): List[Int] = { 
     val targetIndex = source.indexOf(target, index) 
     if(targetIndex != -1) 
      List(targetIndex) ++ getAllIndexes(source, target, targetIndex+1) 
     else 
      List() 
     }