charbuffer.java

java 的源代码

package com.reddragon2046.base.utilities.data.adapters;

import com.reddragon2046.base.utilities.data.*;
import java.util.Iterator;
import java.util.NoSuchElementException;

// Referenced classes of package com.reddragon2046.base.utilities.data.adapters:
//            AbstractArrayAdapter, CharArray, CharIterator, AbstractArrayIterator,
//            Algorithms

public class CharBuffer extends AbstractArrayAdapter
{

    public CharBuffer()
    {
        clear();
    }

    public CharBuffer(int size)
    {
        if(size < 0)
        {
            throw new IllegalArgumentException("Attempt to create an CharBuffer with a negative size");
        } else
        {
            m_length = size;
            m_storage = new char[m_length];
            return;
        }
    }

    public CharBuffer(int size, char object)
    {
        this(size);
        for(int i = 0; i < m_length; i++)
            m_storage[i] = object;

    }

    public CharBuffer(char array[])
    {
        this(array, true);
    }

    CharBuffer(char array[], boolean copyBuffer)
    {
        synchronized(array)
        {
            m_length = array.length;
            if(copyBuffer)
            {
                m_storage = new char[m_length];
                System.arraycopy(array, 0, m_storage, 0, m_length);
            } else
            {
                m_storage = array;
            }
        }
    }

    public CharBuffer(CharBuffer array)
    {
        this(array.m_storage, true);
        m_length = array.m_length;
    }

    public synchronized Object clone()
    {
        return new CharBuffer(this);
    }

    public boolean equals(Object object)
    {
        return (object instanceof CharBuffer) && equals((CharBuffer)object) || (object instanceof CharArray) && equals((CharArray)object);
    }

    public synchronized boolean equals(CharBuffer buffer)
    {
        return CharArray.sliceEquals(m_storage, m_length, buffer.m_storage, buffer.m_length);
    }

    public boolean equals(CharArray array)
    {
        return equals(array.array);
    }

    public synchronized boolean equals(char array[])
    {
        return CharArray.sliceEquals(m_storage, m_length, array, array.length);
    }

    public synchronized String toString()
    {
        return Algorithms.Printing.toString(this, "CharBuffer");
    }

    public synchronized void copy(CharBuffer buffer)
    {
        if(this == buffer)
            return;
        synchronized(buffer)
        {
            if(buffer.m_length > m_storage.length)
            {
                m_storage = buffer.get();
            } else
            {
                System.arraycopy(buffer.m_storage, 0, m_storage, 0, buffer.m_length);
                for(int i = buffer.m_length; i < m_length; i++)
                    m_storage[i] = '\0';

            }
            m_length = buffer.m_length;
        }
    }

    public synchronized void copyTo(char array[])
    {
        synchronized(array)
        {
            System.arraycopy(m_storage, 0, array, 0, Math.min(m_length, array.length));
        }
    }

    public synchronized char[] get()
    {
        char data[] = new char[m_length];
        copyTo(data);
        return data;
    }

    public synchronized int hashCode()
    {
        return Algorithms.Hashing.orderedHash(begin(), m_length);
    }

    public int size()
    {
        return m_length;
    }

    public int capacity()
    {
        return m_storage.length;
    }

    public int maxSize()
    {
        return 0x7fffffff;
    }

    public Object get(int index)
    {
        return new Character(charAt(index));
    }

    public synchronized char charAt(int index)
    {
        AbstractArrayAdapter.checkIndex(index, m_length);
        return m_storage[index];
    }

    public synchronized void put(int index, Object object)
    {
        put(index, asChar(object));
    }

    public synchronized void put(int index, char object)
    {
        AbstractArrayAdapter.checkIndex(index, m_length);
        m_storage[index] = object;
    }

    public synchronized void clear()
    {
        m_storage = new char[10];
        m_length = 0;
    }

    public synchronized Object remove(int index)
    {
        AbstractArrayAdapter.checkIndex(index, m_length);
        Object retval = new Character(m_storage[index]);
        System.arraycopy(m_storage, index + 1, m_storage, index, m_length - index - 1);
        m_storage[--m_length] = '\0';
        return retval;
    }

    public synchronized int remove(int first, int last)
    {
        if(last < first)
            return 0;
        AbstractArrayAdapter.checkRange(first, last, m_length);
        int amount = (last - first) + 1;
        System.arraycopy(m_storage, last + 1, m_storage, first, m_length - last - 1);
        for(int i = m_length - amount; i < m_length; i++)
            m_storage[i] = '\0';

        m_length -= amount;
        return amount;
    }

