/[classpath]/classpath/javax/print/attribute/SetOfIntegerSyntax.java
ViewVC logotype

Diff of /classpath/javax/print/attribute/SetOfIntegerSyntax.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2.2.1 by gnu_andrew, Tue Aug 2 20:12:36 2005 UTC revision 1.2.2.2 by gnu_andrew, Wed Nov 2 00:43:40 2005 UTC
# Line 38  exception statement from your version. * Line 38  exception statement from your version. *
38  package javax.print.attribute;  package javax.print.attribute;
39    
40  import java.io.Serializable;  import java.io.Serializable;
41  import java.util.Vector;  import java.text.CharacterIterator;
42    import java.text.StringCharacterIterator;
43    import java.util.ArrayList;
44    import java.util.Arrays;
45    import java.util.Comparator;
46    
47  /**  /**
48   * @author Michael Koch   * @author Michael Koch
# Line 50  public abstract class SetOfIntegerSyntax Line 54  public abstract class SetOfIntegerSyntax
54    
55    private int[][] members;    private int[][] members;
56    
57    private static int[][] normalize(Vector vecMembers)    private static int[][] normalize(int[][] values, int size)
58    {    {
59      // XXX: Perhaps we should merge ranges that overlap.      // Sort into increasing order.  First the first index is
60            // compared, then the second.
61      int current = 0;      Arrays.sort(values, 0, size, new Comparator()
62      int[][] members = new int[vecMembers.size()][];                  {
63                      public int compare(Object o1, Object o2)
64      while (vecMembers.size() > 0)                    {
65                        int[] v1 = (int[]) o1;
66                        int[] v2 = (int[]) o2;
67                        if (v1[0] == v2[0])
68                          return v1[1] - v2[1];
69                        return v1[0] - v2[0];
70                      }
71                    });
72    
73        // Now coalesce overlapping ranges.
74        int outIndex = 0;
75        for (int i = 0; i < size; ++i)
76        {        {
77          // Search the lowest range.          // Note that we compare with values[i][1]+1, since
78          int[] range = (int[]) vecMembers.elementAt(0);          // we can coalesce {0,1} with {2,x}.
79            int save = i;
80          for (int index = 1; index < vecMembers.size(); index++)          while (i + 1 < size && values[i + 1][0] <= values[i][1] + 1)
81            {            {
82              int[] tmp = (int[]) vecMembers.elementAt(index);              values[i][1] = Math.max(values[i][1], values[i + 1][1]);
83                ++i;
             if (range[0] > tmp[0]  
                 || (range[0] == tmp[0]  
                     && range[0] > tmp[0]))  
               range = tmp;  
84            }            }
85            values[outIndex++] = values[save];
         members[current] = range;  
         current++;  
86        }        }
87            
88      return members;      int[][] result = new int[outIndex][];
89        System.arraycopy(values, 0, result, 0, outIndex);
90        
91        return result;
92    }    }
93        
94    /**    /**
# Line 104  public abstract class SetOfIntegerSyntax Line 116  public abstract class SetOfIntegerSyntax
116     */     */
117    protected SetOfIntegerSyntax(int[][] members)    protected SetOfIntegerSyntax(int[][] members)
118    {    {
119      Vector vecMembers = new Vector();      int[][] newMembers;
120            int outIndex = 0;
121      if (members != null)      if (members == null)
122          newMembers = new int[0][];
123        else
124        {        {
125            newMembers = new int[members.length][];
126          for (int index = 0; index < members.length; index++)          for (int index = 0; index < members.length; index++)
127            {            {
128              int lower;              int lower;
# Line 126  public abstract class SetOfIntegerSyntax Line 141  public abstract class SetOfIntegerSyntax
141              else              else
142                throw new IllegalArgumentException("invalid member element");                throw new IllegalArgumentException("invalid member element");
143    
144                // We only want to reject non-null ranges where lower<0.
145              if (lower <= upper && lower < 0)              if (lower <= upper && lower < 0)
146                throw new IllegalArgumentException("invalid member element");                throw new IllegalArgumentException("invalid member element");
147    
# Line 134  public abstract class SetOfIntegerSyntax Line 150  public abstract class SetOfIntegerSyntax
150                  int[] range = new int[2];                  int[] range = new int[2];
151                  range[0] = lower;                  range[0] = lower;
152                  range[1] = upper;                  range[1] = upper;
153                  vecMembers.add(range);                  newMembers[outIndex++] = range;
154                }                }
155            }            }
156        }        }
157            
158      this.members = normalize(vecMembers);      this.members = normalize(newMembers, outIndex);
159      }
160      
161      private boolean skipWhitespace(StringCharacterIterator i)
162      {
163        while (Character.isWhitespace(i.current()))
164          i.next();
165        return i.current() == CharacterIterator.DONE;
166      }
167      
168      private boolean skipNumber(StringCharacterIterator i)
169      {
170        boolean readAny = false;
171        while (Character.isDigit(i.current()))
172          {
173            readAny = true;
174            i.next();
175          }
176        return readAny;
177      }
178    
179      protected SetOfIntegerSyntax(String s)
180      {
181        ArrayList vals = new ArrayList();
182    
183        StringCharacterIterator it = new StringCharacterIterator(s);
184    
185        while (true)
186          {
187            // Skip whitespace.
188            if (skipWhitespace(it))
189              break;
190    
191            // Parse integer.
192            int index = it.getIndex();
193            if (! skipNumber(it))
194              throw new IllegalArgumentException();
195            int[] item = new int[2];
196            item[0] = Integer.parseInt(s.substring(index, it.getIndex()));
197    
198            if (! skipWhitespace(it))
199              {
200                char c = it.current();
201                if (c == ':' || c == '-')
202                  {
203                    it.next();
204                    if (skipWhitespace(it))
205                      throw new IllegalArgumentException();
206                    index = it.getIndex();
207                    if (! skipNumber(it))
208                      throw new IllegalArgumentException();
209                    item[1] = Integer.parseInt(s.substring(index, it.getIndex()));
210                  }
211                else
212                  item[1] = item[0];
213              }
214            else
215              item[1] = item[0];
216    
217            if (item[0] <= item[1])
218              vals.add(item);
219            
220            if (skipWhitespace(it))
221              break;
222            if (it.current() != ',')
223              throw new IllegalArgumentException();
224            it.next();
225          }
226    
227        members = normalize((int[][]) vals.toArray(new int[0][]), vals.size());
228    }    }
229    
230    /**    /**
# Line 153  public abstract class SetOfIntegerSyntax Line 238  public abstract class SetOfIntegerSyntax
238     */     */
239    protected SetOfIntegerSyntax(int lowerBound, int upperBound)    protected SetOfIntegerSyntax(int lowerBound, int upperBound)
240    {    {
241        // We only want to reject non-null ranges where lower<0.
242      if (lowerBound <= upperBound      if (lowerBound <= upperBound
243          && lowerBound < 0)          && lowerBound < 0)
244        throw new IllegalArgumentException();        throw new IllegalArgumentException();
# Line 175  public abstract class SetOfIntegerSyntax Line 261  public abstract class SetOfIntegerSyntax
261        {        {
262          if (value < members[index][0])          if (value < members[index][0])
263            return false;            return false;
264          else if (value < members[index][1])          else if (value <= members[index][1])
265            return true;            return true;
266        }        }
267    
# Line 205  public abstract class SetOfIntegerSyntax Line 291  public abstract class SetOfIntegerSyntax
291    {    {
292      if (! (obj instanceof SetOfIntegerSyntax))      if (! (obj instanceof SetOfIntegerSyntax))
293        return false;        return false;
294        SetOfIntegerSyntax other = (SetOfIntegerSyntax) obj;
295      throw new Error("not implemented");      if (other.members.length != members.length)
296          return false;
297        for (int i = 0; i < members.length; ++i)
298          {
299            if (members[i][0] != other.members[i][0]
300                || members[i][1] != other.members[i][1])
301              return false;
302          }
303        return true;
304    }    }
305    
306    /**    /**
# Line 216  public abstract class SetOfIntegerSyntax Line 310  public abstract class SetOfIntegerSyntax
310     */     */
311    public int[][] getMembers()    public int[][] getMembers()
312    {    {
313      throw new Error("not implemented");      return (int[][]) members.clone();
314    }    }
315    
316    /**    /**
# Line 226  public abstract class SetOfIntegerSyntax Line 320  public abstract class SetOfIntegerSyntax
320     */     */
321    public int hashCode()    public int hashCode()
322    {    {
323      throw new Error("not implemented");      int result = 0;
324        for (int i = 0; i < members.length; ++i)
325          result += members[i][0] + members[i][1];
326        return result;
327    }    }
328    
329    /**    /**
330     * Returns the smallest value that is greater then x.     * Returns the smallest value that is greater than x which is in this set.
331     *     *
332     * @param x an integer value     * @param x an integer value
333     *     *
# Line 238  public abstract class SetOfIntegerSyntax Line 335  public abstract class SetOfIntegerSyntax
335     */     */
336    public int next(int x)    public int next(int x)
337    {    {
338      throw new Error("not implemented");      for (int i = 0; i < members.length; ++i)
339          {
340            if (x >= members[i][1])
341              continue;
342            if (x < members[i][0])
343              return members[i][0];
344            // X is in this range.
345            return x + 1;
346          }
347        return -1;
348    }    }
349    
350    /**    /**
# Line 248  public abstract class SetOfIntegerSyntax Line 354  public abstract class SetOfIntegerSyntax
354     */     */
355    public String toString()    public String toString()
356    {    {
357      throw new Error("not implemented");      StringBuilder sb = new StringBuilder();
358        for (int i = 0; i < members.length; ++i)
359          {
360            if (i > 0)
361              sb.append(',');
362            sb.append(members[i][0]);
363            if (members[i][0] != members[i][1])
364              {
365                sb.append('-');
366                sb.append(members[i][1]);
367              }
368          }
369        return sb.toString();
370    }    }
371  }  }

Legend:
Removed from v.1.2.2.1  
changed lines
  Added in v.1.2.2.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26