OptionUtils.java

/*
 * Copyright 2008 Alin Dreghiciu.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied.
 *
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.ops4j.pax.exam;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.ops4j.pax.exam.options.CompositeOption;

/**
 * Utility methods related to {@link Option}s.
 *
 * @author Alin Dreghiciu (adreghiciu@gmail.com)
 * @since 0.3.0, December 08, 2008
 */
public class OptionUtils
{

    /**
     * Utility class. Ment to be used via the static factory methods.
     */
    private OptionUtils()
    {
        // utility class
    }

    /**
     * Expand options to one level by expanding eventual {@link CompositeOption}. During this process null options are
     * eliminated.
     *
     * @param options options to be expanded (can be null or an empty array)
     *
     * @return expanded options (never null). In case that the options to be expanded is null an empty array is returned
     */
    public static Option[] expand( final Option... options )
    {
        final List<Option> expanded = new ArrayList<Option>();
        if( options != null )
        {
            for( Option option : options )
            {
                if( option != null )
                {
                    if( option instanceof CompositeOption )
                    {
                        expanded.addAll( Arrays.asList( ( (CompositeOption) option ).getOptions() ) );
                    }
                    else
                    {
                        expanded.add( option );
                    }
                }
            }
        }
        return expanded.toArray( new Option[expanded.size()] );
    }

    /**
     * Combines two arrays of options in one array containing both provided arrays in order they are provided.
     *
     * @param options1 array of options (can be null or empty array)
     * @param options2 array of options (can be null or empty array)
     *
     * @return combined array of options (never null). In case that both arrays are null or empty an empty array is
     *         returned
     */
    public static Option[] combine( final Option[] options1,
                                    final Option... options2 )
    {
        int size1 = 0;
        if( options1 != null && options1.length > 0 )
        {
            size1 += options1.length;
        }
        int size2 = 0;
        if( options2 != null && options2.length > 0 )
        {
            size2 += options2.length;
        }
        final Option[] combined = new Option[size1 + size2];
        if( size1 > 0 )
        {
            System.arraycopy( options1, 0, combined, 0, size1 );
        }
        if( size2 > 0 )
        {
            System.arraycopy( options2, 0, combined, size1, size2 );
        }
        return combined;
    }

    /**
     * Filters the provided options by class returning an array of those option that are instance of the provided class.
     * Before filtering the options are expanded {@link #expand(Option[])}.
     *
     * @param optionType class of the desired options
     * @param options    options to be filtered (can be null or empty array)
     * @param <T>        type of desired options
     *
     * @return array of desired option type (never null). In case that the array of filtered options is null, empty or
     *         there is no option that matches the desired type an empty array is returned
     */
    @SuppressWarnings( "unchecked" )
    public static <T extends Option> T[] filter( final Class<T> optionType,
                                                 final Option... options )
    {
        final List<T> filtered = new ArrayList<T>();
        for( Option option : expand( options ) )
        {
            if( optionType.isAssignableFrom( option.getClass() ) )
            {
                filtered.add( (T) option );
            }
        }
        final T[] result = (T[]) Array.newInstance( optionType, filtered.size() );
        return filtered.toArray( result );
    }

    /**
     * Removes from the provided options all options that are instance of the provided class, returning the remaining
     * options.
     *
     * @param optionType class of the desired options to be removed
     * @param options    options to be filtered (can be null or empty array)
     *
     * @return array of remaining options (never null) after removing the desired type
     */

    public static Option[] remove( final Class<? extends Option> optionType,
                                   final Option... options )
    {
        final List<Option> filtered = new ArrayList<Option>();
        for( Option option : expand( options ) )
        {
            if( !optionType.isAssignableFrom( option.getClass() ) )
            {
                filtered.add( option );
            }
        }
        return filtered.toArray( new Option[filtered.size()] );
    }

}