org.mule.util.CollectionUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mule-core
Mule server and core classes
There is a newer version: 3.9.0
/*
 * $Id: CollectionUtils.java 19191 2010-08-25 21:05:23Z tcarlson $
 * --------------------------------------------------------------------------------------
 * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 *
 * The software in this package is published under the terms of the CPAL v1.0
 * license, a copy of which has been included with this distribution in the
 * LICENSE.txt file.
 */

package org.mule.util;

import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.apache.commons.collections.Predicate;


// @ThreadSafe
public class CollectionUtils extends org.apache.commons.collections.CollectionUtils
{

    /**
     * Creates an array of the given Collection's elements, but with the given
     * Class as element type. Useful for arrays of objects that
     * implement multiple interfaces and a "typed view" onto these objects is
     * required.
     * 
     * @param objects a Collection of objects
     * @param clazz the desired service type of the new array
     * @return null when objects is null, or a new
     *         array containing the elements of the source array which is typed to
     *         the given clazz parameter.
     * @throws IllegalArgumentException if the clazz argument is
     *             null.
     * @throws ArrayStoreException if the elements in objects cannot
     *             be cast to clazz.
     */
    public static T[] toArrayOfComponentType(Collection objects, Class clazz)
    {
        if (objects == null)
        {
            return null;
        }

        if (clazz == null)
        {
            throw new IllegalArgumentException("Array target class must not be null");
        }

        if (objects.isEmpty())
        {
            return (T[]) Array.newInstance(clazz, 0);
        }

        int i = 0, size = objects.size();
        T[] result = (T[]) Array.newInstance(clazz, size);
        Iterator iter = objects.iterator();

        while (i < size && iter.hasNext())
        {
            result[i++] = (T)iter.next();
        }

        return result;
    }

    /**
     * Creates a String representation of the given Collection, with optional
     * newlines between elements. Class objects are represented by their full names.
     * 
     * @param c the Collection to format
     * @param newline indicates whether elements are to be split across lines
     * @return the formatted String
     */
    public static String toString(Collection c, boolean newline)
    {
        if (c == null || c.isEmpty())
        {
            return "[]";
        }

        return toString(c, c.size(), newline);
    }

    /**
     * Calls {@link #toString(Collection, int, boolean)} with false
     * for newline.
     */
    public static String toString(Collection c, int maxElements)
    {
        return toString(c, maxElements, false);
    }

    /**
     * Creates a String representation of the given Collection, with optional
     * newlines between elements. Class objects are represented by their full names.
     * Considers at most maxElements values; overflow is indicated by
     * an appended "[..]" ellipsis.
     * 
     * @param c the Collection to format
     * @param maxElements the maximum number of elements to take into account
     * @param newline indicates whether elements are to be split across lines
     * @return the formatted String
     */
    public static String toString(Collection c, int maxElements, boolean newline)
    {
        if (c == null || c.isEmpty())
        {
            return "[]";
        }

        int origNumElements = c.size();
        int numElements = Math.min(origNumElements, maxElements);
        boolean tooManyElements = (origNumElements > maxElements);

        StringBuffer buf = new StringBuffer(numElements * 32);
        buf.append('[');

        if (newline)
        {
            buf.append(SystemUtils.LINE_SEPARATOR);
        }

        Iterator items = c.iterator();
        for (int i = 0; i < numElements - 1; i++)
        {
            Object item = items.next();

            if (item instanceof Class)
            {
                buf.append(((Class) item).getName());
            }
            else
            {
                buf.append(item);
            }

            if (newline)
            {
                buf.append(SystemUtils.LINE_SEPARATOR);
            }
            else
            {
                buf.append(',').append(' ');
            }
        }

        // don't forget the last one
        Object lastItem = items.next();
        if (lastItem instanceof Class)
        {
            buf.append(((Class) lastItem).getName());
        }
        else
        {
            buf.append(lastItem);
        }

        if (newline)
        {
            buf.append(SystemUtils.LINE_SEPARATOR);
        }

        if (tooManyElements)
        {
            buf.append(" [..]");
        }

        buf.append(']');
        return buf.toString();
    }

    /**
     * Some code uses null to indicate "unset", which makes appending items complex.
     */
    public static List addCreate(List list, Object value)
    {
        if (null == list)
        {
            return singletonList(value);
        }
        else
        {
            list.add(value);
            return list;
        }
    }

    public static List singletonList(Object value)
    {
        List list = new LinkedList();
        list.add(value);
        return list;
    }
    
    public static boolean containsType(Collection collection, final Class type)
    {
        if (type == null)
        {
            return false;
        }
        return exists(collection, new Predicate()
        {
            public boolean evaluate(Object object)
            {
                return object != null && type.isAssignableFrom(object.getClass());
            }
        });
    }
    
    public static void removeType(Collection collection, final Class type)
    {
        if (type == null)
        {
            return;
        }
        filter(collection, new Predicate()
        {
            public boolean evaluate(Object object)
            {
                return object != null && type.isAssignableFrom(object.getClass());
            }
        });
    }

}