Coverage Report - org.webmacro.servlet.ListUtil
 
Classes in this File Line Coverage Branch Coverage Complexity
ListUtil
1%
3/263
0%
0/140
3.231
 
 1  
 /*
 2  
  * Copyright (C) 1998-2000 Semiotek Inc.  All Rights Reserved.
 3  
  *
 4  
  * Redistribution and use in source and binary forms, with or without
 5  
  * modification, are permitted under the terms of either of the following
 6  
  * Open Source licenses:
 7  
  *
 8  
  * The GNU General Public License, version 2, or any later version, as
 9  
  * published by the Free Software Foundation
 10  
  * (http://www.fsf.org/copyleft/gpl.html);
 11  
  *
 12  
  *  or
 13  
  *
 14  
  * The Semiotek Public License (http://webmacro.org/LICENSE.)
 15  
  *
 16  
  * This software is provided "as is", with NO WARRANTY, not even the
 17  
  * implied warranties of fitness to purpose, or merchantability. You
 18  
  * assume all risks and liabilities associated with its use.
 19  
  *
 20  
  * See www.webmacro.org for more information on the WebMacro project.
 21  
  */
 22  
 
 23  
 package org.webmacro.servlet;
 24  
 
 25  
 import java.util.ArrayList;
 26  
 import java.util.Arrays;
 27  
 import java.util.Enumeration;
 28  
 import java.util.Iterator;
 29  
 import java.util.List;
 30  
 import java.util.ListIterator;
 31  
 import java.util.StringTokenizer;
 32  
 
 33  
 /**
 34  
  * A utility class for templates loaded into the context as "List" by ListTool.
 35  
  * It allows template designers to work with Java arrays and lists 
 36  
  * without having to distinguish between them.
 37  
  *
 38  
  * @author Keats Kirsch
 39  
  * @author Zeljko Trogrlic
 40  
  * @version $Revision: 1.1 $
 41  
  * @since Oct. 2000
 42  
  * @see ListTool
 43  
  */
 44  
 public final class ListUtil
 45  
 {
 46  
 
 47  
     /**
 48  
      * Private constructor for a singleton class.
 49  
      */
 50  
     private ListUtil ()
 51  2
     {
 52  2
     }
 53  
 
 54  2
     private static ListUtil _singleton = new ListUtil();
 55  
 
 56  
     /**
 57  
      * @return the singleton instance of this class
 58  
      */
 59  
     public static ListUtil getInstance ()
 60  
     {
 61  0
         return _singleton;
 62  
     }
 63  
 
 64  
     /**
 65  
      * @return true if the argument implements the java.util.List interface, false otherwise.
 66  
      */
 67  
     public boolean isList (Object o)
 68  
     {
 69  0
         if (o == null) return false;
 70  0
         return o instanceof List;
 71  
     }
 72  
 
 73  
     /**
 74  
      * @return true if the argument is an array, otherwise false.
 75  
      */
 76  
     public boolean isArray (Object o)
 77  
     {
 78  0
         if (o == null) return false;
 79  0
         return o.getClass().isArray();
 80  
     }
 81  
 
 82  
     /**
 83  
      * @return false if the argument is a list or an array with at least one element,
 84  
      * true otherwise.
 85  
      */
 86  
     public static boolean isEmpty (Object arg)
 87  
     {
 88  0
         if (arg == null) return true;
 89  0
         if (arg instanceof List) return ((List) arg).isEmpty();
 90  0
         if (arg instanceof Object[]) return ((Object[]) arg).length == 0;
 91  0
         if (arg instanceof Iterator) return ((Iterator) arg).hasNext();
 92  0
         if (arg instanceof Enumeration)
 93  0
             return ((Enumeration) arg).hasMoreElements();
 94  
         // check for primitive arrays
 95  0
         if (arg.getClass().isArray())
 96  
         {
 97  0
             return java.lang.reflect.Array.getLength(arg) == 0;
 98  
         }
 99  0
         return true;
 100  
     }
 101  
 
 102  
     /**
 103  
      * Returns a List for any Object.  The action taken depends on the
 104  
      * type of the argument:
 105  
      * <ul>
 106  
      * <li>arg implements List: return the argument unchanged.</li>
 107  
      * <li>arg is an object array: wrap using Arrays.asList().</li>
 108  
      * <li>arg is an Iterator or Enumeration: all the
 109  
      * elements are copied into a new ArrayList.</li>
 110  
      * <li>arg is an Array of primitives: elements are copied into an ArrayList.</li>
 111  
      *   <ul>
 112  
      *     <li>If the Iterator is a ListIterator it is reset to the beginning</li>
 113  
      *     <li>Otherwise Iterators and Enumerations are exhausted by this method.</li>
 114  
      *   </ul>
 115  
      * <li>arg is null: a new empty List is returned</li>
 116  
      * <li>arg is anything else: it is added to a new list</li>
 117  
      * </ul>
 118  
      *
 119  
      * @param arg
 120  
      */
 121  
     public static List toList (Object arg)
 122  
     {
 123  0
         List list = null;
 124  0
         if (arg instanceof List)
 125  
         {
 126  0
             list = (List) arg;
 127  
         }
 128  0
         else if (arg == null)
 129  
         { // return an empty list
 130  0
             list = Arrays.asList(new Object[0]);
 131  
         }
 132  0
         else if (arg instanceof Object[])
 133  
         {
 134  0
             list = Arrays.asList((Object[]) arg);
 135  
         }
 136  0
         else if (arg instanceof Iterator)
 137  
         {
 138  0
             list = iteratorToList((Iterator) arg);
 139  
         }
 140  0
         else if (arg instanceof Enumeration)
 141  
         {
 142  0
             list = iteratorToList(new org.webmacro.util.EnumIterator((Enumeration) arg));
 143  
         }
 144  0
         else if (arg.getClass().isArray())
 145  
         {
 146  
             // array of primitives
 147  0
             list = iteratorToList(new org.webmacro.util.PrimitiveArrayIterator(arg));
 148  
         }
 149  
         else
 150  
         {
 151  
             // put the object into a single element list
 152  0
             Object[] oa = {arg};
 153  0
             list = Arrays.asList(oa);
 154  
         }
 155  0
         return list;
 156  
     }
 157  
 
 158  
     static private List iteratorToList (Iterator iter)
 159  
     {
 160  0
         List list = new ArrayList();
 161  0
         while (iter.hasNext())
 162  
         {
 163  0
             list.add(iter.next());
 164  
         }
 165  
         // rewind the Iterator if it is a ListIterator
 166  0
         if (iter instanceof ListIterator)
 167  
         {
 168  0
             ListIterator li = (ListIterator) iter;
 169  0
             while (li.hasPrevious()) li.previous();
 170  
         }
 171  0
         return list;
 172  
     }
 173  
 
 174  
     /**
 175  
      * Allows access to elements in an array by position.  Index is zero based.
 176  
      */
 177  
     public static Object getItem (Object[] oa, int pos)
 178  
     {
 179  0
         if ((pos < 0) || ((pos - 1) > oa.length))
 180  0
             throw new IndexOutOfBoundsException(
 181  
                     "Index must be between 0 and " + (oa.length - 1)
 182  
                     + ", user specified " + pos);
 183  0
         return oa[pos];
 184  
     }
 185  
 
 186  
     /**
 187  
      * Allows access to elements in a List by position.  Index is zero based.
 188  
      */
 189  
     public static Object getItem (List list, int pos)
 190  
     {
 191  0
         if (pos < 0 || (pos + 1) > list.size())
 192  0
             throw new IndexOutOfBoundsException(
 193  
                     "Index must be between 0 and " + (list.size() - 1)
 194  
                     + ", user specified " + pos);
 195  0
         return list.get(pos);
 196  
     }
 197  
 
 198  
     /**
 199  
      * Allows access to elements in a array of primitives by position.
 200  
      * The index is zero based.
 201  
      *
 202  
      * @param arr the array of primitives
 203  
      * @param pos the position (0 based) to retrieve from
 204  
      */
 205  
     public static Object getItem (Object arr, int pos)
 206  
     {
 207  0
         if (!arr.getClass().isArray())
 208  0
             throw new IllegalArgumentException(
 209  
                     "The first argument must be of List or array type.");
 210  0
         return java.lang.reflect.Array.get(arr, pos);
 211  
     }
 212  
 
 213  
     /**
 214  
      * @return number of elements in array argument
 215  
      */
 216  
     public static int size (Object[] oa)
 217  
     {
 218  0
         return oa.length;
 219  
     }
 220  
 
 221  
     /**
 222  
      * @return number of elements in List argument
 223  
      */
 224  
     public static int size (List list)
 225  
     {
 226  0
         return list.size();
 227  
     }
 228  
 
 229  
     public static int size (Object arr)
 230  
     {
 231  0
         if (!arr.getClass().isArray())
 232  0
             throw new IllegalArgumentException(
 233  
                     "The argument must be of List or array type.");
 234  0
         return java.lang.reflect.Array.getLength(arr);
 235  
     }
 236  
 
 237  
     /**
 238  
      * @return true if List argument contains the object argument, else false
 239  
      */
 240  
     public static boolean contains (List list, Object o)
 241  
     {
 242  0
         return list.contains(o);
 243  
     }
 244  
 
 245  
     /**
 246  
      * @return true if Array argument contains the object argument, else false
 247  
      */
 248  
     public static boolean contains (Object[] oa, Object o)
 249  
     {
 250  0
         return contains(Arrays.asList(oa), o);
 251  
     }
 252  
 
 253  
     /**
 254  
      * @return true if array argument contains the object argument, else false
 255  
      */
 256  
     public static boolean contains (Object arr, Object o)
 257  
     {
 258  0
         if (!arr.getClass().isArray())
 259  0
             throw new IllegalArgumentException(
 260  
                     "The argument must be of List or array type.");
 261  0
         for (int i = 0; i < java.lang.reflect.Array.getLength(arr); i++)
 262  
         {
 263  0
             if (o.equals(java.lang.reflect.Array.get(arr, i))) return true;
 264  
         }
 265  0
         return false;
 266  
     }
 267  
 
 268  
     /**
 269  
      * Splits list into multiple lists of equal size. If list size cannot be divided
 270  
      * by column count, last part is padded with nulls.
 271  
      * @param arg List to be splitted.
 272  
      * @param colCount Number of elements in each split.
 273  
      * @return List of list parts.
 274  
      */
 275  
     public static List split (List arg, int colCount)
 276  
     {
 277  
 
 278  0
         return split(arg, colCount, true, null);
 279  
     }
 280  
 
 281  
     /**
 282  
      * Splits list into multiple lists of equal size. If list size cannot be divided
 283  
      * by column count, fill parameter determines should it be padded with nulls
 284  
      * or not.
 285  
      * @param arg List to be splitted.
 286  
      * @param colCount Number of elements in each split.
 287  
      * @param pad Last split should be null padded?
 288  
      * @return List of list parts.
 289  
      */
 290  
     public static List split (List arg, int colCount, boolean pad)
 291  
     {
 292  
 
 293  0
         return split(arg, colCount, pad, null);
 294  
     }
 295  
 
 296  
     /**
 297  
      * Splits list into multiple lists of equal size. If list size cannot be divided
 298  
      * by column count, it's padded with pad value.
 299  
      * @param arg List to be splitted.
 300  
      * @param colCount Number of elements in each split.
 301  
      * @param padValue Value that will be used for padding.
 302  
      * @return List of list parts.
 303  
      */
 304  
     public static List split (List arg, int colCount, Object padValue)
 305  
     {
 306  
 
 307  0
         return split(arg, colCount, true, padValue);
 308  
     }
 309  
 
 310  
     /**
 311  
      * Splits list into multiple lists of equal size. If list size cannot be
 312  
      * divided by column count, fill parameter determines should it be padded with
 313  
      * pad value or not.
 314  
      * @param arg List to be splitted.
 315  
      * @param colCount Number of elements in each split.
 316  
      * @param pad Last split should be null padded?
 317  
      * @param padValue Value that will be used for padding.
 318  
      * @return List of list parts.
 319  
      */
 320  
     public static List split (List arg, int colCount, boolean pad,
 321  
                               Object padValue)
 322  
     {
 323  
 
 324  0
         int size = arg.size();
 325  0
         List rows = new ArrayList(size / colCount + 1);
 326  0
         int start = 0;
 327  0
         int end = colCount;
 328  0
         while (start < size)
 329  
         {
 330  
             List row;
 331  
             // check is this last and uncomplete row
 332  0
             if (end > size)
 333  
             {
 334  
                 // using sublist directly can cause synchronization problems
 335  0
                 row = new ArrayList(arg.subList(start, size));
 336  0
                 if (pad)
 337  
                 {
 338  0
                     for (int i = size; i < end; ++i)
 339  
                     {
 340  0
                         row.add(padValue);
 341  
                     }
 342  
                 }
 343  
             }
 344  
             else
 345  
             {
 346  0
                 row = new ArrayList(arg.subList(start, end));
 347  
             }
 348  0
             rows.add(row);
 349  0
             start = end;
 350  0
             end += colCount;
 351  0
         }
 352  0
         return rows;
 353  
     }
 354  
 
 355  
     /**
 356  
      * Splits array into multiple arrays of equal size. If list size
 357  
      * cannot be divided by column count, last part is padded with
 358  
      * nulls.
 359  
      * @param arg array to be splitted.
 360  
      * @param colCount Number of elements in each split.
 361  
      * @return array of list parts.  */
 362  
     public static Object[] split (Object[] arg, int colCount)
 363  
     {
 364  
 
 365  0
         return split(arg, colCount, true, null);
 366  
     }
 367  
 
 368  
     /**
 369  
      * Splits array into multiple arrays of equal size. If list size
 370  
      * cannot be divided by column count, fill parameter determines
 371  
      * should it be padded with nulls or not.
 372  
      * @param arg array to be splitted.
 373  
      * @param colCount Number of elements in each split.
 374  
      * @param pad Last split should be null padded?
 375  
      * @return array of list parts.  */
 376  
     public static Object[] split (Object[] arg, int colCount, boolean pad)
 377  
     {
 378  
 
 379  0
         return split(arg, colCount, pad, null);
 380  
     }
 381  
 
 382  
     /**
 383  
      * Splits array into multiple arrays of equal size. If list size
 384  
      * cannot be divided by column count, it's padded with pad value.
 385  
      * @param arg Object[] to be splitted.
 386  
      * @param colCount Number of elements in each split.
 387  
      * @param padValue Value that will be used for padding.
 388  
      * @return Object[] of list parts.  */
 389  
     public static Object[] split (Object[] arg, int colCount, Object padValue)
 390  
     {
 391  
 
 392  0
         return split(arg, colCount, true, padValue);
 393  
     }
 394  
 
 395  
     /**
 396  
      * Splits array into multiple arrays of equal size. If array size
 397  
      * cannot be divided by column count, fill parameter determines
 398  
      * should it be padded with nulls or not.
 399  
      * @param arg Array to be splitted.
 400  
      * @param colCount Number of elements in each split.
 401  
      * @param pad Last split should be null padded?
 402  
      * @param padValue Value that will be used for padding.
 403  
      * @return Array of array parts.  */
 404  
     public static Object[][] split (Object[] arg, int colCount, boolean pad,
 405  
                                     Object padValue)
 406  
     {
 407  
 
 408  0
         int size = arg.length;
 409  0
         int rowCount = size / colCount;
 410  0
         if ((size % colCount) != 0)
 411  
         {
 412  0
             ++rowCount;
 413  
         }
 414  0
         Object[][] rows = new Object[rowCount][];
 415  0
         int start = 0;
 416  0
         int end = colCount;
 417  0
         for (int rowNo = 0; rowNo < rowCount; ++rowNo)
 418  
         {
 419  
             Object[] row;
 420  
             // check is this last and uncomplete row
 421  0
             if (end > size)
 422  
             {
 423  0
                 int tail = size - start;
 424  0
                 if (pad)
 425  
                 {
 426  0
                     row = new Object[colCount];
 427  0
                     System.arraycopy(arg, start, row, 0, tail);
 428  0
                     if (padValue != null)
 429  
                     {
 430  0
                         for (int i = tail; i < end; ++i)
 431  
                         {
 432  0
                             row[i] = padValue;
 433  
                         }
 434  
                     }
 435  
                 }
 436  
                 else
 437  
                 {
 438  0
                     row = new Object[tail];
 439  0
                     System.arraycopy(arg, start, row, 0, tail);
 440  
                 }
 441  0
             }
 442  
             else
 443  
             {
 444  0
                 row = new Object[colCount];
 445  0
                 System.arraycopy(arg, start, row, 0, colCount);
 446  
             }
 447  0
             rows[rowNo] = row;
 448  0
             start = end;
 449  0
             end += colCount;
 450  
         }
 451  0
         return rows;
 452  
     }
 453  
 
 454  
     /**
 455  
      * Transposes and splits array into multiple arrays of equal size. If array
 456  
      * size cannot be divided by column count, it's padded with nulls.
 457  
      * @param arg Array to be splitted.
 458  
      * @param colCount Number of elements in each split.
 459  
      * @return Array of array parts.
 460  
      */
 461  
     public static Object[][] transposeSplit (Object[] arg, int colCount)
 462  
     {
 463  
 
 464  0
         return transposeSplit(arg, colCount, true, null);
 465  
     }
 466  
 
 467  
     /**
 468  
      * Transposes and splits array into multiple arrays of equal
 469  
      * size. If array size cannot be divided by column count, fill
 470  
      * parameter determines should it be padded with nulls or not.
 471  
      * @param arg Array to be splitted.
 472  
      * @param colCount Number of elements in each split.
 473  
      * @param pad Last split should be null padded?
 474  
      * @return Array of array parts.  */
 475  
     public static Object[][] transposeSplit (Object[] arg, int colCount,
 476  
                                              boolean pad)
 477  
     {
 478  
 
 479  0
         return transposeSplit(arg, colCount, pad, null);
 480  
     }
 481  
 
 482  
     /**
 483  
      * Transposes and splits array into multiple arrays of equal size. If array
 484  
      * size cannot be divided by column count, it's padded with padValue.
 485  
      * @param arg Array to be splitted.
 486  
      * @param colCount Number of elements in each split.
 487  
      * @param padValue Value that will be used for padding.
 488  
      * @return Array of array parts.
 489  
      */
 490  
     public static Object[][] transposeSplit (Object[] arg, int colCount,
 491  
                                              Object padValue)
 492  
     {
 493  
 
 494  0
         return transposeSplit(arg, colCount, true, padValue);
 495  
     }
 496  
 
 497  
     /**
 498  
      * Transposes and splits array into multiple arrays of equal
 499  
      * size. If array size cannot be divided by column count, fill
 500  
      * parameter determines should it be padded with padValue or not.
 501  
      * @param arg Array to be splitted.
 502  
      * @param colCount Number of elements in each split.
 503  
      * @param pad Last split should be null padded?
 504  
      * @param padValue Value that will be used for padding.
 505  
      * @return Array of array parts.
 506  
      */
 507  
     public static Object[][] transposeSplit (Object[] arg, int colCount,
 508  
                                              boolean pad, Object padValue)
 509  
     {
 510  0
         int size = arg.length;
 511  0
         int rowCount = size / colCount;
 512  
         Object[][] rows;
 513  0
         boolean slack = (size % colCount) != 0;
 514  0
         if (slack)
 515  
         {
 516  0
             ++rowCount;
 517  
         }
 518  0
         if (slack && !pad)
 519  
         {
 520  0
             int tail = size % rowCount;
 521  0
             rows = new Object[rowCount][];
 522  0
             for (int rowNo = 0; rowNo < rowCount; ++rowNo)
 523  
             {
 524  0
                 if (rowNo < tail)
 525  
                 {
 526  0
                     rows[rowNo] = new Object[colCount];
 527  
                 }
 528  
                 else
 529  
                 {
 530  0
                     rows[rowNo] = new Object[colCount - 1];
 531  
                 }
 532  
             }
 533  0
         }
 534  
         else
 535  
         {
 536  0
             rows = new Object[rowCount][colCount];
 537  
         }
 538  
 
 539  0
         int pos = 0;
 540  0
         for (int colNo = 0; colNo < colCount; ++colNo)
 541  
         {
 542  0
             for (int rowNo = 0; rowNo < rowCount; ++rowNo)
 543  
             {
 544  0
                 if (pos < size)
 545  
                 {
 546  0
                     rows[rowNo][colNo] = arg[pos++];
 547  
                 }
 548  0
                 else if (pad)
 549  
                 {
 550  0
                     rows[rowNo][colNo] = padValue;
 551  
                 }
 552  
                 else
 553  
                 {
 554  
                     break;
 555  
                 }
 556  
             }
 557  
         }
 558  0
         return rows;
 559  
     }
 560  
 
 561  
     /**
 562  
      * Transposes and splits list into multiple lists of equal size. If list
 563  
      * size cannot be divided by column count, it's padded with nulls.
 564  
      * @param arg List to be splitted.
 565  
      * @param colCount Number of elements in each split.
 566  
      * @return List of list parts.
 567  
      */
 568  
     public static List transposeSplit (List arg, int colCount)
 569  
     {
 570  
 
 571  0
         return transposeSplit(arg, colCount, true, null);
 572  
     }
 573  
 
 574  
     /**
 575  
      * Transposes and splits list into multiple lists of equal size. If
 576  
      * list size cannot be divided by column count, fill parameter
 577  
      * determines should it be padded with nulls or not.
 578  
      * @param arg List to be splitted.
 579  
      * @param colCount Number of elements in each split.
 580  
      * @param pad Last split should be null padded?
 581  
      * @return List of list parts.  */
 582  
     public static List transposeSplit (List arg, int colCount,
 583  
                                        boolean pad)
 584  
     {
 585  
 
 586  0
         return transposeSplit(arg, colCount, pad, null);
 587  
     }
 588  
 
 589  
     /**
 590  
      * Transposes and splits list into multiple lists of equal size. If list
 591  
      * size cannot be divided by column count, it's padded with padValue.
 592  
      * @param arg List to be splitted.
 593  
      * @param colCount Number of elements in each split.
 594  
      * @param padValue Value that will be used for padding.
 595  
      * @return List of list parts.
 596  
      */
 597  
     public static List transposeSplit (List arg, int colCount,
 598  
                                        Object padValue)
 599  
     {
 600  
 
 601  0
         return transposeSplit(arg, colCount, true, padValue);
 602  
     }
 603  
 
 604  
     /**
 605  
      * Transposes and splits list into multiple lists of equal size. If
 606  
      * list size cannot be divided by column count, fill parameter
 607  
      * determines should it be padded with padValue or not.
 608  
      * @param arg List to be splitted.
 609  
      * @param colCount Number of elements in each split.
 610  
      * @param pad Last split should be null padded?
 611  
      * @param padValue Value that will be used for padding.
 612  
      * @return List of list parts.  */
 613  
     public static List transposeSplit (List arg, int colCount,
 614  
                                        boolean pad, Object padValue)
 615  
     {
 616  
 
 617  0
         int size = arg.size();
 618  0
         int rowCount = size / colCount;
 619  0
         if ((size % colCount) != 0)
 620  
         {
 621  0
             ++rowCount;
 622  
         }
 623  0
         List rows = new ArrayList(rowCount);
 624  0
         for (int rowNo = 0; rowNo < rowCount; ++rowNo)
 625  
         {
 626  0
             rows.add(new ArrayList(colCount));
 627  
         }
 628  0
         Iterator it = arg.iterator();
 629  0
         for (int colNo = 0; colNo < colCount; ++colNo)
 630  
         {
 631  0
             for (int rowNo = 0; rowNo < rowCount; ++rowNo)
 632  
             {
 633  0
                 List row = (List) rows.get(rowNo);
 634  0
                 if (it.hasNext())
 635  
                 {
 636  0
                     row.add(it.next());
 637  
                 }
 638  0
                 else if (pad)
 639  
                 {
 640  0
                     row.add(padValue);
 641  
                 }
 642  
                 else
 643  
                 {
 644  
                     break;
 645  
                 }
 646  
             }
 647  
         }
 648  0
         return rows;
 649  
     }
 650  
 
 651  
     public static List createRange (int rangeBegin, int rangeEnd)
 652  
     {
 653  0
         return createRange(rangeBegin, rangeEnd, 1);
 654  
     }
 655  
 
 656  
     public static List createRange (int rangeBegin, int rangeEnd, int incr)
 657  
     {
 658  0
         if (incr > 0)
 659  
         {
 660  0
             if (rangeBegin > rangeEnd)
 661  0
                 throw new IllegalArgumentException("Starting number must be less than ending number");
 662  
         }
 663  0
         else if (incr < 0)
 664  
         {
 665  0
             if (rangeBegin < rangeEnd)
 666  0
                 throw new IllegalArgumentException("Starting number must be greater than ending number");
 667  
         }
 668  
         else
 669  
         { // incr == 0
 670  0
             throw new IllegalArgumentException("Increment cannot be zero");
 671  
         }
 672  
 
 673  0
         int size = ((rangeEnd - rangeBegin) / incr) + 1;
 674  0
         Integer[] ia = new Integer[size];
 675  0
         int i = 0;
 676  0
         for (int num = rangeBegin; (incr > 0) ? num <= rangeEnd : num >= rangeEnd; num += incr)
 677  
         {
 678  0
             ia[i++] = new Integer(num);
 679  
         }
 680  0
         return Arrays.asList(ia);
 681  
     }
 682  
 
 683  
     /** Create a new ArrayList. */
 684  
     public static ArrayList create ()
 685  
     {
 686  0
         return new ArrayList();
 687  
     }
 688  
 
 689  
     /** Create a new ArrayList with the specified capacity. */
 690  
     public static ArrayList create (int capacity)
 691  
     {
 692  0
         return new ArrayList(capacity);
 693  
     }
 694  
 
 695  
     /** 
 696  
      * Append one list to the end of another and return the expanded list.
 697  
      * If the first list is not expandable, return a new expandable list
 698  
      * with the elements of each list appended
 699  
      */
 700  
     public static List append (Object o1, Object o2)
 701  
     {
 702  0
         List l1 = toList(o1);
 703  0
         List l2 = toList(o2);
 704  
         try
 705  
         {
 706  0
             l1.addAll(l2);
 707  0
             return l1;
 708  
         }
 709  0
         catch (Exception e)
 710  
         {
 711  
           // create a new list
 712  0
           List l = new ArrayList(((l1.size() + l2.size()) * 2) + 10);
 713  0
           l.addAll(l1);
 714  0
           l.addAll(l2);
 715  0
           return l;
 716  
         }
 717  
     }
 718  
 
 719  
     /** Create a new list (ArrayList) with all the elements in the supplied list. */
 720  
     public static List copy (Object o)
 721  
     {
 722  0
         List l = toList(o);
 723  0
         if (l.isEmpty()) return new ArrayList(10);
 724  0
         return new ArrayList(l);
 725  
     }
 726  
 
 727  
     /** Test harness. */
 728  
     public static void main (String[] args)
 729  
     {
 730  0
         java.io.PrintWriter out =
 731  
                 new java.io.PrintWriter(System.out, true);
 732  0
         ListUtil lu = ListUtil.getInstance();
 733  
 
 734  0
         out.println("createRange(2, 10, 2): " + createRange(2, 10, 2));
 735  0
         out.println("createRange(-10, 0): " + createRange(-10, 0));
 736  0
         out.println("createRange(21, 10, -5): " + createRange(21, 10, -5));
 737  0
         out.println("createRange(21, 21, -5): " + createRange(21, 21, -5));
 738  
 
 739  0
         Object[] arr = {
 740  
             "ant", "bird", "cat", "dog", "elephant", "ferret", "gopher"
 741  
         };
 742  0
         ArrayList l = new ArrayList(Arrays.asList(arr));
 743  
 
 744  0
         out.println("List/Array results");
 745  0
         out.print("toList(): ");
 746  0
         out.println(ListUtil.toList(l) + "/" + ListUtil.toList(arr));
 747  0
         out.print("size: ");
 748  0
         out.println(ListUtil.size(l) + "/" + ListUtil.size(arr));
 749  0
         out.print("contains(\"bird\"): ");
 750  0
         out.println(ListUtil.contains(l, "bird") + "/" + ListUtil.contains(arr, "bird"));
 751  0
         out.print("contains(\"fish\"): ");
 752  0
         out.println(ListUtil.contains(l, "fish") + "/" + ListUtil.contains(arr, "fish"));
 753  0
         out.print("isArray: ");
 754  0
         out.println(lu.isArray(l) + "/" + lu.isArray(arr));
 755  0
         out.print("isList: ");
 756  0
         out.println(lu.isList(l) + "/" + lu.isList(arr));
 757  0
         out.print("getItem(5): ");
 758  0
         out.println(ListUtil.getItem(l, 5) + "/" + ListUtil.getItem(arr, 5));
 759  0
         out.print("getItem(0): ");
 760  
         try
 761  
         {
 762  0
             out.println(ListUtil.getItem(l, 0) + "/" + ListUtil.getItem(arr, 0));
 763  
         }
 764  0
         catch (Exception e)
 765  
         {
 766  0
             out.println(e);
 767  0
         }
 768  0
         out.println("toList(null): " + ListUtil.toList(null));
 769  0
         out.println("toList(\"a string\"): " + ListUtil.toList("a string"));
 770  
 
 771  0
         StringTokenizer st = new StringTokenizer(
 772  
                 "This is a bunch of words!");
 773  0
         List l2 = ListUtil.toList(st);
 774  0
         out.println("toList(Enumeration): " + l2);
 775  0
         Iterator iter = l2.listIterator();
 776  0
         List l3 = ListUtil.toList(iter);
 777  0
         out.println("toList(Iterator): " + l3 + ", iter.hasNext(): " + iter.hasNext());
 778  
         // test split
 779  0
         out.println("List split with fill");
 780  0
         List splitList1 = split(l, 3, true);
 781  0
         for (Iterator it1 = splitList1.iterator(); it1.hasNext(); )
 782  
         {
 783  0
             out.print("-: ");
 784  0
             List part = (List) it1.next();
 785  0
             for (Iterator it2 = part.iterator(); it2.hasNext(); )
 786  
             {
 787  0
                 out.print(it2.next() + ", ");
 788  
             }
 789  0
             out.println("*");
 790  0
         }
 791  0
         out.println("List transposeSplit");
 792  0
         List splitList2 = transposeSplit(l, 3, false);
 793  0
         for (Iterator it1 = splitList2.iterator(); it1.hasNext(); )
 794  
         {
 795  0
             out.print("-: ");
 796  0
             List part = (List) it1.next();
 797  0
             for (Iterator it2 = part.iterator(); it2.hasNext(); )
 798  
             {
 799  0
                 out.print(it2.next() + ", ");
 800  
             }
 801  0
             out.println("*");
 802  0
         }
 803  0
         out.println("Array split");
 804  0
         Object[] splitArray1 = split(new String[]{"pero"}, 2, false);
 805  0
         for (int i = 0; i < splitArray1.length; ++i)
 806  
         {
 807  0
             out.print("-: ");
 808  0
             Object[] part = (Object[]) splitArray1[i];
 809  0
             for (int j = 0; j < part.length; ++j)
 810  
             {
 811  0
                 out.print(part[j] + ", ");
 812  
             }
 813  0
             out.println("*");
 814  
         }
 815  0
         out.println("Array transposeSplit");
 816  0
         Object[][] splitArray3 = transposeSplit(
 817  
                 new String[]{
 818  
                     "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
 819  
                     "11", "12", "14", "15", "16", "17", "18", "19"
 820  
                 }, 3, false);
 821  0
         for (int i = 0; i < splitArray3.length; ++i)
 822  
         {
 823  0
             out.print("-: ");
 824  0
             for (int j = 0; j < splitArray3[i].length; ++j)
 825  
             {
 826  0
                 out.print(splitArray3[i][j] + ", ");
 827  
             }
 828  0
             out.println("*");
 829  
         }
 830  
         // test primitive arrays
 831  0
         int[] emptyInts = new int[0];
 832  0
         out.println("Empty array of int: isEmpty=" + isEmpty(emptyInts));
 833  0
         char[] chars = {'A', 'B', 'C'};
 834  0
         out.println("Array of char: isEmpty=" + isEmpty(chars) + ", size=" + size(chars));
 835  0
         out.println("contains 'C'=" + contains(chars, new Character('C')));
 836  0
         out.println("contains 'Z'=" + contains(chars, new Character('Z')));
 837  0
         out.println("toList=" + toList(chars));
 838  0
         float[] f = new float[]{1.1f, 2.2f, 3.3f};
 839  0
         out.println("getItem(floats, 0)=" + getItem(f, 0));
 840  0
         List appendList = append(f, chars);
 841  0
         out.println("append(f, chars)=" + appendList);
 842  0
         append(appendList, "another thing");
 843  0
         out.println("append(appendList, \"another thing\")=" + appendList);
 844  0
     }
 845  
 }