https://openjdk.java.net/ 
/*
 * Copyright (c) 1996, 2002, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * (C) Copyright Taligent, Inc. 1996 - All Rights Reserved
 * (C) Copyright IBM Corp. 1996 - All Rights Reserved
 *
 *   The original version of this source code and documentation is copyrighted
 * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
 * materials are provided under terms of a License Agreement between Taligent
 * and Sun. This technology is protected by multiple US and International
 * patents. This notice and attribution to Taligent may not be removed.
 *   Taligent is a registered trademark of Taligent, Inc.
 *
 */

package java.text;


FieldPosition is a simple class used by Format
and its subclasses to identify fields in formatted output. Fields can
be identified in two ways:

    
 
  • By an integer constant, whose names typically end with
     _FIELD. The constants are defined in the various
     subclasses of Format.
 
  • By a Format.Field constant, see ERA_FIELD
     and its friends in DateFormat for an example.




FieldPosition keeps track of the position of the
field within the formatted output with two indices: the index
of the first character of the field and the index of the last
character of the field.


One version of the format method in the various
Format classes requires a FieldPosition
object as an argument. You use this format method
to perform partial formatting or to get information about the
formatted output (such as the position of a field).


If you are interested in the positions of all attributes in the
formatted string use the Format method
formatToCharacterIterator.

Author:     Mark Davis
See Also:
/**
 * <code>FieldPosition</code> is a simple class used by <code>Format</code>
 * and its subclasses to identify fields in formatted output. Fields can
 * be identified in two ways:
 * <ul>
 *  <li>By an integer constant, whose names typically end with
 *      <code>_FIELD</code>. The constants are defined in the various
 *      subclasses of <code>Format</code>.
 *  <li>By a <code>Format.Field</code> constant, see <code>ERA_FIELD</code>
 *      and its friends in <code>DateFormat</code> for an example.
 * </ul>
 * <p>
 * <code>FieldPosition</code> keeps track of the position of the
 * field within the formatted output with two indices: the index
 * of the first character of the field and the index of the last
 * character of the field.
 *
 * <p>
 * One version of the <code>format</code> method in the various
 * <code>Format</code> classes requires a <code>FieldPosition</code>
 * object as an argument. You use this <code>format</code> method
 * to perform partial formatting or to get information about the
 * formatted output (such as the position of a field).
 *
 * <p>
 * If you are interested in the positions of all attributes in the
 * formatted string use the <code>Format</code> method
 * <code>formatToCharacterIterator</code>.
 *
 * @author      Mark Davis
 * @see         java.text.Format
 */
