src/main/java/jp/sourceforge/mikutoga/corelib/ListUtil.java

   1 /*
   2  * List utilities
   3  *
   4  * License : The MIT License
   5  * Copyright(c) 2010 MikuToga Partners
   6  */
   7
   8 package jp.sourceforge.mikutoga.corelib;
   9
  10 import java.lang.reflect.Constructor;
  11 import java.lang.reflect.InvocationTargetException;
  12 import java.util.List;
  13 import jp.sourceforge.mikutoga.pmd.model.SerialNumbered;
  14
  15 /**
  16  * リスト構造の各種ユーティリティ。
  17  */
  18 public final class ListUtil {
  19
  20     /**
  21      * 隠しコンストラクタ。
  22      */
  23     private ListUtil(){
  24         assert false;
  25         throw new AssertionError();
  26     }
  27
  28     /**
  29      * リストの出現順にシリアルナンバーを割り振る。
  30      * シリアルナンバー先頭は0。
  31      * @param list リスト。
  32      */
  33     public static void assignIndexedSerial(
  34             List<? extends SerialNumbered> list){
  35         int serial = 0;
  36         for(SerialNumbered numbered : list){
  37             numbered.setSerialNumber(serial);
  38             serial++;
  39         }
  40
  41         return;
  42     }
  43
  44     /**
  45      * リストの要素数を拡張する。
  46      * 追加された要素にはnullが収められる。
  47      * リストがすでに指定サイズ以上の要素数を持つ場合、何もしない。
  48      * @param <E> 型
  49      * @param list リスト
  50      * @param newSize 新サイズ
  51      */
  52     public static <E> void extendList(List<E> list, int newSize){
  53         int remain = newSize - list.size();
  54         if(remain <= 0) return;
  55
  56         for(int ct = 1; ct <= remain; ct++){
  57             list.add(null);
  58         }
  59
  60         assert list.size() == newSize;
  61
  62         return;
  63     }
  64
  65     /**
  66      * リストのnull要素をデフォルトコンストラクタによるインスタンスで埋める。
  67      * null要素がなければなにもしない。
  68      * @param <E> 型
  69      * @param list リスト
  70      * @param cons コンストラクタ
  71      * @return 埋めた数
  72      */
  73     public static <E> int fillDefCons(List<E> list,
  74                                       Constructor<? extends E> cons){
  75         int result = 0;
  76
  77         int size = list.size();
  78         for(int pt = 0; pt < size; pt++){
  79             E elem = list.get(pt);
  80             if(elem != null) continue;
  81
  82             try{
  83                 elem = cons.newInstance();
  84             }catch(InstantiationException e){
  85                 assert false;
  86                 throw new AssertionError(e);
  87             }catch(IllegalAccessException e){
  88                 assert false;
  89                 throw new AssertionError(e);
  90             }catch(InvocationTargetException e){
  91                 Throwable cause = e.getTargetException();
  92                 if(cause instanceof RuntimeException){
  93                     throw (RuntimeException) cause;
  94                 }
  95                 if(cause instanceof Error){
  96                     throw (Error) cause;
  97                 }
  98                 assert false;
  99                 throw new AssertionError(e);
 100             }
 101
 102             list.set(pt, elem);
 103             result++;
 104         }
 105
 106         return result;
 107     }
 108
 109     /**
 110      * リストのnull要素をデフォルトコンストラクタによるインスタンスで埋める。
 111      * @param <E> 型
 112      * @param list リスト
 113      * @param klass デフォルトコンストラクタの属するクラス
 114      * @return 埋めた数
 115      */
 116     public static <E> int fillDefCons(List<E> list, Class<? extends E> klass){
 117         Constructor<? extends E> cons;
 118         try{
 119             cons = klass.getConstructor();
 120         }catch(NoSuchMethodException e){
 121             assert false;
 122             throw new AssertionError(e);
 123         }
 124
 125         return fillDefCons(list, cons);
 126     }
 127
 128     /**
 129      * リスト要素数の拡張とデフォルトコンストラクタによる要素埋めを行う。
 130      * 追加された要素および既存のnull要素には
 131      * デフォルトコンストラクタによるインスタンスが収められる。
 132      * @param <E> 型
 133      * @param list リスト
 134      * @param klass デフォルトコンストラクタの属するクラス
 135      * @param newSize 新サイズ
 136      * @return 埋めた数。
 137      */
 138     public static <E> int prepareDefConsList(List<E> list,
 139                                              Class<? extends E> klass,
 140                                              int newSize ){
 141         extendList(list, newSize);
 142         int result = fillDefCons(list, klass);
 143         return result;
 144     }
 145
 146 }