libcore.icu.CollationElementIteratorICU.setOffset java code examples

Common ways to obtain CollationElementIteratorICU

private void myMethod () {
     CollationElementIteratorICU c =String source;CollationElementIteratorICU.getInstance(collatorAddress, source)
new CollationElementIteratorICU(address)
Smart code suggestions by Codota
}

/**
 * Points the iterator at the collation element associated with the
 * character in the source string which is found at the supplied offset.
 * After this call completes, an invocation of the {@link #next()} method
 * will return this collation element.
 * <p>
 * If {@code newOffset} corresponds to a character which is part of a
 * sequence that maps to a single collation element then the iterator is
 * adjusted to the start of that sequence. As a result of this, any
 * subsequent call made to {@code getOffset()} may not return the same value
 * set by this method.
 * <p>
 * If the decomposition mode is on, and offset is in the middle of a
 * decomposable range of source text, the iterator may not return a correct
 * result for the next forwards or backwards iteration. The user must ensure
 * that the offset is not in the middle of a decomposable range.
 *
 * @param newOffset
 *            the character offset into the original source string to set.
 *            Note that this is not an offset into the corresponding
 *            sequence of collation elements.
 */
public void setOffset(int newOffset) {
  this.icuIterator.setOffset(newOffset);
}

/**
 * Points the iterator at the collation element associated with the
 * character in the source string which is found at the supplied offset.
 * After this call completes, an invocation of the {@link #next()} method
 * will return this collation element.
 * <p>
 * If {@code newOffset} corresponds to a character which is part of a
 * sequence that maps to a single collation element then the iterator is
 * adjusted to the start of that sequence. As a result of this, any
 * subsequent call made to {@code getOffset()} may not return the same value
 * set by this method.
 * <p>
 * If the decomposition mode is on, and offset is in the middle of a
 * decomposable range of source text, the iterator may not return a correct
 * result for the next forwards or backwards iteration. The user must ensure
 * that the offset is not in the middle of a decomposable range.
 *
 * @param newOffset
 *            the character offset into the original source string to set.
 *            Note that this is not an offset into the corresponding
 *            sequence of collation elements.
 */
public void setOffset(int newOffset) {
  this.icuIterator.setOffset(newOffset);
}

/**
 * Points the iterator at the collation element associated with the
 * character in the source string which is found at the supplied offset.
 * After this call completes, an invocation of the {@link #next()} method
 * will return this collation element.
 * <p>
 * If {@code newOffset} corresponds to a character which is part of a
 * sequence that maps to a single collation element then the iterator is
 * adjusted to the start of that sequence. As a result of this, any
 * subsequent call made to {@code getOffset()} may not return the same value
 * set by this method.
 * <p>
 * If the decomposition mode is on, and offset is in the middle of a
 * decomposable range of source text, the iterator may not return a correct
 * result for the next forwards or backwards iteration. The user must ensure
 * that the offset is not in the middle of a decomposable range.
 *
 * @param newOffset
 *            the character offset into the original source string to set.
 *            Note that this is not an offset into the corresponding
 *            sequence of collation elements.
 */
public void setOffset(int newOffset) {
  this.icuIterator.setOffset(newOffset);
}

/**
 * Points the iterator at the collation element associated with the
 * character in the source string which is found at the supplied offset.
 * After this call completes, an invocation of the {@link #next()} method
 * will return this collation element.
 * <p>
 * If {@code newOffset} corresponds to a character which is part of a
 * sequence that maps to a single collation element then the iterator is
 * adjusted to the start of that sequence. As a result of this, any
 * subsequent call made to {@code getOffset()} may not return the same value
 * set by this method.
 * <p>
 * If the decomposition mode is on, and offset is in the middle of a
 * decomposable range of source text, the iterator may not return a correct
 * result for the next forwards or backwards iteration. The user must ensure
 * that the offset is not in the middle of a decomposable range.
 *
 * @param newOffset
 *            the character offset into the original source string to set.
 *            Note that this is not an offset into the corresponding
 *            sequence of collation elements.
 */
public void setOffset(int newOffset) {
  this.icuIterator.setOffset(newOffset);
}

