org.apache.lucene.analysis.tokenattributes

## Class CharTermAttributeImpl

- java.lang.Object
- - org.apache.lucene.util.AttributeImpl
  - - org.apache.lucene.analysis.tokenattributes.CharTermAttributeImpl

All Implemented Interfaces:
  Appendable, CharSequence, Cloneable, CharTermAttribute, TermToBytesRefAttribute, Attribute

Direct Known Subclasses:
  PackedTokenAttributeImpl

    public class CharTermAttributeImpl
    extends AttributeImpl
    implements CharTermAttribute, TermToBytesRefAttribute, Cloneable

Default implementation of `CharTermAttribute`.

### Field Summary

Fields
`protected BytesRefBuilder` `builder` May be used by subclasses to convert to different charsets / encodings for implementing `getBytesRef()`.

### Constructor Summary

Constructors
Constructor and Description
`CharTermAttributeImpl()` Initialize this attribute with empty term text

### Method Summary

All Methods Instance Methods Concrete Methods
`CharTermAttribute` `append(char c)`
`CharTermAttribute` `append(CharSequence csq)`
`CharTermAttribute` `append(CharSequence csq, int start, int end)`
`CharTermAttribute` `append(CharTermAttribute ta)` Appends the contents of the other `CharTermAttribute` to this character sequence.
`CharTermAttribute` `append(String s)` Appends the specified `String` to this character sequence.
`CharTermAttribute` `append(StringBuilder s)` Appends the specified `StringBuilder` to this character sequence.
`char[]` `buffer()` Returns the internal termBuffer character array which you can then directly alter.
`char` `charAt(int index)`
`void` `clear()` Clears the values in this AttributeImpl and resets it to its default value.
`CharTermAttributeImpl` `clone()` In most cases the clone is, and should be, deep in order to be able to properly capture the state of all attributes.
`void` `copyBuffer(char[] buffer, int offset, int length)` Copies the contents of buffer, starting at offset for length characters, into the termBuffer array.
`void` `copyTo(AttributeImpl target)` Copies the values from this Attribute into the passed-in target attribute.
`boolean` `equals(Object other)`
`BytesRef` `getBytesRef()` Retrieve this attribute's BytesRef.
`int` `hashCode()`
`int` `length()`
`void` `reflectWith(AttributeReflector reflector)` This method is for introspection of attributes, it should simply add the key/values this attribute holds to the given `AttributeReflector`.
`char[]` `resizeBuffer(int newSize)` Grows the termBuffer to at least size newSize, preserving the existing content.
`CharTermAttribute` `setEmpty()` Sets the length of the termBuffer to zero.
`CharTermAttribute` `setLength(int length)` Set number of valid characters (length of the term) in the termBuffer array.
`CharSequence` `subSequence(int start, int end)`
`String` `toString()` Returns solely the term text as specified by the `CharSequence` interface.

### Methods inherited from class org.apache.lucene.util.AttributeImpl

`end, reflectAsString`

### Methods inherited from class java.lang.Object

