https://openjdk.java.net/ 
/*
 * Copyright (c) 1996, 2019, 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:
Since:1.1
/**
 * {@code FieldPosition} is a simple class used by {@code Format}
 * 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}. The constants are defined in the various
 *      subclasses of {@code Format}.
 *  <li>By a {@code Format.Field} constant, see {@code ERA_FIELD}
 *      and its friends in {@code DateFormat} for an example.
 * </ul>
 * <p>
 * {@code 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.
 *
 * <p>
 * One version of the {@code format} method in the various
 * {@code Format} classes requires a {@code FieldPosition}
 * object as an argument. You use this {@code format} 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} method
 * {@code formatToCharacterIterator}.
 *
 * @author      Mark Davis
 * @since 1.1
 * @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.

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

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

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

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

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

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

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

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

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

Params:
  • ei – the end index
Since:1.2
/**
     * Sets the end index.  For use by subclasses of Format.
     *
     * @param ei the end index
     * @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} 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} value and
     * {@code attribute} 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} value and
     * {@code attribute} is equal to it, or true if the receiver
     * represents an inteter constant and {@code field} 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} 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);
            }
        }
    }
}