Changeset 976 for AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/util/CollectionUtils.java

Timestamp:

08/14/10 15:10:12 (22 months ago)

Author:

kasper

Message:

Made it possible to configure jobs using "configurable bean" acting as a prototype for actual executed beans

File:

• AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/util/CollectionUtils.java (modified) (4 diffs)

AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/util/CollectionUtils.java

@@ -1 +1 @@
 package org.eobjects.analyzer.util;
 
+import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -11 +12 @@
                 // prevent instantiation
         }
-        
+
         public static <T> List<T> list(T... elements) {
                 return list(ArrayList.class, elements);
@@ -29 +30 @@
                 }
         }
-        
+
         public static <T> Set<T> set(T... elements) {
                 return set(HashSet.class, elements);
@@ -46 +47 @@
                 }
         }
+
+        @SuppressWarnings("unchecked")
+        public static <E> E[] array(E[] existingArray, E... elements) {
+                if (existingArray == null) {
+                        return elements;
+                }
+                Object result = Array.newInstance(elements.getClass()
+                                .getComponentType(), existingArray.length + elements.length);
+                System.arraycopy(existingArray, 0, result, 0, existingArray.length);
+                System.arraycopy(elements, 0, result, existingArray.length,
+                                elements.length);
+                return (E[]) result;
+        }
+
+        @SuppressWarnings("unchecked")
+        public static <E> E[] array(Class<E> elementClass, Object existingArray, E... elements) {
+                if (existingArray == null) {
+                        return elements;
+                }
+                E[] result;
+                if (existingArray.getClass().isArray()) {
+                        int length = Array.getLength(existingArray);
+                        result = (E[]) Array.newInstance(elementClass, length + elements.length);
+                        System.arraycopy(existingArray, 0, result, 0, length);
+                        System.arraycopy(elements, 0, result, length, elements.length);
+                } else {
+                        result = (E[]) Array.newInstance(elementClass, 1 + elements.length);
+                        result[0] = (E) existingArray;
+                        System.arraycopy(elements, 0, result, 1, elements.length);
+                }
+
+                return result;
+        }
+
+        public static <E> E[] arrayRemove(E[] array, E elementToRemove) {
+                boolean found = false;
+                @SuppressWarnings("unchecked")
+                E[] result = (E[]) Array.newInstance(array.getClass()
+                                .getComponentType(), array.length - 1);
+                int nextIndex = 0;
+                for (E e : array) {
+                        if (e == elementToRemove) {
+                                found = true;
+                        } else {
+                                result[nextIndex] = e;
+                                nextIndex++;
+                        }
+                }
+                if (!found) {
+                        return array;
+                }
+                return result;
+        }
+
+        public static Object arrayRemove(Object array, Object elementToRemove) {
+                boolean found = false;
+                int oldLength = Array.getLength(array);
+                Object result = Array.newInstance(array.getClass().getComponentType(),
+                                oldLength - 1);
+                int nextIndex = 0;
+                for (int i = 0; i < oldLength; i++) {
+                        Object e = Array.get(array, i);
+                        if (e == elementToRemove) {
+                                found = true;
+                        } else {
+                                Array.set(result, nextIndex, e);
+                                nextIndex++;
+                        }
+                }
+                if (!found) {
+                        return array;
+                }
+                return result;
+        }
+
+        @SuppressWarnings("unchecked")
+        public static <E> E[] arrayOf(Class<E> elementClass, Object arrayOrElement) {
+                if (arrayOrElement == null) {
+                        return null;
+                }
+                if (arrayOrElement.getClass().isArray()) {
+                        return (E[]) arrayOrElement;
+                }
+                Object result = Array.newInstance(elementClass, 1);
+                Array.set(result, 0, arrayOrElement);
+                return (E[]) result;
+        }
 }