CharArray.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.text;
 
import javolution.util.function.Equalities;
 
public final class CharArray implements CharSequence, Comparable<CharSequence> {
 
    private char[] _array;
 
    private int _offset;
 
    private int _length;
 
    public CharArray() {
        _array = NO_CHAR;
    }
 
    private static final char[] NO_CHAR = new char[0];
 
    public CharArray(int capacity) {
        _array = new char[capacity];
    }
 
    public CharArray(String string) {
        _array = string.toCharArray();
        _length = string.length();
    }
 
    public char[] array() {
        return _array;
    }
 
    public int length() {
        return _length;
    }
 
    public int offset() {
        return _offset;
    }
 
    public CharArray setArray(char[] array, int offset, int length) {
        _array = array;
        _offset = offset;
        _length = length;
        return this;
    }
 
    public final int indexOf(java.lang.CharSequence csq) {
        final char c = csq.charAt(0);
        final int csqLength = csq.length();
        for (int i = _offset, end = _offset + _length - csqLength + 1; i < end; i++) {
            if (_array[i] == c) { // Potential match.
                boolean match = true;
                for (int j = 1; j < csqLength; j++) {
                    if (_array[i + j] != csq.charAt(j)) {
                        match = false;
                        break;
                    }
                }
                if (match) { return i - _offset; }
            }
        }
        return -1;
    }
 
    public final int indexOf(char c) {
        for (int i = _offset, end = _offset + _length; i < end; i++) {
            if (_array[i] == c)
                return i - _offset;
        }
        return -1;
    }
 
    @Override
    public String toString() {
        return new String(_array, _offset, _length);
    }
 
    @Override
    public int hashCode() {
        int h = 0;
        for (int i = 0, j = _offset; i < _length; i++) {
            h = 31 * h + _array[j++];
        }
        return h;
    }
 
    @Override
    public boolean equals(Object that) {
        if (that instanceof String) {
            return equals((String) that);
        } else if (that instanceof CharArray) {
            return equals((CharArray) that);
        } else if (that instanceof java.lang.CharSequence) {
            return equals((java.lang.CharSequence) that);
        } else {
            return false;
        }
    }
 
    // Do not make public or String instances may not use equals(String)
    private boolean equals(java.lang.CharSequence chars) {
        if (chars == null)
            return false;
        if (this._length != chars.length())
            return false;
        for (int i = _length, j = _offset + _length; --i >= 0;) {
            if (_array[--j] != chars.charAt(i))
                return false;
        }
        return true;
    }
 
    public boolean equals(CharArray that) {
        if (this == that)
            return true;
        if (that == null)
            return false;
        if (this._length != that._length)
            return false;
        final char[] thatArray = that._array;
        for (int i = that._offset + _length, j = _offset + _length; --j >= _offset;) {
            if (_array[j] != thatArray[--i])
                return false;
        }
        return true;
    }
 
    public boolean equals(String str) {
        if (str == null)
            return false;
        if (_length != str.length())
            return false;
        for (int i = _length, j = _offset + _length; --i >= 0;) {
            if (_array[--j] != str.charAt(i))
                return false;
        }
        return true;
    }
 
    public int compareTo(CharSequence seq) {
        return Equalities.LEXICAL.compare(this, seq);
    }
 
    public boolean toBoolean() {
        return TypeFormat.parseBoolean(this);
    }
 
    public int toInt() {
        return TypeFormat.parseInt(this);
    }
 
    public int toInt(int radix) {
        return TypeFormat.parseInt(this, radix);
    }
 
    public long toLong() {
        return TypeFormat.parseLong(this);
    }
 
    public long toLong(int radix) {
        return TypeFormat.parseLong(this, radix);
    }
 
    public float toFloat() {
        return TypeFormat.parseFloat(this);
    }
 
    public double toDouble() {
        return TypeFormat.parseDouble(this);
    }
 
    // Implements CharSequence
    public char charAt(int index) {
        if ((index < 0) || (index >= _length))
            throw new IndexOutOfBoundsException("index: " + index);
        return _array[_offset + index];
    }
 
    // Implements CharSequence
    public java.lang.CharSequence subSequence(int start, int end) {
        if ((start < 0) || (end < 0) || (start > end) || (end > this.length()))
            throw new IndexOutOfBoundsException();
        CharArray chars = new CharArray();
        chars._array = _array;
        chars._offset = _offset + start;
        chars._length = end - start;
        return chars;
    }
 
    // Implements CharSequence
    public void getChars(int start, int end, char dest[], int destPos) {
        if ((start < 0) || (end < 0) || (start > end) || (end > _length))
            throw new IndexOutOfBoundsException();
        System.arraycopy(_array, start + _offset, dest, destPos, end - start);
    }
 
}