Transliterator Classe

Definizione

[Android.Runtime.Register("android/icu/text/Transliterator", ApiSince=29, DoNotGenerateAcw=true)]
public abstract class Transliterator : Java.Lang.Object

[<Android.Runtime.Register("android/icu/text/Transliterator", ApiSince=29, DoNotGenerateAcw=true)>]
type Transliterator = class
    inherit Object

Ereditarietà

Object

JavaObject

Object

Transliterator

Attributi

RegisterAttribute

Commenti

Transliterator è una classe astratta che traslittera il testo da un formato a un altro. Il tipo più comune di transliteratore è uno script, o alfabeto, transliteratore. Ad esempio, un transliteratore russo in alfabeto latino modifica il testo russo scritto in caratteri cirilici in caratteri latini foneticamente equivalenti. Non è <em>translate</em> russo in inglese! La traslitterazione, diversamente dalla traduzione, opera sui caratteri, senza riferimento ai significati di parole e frasi.

Anche se la conversione di script è l'uso più comune, un transliteratore può effettivamente eseguire una classe più generale di attività. Definisce infatti Transliterator un'API molto generale che specifica solo che un segmento del testo di input viene sostituito da un nuovo testo. I particolari di questa conversione sono determinati interamente dalle sottoclassi di Transliterator.

<b>I traslitterati sono senza< stato/b>

Transliteratorgli oggetti sono senza stato</em>; non mantengono informazioni tra le chiamate a <.>transliterate() Di conseguenza, i thread possono condividere traslitteratori senza sincronizzarli. Questo potrebbe sembrare limitare la complessità dell'operazione di traslitterazione. In pratica, le sottoclassi eseguono traslitterazioni complesse ritardando la sostituzione del testo fino a quando non è noto che non sono possibili altre sostituzioni. In altre parole, anche se gli Transliterator oggetti sono senza stato, il testo di origine stesso incorpora tutte le informazioni necessarie e l'operazione ritardata consente complessità arbitraria.

<b>Traslitterazione< batch/b>

Il modo più semplice per eseguire la traslitterazione è tutto in una sola volta, su una stringa di testo esistente. Questa operazione viene definita <>traslitterazione batch</em> em. Ad esempio, data una stringa input e un transliteratore t, la chiamata

<blockquote/blockquote>String result = t.transliterate(input); <>

lo traslittererà e restituirà il risultato. Altri metodi consentono al client di specificare una sottostringa da traslitterare e di usare Replaceable oggetti anziché stringhe, per mantenere le informazioni fuori banda ,ad esempio gli stili di testo.

<b>Traslitterazione< tastiera/b>

Un po'più coinvolti è la <>tastiera</em> o la traslitterazione incrementale. Si tratta della traslitterazione di testo che arriva da un'origine (in genere la tastiera dell'utente) un carattere alla volta o in un altro modo a fasi.

Nella traslitterazione della tastiera, un Replaceable buffer archivia il testo. Come testo viene inserito, il più possibile viene traslitterato in volo. Ciò significa che un'interfaccia utente grafica che visualizza il contenuto del buffer può mostrare il testo modificato man mano che arriva ogni nuovo carattere.

Si consideri il transliteratore semplice basato su regole:

<blockquote/blockquote> th&gt;{theta}<br> t&gt;{tau} <>

Quando l'utente digita 't', non succederà nulla, poiché il transliteratore è in attesa di vedere se il carattere successivo è 'h'. Per risolvere questo problema, viene introdotta la nozione di cursore, contrassegnata da un '|' nella stringa di output:

<blockquote/blockquote> t&gt;|{tau}<br> {tau}h&gt;{theta} <>

Ora quando l'utente digita 't', viene visualizzato tau e se il carattere successivo è 'h', il tau cambia in un theta. Questa operazione viene eseguita mantenendo una posizione del cursore (indipendente dal punto di inserimento e invisibile nell'interfaccia utente grafica) tra le chiamate a transliterate(). In genere, il cursore sarà coincidente con il punto di inserimento, ma in un caso simile a quello precedente precederà il punto di inserimento.

I metodi di traslitterazione da tastiera mantengono un set di tre indici aggiornati con ogni chiamata a transliterate(), incluso il cursore, l'avvio e il limite. Questi indici vengono modificati dal metodo e vengono passati e eseguiti tramite un oggetto Position. L'indice start contrassegna l'inizio della sottostringa che verrà esaminata dal transliteratore. È avanzato man mano che viene eseguito il commit del testo ( ma non è l'indice di cui è stato eseguito il commit, ovvero ).cursor L'indice cursor , descritto in precedenza, contrassegna il punto in cui il transliteratore è stato arrestato, perché ha raggiunto la fine o perché richiedeva più caratteri per disambiguare tra gli input possibili. L'oggetto cursor può anche essere impostato in modo esplicito in base alle regole. Qualsiasi carattere prima che l'indice cursor venga bloccato. Le chiamate future di traslitterazione da tastiera all'interno di questa sequenza di input non verranno modificate. Il nuovo testo viene inserito in corrispondenza dell'indice limit , che contrassegna la fine della sottostringa esaminata dal transliteratore.

