public PDNumberTreeNode(Class valueClass) 
{
        node = new COSDictionary();
        valueType = valueClass;
}

Constructor.

Parameters:

valueClass - The PD Model type of object that is the value.

 public PDNumberTreeNode(COSDictionary dict,
    Class valueClass) 
{
        node = dict;
        valueType = valueClass;
}

Constructor.

Parameters:

dict - The dictionary that holds the name information.

valueClass - The PD Model type of object that is the value.

 protected Object convertCOSToPD(COSBase base) throws IOException 
{
        Object retval = null;
        try
        {
            Constructor ctor = valueType.getConstructor( new Class[] { base.getClass() } );
            retval = ctor.newInstance( new Object[] { base } );
        }
        catch( Throwable t )
        {
            throw new IOException( "Error while trying to create value in number tree:" + t.getMessage());
        }
        return retval;
}

Method to convert the COS value in the name tree to the PD Model object. The default implementation will simply use reflection to create the correct object type. Subclasses can do whatever they want.

 protected PDNumberTreeNode createChildNode(COSDictionary dic) 
{
        return new PDNumberTreeNode(dic,valueType);
}

Create a child node object.

 public COSDictionary getCOSDictionary() 
{
        return node;
}

Convert this standard java object to a COS object.

 public COSBase getCOSObject() 
{
        return node;
}

Convert this standard java object to a COS object.

 public List getKids() 
{
        List retval = null;
        COSArray kids = (COSArray)node.getDictionaryObject( COSName.KIDS );
        if( kids != null )
        {
            List pdObjects = new ArrayList();
            for( int i=0; i< kids.size(); i++ )
            {
                pdObjects.add( createChildNode( (COSDictionary)kids.getObject(i) ) );
            }
            retval = new COSArrayList(pdObjects,kids);
        }
        return retval;
}

Return the children of this node. This list will contain PDNumberTreeNode objects.

 public Integer getLowerLimit() 
{
        Integer retval = null;
        COSArray arr = (COSArray)node.getDictionaryObject( COSName.LIMITS );
        if( arr != null )
        {
            retval = Integer.valueOf(arr.getInt( 0 ));
        }
        return retval;
}

Get the lowest value for a key in the name map.

 public Map getNumbers() throws IOException 
{
        Map indices = null;
        COSArray namesArray = (COSArray)node.getDictionaryObject( COSName.NUMS );
        if( namesArray != null )
        {
            indices = new HashMap();
            for( int i=0; i< namesArray.size(); i+=2 )
            {
                COSInteger key = (COSInteger)namesArray.getObject(i);
                COSBase cosValue = namesArray.getObject( i+1 );
                Object pdValue = convertCOSToPD( cosValue );
                indices.put( Integer.valueOf(key.intValue()), pdValue );
            }
            indices = Collections.unmodifiableMap(indices);
        }
        return indices;
}

This will return a map of numbers. The key will be a java.lang.Integer, the value will depend on where this class is being used.

 public Integer getUpperLimit() 
{
        Integer retval = null;
        COSArray arr = (COSArray)node.getDictionaryObject( COSName.LIMITS );
        if( arr != null )
        {
            retval = Integer.valueOf(arr.getInt( 1 ));
        }
        return retval;
}

Get the highest value for a key in the name map.

 public Object getValue(Integer index) throws IOException 
{
        Object retval = null;
        Map names = getNumbers();
        if( names != null )
        {
            retval = names.get( index );
        }
        else
        {
            List kids = getKids();
            for( int i=0; i< kids.size() && retval == null; i++ )
            {
                PDNumberTreeNode childNode = (PDNumberTreeNode)kids.get( i );
                if( childNode.getLowerLimit().compareTo( index ) < = 0 &&
                        childNode.getUpperLimit().compareTo( index )  >= 0 )
                {
                    retval = childNode.getValue( index );
                }
            }
        }
        return retval;
}

Returns the value corresponding to an index in the number tree.

 public  void setKids(List kids) 
{
        node.setItem( "Kids", COSArrayList.converterToCOSArray( kids ) );
}

Set the children of this number tree.

 public  void setNumbers(Map numbers) 
{
        if( numbers == null )
        {
            node.setItem( COSName.NUMS, (COSObjectable)null );
            node.setItem( "Limits", (COSObjectable)null);
        }
        else
        {
            List keys = new ArrayList( numbers.keySet() );
            Collections.sort( keys );
            COSArray array = new COSArray();
            for( int i=0; i< keys.size(); i++ )
            {
                Integer key = (Integer)keys.get(i);
                array.add( COSInteger.get( key ) );
                COSObjectable obj = (COSObjectable)numbers.get( key );
                array.add( obj );
            }
            Integer lower = null;
            Integer upper = null;
            if( keys.size()  > 0 )
            {
                lower = (Integer)keys.get( 0 );
                upper = (Integer)keys.get( keys.size()-1 );
            }
            setUpperLimit( upper );
            setLowerLimit( lower );
            node.setItem( "Names", array );
        }
}

Set the names of for this node. The keys should be java.lang.String and the values must be a COSObjectable. This method will set the appropriate upper and lower limits based on the keys in the map.