public class FieldPosition {

    
Input: Desired field to determine start and end offsets for.
The meaning depends on the subclass of Format.

/**
     * Input: Desired field to determine start and end offsets for.
     * The meaning depends on the subclass of Format.
     */
    int field = 0;

    
Output: End offset of field in text.
If the field does not occur in the text, 0 is returned.

/**
     * Output: End offset of field in text.
     * If the field does not occur in the text, 0 is returned.
     */
    int endIndex = 0;

    
Output: Start offset of field in text.
If the field does not occur in the text, 0 is returned.

/**
     * Output: Start offset of field in text.
     * If the field does not occur in the text, 0 is returned.
     */
    int beginIndex = 0;

    
Desired field this FieldPosition is for.

/**
     * Desired field this FieldPosition is for.
     */
    private Format.Field attribute;

    
Creates a FieldPosition object for the given field.  Fields are
identified by constants, whose names typically end with _FIELD,
in the various subclasses of Format.

See Also:
/**
     * Creates a FieldPosition object for the given field.  Fields are
     * identified by constants, whose names typically end with _FIELD,
     * in the various subclasses of Format.
     *
     * @see java.text.NumberFormat#INTEGER_FIELD
     * @see java.text.NumberFormat#FRACTION_FIELD
     * @see java.text.DateFormat#YEAR_FIELD
     * @see java.text.DateFormat#MONTH_FIELD
     */
    public FieldPosition(int field) {
        this.field = field;
    }

    
Creates a FieldPosition object for the given field constant. Fields are
identified by constants defined in the various Format
subclasses. This is equivalent to calling
new FieldPosition(attribute, -1).

Params:
  • attribute – Format.Field constant identifying a field
Since:1.4
/**
     * Creates a FieldPosition object for the given field constant. Fields are
     * identified by constants defined in the various <code>Format</code>
     * subclasses. This is equivalent to calling
     * <code>new FieldPosition(attribute, -1)</code>.
     *
     * @param attribute Format.Field constant identifying a field
     * @since 1.4
     */
    public FieldPosition(Format.Field attribute) {
        this(attribute, -1);
    }

    
Creates a FieldPosition object for the given field.
The field is identified by an attribute constant from one of the
Field subclasses as well as an integer field ID
defined by the Format subclasses. Format
subclasses that are aware of Field should give precedence
to attribute and ignore fieldID if
attribute is not null. However, older Format
subclasses may not be aware of Field and rely on
fieldID. If the field has no corresponding integer
constant, fieldID should be -1.

Params:
  • attribute – Format.Field constant identifying a field
  • fieldID – integer constantce identifying a field
Since:1.4
/**
     * Creates a <code>FieldPosition</code> object for the given field.
     * The field is identified by an attribute constant from one of the
     * <code>Field</code> subclasses as well as an integer field ID
     * defined by the <code>Format</code> subclasses. <code>Format</code>
     * subclasses that are aware of <code>Field</code> should give precedence
     * to <code>attribute</code> and ignore <code>fieldID</code> if
     * <code>attribute</code> is not null. However, older <code>Format</code>
     * subclasses may not be aware of <code>Field</code> and rely on
     * <code>fieldID</code>. If the field has no corresponding integer
     * constant, <code>fieldID</code> should be -1.
     *
     * @param attribute Format.Field constant identifying a field
     * @param fieldID integer constantce identifying a field
     * @since 1.4
     */
    public FieldPosition(Format.Field attribute, int fieldID) {
        this.attribute = attribute;
        this.field = fieldID;
    }

    
Returns the field identifier as an attribute constant
from one of the Field subclasses. May return null if
the field is specified only by an integer field ID.

Returns:Identifier for the field
Since:1.4
/**
     * Returns the field identifier as an attribute constant
     * from one of the <code>Field</code> subclasses. May return null if
     * the field is specified only by an integer field ID.
     *
     * @return Identifier for the field
     * @since 1.4
     */
    public Format.Field getFieldAttribute() {
        return attribute;
    }

    
Retrieves the field identifier.

/**
     * Retrieves the field identifier.
     */
    public int getField() {
        return field;
    }

    
Retrieves the index of the first character in the requested field.

/**
     * Retrieves the index of the first character in the requested field.
     */
    public int getBeginIndex() {
        return beginIndex;
    }

    
Retrieves the index of the character following the last character in the
requested field.

/**
     * Retrieves the index of the character following the last character in the
     * requested field.
     */
    public int getEndIndex() {
        return endIndex;
    }

    
Sets the begin index.  For use by subclasses of Format.

Since:1.2
/**
     * Sets the begin index.  For use by subclasses of Format.
     * @since 1.2
     */
    public void setBeginIndex(int bi) {
        beginIndex = bi;
    }

    
Sets the end index.  For use by subclasses of Format.

Since:1.2
/**
     * Sets the end index.  For use by subclasses of Format.
     * @since 1.2
     */
    public void setEndIndex(int ei) {
        endIndex = ei;
    }

    
Returns a Format.FieldDelegate instance that is associated
with the FieldPosition. When the delegate is notified of the same
field the FieldPosition is associated with, the begin/end will be
adjusted.

/**
     * Returns a <code>Format.FieldDelegate</code> instance that is associated
     * with the FieldPosition. When the delegate is notified of the same
     * field the FieldPosition is associated with, the begin/end will be
     * adjusted.
     */
    Format.FieldDelegate getFieldDelegate() {
        return new Delegate();
    }

    
Overrides equals

/**
     * Overrides equals
     */
    public boolean equals(Object obj)
    {
        if (obj == null) return false;
        if (!(obj instanceof FieldPosition))
            return false;
        FieldPosition other = (FieldPosition) obj;
        if (attribute == null) {
            if (other.attribute != null) {
                return false;
            }
        }
        else if (!attribute.equals(other.attribute)) {
            return false;
        }
        return (beginIndex == other.beginIndex
            && endIndex == other.endIndex
            && field == other.field);
    }

    
Returns a hash code for this FieldPosition.

Returns:a hash code value for this object
/**
     * Returns a hash code for this FieldPosition.
     * @return a hash code value for this object
     */
    public int hashCode() {
        return (field << 24) | (beginIndex << 16) | endIndex;
    }

    
Return a string representation of this FieldPosition.

Returns: a string representation of this object
/**
     * Return a string representation of this FieldPosition.
     * @return  a string representation of this object
     */
    public String toString() {
        return getClass().getName() +
            "[field=" + field + ",attribute=" + attribute +
            ",beginIndex=" + beginIndex +
            ",endIndex=" + endIndex + ']';
    }


    
Return true if the receiver wants a Format.Field value and
attribute is equal to it.

/**
     * Return true if the receiver wants a <code>Format.Field</code> value and
     * <code>attribute</code> is equal to it.
     */
    private boolean matchesField(Format.Field attribute) {
        if (this.attribute != null) {
            return this.attribute.equals(attribute);
        }
        return false;
    }

    
Return true if the receiver wants a Format.Field value and
attribute is equal to it, or true if the receiver
represents an inteter constant and field equals it.

/**
     * Return true if the receiver wants a <code>Format.Field</code> value and
     * <code>attribute</code> is equal to it, or true if the receiver
     * represents an inteter constant and <code>field</code> equals it.
     */
    private boolean matchesField(Format.Field attribute, int field) {
        if (this.attribute != null) {
            return this.attribute.equals(attribute);
        }
        return (field == this.field);
    }


    
An implementation of FieldDelegate that will adjust the begin/end
of the FieldPosition if the arguments match the field of
the FieldPosition.

/**
     * An implementation of FieldDelegate that will adjust the begin/end
     * of the FieldPosition if the arguments match the field of
     * the FieldPosition.
     */
    private class Delegate implements Format.FieldDelegate {
        
Indicates whether the field has been  encountered before. If this
is true, and formatted is invoked, the begin/end
are not updated.

/**
         * Indicates whether the field has been  encountered before. If this
         * is true, and <code>formatted</code> is invoked, the begin/end
         * are not updated.
         */
        private boolean encounteredField;

        public void formatted(Format.Field attr, Object value, int start,
                              int end, StringBuffer buffer) {
            if (!encounteredField && matchesField(attr)) {
                setBeginIndex(start);
                setEndIndex(end);
                encounteredField = (start != end);
            }
        }

        public void formatted(int fieldID, Format.Field attr, Object value,
                              int start, int end, StringBuffer buffer) {
            if (!encounteredField && matchesField(attr, fieldID)) {
                setBeginIndex(start);
                setEndIndex(end);
                encounteredField = (start != end);
            }
        }
    }
}