/**
 * Points the iterator at the collation element associated with the
 * character in the source string which is found at the supplied offset.
 * After this call completes, an invocation of the {@link #next()} method
 * will return this collation element.
 * <p>
 * If {@code newOffset} corresponds to a character which is part of a
 * sequence that maps to a single collation element then the iterator is
 * adjusted to the start of that sequence. As a result of this, any
 * subsequent call made to {@code getOffset()} may not return the same value
 * set by this method.
 * <p>
 * If the decomposition mode is on, and offset is in the middle of a
 * decomposable range of source text, the iterator may not return a correct
 * result for the next forwards or backwards iteration. The user must ensure
 * that the offset is not in the middle of a decomposable range.
 *
 * @param newOffset
 *            the character offset into the original source string to set.
 *            Note that this is not an offset into the corresponding
 *            sequence of collation elements.
 */
public void setOffset(int newOffset) {
  this.icuIterator.setOffset(newOffset);
}

/**
 * Points the iterator at the collation element associated with the
 * character in the source string which is found at the supplied offset.
 * After this call completes, an invocation of the {@link #next()} method
 * will return this collation element.
 * <p>
 * If {@code newOffset} corresponds to a character which is part of a
 * sequence that maps to a single collation element then the iterator is
 * adjusted to the start of that sequence. As a result of this, any
 * subsequent call made to {@code getOffset()} may not return the same value
 * set by this method.
 * <p>
 * If the decomposition mode is on, and offset is in the middle of a
 * decomposable range of source text, the iterator may not return a correct
 * result for the next forwards or backwards iteration. The user must ensure
 * that the offset is not in the middle of a decomposable range.
 *
 * @param newOffset
 *            the character offset into the original source string to set.
 *            Note that this is not an offset into the corresponding
 *            sequence of collation elements.
 */
public void setOffset(int newOffset) {
  this.icuIterator.setOffset(newOffset);
}

/**
 * Points the iterator at the collation element associated with the
 * character in the source string which is found at the supplied offset.
 * After this call completes, an invocation of the {@link #next()} method
 * will return this collation element.
 * <p>
 * If {@code newOffset} corresponds to a character which is part of a
 * sequence that maps to a single collation element then the iterator is
 * adjusted to the start of that sequence. As a result of this, any
 * subsequent call made to {@code getOffset()} may not return the same value
 * set by this method.
 * <p>
 * If the decomposition mode is on, and offset is in the middle of a
 * decomposable range of source text, the iterator may not return a correct
 * result for the next forwards or backwards iteration. The user must ensure
 * that the offset is not in the middle of a decomposable range.
 *
 * @param newOffset
 *            the character offset into the original source string to set.
 *            Note that this is not an offset into the corresponding
 *            sequence of collation elements.
 */
public void setOffset(int newOffset) {
  this.icuIterator.setOffset(newOffset);
}

Javadoc

Set the offset of the current source character. This is an offset into the text of the character to be processed.

Popular methods of CollationElementIteratorICU

<init>
getInstance
getMaxExpansion
Get the maximum length of any expansion sequences that end with the specified comparison order.
getOffset
Get the offset of the current source character. This is an offset into the text of the character con
next
Get the ordering priority of the next collation element in the text. A single character may contain
previous
Get the ordering priority of the previous collation element in the text. A single character may cont
primaryOrder
Gets the primary order of a collation order.
reset
Reset the collation elements to their initial state. This will move the 'cursor' to the beginning of
secondaryOrder
Gets the secondary order of a collation order.
setText
tertiaryOrder
Gets the tertiary order of a collation order.

tertiaryOrder

Popular in Java

Running tasks concurrently on multiple threads
putExtra (Intent)
scheduleAtFixedRate (Timer)
requestLocationUpdates (LocationManager)
Point (java.awt)
A point representing a location in (x,y) coordinate space, specified in integer precision.
IOException (java.io)
Signals a general, I/O-related error. Error details may be specified when calling the constructor, a
Path (java.nio.file)
SecureRandom (java.security)
This class generates cryptographically secure pseudo-random numbers. It is best to invoke SecureRand
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
Semaphore (java.util.concurrent)
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if

Best Java code snippets using libcore.icu.CollationElementIteratorICU.setOffset (Showing top 7 results out of 315)