public COSArrayList() 
{
        array = new COSArray();
        actual = new ArrayList();
}

Default constructor.

 public COSArrayList(List actualList,
    COSArray cosArray) 
{
        actual = actualList;
        array = cosArray;
}

Constructor.

Parameters:

actualList - The list of standard java objects

cosArray - The COS array object to sync to.

 public COSArrayList(Object actualObject,
    COSBase item,
    COSDictionary dictionary,
    COSName dictionaryKey) 
{
        array = new COSArray();
        array.add( item );
        actual = new ArrayList();
        actual.add( actualObject );
        parentDict = dictionary;
        dictKey = dictionaryKey;
}

This is a really special constructor. Sometimes the PDF spec says that a dictionary entry can either be a single item or an array of those items. But in the PDModel interface we really just want to always return a java.util.List. In the case were we get the list and never modify it we don't want to convert to COSArray and put one element, unless we append to the list. So here we are going to create this object with a single item instead of a list, but allow more items to be added and then converted to an array.

Parameters:

actualObject - The PDModel object.

item - The COS Model object.

dictionary - The dictionary that holds the item, and will hold the array if an item is added.

dictionaryKey - The key into the dictionary to set the item.

 public COSArrayList(Object actualObject,
    COSBase item,
    COSDictionary dictionary,
    String dictionaryKey) 
{
        this( actualObject, item, dictionary, COSName.getPDFName(dictionaryKey) );
}

 public boolean add(Object o) 
{
        //when adding if there is a parentDict then change the item
        //in the dictionary from a single item to an array.
        if( parentDict != null )
        {
            parentDict.setItem( dictKey, array );
            //clear the parent dict so it doesn't happen again, there might be
            //a usecase for keeping the parentDict around but not now.
            parentDict = null;
        }
        //string is a special case because we can't subclass to be COSObjectable
        if( o instanceof String )
        {
            array.add( new COSString( (String)o ) );
        }
        else if( o instanceof DualCOSObjectable )
        {
            DualCOSObjectable dual = (DualCOSObjectable)o;
            array.add( dual.getFirstCOSObject() );
            array.add( dual.getSecondCOSObject() );
        }
        else
        {
            array.add( ((COSObjectable)o).getCOSObject() );
        }
        return actual.add(o);
}

{@inheritDoc}

 public  void add(int index,
    Object element) 
{
        //when adding if there is a parentDict then change the item
        //in the dictionary from a single item to an array.
        if( parentDict != null )
        {
            parentDict.setItem( dictKey, array );
            //clear the parent dict so it doesn't happen again, there might be
            //a usecase for keeping the parentDict around but not now.
            parentDict = null;
        }
        actual.add( index, element );
        if( element instanceof String )
        {
            array.add( index, new COSString( (String)element ) );
        }
        else if( element instanceof DualCOSObjectable )
        {
            DualCOSObjectable dual = (DualCOSObjectable)element;
            array.add( index*2, dual.getFirstCOSObject() );
            array.add( index*2+1, dual.getSecondCOSObject() );
        }
        else
        {
            array.add( index, ((COSObjectable)element).getCOSObject() );
        }
}

{@inheritDoc}

 public boolean addAll(Collection c) 
{
        //when adding if there is a parentDict then change the item
        //in the dictionary from a single item to an array.
        if( parentDict != null && c.size()  > 0)
        {
            parentDict.setItem( dictKey, array );
            //clear the parent dict so it doesn't happen again, there might be
            //a usecase for keeping the parentDict around but not now.
            parentDict = null;
        }
        array.addAll( toCOSObjectList( c ) );
        return actual.addAll( c );
}

{@inheritDoc}

 public boolean addAll(int index,
    Collection c) 
{
        //when adding if there is a parentDict then change the item
        //in the dictionary from a single item to an array.
        if( parentDict != null && c.size()  > 0)
        {
            parentDict.setItem( dictKey, array );
            //clear the parent dict so it doesn't happen again, there might be
            //a usecase for keeping the parentDict around but not now.
            parentDict = null;
        }
        if( c.size()  >0 && c.toArray()[0] instanceof DualCOSObjectable )
        {
            array.addAll( index*2, toCOSObjectList( c ) );
        }
        else
        {
            array.addAll( index, toCOSObjectList( c ) );
        }
        return actual.addAll( index, c );
}