    public synchronized Object popBack()
    {
        if(m_length == 0)
        {
            throw new NoSuchElementException("CharBuffer is empty");
        } else
        {
            Object r = new Character(m_storage[--m_length]);
            m_storage[m_length] = '\0';
            return r;
        }
    }

    public synchronized boolean add(Object object)
    {
        add(asChar(object));
        return true;
    }

    public synchronized void add(char object)
    {
        if(m_length == m_storage.length)
        {
            char tmp[] = getNextStorage(1);
            copyTo(tmp);
            m_storage = tmp;
        }
        m_storage[m_length++] = object;
    }

    public void pushBack(Object object)
    {
        add(asChar(object));
    }

    public void pushBack(char object)
    {
        add(object);
    }

    public CharIterator insert(CharIterator pos, Object object)
    {
        return insert(pos, asChar(object));
    }

    public CharIterator insert(CharIterator pos, char object)
    {
        insert(pos.getInternalIndex(), object);
        return new CharIterator(this, pos.getInternalIndex());
    }

    public void insert(int index, Object object)
    {
        insert(index, asChar(object));
    }

    public synchronized void insert(int index, char object)
    {
        AbstractArrayAdapter.checkIndex(index, m_length + 1);
        if(m_length != m_storage.length)
        {
            if(index != m_length)
                System.arraycopy(m_storage, index, m_storage, index + 1, m_length - index);
        } else
        {
            char tmp[] = getNextStorage(1);
            System.arraycopy(m_storage, 0, tmp, 0, index);
            System.arraycopy(m_storage, index, tmp, index + 1, m_length - index);
            m_storage = tmp;
        }
        m_storage[index] = object;
        m_length++;
    }

    public void insert(CharIterator pos, int n, Object object)
    {
        insert(pos, n, asChar(object));
    }

    public void insert(CharIterator pos, int n, char object)
    {
        insert(pos.getInternalIndex(), n, object);
    }

    public void insert(int index, int n, Object object)
    {
        insert(index, n, asChar(object));
    }

    public synchronized void insert(int index, int n, char object)
    {
        if(n < 0)
            throw new IllegalArgumentException("Attempt to insert a negative number of objects.");
        if(n == 0)
            return;
        AbstractArrayAdapter.checkIndex(index, m_length + 1);
        if(m_storage.length - m_length >= n)
        {
            System.arraycopy(m_storage, index, m_storage, index + n, m_length - index);
        } else
        {
            char tmp[] = getNextStorage(n);
            System.arraycopy(m_storage, 0, tmp, 0, index);
            System.arraycopy(m_storage, index, tmp, index + n, m_length - index);
            m_storage = tmp;
        }
        for(int i = index; i < index + n; i++)
            m_storage[i] = object;

        m_length += n;
    }

    public void insert(CharIterator pos, ForwardIterator first, ForwardIterator last)
    {
        insert(pos.getInternalIndex(), first, last);
    }

    public synchronized void insert(int index, ForwardIterator first, ForwardIterator last)
    {
        int n = first.distance(last);
        if(n == 0)
            return;
        ForwardIterator firstx = (ForwardIterator)first.clone();
        if(m_storage.length - m_length >= n)
        {
            System.arraycopy(m_storage, index, m_storage, index + n, m_length - index);
        } else
        {
            char tmp[] = getNextStorage(n);
            System.arraycopy(m_storage, 0, tmp, 0, index);
            System.arraycopy(m_storage, index, tmp, index + n, m_length - index);
            m_storage = tmp;
        }
        m_length += n;
        for(int i = index; i < index + n; i++)
            put(i, firstx.next());

    }

    public synchronized void swap(CharBuffer array)
    {
        synchronized(array)
        {
            int oldLength = m_length;
            char oldStorage[] = m_storage;
            m_length = array.m_length;
            m_storage = array.m_storage;
            array.m_length = oldLength;
            array.m_storage = oldStorage;
        }
    }

    public Iterator iterator()
    {
        return begin();
    }

    public ForwardIterator start()
    {
        return begin();
    }

    public ForwardIterator finish()
    {
        return end();
    }

    public synchronized BidirectionalIterator begin()
    {
        return new CharIterator(this, 0);
    }