Poiché la traslitterazione della tastiera presuppone che arrivino più caratteri, è conservativo nel suo funzionamento. Si traslittera solo quando può farlo senza ambiguità. In caso contrario, attende l'arrivo di più caratteri. Quando il codice client sa che non sono disponibili altri caratteri, forse perché l'utente ha eseguito un'operazione di terminazione dell'input, deve chiamare finishTransliteration() per completare eventuali traslitterazioni in sospeso.

<b>Inverses</b>

Le coppie di traslitteratori possono essere inverse l'una dell'altra. Ad esempio, se transliterator <b>A</b> traslittera i caratteri incrementando il valore Unicode (quindi "abc" -> "def") e transliterator <b></b> decrementa i valori di carattere, quindi <b>A</b> è un inverso di <b></b> e viceversa. Se si compone <b>A</b> con <b></b> in un transliteratore composto, il risultato è il transliteratore di identità, ovvero un transliteratore che non modifica il testo di input.

Il Transliterator metodo getInverse() restituisce l'inverso di un transliteratore, se esistente o null in caso contrario. Tuttavia, il risultato di getInverse() solito em <>not</em> sarà un vero inverso matematico. Ciò è dovuto al fatto che i traslitteratori inversa sono difficili da formulare. Si considerino ad esempio due traslitteratori: <b>AB</b>, che traslittera il carattere 'A' in 'B' e <b>BA</b>, che traslittera 'B' in 'A'. Potrebbe sembrare che questi siano inverse esatte, dal momento che

<blockquote>"A" x <b>AB</b> -> "B"<br> "B" x <b>BA</b> -> "A"</blockquote>

dove 'x' rappresenta la traslitterazione. Tuttavia,

<blockquote>"ABCD" x <b>AB</b> -> "BBCD"<br> "BBCD" x <b>BA</b> -> "AACD"</blockquote>

quindi <b AB>/b<> composto con <b>BA</b> non è l'identità. Tuttavia, b BA/b< può essere considerato utilemente come >b AB</b> inverso, ed è su questa base che <b>AB</b>< potrebbe legittimamente restituire >b<>BA.getInverse()/b.<><>

<b>Filtro</b>

Ogni transliteratore ha un filtro, che limita le modifiche a tali caratteri selezionati dal filtro. Il filtro influisce solo sui caratteri modificati: i caratteri esterni al filtro fanno ancora parte del contesto per il filtro. Ad esempio, nell'esempio seguente anche se 'x' viene filtrato e non viene convertito in y, influisce sulla conversione di 'a'.

String rules = "x > y; x{a} > b; ";
            Transliterator tempTrans = Transliterator.createFromRules("temp", rules, Transliterator.FORWARD);
            tempTrans.setFilter(new UnicodeSet("[a]"));
            String tempResult = tempTrans.transform("xa");
            // results in "xb"

<ID b>e nomi< visualizzati/b>

Un transliteratore è designato da una stringa di identificatore breve o <em>ID</em>. Gli ID seguono il formato <em>source-destination</em>, dove <em>source</em> descrive l'entità da sostituire e <em>destination</em descrive l'entità che sostituisce >em<source>/em<>. Le entità possono essere i nomi di script, sequenze particolari di caratteri o qualsiasi altra cosa è che il transliteratore converte in o da. Ad esempio, un transliteratore dal russo al latino potrebbe essere denominato "russo-latino". Un transliteratore dalle sequenze di escape da tastiera a caratteri latini-1 potrebbe essere denominato "KeyboardEscape-Latin1". Per convenzione, i nomi delle entità di sistema sono in inglese, con le lettere iniziali di parole maiuscole; I nomi di entità utente possono seguire qualsiasi formato purché non contengano trattini.

Oltre agli ID programmatici, gli oggetti transliterator hanno nomi visualizzati per la presentazione nelle interfacce utente, restituiti da #getDisplayName.

<b>Traslitteratori< composti/b>