{@inheritDoc}

 public  void clear() 
{
        //when adding if there is a parentDict then change the item
        //in the dictionary from a single item to an array.
        if( parentDict != null )
        {
            parentDict.setItem( dictKey, (COSBase)null );
        }
        actual.clear();
        array.clear();
}

{@inheritDoc}

 public boolean contains(Object o) 
{
        return actual.contains(o);
}

{@inheritDoc}

 public boolean containsAll(Collection c) 
{
        return actual.containsAll( c );
}

{@inheritDoc}

 public static List convertCOSNameCOSArrayToList(COSArray nameArray) 
{
        List retval = null;
        if( nameArray != null )
        {
            List names = new ArrayList();
            for( int i=0; i< nameArray.size(); i++ )
            {
                names.add( ((COSName)nameArray.getObject( i )).getName() );
            }
            retval = new COSArrayList( names, nameArray );
        }
        return retval;
}

This will take an array of COSName and return a COSArrayList of java.lang.String values.

 public static List convertCOSStringCOSArrayToList(COSArray stringArray) 
{
        List retval = null;
        if( stringArray != null )
        {
            List string = new ArrayList();
            for( int i=0; i< stringArray.size(); i++ )
            {
                string.add( ((COSString)stringArray.getObject( i )).getString() );
            }
            retval = new COSArrayList( string, stringArray );
        }
        return retval;
}

This will take an array of COSString and return a COSArrayList of java.lang.String values.

 public static List convertFloatCOSArrayToList(COSArray floatArray) 
{
        List retval = null;
        if( floatArray != null )
        {
            List numbers = new ArrayList();
            for( int i=0; i< floatArray.size(); i++ )
            {
                numbers.add( new Float( ((COSNumber)floatArray.get( i )).floatValue() ) );
            }
            retval = new COSArrayList( numbers, floatArray );
        }
        return retval;
}

This will take an array of COSNumbers and return a COSArrayList of java.lang.Float values.

 public static List convertIntegerCOSArrayToList(COSArray intArray) 
{
        List numbers = new ArrayList();
        for( int i=0; i< intArray.size(); i++ )
        {
            numbers.add( new Integer( ((COSNumber)intArray.get( i )).intValue() ) );
        }
        return new COSArrayList( numbers, intArray );
}

This will take an array of COSNumbers and return a COSArrayList of java.lang.Integer values.

 public static COSArray convertStringListToCOSNameCOSArray(List strings) 
{
        COSArray retval = new COSArray();
        for( int i=0; i< strings.size(); i++ )
        {
            Object next = strings.get( i );
            if( next instanceof COSName )
            {
                retval.add( (COSName)next );
            }
            else
            {
                retval.add( COSName.getPDFName( (String)next ) );
            }
        }
        return retval;
}

This will take an list of string objects and return a COSArray of COSName objects.

 public static COSArray convertStringListToCOSStringCOSArray(List strings) 
{
        COSArray retval = new COSArray();
        for( int i=0; i< strings.size(); i++ )
        {
            retval.add( new COSString( (String)strings.get( i ) ) );
        }
        return retval;
}

This will take an list of string objects and return a COSArray of COSName objects.

 public static COSArray converterToCOSArray(List cosObjectableList) 
{
        COSArray array = null;
        if( cosObjectableList != null )
        {
            if( cosObjectableList instanceof COSArrayList )
            {
                //if it is already a COSArrayList then we don't want to recreate the array, we want to reuse it.
                array = ((COSArrayList)cosObjectableList).array;
            }
            else
            {
                array = new COSArray();
                Iterator iter = cosObjectableList.iterator();
                while( iter.hasNext() )
                {
                    Object next = iter.next();
                    if( next instanceof String )
                    {
                        array.add( new COSString( (String)next ) );
                    }
                    else if( next instanceof Integer || next instanceof Long )
                    {
                        array.add( COSInteger.get( ((Number)next).longValue() ) );
                    }
                    else if( next instanceof Float || next instanceof Double )
                    {
                        array.add( new COSFloat( ((Number)next).floatValue() ) );
                    }
                    else if( next instanceof COSObjectable )
                    {
                        COSObjectable object = (COSObjectable)next;
                        array.add( object.getCOSObject() );
                    }
                    else if( next instanceof DualCOSObjectable )
                    {
                        DualCOSObjectable object = (DualCOSObjectable)next;
                        array.add( object.getFirstCOSObject() );
                        array.add( object.getSecondCOSObject() );
                    }
                    else if( next == null )
                    {
                        array.add( COSNull.NULL );
                    }
                    else
                    {
                        throw new RuntimeException( "Error: Don't know how to convert type to COSBase '" +
                        next.getClass().getName() + "'" );
                    }
                }
            }
        }
        return array;
}

