View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
6    */
7   package org.mule.util;
8   
9   import java.lang.reflect.Array;
10  import java.util.Collection;
11  import java.util.Iterator;
12  import java.util.LinkedList;
13  import java.util.List;
14  
15  import org.apache.commons.collections.Predicate;
16  
17  
18  // @ThreadSafe
19  public class CollectionUtils extends org.apache.commons.collections.CollectionUtils
20  {
21  
22      /**
23       * Creates an array of the given Collection's elements, but with the given
24       * <code>Class</code> as element type. Useful for arrays of objects that
25       * implement multiple interfaces and a "typed view" onto these objects is
26       * required.
27       * 
28       * @param objects a Collection of objects
29       * @param clazz the desired service type of the new array
30       * @return <code>null</code> when objects is <code>null</code>, or a new
31       *         array containing the elements of the source array which is typed to
32       *         the given <code>clazz</code> parameter.
33       * @throws IllegalArgumentException if the <code>clazz</code> argument is
34       *             <code>null</code>.
35       * @throws ArrayStoreException if the elements in <code>objects</code> cannot
36       *             be cast to <code>clazz</code>.
37       */
38      public static <T>T[] toArrayOfComponentType(Collection objects, Class<T> clazz)
39      {
40          if (objects == null)
41          {
42              return null;
43          }
44  
45          if (clazz == null)
46          {
47              throw new IllegalArgumentException("Array target class must not be null");
48          }
49  
50          if (objects.isEmpty())
51          {
52              return (T[]) Array.newInstance(clazz, 0);
53          }
54  
55          int i = 0, size = objects.size();
56          T[] result = (T[]) Array.newInstance(clazz, size);
57          Iterator iter = objects.iterator();
58  
59          while (i < size && iter.hasNext())
60          {
61              result[i++] = (T)iter.next();
62          }
63  
64          return result;
65      }
66  
67      /**
68       * Creates a String representation of the given Collection, with optional
69       * newlines between elements. Class objects are represented by their full names.
70       * 
71       * @param c the Collection to format
72       * @param newline indicates whether elements are to be split across lines
73       * @return the formatted String
74       */
75      public static String toString(Collection c, boolean newline)
76      {
77          if (c == null || c.isEmpty())
78          {
79              return "[]";
80          }
81  
82          return toString(c, c.size(), newline);
83      }
84  
85      /**
86       * Calls {@link #toString(Collection, int, boolean)} with <code>false</code>
87       * for newline.
88       */
89      public static String toString(Collection c, int maxElements)
90      {
91          return toString(c, maxElements, false);
92      }
93  
94      /**
95       * Creates a String representation of the given Collection, with optional
96       * newlines between elements. Class objects are represented by their full names.
97       * Considers at most <code>maxElements</code> values; overflow is indicated by
98       * an appended "[..]" ellipsis.
99       * 
100      * @param c the Collection to format
101      * @param maxElements the maximum number of elements to take into account
102      * @param newline indicates whether elements are to be split across lines
103      * @return the formatted String
104      */
105     public static String toString(Collection c, int maxElements, boolean newline)
106     {
107         if (c == null || c.isEmpty())
108         {
109             return "[]";
110         }
111 
112         int origNumElements = c.size();
113         int numElements = Math.min(origNumElements, maxElements);
114         boolean tooManyElements = (origNumElements > maxElements);
115 
116         StringBuffer buf = new StringBuffer(numElements * 32);
117         buf.append('[');
118 
119         if (newline)
120         {
121             buf.append(SystemUtils.LINE_SEPARATOR);
122         }
123 
124         Iterator items = c.iterator();
125         for (int i = 0; i < numElements - 1; i++)
126         {
127             Object item = items.next();
128 
129             if (item instanceof Class)
130             {
131                 buf.append(((Class) item).getName());
132             }
133             else
134             {
135                 buf.append(item);
136             }
137 
138             if (newline)
139             {
140                 buf.append(SystemUtils.LINE_SEPARATOR);
141             }
142             else
143             {
144                 buf.append(',').append(' ');
145             }
146         }
147 
148         // don't forget the last one
149         Object lastItem = items.next();
150         if (lastItem instanceof Class)
151         {
152             buf.append(((Class) lastItem).getName());
153         }
154         else
155         {
156             buf.append(lastItem);
157         }
158 
159         if (newline)
160         {
161             buf.append(SystemUtils.LINE_SEPARATOR);
162         }
163 
164         if (tooManyElements)
165         {
166             buf.append(" [..]");
167         }
168 
169         buf.append(']');
170         return buf.toString();
171     }
172 
173     /**
174      * Some code uses null to indicate "unset", which makes appending items complex.
175      */
176     public static List addCreate(List list, Object value)
177     {
178         if (null == list)
179         {
180             return singletonList(value);
181         }
182         else
183         {
184             list.add(value);
185             return list;
186         }
187     }
188 
189     public static List singletonList(Object value)
190     {
191         List list = new LinkedList();
192         list.add(value);
193         return list;
194     }
195     
196     public static boolean containsType(Collection<?> collection, final Class<?> type)
197     {
198         if (type == null)
199         {
200             return false;
201         }
202         return exists(collection, new Predicate()
203         {
204             public boolean evaluate(Object object)
205             {
206                 return object != null && type.isAssignableFrom(object.getClass());
207             }
208         });
209     }
210     
211     public static void removeType(Collection<?> collection, final Class<?> type)
212     {
213         if (type == null)
214         {
215             return;
216         }
217         filter(collection, new Predicate()
218         {
219             public boolean evaluate(Object object)
220             {
221                 return object != null && type.isAssignableFrom(object.getClass());
222             }
223         });
224     }
225 
226 }