    public synchronized BidirectionalIterator end()
    {
        return new CharIterator(this, m_length);
    }

    public synchronized void trimToSize()
    {
        if(m_length < m_storage.length)
            m_storage = get();
    }

    public synchronized void ensureCapacity(int n)
    {
        if(n < 0)
            throw new IllegalArgumentException("Attempt to reserve a negative size.");
        if(m_storage.length < n)
        {
            char tmp[] = new char[n];
            if(m_length > 0)
                System.arraycopy(m_storage, 0, tmp, 0, m_length);
            m_storage = tmp;
        }
    }

    public synchronized Object popFront()
    {
        if(m_length == 0)
        {
            throw new NoSuchElementException("CharBuffer is empty");
        } else
        {
            Object result = new Character(m_storage[0]);
            remove(0);
            return result;
        }
    }

    public void pushFront(Object object)
    {
        insert(0, object);
    }

    public void pushFront(char object)
    {
        insert(0, object);
    }

    public synchronized int remove(Object object, int count)
    {
        char tmp = asChar(object);
        int removed = 0;
        while(count > 0)
        {
            int i = indexOf(tmp);
            if(i < 0)
                break;
            count--;
            removed++;
            remove(i);
        }
        return removed;
    }

    public synchronized int remove(int first, int last, Object object)
    {
        asChar(object);
        if(last < first)
        {
            return 0;
        } else
        {
            AbstractArrayAdapter.checkRange(first, last, m_length);
            CharIterator firstx = new CharIterator(this, first);
            CharIterator lastx = new CharIterator(this, last + 1);
            CharIterator finish = (CharIterator)Algorithms.Removing.remove(firstx, lastx, object);
            return remove(finish.getInternalIndex(), last);
        }
    }

    public int replace(Object oldValue, Object newValue)
    {
        return replace(asChar(oldValue), asChar(newValue));
    }

    public int replace(char oldValue, char newValue)
    {
        return replace(0, m_length, oldValue, newValue);
    }

    public int replace(int first, int last, Object oldValue, Object newValue)
    {
        return replace(first, last, asChar(oldValue), asChar(newValue));
    }

    public synchronized int replace(int first, int last, char oldValue, char newValue)
    {
        AbstractArrayAdapter.checkRange(first, last - 1, m_length);
        int n = 0;
        for(; first < last; first++)
            if(m_storage[first] == oldValue)
            {
                m_storage[first] = newValue;
                n++;
            }

        return n;
    }

    public int count(Object object)
    {
        return count(asChar(object));
    }

    public int count(char object)
    {
        return count(0, m_length - 1, object);
    }

    public int count(int first, int last, Object object)
    {
        return count(first, last, asChar(object));
    }

    public synchronized int count(int first, int last, char object)
    {
        AbstractArrayAdapter.checkRange(first, last, m_length);
        int n = 0;
        for(; first < last; first++)
            if(m_storage[first] == object)
                n++;

        return n;
    }

    public int indexOf(Object object)
    {
        return indexOf(asChar(object));
    }

    public int indexOf(char object)
    {
        return indexOf(0, m_length - 1, object);
    }

    public int indexOf(int first, int last, Object object)
    {
        return indexOf(first, last, asChar(object));
    }

    public synchronized int indexOf(int first, int last, char object)
    {
        if(last < first)
            return -1;
        AbstractArrayAdapter.checkRange(first, last, m_length);
        for(; first <= last; first++)
            if(m_storage[first] == object)
                return first;

        return -1;
    }

    public void setSize(int newSize)
    {
        if(newSize < 0)
            throw new IllegalArgumentException("Attempt to become a negative size.");
        if(m_length > newSize)
            remove(newSize, m_length - 1);
        else
        if(m_length < newSize)
            insert(m_length, newSize - m_length, '\0');
    }

    public boolean contains(Object object)
    {
        return contains(asChar(object));
    }

    public boolean contains(char object)
    {
        return indexOf(object) != -1;
    }

    private char[] getNextStorage(int n)
    {
        int newSize = Math.max(AbstractArrayAdapter.getNextSize(m_length), m_length + n);
        char tmp[] = new char[newSize];
        return tmp;
    }

    static char asChar(Object object)
    {
        return ((Character)object).charValue();
    }

    static final char DEFAULT_VALUE = 0;
    char m_storage[];
    int m_length;
    static final long serialVersionUID = 0xf547256c4bc6896eL;
}