`finalize, getClass, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface java.lang.CharSequence

`chars, codePoints`

### Field Detail

#### builder

    protected BytesRefBuilder builder

May be used by subclasses to convert to different charsets / encodings for implementing `getBytesRef()`.

### Constructor Detail

#### CharTermAttributeImpl

    public CharTermAttributeImpl()

Initialize this attribute with empty term text

### Method Detail

#### copyBuffer

    public final void copyBuffer(char[] buffer,
                                 int offset,
                                 int length)

Description copied from interface: `CharTermAttribute`
Copies the contents of buffer, starting at offset for length characters, into the termBuffer array.

Specified by:
  `copyBuffer` in interface `CharTermAttribute`
Parameters:
  `buffer` - the buffer to copy
  `offset` - the index in the buffer of the first character to copy
  `length` - the number of characters to copy

#### buffer

    public final char[] buffer()

Description copied from interface: `CharTermAttribute`
Returns the internal termBuffer character array which you can then directly alter. If the array is too small for your token, use `CharTermAttribute.resizeBuffer(int)` to increase it. After altering the buffer be sure to call `CharTermAttribute.setLength(int)` to record the number of valid characters that were placed into the termBuffer.

NOTE: The returned buffer may be larger than the valid `CharSequence.length()`.

Specified by:
  `buffer` in interface `CharTermAttribute`

#### resizeBuffer

    public final char[] resizeBuffer(int newSize)

Description copied from interface: `CharTermAttribute`
Grows the termBuffer to at least size newSize, preserving the existing content.

Specified by:
  `resizeBuffer` in interface `CharTermAttribute`
Parameters:
  `newSize` - minimum size of the new termBuffer
Returns:
  newly created termBuffer with `length >= newSize`

#### setLength

    public final CharTermAttribute setLength(int length)

Description copied from interface: `CharTermAttribute`
Set number of valid characters (length of the term) in the termBuffer array. Use this to truncate the termBuffer or to synchronize with external manipulation of the termBuffer. Note: to grow the size of the array, use `CharTermAttribute.resizeBuffer(int)` first.

Specified by:
  `setLength` in interface `CharTermAttribute`
Parameters:
  `length` - the truncated length

#### setEmpty

    public final CharTermAttribute setEmpty()

Description copied from interface: `CharTermAttribute`
Sets the length of the termBuffer to zero. Use this method before appending contents using the `Appendable` interface.

Specified by:
  `setEmpty` in interface `CharTermAttribute`

#### getBytesRef

    public BytesRef getBytesRef()

Description copied from interface: `TermToBytesRefAttribute`
Retrieve this attribute's BytesRef. The bytes are updated from the current term. The implementation may return a new instance or keep the previous one.

Specified by:
  `getBytesRef` in interface `TermToBytesRefAttribute`
Returns:
  a BytesRef to be indexed (only stays valid until token stream gets incremented)

#### length

    public final int length()

Specified by:
  `length` in interface `CharSequence`

#### charAt

    public final char charAt(int index)

Specified by:
  `charAt` in interface `CharSequence`

#### subSequence

    public final CharSequence subSequence(int start,
                                          int end)

Specified by:
  `subSequence` in interface `CharSequence`

#### append

    public final CharTermAttribute append(CharSequence csq)

Specified by:
  `append` in interface `Appendable`
Specified by:
  `append` in interface `CharTermAttribute`

#### append

    public final CharTermAttribute append(CharSequence csq,
                                          int start,
                                          int end)

Specified by:
  `append` in interface `Appendable`
Specified by:
  `append` in interface `CharTermAttribute`

#### append

    public final CharTermAttribute append(char c)

Specified by:
  `append` in interface `Appendable`
Specified by:
  `append` in interface `CharTermAttribute`

#### append

    public final CharTermAttribute append(String s)

Description copied from interface: `CharTermAttribute`
Appends the specified `String` to this character sequence.

The characters of the `String` argument are appended, in order, increasing the length of this sequence by the length of the argument. If argument is `null`, then the four characters `"null"` are appended.

Specified by:
  `append` in interface `CharTermAttribute`

#### append

    public final CharTermAttribute append(StringBuilder s)

Description copied from interface: `CharTermAttribute`
Appends the specified `StringBuilder` to this character sequence.

The characters of the `StringBuilder` argument are appended, in order, increasing the length of this sequence by the length of the argument. If argument is `null`, then the four characters `"null"` are appended.

Specified by:
  `append` in interface `CharTermAttribute`

#### append

    public final CharTermAttribute append(CharTermAttribute ta)

Description copied from interface: `CharTermAttribute`
Appends the contents of the other `CharTermAttribute` to this character sequence.

The characters of the `CharTermAttribute` argument are appended, in order, increasing the length of this sequence by the length of the argument. If argument is `null`, then the four characters `"null"` are appended.

Specified by:
  `append` in interface `CharTermAttribute`

#### hashCode

    public int hashCode()

Overrides:
  `hashCode` in class `Object`

#### clear

    public void clear()

Description copied from class: `AttributeImpl`
Clears the values in this AttributeImpl and resets it to its default value. If this implementation implements more than one Attribute interface it clears all.

Specified by:
  `clear` in class `AttributeImpl`

#### clone

    public CharTermAttributeImpl clone()

Description copied from class: `AttributeImpl`
In most cases the clone is, and should be, deep in order to be able to properly capture the state of all attributes.

Overrides:
  `clone` in class `AttributeImpl`

#### equals

    public boolean equals(Object other)

Overrides:
  `equals` in class `Object`

#### toString

    public String toString()

Returns solely the term text as specified by the `CharSequence` interface.

Specified by:
  `toString` in interface `CharSequence`
Overrides:
  `toString` in class `Object`

#### reflectWith

    public void reflectWith(AttributeReflector reflector)

Description copied from class: `AttributeImpl`
This method is for introspection of attributes, it should simply add the key/values this attribute holds to the given `AttributeReflector`.

Implementations look like this (e.g. for a combined attribute implementation):

       public void reflectWith(AttributeReflector reflector) {
         reflector.reflect(CharTermAttribute.class, "term", term());
         reflector.reflect(PositionIncrementAttribute.class, "positionIncrement", getPositionIncrement());
       }

If you implement this method, make sure that for each invocation, the same set of `Attribute` interfaces and keys are passed to `AttributeReflector.reflect(java.lang.Class<? extends org.apache.lucene.util.Attribute>, java.lang.String, java.lang.Object)` in the same order, but possibly different values. So don't automatically exclude e.g. `null` properties!

Specified by:
  `reflectWith` in class `AttributeImpl`
See Also:
  `AttributeImpl.reflectAsString(boolean)`

#### copyTo

    public void copyTo(AttributeImpl target)

Description copied from class: `AttributeImpl`
Copies the values from this Attribute into the passed-in target attribute. The target implementation must support all the Attributes this implementation supports.

Specified by:
  `copyTo` in class `AttributeImpl`