Oltre ai traslitteratori di sistema incorporati come "Latino-Greco", sono presenti anche <translitterrati em>incorporati.<> Questi vengono implementati componendo due o più traslitteratori componenti. Ad esempio, se sono presenti script "A", "B", "C" e "D" e si vuole traslitterare tra tutte le coppie, è necessario scrivere 12 traslitteratori: "A-B", "A-C", "A-D", "B-A",..., "D-A", "D-B", "D-C". Se è possibile convertire tutti gli script in uno script intermedio "M", invece di scrivere 12 set di regole, è sufficiente scrivere 8: "A~M", "B~M", "C~M", "D~M", "M~A", "M~B", "M~C", "M~D". (Questo potrebbe non sembrare una grande vittoria, ma è davvero 2 em n/em< vs. >em n<>/em<>sup<2>/sup< - em>n</em, >quindi <em>n</em>< diventa più grande il guadagno diventa significativo.><> Con 9 script, si tratta di set di regole da 18 a 72, una grande differenza. Si noti l'uso di "~" anziché "-" per il separatore di script qui; ciò indica che il transliteratore specificato deve essere composto con altri, anziché essere usato così com'è.

È possibile creare un'istanza di traslitterati composti come di consueto. Ad esempio, il transliteratore di sistema "Devanagari-Gujarati" è un transliteratore composto costruito internamente come "Devanagari~InterIndic; InterIndic~Gujarati". Quando viene creata un'istanza di questo transliteratore, sembra esternamente essere un transliteratore standard (ad esempio, getID() restituisce "Devanagari-Gujarati".

<b>Sintassi< della regola/b>

Un set di regole determina come eseguire le traduzioni. Le regole all'interno di un set di regole sono separate da punti (';') e virgola. Per includere un punto e virgola letterale, anteporre una barra rovesciata ('\'). Il Pattern_White_Space Unicode viene ignorato. Se il primo carattere non vuoto in una riga è '#', l'intera riga viene ignorata come commento.

Ogni set di regole è costituito da due gruppi, uno avanti e un altro inverso. Si tratta di una convenzione che non viene applicata; le regole per una direzione possono essere omesse, con il risultato che le traduzioni in tale direzione non modificheranno il testo di origine. Inoltre, è possibile specificare regole bidirezionali forward-reverse per le trasformazioni simmetriche.

Nota: un'altra descrizione della sintassi della regola transliterator è disponibile nella sezione Sintassi delle regole di trasformazione di UTS #35: Unicode LDML. Le regole vengono visualizzate usando i simboli freccia ← e → e ↔ . L'ICU supporta sia quelli che i simboli ASCII equivalenti < e > e < >.

Le istruzioni regola accettano una delle seguenti forme:

<dl>dt/dt<>$alefmadda=\\u0622;<> dd<definizione di variabile complessa.><></strong> Il nome a sinistra viene assegnato il testo a destra. In questo esempio, dopo questa istruzione, le istanze del nome della mano sinistra, "$alefmadda", verrà sostituito dal carattere Unicode U+0622. I nomi delle variabili devono iniziare con una lettera e sono costituiti solo da lettere, cifre e caratteri di sottolineatura. Il caso è significativo. I nomi duplicati causano la generazione di un'eccezione, ovvero le variabili non possono essere ridefinite. Il lato destro può contenere testo ben formato di qualsiasi lunghezza, incluso nessun testo ("$empty=;"). Il lato destro può contenere modelli incorporatiUnicodeSet, ad esempio "$softvowel=[eiyEIY]".</dd><dt/dt>ai>$alefmadda;<>< dd><regola>di conversione avanzata avanzata.</strong> Questa regola indica che la stringa a sinistra verrà modificata nella stringa a destra quando si esegue la traslitterazione in avanti.</dd><dt/dt>ai<$alefmadda;<>< dd><regola di conversione inversa avanzata.></strong> Questa regola indica che la stringa a destra verrà modificata nella stringa a sinistra quando si esegue la traslitterazione inversa.</dd></dl>

<dl>dt/dt<>ai<>$alefmadda;<> dd<strong><Regola di conversione bidirezionale.></strong> Questa regola indica che la stringa a destra verrà modificata nella stringa a sinistra quando si esegue la traslitterazione in avanti e viceversa quando si esegue la traslitterazione inversa.</dd></dl>

Le regole di traduzione sono costituite da un <modello> di corrispondenza em</em> e da una <stringa> di output em</em>. Il modello di corrispondenza è costituito da caratteri letterali, preceduti facoltativamente dal contesto e, facoltativamente, seguiti dal contesto. I caratteri di contesto, ad esempio i caratteri dei criteri letterali, devono essere confrontati nel testo traslitterato. Tuttavia, a differenza dei caratteri del modello letterale, non vengono sostituiti dal testo di output. Ad esempio, il modello "abc{def}" indica i caratteri "def" deve essere preceduto da "abc" per una corrispondenza con esito positivo. Se c'è una corrispondenza riuscita, "def" verrà sostituito, ma non "abc". L'ultima '}' è facoltativa, quindi "abc{def" equivale a "abc{def}". Un altro esempio è "{123}456" (o "123}456") in cui il modello letterale "123" deve essere seguito da "456".

La stringa di output di una regola in avanti o inversa è costituita da caratteri per sostituire i caratteri del criterio letterale. Se la stringa di output contiene il carattere '|', viene impiegato per indicare la posizione del cursore< em>/em< dopo la >sostituzione. Il cursore è il punto del testo in corrispondenza del quale verrà applicata la successiva sostituzione, se presente, . Il cursore viene in genere posizionato all'interno del testo sostitutivo; tuttavia, può essere effettivamente inserito nel contesto precending o seguente usando il carattere speciale '

per android.icu.text.Transliterator.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.