abstractozonecollection.java

Java的面向对象数据库系统的源代码

     * the Iterator's remove method does). After the first element has been
     * removed, true is returned; if the end of the collection is reached, false
     * is returned.
     *
     * @param o the object to remove from this collection
     * @return true if the remove operation caused the Collection to change, or
     *         equivalently if the collection did contain o.
     * @throws UnsupportedOperationException if this collection's Iterator
     *         does not support the remove method
     * @see Iterator#remove()
     */
    public boolean remove(Object o) {
        Iterator itr = _org_ozoneDB_internalIterator();
        int pos = size();
        while (--pos >= 0)
            if (equals(o, itr.next())) {
                itr.remove();
                return true;
            }
        return false;
    }
    
    /**
     * Remove from this collection all its elements that are contained in a given
     * collection (optional operation). This implementation iterates over this
     * collection, and for each element tests if it is contained in the given
     * collection. If so, it is removed by the Iterator's remove method (thus
     * this method will fail with an UnsupportedOperationException if the
     * Iterator's remove method does).
     *
     * @param c the collection to remove the elements of
     * @return true if the remove operation caused the Collection to change
     * @throws UnsupportedOperationException if this collection's Iterator
     *         does not support the remove method
     * @see Iterator#remove()
     */
    public boolean removeAll(Collection c) {
        return removeAllInternal(c);
    }
    
    /**
     * Remove from this collection all its elements that are contained in a given
     * collection (optional operation). This implementation iterates over this
     * collection, and for each element tests if it is contained in the given
     * collection. If so, it is removed by the Iterator's remove method (thus
     * this method will fail with an UnsupportedOperationException if the
     * Iterator's remove method does). This method is necessary for ArrayList,
     * which cannot publicly override removeAll but can optimize this call.
     *
     * @param c the collection to remove the elements of
     * @return true if the remove operation caused the Collection to change
     * @throws UnsupportedOperationException if this collection's Iterator
     *         does not support the remove method
     * @see Iterator#remove()
     */
    boolean removeAllInternal(Collection c) {
        Iterator itr;
        if (c instanceof OzoneCollection) {
            itr = ((OzoneCollection) c)._org_ozoneDB_internalIterator();
        } else {
            itr = c.iterator();
        }
        boolean modified = false;
        int pos = size();
        while (--pos >= 0)
            if (c.contains(itr.next())) {
                itr.remove();
                modified = true;
            }
        return modified;
    }
    
    /**
     * Remove from this collection all its elements that are not contained in a
     * given collection (optional operation). This implementation iterates over
     * this collection, and for each element tests if it is contained in the
     * given collection. If not, it is removed by the Iterator's remove method
     * (thus this method will fail with an UnsupportedOperationException if
     * the Iterator's remove method does).
     *
     * @param c the collection to retain the elements of
     * @return true if the remove operation caused the Collection to change
     * @throws UnsupportedOperationException if this collection's Iterator
     *         does not support the remove method
     * @see Iterator#remove()
     */
    public boolean retainAll(Collection c) {
        return retainAllInternal(c);
    }
    
    /**
     * Remove from this collection all its elements that are not contained in a
     * given collection (optional operation). This implementation iterates over
     * this collection, and for each element tests if it is contained in the
     * given collection. If not, it is removed by the Iterator's remove method
     * (thus this method will fail with an UnsupportedOperationException if
     * the Iterator's remove method does). This method is necessary for
     * ArrayList, which cannot publicly override retainAll but can optimize
     * this call.
     *
     * @param c the collection to retain the elements of
     * @return true if the remove operation caused the Collection to change
     * @throws UnsupportedOperationException if this collection's Iterator
     *         does not support the remove method
     * @see Iterator#remove()
     */
    boolean retainAllInternal(Collection c) {
        Iterator itr;
        if (c instanceof OzoneCollection) {
            itr = ((OzoneCollection) c)._org_ozoneDB_internalIterator();
        } else {
            itr = c.iterator();
        }
        boolean modified = false;
        int pos = size();
        while (--pos >= 0)
            if (!c.contains(itr.next())) {
                itr.remove();
                modified = true;
            }
        return modified;
    }
    
    /**
     * Return an array containing the elements of this collection. This
     * implementation creates an Object array of size size() and then iterates
     * over the collection, setting each element of the array from the value
     * returned by the iterator. The returned array is safe, and is not backed
     * by the collection.
     *
     * @return an array containing the elements of this collection
     */
    public Object[] toArray() {
        Iterator itr = _org_ozoneDB_internalIterator();
        int size = size();
        Object[] a = new Object[size];
        for (int pos = 0; pos < size; pos++)
            a[pos] = itr.next();
        return a;
    }
    
    /**
     * Copy the collection into a given array if it will fit, or into a
     * dynamically created array of the same run-time type as the given array if
     * not. If there is space remaining in the array, the first element after the
     * end of the collection is set to null (this is only useful if the
     * collection is known to contain no null elements, however). This
     * implementation first tests whether the given array is large enough to hold
     * all the elements of the collection. If not, the reflection API is used to
     * allocate a new array of the same run-time type. Next an iterator is
     * obtained over the collection and the elements are placed in the array as
     * they are returned by the iterator. Finally the first spare element, if
     * any, of the array is set to null, and the created array is returned.
     * The returned array is safe; it is not backed by the collection. Note that
     * null may not mark the last element, if the collection allows null
     * elements.
     *
     * @param a the array to copy into, or of the correct run-time type
     * @return the array that was produced
     * @throws NullPointerException if the given array is null
     * @throws ArrayStoreException if the type of the array precludes holding
     *         one of the elements of the Collection
     */
    public Object[] toArray(Object[] a) {
        int size = size();
        if (a.length < size)
            a = (Object[]) Array.newInstance(a.getClass().getComponentType(),
            size);
        else if (a.length > size)
            a[size] = null;
        
        Iterator itr = _org_ozoneDB_internalIterator();
        for (int pos = 0; pos < size; pos++)
            a[pos] = itr.next();
        
        return a;
    }
    
    /**
     * Creates a String representation of the Collection. The string returned is
     * of the form "[a, b, ...]" where a and b etc are the results of calling
     * toString on the elements of the collection. This implementation obtains an
     * Iterator over the Collection and adds each element to a StringBuffer as it
     * is returned by the iterator.
     *
     * @return a String representation of the Collection
     */
    public String toString() {
        Iterator itr = _org_ozoneDB_internalIterator();
        StringBuffer r = new StringBuffer("[");
        for (int pos = size(); pos > 0; pos--) {
            r.append(itr.next());
            if (pos > 1)
                r.append(", ");
        }
        r.append("]");
        return r.toString();
    }
    
    /**
     * Compare two objects according to Collection semantics.
     *
     * @param o1 the first object
     * @param o2 the second object
     * @return o1 == null ? o2 == null : o1.equals(o2)
     */
    // Package visible for use throughout java.util.
    // It may be inlined since it is final.
    static final boolean equals(Object o1, Object o2) {
        return o1 == null ? o2 == null : o1.equals(o2);
    }
    
    /**
     * Hash an object according to Collection semantics.
     *
     * @param o the object to hash
     * @return o1 == null ? 0 : o1.hashCode()
     */
    // Package visible for use throughout java.util.
    // It may be inlined since it is final.
    static final int hashCode(Object o) {
        return o == null ? 0 : o.hashCode();
    }

    /** <p>Returns a non-ozone <code>Collection</code> that contains the same
     * entries as this persistent one; it is (by nature of the client-server
     * enviromnent) always a 'deep' copy of this <code>OzoneCollection</code>.
     * I.e. the contents of this <code>OzoneCollection</code> instance are
     * always copied to the client by use of serialization.</p>
     * <p>This means that if this instance holds non-ozone objects, these
     * objects are send to the calling client by means of serialization. If
     * this instance holds ozone objects, it actually holds proxies to these
     * objects. These proxies are copied and send to the client, resulting in
     * different proxies to the same ozone objects.</p>
     * <p>Note that all subclasses of <code>OzoneCollection</code> (or
     * <code>OzoneMap</code>) have <code>getClientXxx()</code> member functions
     * that returns a collection of type <code>Xxx</code>; these simply return
     * a the same result value as <code>getClientCollection()</code>, without
     * the need for a typecast.</p>
     */
    public Collection getClientCollection() {
        throw new UnsupportedOperationException();
    }
    
}