/** This is a class for representing nonnegative integers
      It implicitly uses ordinary lexicographical ordering,
        rather than the natural ordering for integers.
*/
//  Values are represented as arrays of digits.
//  Negative values are represented as 0.

import java.util.*;
public class TrieIntegerString implements Lexicographical
{

private int data;
private int[] digits;
private int alphabetSize = 11;


/** A constructor for the object representing a given integer
     @param d the integer
*/
// A vector is used to store the digits in reverse
//   order.  The vector is then traversed in reverse
//   order to build the array of digits.

public TrieIntegerString(int d)                {
  data=d;
  if (d<=0)
    digits=new int[] {0};
  else                                        {
    Vector v = new Vector(10);
    while (d>0)                {
      v.add(new Integer(d%10));
      d=d/10;                  }
    int size=v.size();
    digits=new int[size];
    for (int i=0; i<size; i++)
      digits[i]=
       ((Integer) v.get(size-1-i)).intValue();} }


public int length()                    {
  return digits.length;                }



/**
     @param posn a position of a character
     @return the character code of the
       digit at the given position.
     Note that because of the existence
       of a terminator character, this
       code is one greater than the
       digit itself.  If there is no
       character at the given position,
       the character code 0 of the
       terminator character is returned.
*/
public int elementAt(int posn)           {
  if (posn < 0 || posn>=digits.length)
    return 0;
  else
    return 1+digits[posn];               }



public int getAlphabetSize()                {
  return alphabetSize;                      }

public String toString()                    {
  return String.valueOf(data);              }

};