organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-13 08:53:20 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 3

ICU-12450 move com.ibm.icu.text.TransformTransliterator to org.unicode.unused

Browse source 
X-SVN-Rev: 38686
This commit is contained in:
Markus Scherer 2016-05-03 20:40:47 +00:00
parent 1cb09a85a3
commit a97bd99a2e
1 changed files with 0 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

127
icu4j/main/classes/translit/src/com/ibm/icu/text/TransformTransliterator.java
View file

@ -1,127 +0,0 @@
/*
* Copyright (C) 1996-2004, International Business Machines Corporation and
* others. All Rights Reserved.
*
*/
package com.ibm.icu.text;
//import java.util.*;
abstract class TransformTransliterator {
// Currently unused
}
///**
// * An abstract class for transliterators based on a transform
// * operation. To create a transliterator that implements a
// * transformation, create a subclass of this class and implement the
// * abstract <code>transform()</code> and <code>hasTransform()</code>
// * methods.
// * @author Alan Liu
// */
//abstract class TransformTransliterator extends Transliterator {
//
// /**
// * Constructs a transliterator. For use by subclasses.
// */
// protected TransformTransliterator(String id, UnicodeFilter f) {
// super(id, f);
// }
//
// /**
// * Implements {@link Transliterator#handleTransliterate}.
// */
// protected void handleTransliterate(Replaceable text,
// Position offsets, boolean incremental) {
//
// int start;
// for (start = offsets.start; start < offsets.limit; ++start) {
// // Scan for the first character that is != its transform.
// // If there are none, we fall out without doing anything.
// char c = text.charAt(start);
// if (hasTransform(c)) {
// // There is a transforming character at start. Break
// // up the remaining string, from start to
// // offsets.limit, into segments of unfiltered and
// // filtered characters. Only transform the unfiltered
// // characters. As always, minimize the number of
// // calls to Replaceable.replace().
//
// int len = offsets.limit - start;
// // assert(len >= 1);
//
// char[] buf = new char[len];
// text.getChars(start, offsets.limit, buf, 0);
//
// int segStart = 0;
// int segLimit;
// UnicodeFilter filt = getFilter();
//
// // lenDelta is the accumulated length difference for
// // all transformed segments. It is new length - old
// // length.
// int lenDelta = 0;
//
// // Set segStart, segLimit to the unfiltered segment
// // starting with start. If the filter is null, then
// // segStart/Limit will be set to the whole string,
// // that is, 0/len.
// do {
// // Set segLimit to the first filtered char at or
// // after segStart.
// segLimit = len;
// if (filt != null) {
// segLimit = segStart;
// while (segLimit < len && filt.contains(buf[segLimit])) {
// ++segLimit;
// }
// }
//
// // Transform the unfiltered chars between segStart
// // and segLimit.
// int segLen = segLimit - segStart;
// if (segLen != 0) {
// String newStr = transform(
// new String(buf, segStart, segLen));
// text.replace(start, start + segLen, newStr);
// start += newStr.length();
// lenDelta += newStr.length() - segLen;
// }
//
// // Set segStart to the first unfiltered char at or
// // after segLimit.
// segStart = segLimit;
// if (filt != null) {
// while (segStart < len && !filt.contains(buf[segStart])) {
// ++segStart;
// }
// }
// start += segStart - segLimit;
//
// } while (segStart < len);
//
// offsets.limit += lenDelta;
// offsets.contextLimit += lenDelta;
// offsets.start = offsets.limit;
// return;
// }
// }
// // assert(start == offsets.limit);
// offsets.start = start;
// }
//
// /**
// * Subclasses must implement this method to determine whether a
// * given character has a transform that is not equal to itself.
// * This is approximately equivalent to <code>c !=
// * transform(String.valueOf(c))</code>, where
// * <code>String.valueOf(c)</code> returns a String containing the
// * single character (not integer) <code>c</code>. Subclasses that
// * transform all their input can simply return <code>true</code>.
// */
// protected abstract boolean hasTransform(int c);
//
// /**
// * Subclasses must implement this method to transform a string.
// */
// protected abstract String transform(String s);
//}