Utils.java

  1. package com.gh.mygreen.xlsmapper.util;

  3. import java.lang.reflect.InvocationTargetException;
  4. import java.lang.reflect.Method;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.Collection;
  8. import java.util.Iterator;
  9. import java.util.LinkedHashSet;
  10. import java.util.LinkedList;
  11. import java.util.List;
  12. import java.util.Locale;
  13. import java.util.Map;
  14. import java.util.Optional;
  15. import java.util.Queue;
  16. import java.util.Set;

  18. import org.apache.poi.ss.usermodel.Sheet;

  20. import com.gh.mygreen.xlsmapper.BeanFactory;
  21. import com.gh.mygreen.xlsmapper.Configuration;
  22. import com.gh.mygreen.xlsmapper.XlsMapperException;
  23. import com.gh.mygreen.xlsmapper.annotation.XlsTrim;
  24. import com.gh.mygreen.xlsmapper.cellconverter.DefaultElementConverter;
  25. import com.gh.mygreen.xlsmapper.cellconverter.ElementConverter;
  26. import com.gh.mygreen.xlsmapper.fieldprocessor.ProcessCase;
  27. import com.gh.mygreen.xlsmapper.validation.SheetBindingErrors;


  30. /**
  31.  * ユーティリティクラス。
  32.  *
  33.  * @version 2.3
  34.  * @author T.TSUCHIE
  35.  * @author Naoki Takezoe
  36.  * @author Mitsuyoshi Hasegawa
  37.  *
  38.  */
  39. public class Utils {

  41.     @SuppressWarnings("rawtypes")
  42.     private static final ElementConverter ELEMENT_CONVERTER = new DefaultElementConverter();

  44.     /**
  45.      * コレクションの要素を指定した区切り文字で繋げて1つの文字列とする。
  46.      * @param col 処理対象のコレクション。
  47.      * @param separator 区切り文字。
  48.      * @param ignoreEmptyElement 空、nullの要素を無視するかどうか。
  49.      * @param trim トリムをするかどうか。
  50.      * @param elementConverter 要素を変換するクラス。
  51.      * @return 結合した文字列
  52.      */
  53.     @SuppressWarnings("rawtypes")
  54.     public static String join(final Collection<?> col, final String separator,
  55.             final boolean ignoreEmptyElement, final boolean trim, final ElementConverter elementConverter) {

  57.         final List<Object> list = new ArrayList<Object>();
  58.         for(Object element : col) {
  59.             if(element == null) {
  60.                 continue;
  61.             }

  63.             Object value = element;

  65.             if(element instanceof String) {
  66.                 String str = (String) element;
  67.                 if(ignoreEmptyElement && isEmpty(str)) {
  68.                     continue;

  70.                 } else if(trim) {
  71.                     value = str.trim();
  72.                 }

  74.             } else if(element instanceof Character && isEmpty(element.toString())) {
  75.                 String str = element.toString();
  76.                 if(ignoreEmptyElement && isEmpty(str)) {
  77.                     continue;

  79.                 } else if(trim) {
  80.                     value = str.trim().charAt(0);
  81.                 }

  83.             } else if(char.class.isAssignableFrom(element.getClass())) {
  84.                 String str = element.toString();
  85.                 if(ignoreEmptyElement && isEmpty(str)) {
  86.                     continue;

  88.                 } else if(trim) {
  89.                     value = str.trim().charAt(0);
  90.                 }
  91.             }

  93.             list.add(value);

  95.         }

  97.         return join(list, separator, elementConverter);

  99.     }

  101.     /**
  102.      * 配列の要素を指定した区切り文字で繋げて1つの文字列とする。
  103.      * @param arrays 結合対象の配列
  104.      * @param separator 区切り文字
  105.      * @return 結合した文字列
  106.      */
  107.     public static String join(final Object[] arrays, final String separator) {

  109.         return join(arrays, separator, ELEMENT_CONVERTER);

  111.     }

  113.     /**
  114.      * 配列の要素を指定した区切り文字で繋げて1つの文字列とする。
  115.      * @param arrays 結合対象の配列
  116.      * @param separator 区切り文字
  117.      * @param elementConverter 要素を変換するクラス。
  118.      * @return 結合した文字列
  119.      */
  120.     @SuppressWarnings({"rawtypes", "unchecked"})
  121.     public static String join(final Object[] arrays, final String separator, final ElementConverter elementConverter) {

  123.         if(arrays == null) {
  124.             return "";
  125.         }

  127.         final int len = arrays.length;
  128.         if(len == 0) {
  129.             return "";
  130.         }

  132.         StringBuilder sb = new StringBuilder();
  133.         for(int i=0; i < len; i++) {
  134.             final Object element = arrays[i];
  135.             sb.append(elementConverter.convertToString(element));

  137.             if(separator != null && (i < len-1)) {
  138.                 sb.append(separator);
  139.             }
  140.         }

  142.         return sb.toString();

  144.     }

  146.     /**
  147.      * Collectionの要素を指定した区切り文字で繋げて1つの文字列とする。
  148.      * @param col 結合対象のコレクション
  149.      * @param separator 区切り文字
  150.      * @return 結合した文字列
  151.      */
  152.     public static String join(final Collection<?> col, final String separator) {
  153.         return join(col, separator, ELEMENT_CONVERTER);
  154.     }

  156.     /**
  157.      * Collectionの要素を指定した区切り文字で繋げて1つの文字列とする。
  158.      * @param col 結合対象のコレクション
  159.      * @param separator 区切り文字
  160.      * @param elementConverter 要素を変換するクラス。
  161.      * @return 結合した文字列
  162.      */
  163.     @SuppressWarnings({"rawtypes", "unchecked"})
  164.     public static String join(final Collection<?> col, final String separator, final ElementConverter elementConverter) {

  166.         if(col == null) {
  167.             return "";
  168.         }

  170.         final int size = col.size();
  171.         if(size == 0) {
  172.             return "";
  173.         }

  175.         StringBuilder sb = new StringBuilder();
  176.         for(Iterator<?> itr = col.iterator(); itr.hasNext();) {
  177.             final Object element = itr.next();
  178.             String text = elementConverter.convertToString(element);
  179.             sb.append(text);

  181.             if(separator != null && itr.hasNext()) {
  182.                 sb.append(separator);
  183.             }
  184.         }

  186.         return sb.toString();

  188.     }

  190.     /**
  191.      * 先頭の文字を大文字にする。
  192.      * <pre>
  193.      * Utils.capitalize(null)  = null
  194.      * Utils.capitalize("")    = ""
  195.      * Utils.capitalize("cat") = "Cat"
  196.      * Utils.capitalize("cAt") = "CAt"
  197.      * </pre>
  198.      * @param str
  199.      * @return 引数がnull、空文字の場合、そのまま返す。
  200.      */
  201.     public static String capitalize(final String str) {
  202.         final int strLen;
  203.         if(str == null || (strLen = str.length()) == 0) {
  204.             return str;
  205.         }

  207.         return new StringBuilder(strLen)
  208.             .append(String.valueOf(str.charAt(0)).toUpperCase())
  209.             .append(str.substring(1))
  210.             .toString();
  211.     }

  213.     /**
  214.      * 先頭の文字を小文字にする。
  215.      * @param str 変換対象の文字
  216.      * @return 引数がnull、空文字の場合、そのまま返す。
  217.      */
  218.     public static String uncapitalize(final String str) {
  219.         final int strLen;
  220.         if(str == null || (strLen = str.length()) == 0) {
  221.             return str;
  222.         }

  224.         return new StringBuilder(strLen)
  225.             .append(String.valueOf(str.charAt(0)).toLowerCase())
  226.             .append(str.substring(1))
  227.             .toString();
  228.     }

  230.     /**
  231.      * システム設定に従いラベルを比較する。
  232.      * <p>正規表現や正規化を行い指定する。
  233.      *
  234.      * @since 1.1
  235.      * @param text1 セルのラベル
  236.      * @param text2 アノテーションに指定されているラベル。
  237.      *              {@literal /<ラベル>/}と指定する場合、正規表現による比較を行う。
  238.      * @param config システム設定
  239.      * @return true:ラベルが一致する。比較対象のラベルがnullの場合は、falseを返す。
  240.      */
  241.     public static boolean matches(final String text1, final String text2, final Configuration config){
  242.         
  243.         if(text1 == null || text2 == null) {
  244.             return false;
  245.         }
  246.         
  247.         if(config.isRegexLabelText() && text2.startsWith("/") && text2.endsWith("/")){
  248.             return normalize(text1, config).matches(text2.substring(1, text2.length() - 1));
  249.         } else {
  250.             return normalize(text1, config).equals(normalize(text2, config));
  251. //            return normalize(text1, config).equals(text2);
  252.         }
  253.     }

  255.     /**
  256.      * システム設定に従いラベルを正規化する。
  257.      * @since 1.1
  258.      * @param text セルのラベル
  259.      * @param config システム設定
  260.      * @return true:ラベルが一致する。
  261.      */
  262.     public static String normalize(final String text, final Configuration config){
  263.         if(text != null && config.isNormalizeLabelText()){
  264.             return text.trim().replaceAll("[\n\r]", "").replaceAll("[\t 　]+", " ");
  265.         }
  266.         return text;
  267.     }

  269.     /**
  270.      * 文字列が空文字か判定する。
  271.      * <p>文字数が1でかつ、{@literal \u0000}のときは、trueを判定する。</p>
  272.      * @param str 判定対象の文字
  273.      * @return trueの場合、空文字を判定する。
  274.      */
  275.     public static boolean isEmpty(final String str) {
  276.         if(str == null || str.isEmpty()) {
  277.             return true;
  278.         }

  280.         if(str.length() == 1) {
  281.             return str.charAt(0) == '\u0000';
  282.         }

  284.         return false;
  285.     }

  287.     /**
  288.      * 文字列が空文字でないか判定する。
  289.      * @param str 判定対象の文字
  290.      * @return
  291.      */
  292.     public static boolean isNotEmpty(final String str) {
  293.         return !isEmpty(str);
  294.     }

  296.     /**
  297.      * コレクションが空か判定する。
  298.      * @param collection
  299.      * @return nullまたはサイズが0のときにtrueを返す。
  300.      */
  301.     public static boolean isEmpty(final Collection<?> collection) {
  302.         if(collection == null || collection.isEmpty()) {
  303.             return true;
  304.         }

  306.         return false;
  307.     }

  309.     public static boolean isNotEmpty(final Collection<?> collection) {
  310.         return !isEmpty(collection);
  311.     }
  312.     
  313.     /**
  314.      * Mapが空か判定する。
  315.      * @param map
  316.      * @return nullまたはサイズが0のときにtrueを返す。
  317.      */
  318.     public static boolean isEmpty(final Map<?, ?> map) {
  319.         if(map == null || map.isEmpty()) {
  320.             return true;
  321.         }

  323.         return false;
  324.     }

  326.     public static boolean isNotEmpty(final Map<?, ?> map) {
  327.         return !isEmpty(map);
  328.     }

  330.     /**
  331.      * 配列がが空か判定する。
  332.      * @param arrays
  333.      * @return nullまたは、配列のサイズが0のときにtrueを返す。
  334.      */
  335.     public static boolean isEmpty(final Object[] arrays) {
  336.         if(arrays == null || arrays.length == 0) {
  337.             return true;
  338.         }

  340.         return false;
  341.     }

  343.     /**
  344.      * 配列が空でないか判定する
  345.      * @param arrays
  346.      * @return
  347.      */
  348.     public static boolean isNotEmpty(final Object[] arrays) {
  349.         return !isEmpty(arrays);
  350.     }
  351.     
  352.     /**
  353.      * オブジェクトの比較を行う。
  354.      * <p>値がnullの場合を考慮する。
  355.      * @param obj1
  356.      * @param obj2
  357.      * @return
  358.      */
  359.     public static boolean equals(final Object obj1, final Object obj2) {

  361.         if(obj1 == null && obj2 == null) {
  362.             return true;
  363.         }

  365.         if(obj1 == null) {
  366.             return false;
  367.         }

  369.         if(obj2 == null) {
  370.             return false;
  371.         }

  373.         return obj1.equals(obj2);

  375.     }

  377.     public static boolean notEquals(final Object obj1, final Object obj2) {
  378.         return !equals(obj1, obj2);
  379.     }

  381.     /**
  382.      * オブジェクトを文字列に変換する。
  383.      * <p>nullの場合、文字列として "null"を返す。
  384.      * <p>単純に、{@link Object#toString()}を呼び出す。
  385.      * @param value
  386.      * @return
  387.      */
  388.     public static String convertToString(final Object value) {

  390.         if(value == null) {
  391.             return "null";
  392.         }

  394.         return value.toString();

  396.     }

  398.     /**
  399.      * アノテーションの属性trimに従い、文字列をトリムする。
  400.      * @param value トリム対象の文字
  401.      * @param trimAnno トリムのアノテーション
  402.      * @return トリミングした結果。
  403.      */
  404.     public static String trim(final String value, final Optional<XlsTrim> trimAnno) {

  406.         if(!trimAnno.isPresent() || value == null) {
  407.             return value;
  408.         }

  410.         return value.trim();

  412.     }

  414.     /**
  415.      * 文字列をトリムする。
  416.      * @param value トリム対象の文字
  417.      * @param trimmed トリムするかどうか。
  418.      * @return トリミングした結果。
  419.      */
  420.     public static String trim(final String value, final boolean trimmed) {
  421.         if(!trimmed || value == null) {
  422.             return value;
  423.         }

  425.         return value.trim();

  427.     }
  428.     
  429.     /**
  430.      * 文字列をbooleanに変換します。
  431.      * 
  432.      * @since 2.3
  433.      * @param value 変換対象の値。
  434.      * @param defaultValue 変換対象がnull or 空文字の時のデフォルト値。
  435.      * @return 引数がnullのとき、falseを返します。
  436.      */
  437.     public static boolean toBoolean(final String value, final boolean defaultValue) {
  438.         String text = trim(value, true);
  439.         if(isEmpty(text)) {
  440.             return defaultValue;
  441.         }
  442.         
  443.         return Boolean.valueOf(text.toLowerCase());
  444.     }

  446.     /**
  447.      * PostProcessなどのメソッドを実行する。
  448.      * <p>メソッドの引数が既知のものであれば、インスタンスを設定する。
  449.      *
  450.      * @param processObj 実行対象の処理が埋め込まれているオブジェクト。
  451.      * @param method 実行対象のメソッド情報
  452.      * @param beanObj 処理対象のBeanオブジェクト。
  453.      * @param sheet シート情報
  454.      * @param config 共通設定
  455.      * @param errors エラー情報
  456.      * @param processCase 処理ケース
  457.      * @throws XlsMapperException
  458.      */
  459.     public static void invokeNeedProcessMethod(final Object processObj, final Method method, final Object beanObj,
  460.             final Sheet sheet, final Configuration config, final SheetBindingErrors<?> errors, final ProcessCase processCase)
  461.                     throws XlsMapperException {

  463.         final Class<?>[] paramTypes = method.getParameterTypes();
  464.         final Object[] paramValues =  new Object[paramTypes.length];

  466.         for(int i=0; i < paramTypes.length; i++) {
  467.             if(Sheet.class.isAssignableFrom(paramTypes[i])) {
  468.                 paramValues[i] = sheet;

  470.             } else if(Configuration.class.isAssignableFrom(paramTypes[i])) {
  471.                 paramValues[i] = config;

  473.             } else if(SheetBindingErrors.class.isAssignableFrom(paramTypes[i])) {
  474.                 paramValues[i] = errors;

  476.             } else if(paramTypes[i].isAssignableFrom(beanObj.getClass())) {
  477.                 paramValues[i] = beanObj;

  479.             } else if(ProcessCase.class.equals(paramTypes[i])) {
  480.                 paramValues[i] = processCase;

  482.             } else if(paramTypes[i].equals(Object.class)) {
  483.                 paramValues[i] = beanObj;

  485.             } else {
  486.                 paramValues[i] = null;
  487.             }
  488.         }

  490.         try {
  491.             method.setAccessible(true);
  492.             method.invoke(processObj, paramValues);
  493.         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  494.             Throwable t = e.getCause() == null ? e : e.getCause();
  495.             throw new XlsMapperException(
  496.                     String.format("fail execute method '%s#%s'.", processObj.getClass().getName(), method.getName()),
  497.                     t);
  498.         }
  499.     }

  501.     /**
  502.      * 文字列形式のロケールをオブジェクトに変換する。
  503.      * <p>アンダーバーで区切った'ja_JP'を分解して、Localeに渡す。
  504.      * @param str
  505.      * @return 引数が空の時はデフォルトロケールを返す。
  506.      */
  507.     public static Locale getLocale(final String str) {

  509.         if(isEmpty(str)) {
  510.             return Locale.getDefault();
  511.         }

  513.         if(!str.contains("_")) {
  514.             return new Locale(str);
  515.         }

  517.         final String[] split = str.split("_");
  518.         if(split.length == 2) {
  519.             return new Locale(split[0], split[1]);

  521.         } else {
  522.             return new Locale(split[0], split[1], split[2]);
  523.         }

  525.     }

  527.     /**
  528.      * エスケープ文字を除去した文字列を取得する。
  529.      * @param str
  530.      * @param escapeChar
  531.      * @return
  532.      */
  533.     public static String removeEscapeChar(final String str, final char escapeChar) {

  535.         if(str == null || str.isEmpty()) {
  536.             return str;
  537.         }

  539.         final String escapeStr = String.valueOf(escapeChar);
  540.         StringBuilder sb = new StringBuilder();

  542.         LinkedList<String> stack = new LinkedList<String>();

  544.         final int length = str.length();
  545.         for(int i=0; i < length; i++) {
  546.             final char c = str.charAt(i);

  548.             if(StackUtils.equalsTopElement(stack, escapeStr)) {
  549.                 // スタックの一番上がエスケープ文字の場合
  550.                 StackUtils.popup(stack);
  551.                 sb.append(c);

  553.             } else if(c == escapeChar) {
  554.                 // スタックに積む
  555.                 stack.push(String.valueOf(c));

  557.             } else {
  558.                 sb.append(c);
  559.             }

  561.         }

  563.         if(!stack.isEmpty()) {
  564.             sb.append(StackUtils.popupAndConcat(stack));
  565.         }

  567.         return sb.toString();

  569.     }

  571.     /**
  572.      * Listのインスタンスを他のCollectionのインスタンスに変換する。
  573.      * <p>ただし、変換先のクラスタイプがインタフェースの場合は変換しない。
  574.      * <p>変換元のクラスと変換先のクラスが同じ場合は、変換しない。
  575.      *
  576.      * @since 1.0
  577.      * @param list 変換元のListのインスタンス
  578.      * @param toClass 変換先のCollectionのクラス
  579.      * @param beanFactory てインスタンスを生成するファクトリクラス。
  580.      * @return 変換したコレクションのインスタンス
  581.      */
  582.     @SuppressWarnings({"rawtypes", "unchecked"})
  583.     public static Collection convertListToCollection(final List list, final Class<Collection> toClass,
  584.             final BeanFactory<Class<?>, Object> beanFactory) {

  586.         if(list.getClass().equals(toClass)) {
  587.             return list;
  588.         }

  590.         if(toClass.isInterface()) {
  591.             if(List.class.isAssignableFrom(toClass)) {
  592.                 // 変換先がListの実態の場合はそのまま。
  593.                 return list;

  595.             } else if(Set.class.isAssignableFrom(toClass)) {

  597.                 Collection value = (Collection) beanFactory.create(LinkedHashSet.class);
  598.                 value.addAll(list);
  599.                 return value;

  601.             } else if(Queue.class.isAssignableFrom(toClass)) {

  603.                 Collection value = (Collection) beanFactory.create(LinkedList.class);
  604.                 value.addAll(list);
  605.                 return value;

  607.             } else if(Collection.class.isAssignableFrom(toClass)) {
  608.                 Collection value = (Collection) beanFactory.create(ArrayList.class);
  609.                 value.addAll(list);
  610.                 return value;

  612.             } else {
  613.                 throw new IllegalArgumentException("not support class type:" + toClass.getName());
  614.             }

  616.         }

  618.         Collection value = (Collection) beanFactory.create(toClass);
  619.         value.addAll(list);

  621.         return value;

  623.     }

  625.     /**
  626.      * CollectionのインスタンスをListに変換する。
  627.      *
  628.      * @since 1.0
  629.      * @param collection 変換元のCollectionのインスタンス。
  630.      * @return 変換したListのインスタンス。
  631.      */
  632.     public static <T> List<T> convertCollectionToList(final Collection<T> collection) {

  634.         if(List.class.isAssignableFrom(collection.getClass())) {
  635.             return (List<T>)collection;
  636.         }

  638.         return new ArrayList<>(collection);

  640.     }

  642.     /**
  643.      * リストに要素のインデックスを指定して追加します。
  644.      * <p>リストのサイズが足りない場合は、サイズを自動的に変更します。</p>
  645.      * @since 2.0
  646.      * @param list リスト
  647.      * @param element 追加する要素。値はnullでもよい。
  648.      * @param index 追加する要素のインデックス番号(0以上)
  649.      * @throws IllegalArgumentException {@literal list == null.}
  650.      * @throws IllegalArgumentException {@literal index < 0.}
  651.      */
  652.     public static <P> void addListWithIndex(final List<P> list, final P element, final int index) {
  653.         ArgUtils.notNull(list, "list");
  654.         ArgUtils.notMin(index, 0, "index");

  656.         final int listSize = list.size();
  657.         if(listSize < index) {
  658.             // 足りない場合は、要素を追加する。
  659.             final int lackSize = index - listSize;
  660.             for(int i=0; i < lackSize; i++) {
  661.                 list.add(null);
  662.             }
  663.             list.add(element);

  665.         } else if(listSize == index) {
  666.             // 最後の要素に追加する
  667.             list.add(element);

  669.         } else {
  670.             // リストのサイズが足りている場合
  671.             list.set(index, element);
  672.         }

  674.     }

  676.     /**
  677.      * プリミティブ型のデフォルト値を取得します。
  678.      * @param type 変換対象のクラスタイプ。
  679.      * @return 対応していない型の場合は、nullを返します。
  680.      * @throws IllegalArgumentException {@literal type is null.}
  681.      */
  682.     public static Object getPrimitiveDefaultValue(final Class<?> type) {
  683.         ArgUtils.notNull(type, "type");

  685.         if(!type.isPrimitive()) {
  686.             return null;
  687.         }

  689.         if(type.equals(boolean.class)) {
  690.             return false;

  692.         } else if(type.equals(char.class)) {
  693.             return '\u0000';

  695.         } else if(type.equals(byte.class)) {
  696.             return (byte)0;

  698.         } else if(type.equals(short.class)) {
  699.             return (short)0;

  701.         } else if(type.equals(int.class)) {
  702.             return 0;

  704.         } else if(type.equals(long.class)) {
  705.             return 0l;

  707.         } else if(type.equals(float.class)) {
  708.             return 0.0f;

  710.         } else if(type.equals(double.class)) {
  711.             return 0.0d;

  713.         }

  715.         return null;
  716.     }

  718.     /**
  719.      * 配列を{@link List}に変換します。
  720.      * プリミティブ型の配列をを考慮して処理します。
  721.      * @param object 変換対象の配列
  722.      * @param componentType 配列の要素のタイプ
  723.      * @return 配列がnullの場合は、空のリストに変換します。
  724.      * @throws IllegalArgumentException {@literal arrayが配列でない場合。componentTypeがサポートしていないプリミティブ型の場合。}
  725.      */
  726.     public static List<Object> asList(final Object object, final Class<?> componentType) {
  727.         ArgUtils.notNull(componentType, "componentType");

  729.         if(object == null) {
  730.             return new ArrayList<>();
  731.         }

  733.         if(!object.getClass().isArray()) {
  734.             throw new IllegalArgumentException(String.format("args0 is not arrays : %s.", object.getClass().getName()));
  735.         }

  737.         if(!componentType.isPrimitive()) {
  738.             return Arrays.asList((Object[])object);
  739.         }

  741.         if(componentType.equals(boolean.class)) {
  742.             boolean[] array = (boolean[])object;
  743.             List<Object> list = new ArrayList<>(array.length);
  744.             for(boolean v : array) {
  745.                 list.add(v);
  746.             }
  747.             return list;

  749.         } else if(componentType.equals(char.class)) {
  750.             char[] array = (char[])object;
  751.             List<Object> list = new ArrayList<>(array.length);
  752.             for(char v : array) {
  753.                 list.add(v);
  754.             }
  755.             return list;

  757.         } else if(componentType.equals(byte.class)) {
  758.             byte[] array = (byte[])object;
  759.             List<Object> list = new ArrayList<>(array.length);
  760.             for(byte v : array) {
  761.                 list.add(v);
  762.             }
  763.             return list;

  765.         } else if(componentType.equals(short.class)) {
  766.             short[] array = (short[])object;
  767.             List<Object> list = new ArrayList<>(array.length);
  768.             for(short v : array) {
  769.                 list.add(v);
  770.             }
  771.             return list;

  773.         } else if(componentType.equals(int.class)) {
  774.             int[] array = (int[])object;
  775.             List<Object> list = new ArrayList<>(array.length);
  776.             for(int v : array) {
  777.                 list.add(v);
  778.             }
  779.             return list;

  781.         } else if(componentType.equals(long.class)) {
  782.             long[] array = (long[])object;
  783.             List<Object> list = new ArrayList<>(array.length);
  784.             for(long v : array) {
  785.                 list.add(v);
  786.             }
  787.             return list;

  789.         } else if(componentType.equals(float.class)) {
  790.             float[] array = (float[])object;
  791.             List<Object> list = new ArrayList<>(array.length);
  792.             for(float v : array) {
  793.                 list.add(v);
  794.             }
  795.             return list;

  797.         } else if(componentType.equals(double.class)) {
  798.             double[] array = (double[])object;
  799.             List<Object> list = new ArrayList<>(array.length);
  800.             for(double v : array) {
  801.                 list.add(v);
  802.             }
  803.             return list;

  805.         }

  807.         throw new IllegalArgumentException(String.format("not support primitive type : %s.", componentType.getName()));

  809.     }

  811.     /**
  812.      * コレクションを配列に変換する。
  813.      * @param collection 変換対象のコレクション。
  814.      * @return 変換した配列。
  815.      * @throws IllegalArgumentException {@literal collection is null.}
  816.      */
  817.     public static int[] toArray(final Collection<Integer> collection) {
  818.         ArgUtils.notNull(collection, "collection");

  820.         final int size = collection.size();
  821.         final int[] array = new int[size];

  823.         int i=0;
  824.         for(Integer value : collection) {
  825.             array[i] = value;
  826.             i++;
  827.         }

  829.         return array;
  830.     }

  832.     /**
  833.      * 配列のサイズを取得します。
  834.      * プリミティブ型の配列をを考慮して処理します。
  835.      * @param object 取得対象の配列
  836.      * @param componentType 配列の要素のタイプ
  837.      * @return 配列がnullの場合は、0を返します。
  838.      * @throws IllegalArgumentException {@literal arrayが配列でない場合。componentTypeがサポートしていないプリミティブ型の場合。}
  839.      */
  840.     public static int getArraySize(final Object object, final Class<?> componentType) {

  842.         ArgUtils.notNull(componentType, "componentType");

  844.         if(object == null) {
  845.             return 0;
  846.         }

  848.         if(!object.getClass().isArray()) {
  849.             throw new IllegalArgumentException(String.format("args0 is not arrays : %s.", object.getClass().getName()));
  850.         }

  852.         if(!componentType.isPrimitive()) {
  853.             return ((Object[])object).length;
  854.         }

  856.         if(componentType.equals(boolean.class)) {
  857.             return ((boolean[]) object).length;

  859.         } else if(componentType.equals(char.class)) {
  860.             return ((char[]) object).length;

  862.         } else if(componentType.equals(byte.class)) {
  863.             return ((byte[]) object).length;

  865.         } else if(componentType.equals(short.class)) {
  866.             return ((short[]) object).length;

  868.         } else if(componentType.equals(int.class)) {
  869.             return ((int[]) object).length;

  871.         } else if(componentType.equals(long.class)) {
  872.             return ((long[]) object).length;

  874.         } else if(componentType.equals(float.class)) {
  875.             return ((byte[]) object).length;

  877.         } else if(componentType.equals(double.class)) {
  878.             return ((byte[]) object).length;

  880.         }

  882.         throw new IllegalArgumentException(String.format("not support primitive type : %s.", componentType.getName()));
  883.     }

  885.     /**
  886.      * 文字列配列の結合
  887.      * @param array1
  888.      * @param array2
  889.      * @return 結合した配列。引数のどちらからnullの場合は、cloneした配列を返します。
  890.      */
  891.     public static String[] concat(final String[] array1, final String[] array2) {

  893.         if(array1 == null || array1.length == 0) {
  894.             return clone(array2);

  896.         } else if(array2 == null || array2.length == 0) {
  897.             return clone(array1);
  898.         }

  900.         final String[] joinedArray = new String[array1.length + array2.length];
  901.         System.arraycopy(array1, 0, joinedArray, 0, array1.length);
  902.         System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
  903.         return joinedArray;

  905.     }

  907.     /**
  908.      * 文字列の配列をクローンします。
  909.      * @param array クローン対象の配列
  910.      * @return クローンした配列。引数がnullの場合は、nullを返します。
  911.      */
  912.     public static String[] clone(final String[] array) {
  913.         if (array == null) {
  914.             return null;
  915.         }
  916.         return array.clone();
  917.     }

  919.     /**
  920.      * 読み込み処理のケースか判定する。
  921.      * <p>ケースが指定されていないときは、該当すると判定する。</p>
  922.      * @since 2.0
  923.      * @param cases 判定対象のケース
  924.      * @return trueのとき、読み込み対象と判定する。
  925.      */
  926.     public static boolean isLoadCase(final ProcessCase[] cases) {

  928.         if(cases == null || cases.length == 0) {
  929.             return true;
  930.         }

  932.         for(ProcessCase pc : cases) {
  933.             if(pc == ProcessCase.Load) {
  934.                 return true;
  935.             }
  936.         }

  938.         return false;

  940.     }

  942.     /**
  943.      * 書き込み処理のケースか判定する。
  944.      * <p>ケースが指定されていないときは、該当すると判定する。</p>
  945.      * @since 2.0
  946.      * @param cases 判定対象のケース
  947.      * @return trueのとき、書き込み対象と判定する。
  948.      */
  949.     public static boolean isSaveCase(final ProcessCase[] cases) {

  951.         if(cases == null || cases.length == 0) {
  952.             return true;
  953.         }

  955.         for(ProcessCase pc : cases) {
  956.             if(pc == ProcessCase.Save) {
  957.                 return true;
  958.             }
  959.         }

  961.         return false;

  963.     }

  965.     /**
  966.      * 現在の処理ケースが該当するか判定する。
  967.      * <p>ケースが指定されていないときは、該当すると判定する。</p>
  968.      * @param currentCase 現在の処理ケース
  969.      * @param cases 判定対象のケース
  970.      * @return trueのとき判定対象。
  971.      * @throws IllegalArgumentException {@code currentCase is null.}
  972.      */
  973.     public static boolean isProcessCase(final ProcessCase currentCase, ProcessCase[] cases) {

  975.         ArgUtils.notNull(currentCase, "currentCase");

  977.         if(currentCase == ProcessCase.Load) {
  978.             return isLoadCase(cases);
  979.         } else if(currentCase == ProcessCase.Save) {
  980.             return isSaveCase(cases);
  981.         } else {
  982.             throw new IllegalArgumentException("currentCase is not support:" + currentCase);
  983.         }

  985.     }


  988. }
Created with JaCoCo 0.8.5.201910111838