This will convert a list of COSObjectables to an array list of COSBase objects.

 public boolean equals(Object o) 
{
        return actual.equals( o );
}

{@inheritDoc}

 public Object get(int index) 
{
        return actual.get( index );
}

{@inheritDoc}

 public int hashCode() 
{
        return actual.hashCode();
}

{@inheritDoc}

 public int indexOf(Object o) 
{
        return actual.indexOf( o );
}

{@inheritDoc}

 public boolean isEmpty() 
{
        return actual.isEmpty();
}

{@inheritDoc}

 public Iterator iterator() 
{
        return actual.iterator();
}

{@inheritDoc}

 public int lastIndexOf(Object o) 
{
        return actual.indexOf( o );
}

{@inheritDoc}

 public ListIterator listIterator() 
{
        return actual.listIterator();
}

{@inheritDoc}

 public ListIterator listIterator(int index) 
{
        return actual.listIterator( index );
}

{@inheritDoc}

 public boolean remove(Object o) 
{
        boolean retval = true;
        int index = actual.indexOf( o );
        if( index  >= 0 )
        {
            actual.remove( index );
            array.remove( index );
        }
        else
        {
            retval = false;
        }
        return retval;
}

{@inheritDoc}

 public Object remove(int index) 
{
        if( array.size()  > index && array.get( index ) instanceof DualCOSObjectable )
        {
            //remove both objects
            array.remove( index );
            array.remove( index );
        }
        else
        {
            array.remove( index );
        }
        return actual.remove( index );
}

{@inheritDoc}

 public boolean removeAll(Collection c) 
{
        array.removeAll( toCOSObjectList( c ) );
        return actual.removeAll( c );
}

{@inheritDoc}

 public boolean retainAll(Collection c) 
{
        array.retainAll( toCOSObjectList( c ) );
        return actual.retainAll( c );
}

{@inheritDoc}

 public Object set(int index,
    Object element) 
{
        if( element instanceof String )
        {
            COSString item = new COSString( (String)element );
            if( parentDict != null && index == 0 )
            {
                parentDict.setItem( dictKey, item );
            }
            array.set( index, item );
        }
        else if( element instanceof DualCOSObjectable )
        {
            DualCOSObjectable dual = (DualCOSObjectable)element;
            array.set( index*2, dual.getFirstCOSObject() );
            array.set( index*2+1, dual.getSecondCOSObject() );
        }
        else
        {
            if( parentDict != null && index == 0 )
            {
                parentDict.setItem( dictKey, ((COSObjectable)element).getCOSObject() );
            }
            array.set( index, ((COSObjectable)element).getCOSObject() );
        }
        return actual.set( index, element );
}

{@inheritDoc}

 public int size() 
{
        return actual.size();
}

{@inheritDoc}

 public List subList(int fromIndex,
    int toIndex) 
{
        return actual.subList( fromIndex, toIndex );
}

{@inheritDoc}

 public Object[] toArray() 
{
        return actual.toArray();
}

{@inheritDoc}

 public Object[] toArray(Object[] a) 
{
        return actual.toArray(a);
}

{@inheritDoc}

 public COSArray toList() 
{
        return array;
}

This will return then underlying COSArray.

 public String toString() 
{
        return "COSArrayList{" + array.toString() + "}";
}

{@inheritDoc}