/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: InterfaceContainer.java,v $
* $Revision: 1.4 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org 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 Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
package com.sun.star.lib.uno.helper;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Collection;
import com.sun.star.lang.EventObject;
import com.sun.star.lang.XEventListener;
import com.sun.star.uno.UnoRuntime;
/**
* This class is a container for interfaces.
*
* It is intended to be used as storage for UNO interface of a specific type.
* The client has to ensure that the container contains only elements of the same
* type. If one needs to store different types, then one uses OMultiTypeInterfaceContainer.
* When the client calls disposeAndClear, the contained objects are queried for
* com.sun.star.lang.XEventListener and disposing is called. Afterwards
* the list cannot be used anymore.
*
* This list does not allow null values.
* All methods are thread-safe. The same holds true for
* iterators, issued by this class. Several iterators can exist at the same time and can also
* be modified (java.util.ListIterator.add, java.util.ListIterator.remove etc.). To make this work,
* the InterfaceContainer provides the iterators with copys of the list's data.
* The add and remove calls on the iterator modify the data in the iterator's list as well as
* in InterfaceContainer. Modification on InterfaceContainer, however, are not
* synchronized with existing iterators. For example
* <pre>
* InterfaceContainer cont= new InterfaceContainer();
* ListIterator it= cont.listIterator();
*
* cont.add( someInterface);
* // one cannot obtain someInterface through iterator it,
* // instead get a new iterator
* it= cont.listIterator();
* // it now keeps a fresh copy of cont and hence contains someInterface
*
* // Adding an interface on the iterator will cause the interface also to be added
* // to InterfaceContainer
* it.add( someOtherInterface);
* // someOtherInterface is now in it and cont
* ListIterator it2= cont.listIterator();
* //someOtherInterface can also be obtained by all newly created iterators, e.g. it2.
* </pre>
*
* The add and remove methods of an iterator work on a particular location within a list,
* dependent on what the value of the iterator's cursor is. After the call the value at the
* appropriate position has been modified. Since the iterator received a copy of InterfaceContainer's
* data, InterfaceContainer may have been modified (by List methods or through other iterators).
* Therefore both data sets may not contain the same elements anymore. Consequently, a List method
* that modifies data, does not modify InterfaceContainer's data at a certain index
* (according to the iterators cursor). Instead, new elements are added at the end of list. When
* Iterator.remove is called, then the first occurrence of that element in InterfaceContainer
* is removed.
* ListIterator.set is not supported.
*
* A lot of methods resemble those of the to java.util.List interface, allthough
* this class does not implement it. However, the list iterators returned, for example by
* the listIterator method implement the java.util.ListIterator interface.
* Implementing the List interface would mean to support all none - optional methods as
* prescribed by the interface declaration. Among those is the subList method which returns
* a range of values of the list's data wrapped in a List implementation. Changes to the sub
* list have to cause changes in the main list. This is a problem, since this class is to be
* used in a multi-threaded environment. The sub list could work on a copy as the iterators
* do, but all the functions which work on an given index could not be properly supported.
* Unfortunatly, the List interface documentation states that all optional methods implemented
* by the list have to be implemented in the sub list. That would mean to do without all those
* critical methods, allthough they might work well in the "main list" (as opposed to sub list).
*/
public class InterfaceContainer implements Cloneable
{
final boolean DEBUG= false;
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer.
*/
Object elementData[];
/**
* The size of the ArrayList (the number of elements it contains).
*
* @serial
*/
private int size;
//private ArrayList data= new ArrayList();
/** Creates a new instance of InterfaceContainer */
public InterfaceContainer()
{
this(10);
}
/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list.
* @exception IllegalArgumentException if the specified initial capacity
* is negative
*/
public InterfaceContainer(int initialCapacity)
{
if (initialCapacity < 0)
throw new java.lang.IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
/**
* Trims the capacity of this <tt>ArrayList</tt> instance to be the
* list's current size. An application can use this operation to minimize
* the storage of an <tt>ArrayList</tt> instance.
*/
synchronized public void trimToSize()
{
int oldCapacity = elementData.length;
if (size < oldCapacity)
{
Object oldData[] = elementData;
elementData = new Object[size];
System.arraycopy(oldData, 0, elementData, 0, size);
}
}
/**
* Increases the capacity of this <tt>ArrayList</tt> instance, if
* necessary, to ensure that it can hold at least the number of elements
* specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity.
*/
synchronized public void ensureCapacity(int minCapacity)
{
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity)
{
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
elementData = new Object[newCapacity];
System.arraycopy(oldData, 0, elementData, 0, size);
}
}
/**
* Appends the specified element to the end of this list.
*
* @param o element to be appended to this list.
* @return <tt>true</tt> (as per the general contract of Collection.add).
*/
synchronized public boolean add(Object o)
{
boolean ret= false;
if (elementData != null && o != null)
{
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = o;
ret= true;
}
return ret;
}
/**
* Inserts the specified element at the specified position in this
* list. Shifts the element currently at that position (if any) and
* any subsequent elements to the right (adds one to their indices).
*
* @param index index at which the specified element is to be inserted.
* @param element element to be inserted.
* @throws IndexOutOfBoundsException if index is out of range
* <tt>(index < 0 || index > size())</tt>.
*/
synchronized public void add(int index, Object element)
{
if (elementData != null && element != null)
{
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
ensureCapacity(size+1);
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
}
/**
* Appends all of the elements in the specified Collection to the end of
* this list, in the order that they are returned by the
* specified Collection's Iterator. The behavior of this operation is
* undefined if the specified Collection is modified while the operation
* is in progress. (This implies that the behavior of this call is
* undefined if the specified Collection is this list, and this
* list is nonempty.)
*
* @param c the elements to be inserted into this list.
* @throws IndexOutOfBoundsException if index out of range <tt>(index
* < 0 || index > size())</tt>.
*/
synchronized public boolean addAll(Collection c)
{
int numNew = c.size();
ensureCapacity(size + numNew);
Iterator e = c.iterator();
for (int i=0; i<numNew; i++)
{
Object o= e.next();
if (o != null)
elementData[size++] = o;
}
return numNew != 0;
}
/**
* Inserts all of the elements in the specified Collection into this
* list, starting at the specified position. Shifts the element
* currently at that position (if any) and any subsequent elements to
* the right (increases their indices). The new elements will appear
* in the list in the order that they are returned by the
* specified Collection's iterator.
*
* @param index index at which to insert first element
* from the specified collection.
* @param c elements to be inserted into this list.
* @throws IndexOutOfBoundsException if index out of range <tt>(index
* < 0 || index > size())</tt>.
*/
synchronized public boolean addAll(int index, Collection c)
{
boolean ret= false;
if (elementData != null)
{
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
// only add the non-null elements
int sizeCol= c.size();
Object[] arColl= new Object[sizeCol];
Iterator icol= c.iterator();
int curIndex= 0;
for (int i=0; i < sizeCol; i++)
{
Object o= icol.next();
if (o != null)
arColl[curIndex++]= o;
}
int numNew = curIndex;
ensureCapacity(size + numNew); // Increments modCount!!
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
for (int i=0; i<numNew; i++)
{
elementData[index++]= arColl[i];
}
size += numNew;
ret= numNew != 0;
}
return ret;
}
/**
* Removes all of the elements from this list. The list will
* be empty after this call returns.
*/
synchronized public void clear()
{
if (elementData != null)
{
// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
}
/**
* Returns <tt>true</tt> if this list contains the specified element.
*
* @param elem element whose presence in this List is to be tested.
*/
synchronized public boolean contains(Object elem)
{
return indexOf(elem) >= 0;
}
synchronized public boolean containsAll(Collection collection)
{
boolean retVal= true;
if (elementData != null && collection != null)
{
Iterator it= collection.iterator();
while (it.hasNext())
{
Object obj= it.next();
if (false == contains(obj))
{
retVal= false;
break;
}
}
}
return retVal;
}
/**
* Returns the element at the specified position in this list.
*
* @param index index of element to return.
* @return the element at the specified position in this list.
* @throws IndexOutOfBoundsException if index is out of range <tt>(index
* < 0 || index >= size())</tt>.
*/
synchronized public Object get(int index)
{
if (elementData != null)
{
RangeCheck(index);
return elementData[index];
}
return null;
}
/**
* Searches for the first occurence of the given argument, testing
* for equality using the <tt>equals</tt> method.
*
* @param elem an object.
* @return the index of the first occurrence of the argument in this
* list; returns <tt>-1</tt> if the object is not found.
* @see Object#equals(Object)
*/
synchronized public int indexOf(Object elem)
{
int index= -1;
if (elementData != null && elem != null)
{
for (int i = 0; i < size; i++)
{
if (elem == elementData[i])
{
index= i;
break;
}
}
if (index == -1)
{
for (int i = 0; i < size; i++)
{
if (UnoRuntime.areSame(elem, elementData[i]))
{
index= i;
break;
}
}
}
}
return index;
}
/**
* Tests if this list has no elements.
*
* @return <tt>true</tt> if this list has no elements;
* <tt>false</tt> otherwise.
*/
synchronized public boolean isEmpty()
{
return size == 0;
}
synchronized public Iterator iterator()
{
if (elementData != null)
{
InterfaceContainer aCopy= (InterfaceContainer) clone();
return new Itr(aCopy);
}
return null;
}
/**
* Returns the index of the last occurrence of the specified object in
* this list.
*
* @param elem the desired element.
* @return the index of the last occurrence of the specified object in
* this list; returns -1 if the object is not found.
*/
synchronized public int lastIndexOf(Object elem)
{
int index= -1;
if (elementData != null && elem != null)
{
for (int i = size-1; i >= 0; i--)
{
if (elem == elementData[i])
{
index= i;
break;
}
}
if (index == -1)
{
for (int i = size-1; i >= 0; i--)
{
if (UnoRuntime.areSame(elem, elementData[i]))
{
index= i;
break;
}
}
}
}
return index;
}
/**
* Returns a shallow copy of this <tt>ArrayList</tt> instance. The contained
* references are copied but the objects not.
*
* @return a clone of this <tt>List</tt> instance.
*/
synchronized public Object clone()
{
Object ret= null;
if (elementData != null)
{
InterfaceContainer cont= new InterfaceContainer();
cont.elementData = new Object[size];
cont.size= size;
System.arraycopy(elementData, 0, cont.elementData, 0, size);
ret= cont;
}
return ret;
}
synchronized public ListIterator listIterator()
{
return listIterator(0);
}
/** The iterator keeps a copy of the list. Changes to InterfaceContainer do not
* affect the data of the iterator. Conversly, changes to the iterator are effect
* InterfaceContainer.
*/
synchronized public ListIterator listIterator(int index)
{
if (elementData != null)
{
InterfaceContainer aCopy= (InterfaceContainer) clone();
return new LstItr(aCopy, index);
}
return null;
}
/**
* Removes the element at the specified position in this list.
* Shifts any subsequent elements to the left (subtracts one from their
* indices).
*
* @param index the index of the element to removed.
* @return the element that was removed from the list.
* @throws IndexOutOfBoundsException if index out of range <tt>(index
* < 0 || index >= size())</tt>.
*/
synchronized public Object remove(int index)
{
Object ret= null;
if (elementData != null)
{
RangeCheck(index);
ret= elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
}
return ret;
}
/** Parameter obj may */
synchronized public boolean remove(Object obj)
{
boolean ret= false;
if (elementData != null && obj != null)
{
int index= indexOf(obj);
if (index != -1)
{
ret= true;
remove(index);
}
}
return ret;
}
synchronized public boolean removeAll(Collection collection)
{
boolean retVal= false;
if (elementData != null && collection != null)
{
Iterator it= collection.iterator();
while (it.hasNext())
{
Object obj= it.next();
boolean bMod= remove( obj);
if (bMod)
retVal= true;
}
}
return retVal;
}
synchronized public boolean retainAll(Collection collection)
{
boolean retVal= false;
if (elementData != null && collection != null)
{
// iterate over data
Object[] arRetained= new Object[size];
int indexRetained= 0;
for(int i= 0; i < size; i++)
{
Object curElem= elementData[i];
// try to find the element in collection
Iterator itColl= collection.iterator();
boolean bExists= false;
while (itColl.hasNext())
{
if (curElem == itColl.next())
{
// current element is in collection
bExists= true;
break;
}
}
if (bExists == false)
{
itColl= collection.iterator();
while (itColl.hasNext())
{
Object o= itColl.next();
if (o != null)
{
if (UnoRuntime.areSame(o, curElem))
{
bExists= true;
break;
}
}
}
}
if (bExists == true)
arRetained[indexRetained++]= curElem;
}
retVal= size != indexRetained;
if (indexRetained > 0)
{
elementData= arRetained;
size= indexRetained;
}
}
return retVal;
}
/** Not supported.
* @param index index of element to replace.
* @param element element to be stored at the specified position.
* @return the element previously at the specified position.
* @throws IndexOutOfBoundsException if index out of range
* <tt>(index < 0 || index >= size())</tt>.
*/
synchronized public Object set(int index, Object element)
{
Object ret= null;
if (elementData != null && element != null)
{
RangeCheck(index);
ret = elementData[index];
elementData[index] = element;
}
return ret;
}
/**
* Returns the number of elements in this list.
*
* @return the number of elements in this list.
*/
synchronized public int size()
{
if (elementData != null)
return size;
return 0;
}
/**
* Returns an array containing all of the elements in this list
* in the correct order.
*
* @return an array containing all of the elements in this list
* in the correct order.
*/
synchronized public Object[] toArray()
{
if (elementData != null)
{
Object[] result = new Object[size];
System.arraycopy(elementData, 0, result, 0, size);
return result;
}
return null;
}
/**
* Returns an array containing all of the elements in this list in the
* correct order. The runtime type of the returned array is that of the
* specified array. If the list fits in the specified array, it is
* returned therein. Otherwise, a new array is allocated with the runtime
* type of the specified array and the size of this list.<p>
*
* If the list fits in the specified array with room to spare (i.e., the
* array has more elements than the list), the element in the array
* immediately following the end of the collection is set to
* <tt>null</tt>. This is useful in determining the length of the list
* <i>only</i> if the caller knows that the list does not contain any
* <tt>null</tt> elements.
*
* @param a the array into which the elements of the list are to
* be stored, if it is big enough; otherwise, a new array of the
* same runtime type is allocated for this purpose.
* @return an array containing the elements of the list.
* @throws ArrayStoreException if the runtime type of a is not a supertype
* of the runtime type of every element in this list.
*/
synchronized public Object[] toArray(Object a[])
{
if (a.length < size)
a = (Object[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
if (elementData != null)
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
/**
* Check if the given index is in range. If not, throw an appropriate
* runtime exception.
*/
private void RangeCheck(int index)
{
if (index >= size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
}
public void disposeAndClear(EventObject evt)
{
Iterator aIt;
synchronized (this)
{
aIt= iterator();
// Container freigeben, falls im disposing neue Eintraege kommen
// set the member to null, the iterator delete the values
clear();
elementData= null;
size= 0;
}
if (aIt != null)
{
while( aIt.hasNext() )
{
try
{
Object o= aIt.next();
XEventListener evtListener= UnoRuntime.queryInterface(
XEventListener.class, o);
if( evtListener != null )
evtListener.disposing( evt );
}
catch ( RuntimeException e)
{
// be robust, if e.g. a remote bridge has disposed already.
// there is no way, to delegate the error to the caller :o(.
}
}
}
}
private class Itr implements Iterator
{
InterfaceContainer dataIt;
/**
* Index of element to be returned by subsequent call to next.
*/
int cursor= 0;
/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.
*/
int lastRet = -1;
/** The object that has been returned by most recent call to next
* or previous. Reset to null if this element is deleted by a call
* to remove.
*/
Object lastRetObj= null;
Itr(InterfaceContainer _data)
{
dataIt= _data;
}
synchronized public boolean hasNext()
{
return cursor !=dataIt.size();
}
public synchronized Object next()
{
try
{
Object next = dataIt.get(cursor);
lastRet = cursor++;
lastRetObj= next;
return next;
}
catch(java.lang.IndexOutOfBoundsException e)
{
throw new java.util.NoSuchElementException();
}
}
/** Removes the interface from the list, that has been last returned by a
* call to next(). This is done according to the specification of the interface
* method. The element is also removed from InterfaceContainer but independent
* of the location. If the element is multiple times in InterfaceContainer then
* it is up to the java.util.ArrayList implementation what element is removed.
*/
public synchronized void remove()
{
if (lastRet == -1)
throw new IllegalStateException();
// Remove the entry from InterfaceContainer.
InterfaceContainer.this.remove(lastRetObj);
dataIt.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
lastRetObj= null;
}
}
private class LstItr extends Itr implements ListIterator
{
LstItr(InterfaceContainer _data, int _index)
{
super(_data);
cursor= _index;
}
/** Inserts an element to the iterators list according to the specification
* of this interface method. The element is also added to InterfaceContainer
* but its location within the list cannot be guaranteed.
*/
public synchronized void add(Object o)
{
InterfaceContainer.this.add(o);
dataIt.add(cursor++, o);
lastRet = -1;
lastRetObj= null;
}
synchronized public boolean hasPrevious()
{
return cursor != 0;
}
synchronized public int nextIndex()
{
return cursor;
}
public synchronized Object previous()
{
try
{
Object previous = dataIt.get(--cursor);
lastRet = cursor;
lastRetObj= previous;
return previous;
} catch(IndexOutOfBoundsException e)
{
throw new NoSuchElementException();
}
}
synchronized public int previousIndex()
{
return cursor-1;
}
/** This is not possible since several iterators can modify InterfaceContainer
*/
public synchronized void set(Object o)
{
throw new UnsupportedOperationException();
}
} // class LstItr
}