streamflow.model.generator.RandomGenerator.java Source code

Java tutorial

Introduction

Here is the source code for streamflow.model.generator.RandomGenerator.java

Source

/**
 * Copyright 2014 Lockheed Martin Corporation
 *
 * 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 streamflow.model.generator;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.math.RandomUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class RandomGenerator {

    protected static final Logger LOG = LoggerFactory.getLogger(RandomGenerator.class);

    public static <T> T randomObject(Class<T> objectClass) {
        return randomObject(objectClass, null);
    }

    public static <T, V> T randomObject(Class<T> objectClass, Class<V> typeClass1) {
        return randomObject(objectClass, typeClass1, null);
    }

    public static <T, V, W> T randomObject(Class<T> objectClass, Class<V> typeClass1, Class<W> typeClass2) {
        T object = null;

        try {
            if (boolean.class.isAssignableFrom(objectClass) || Boolean.class.isAssignableFrom(objectClass)) {
                object = (T) randomBoolean();
            } else if (byte.class.isAssignableFrom(objectClass) || Byte.class.isAssignableFrom(objectClass)) {
                object = (T) randomByte();
            } else if (char.class.isAssignableFrom(objectClass) || Character.class.isAssignableFrom(objectClass)) {
                object = (T) randomChar();
            } else if (short.class.isAssignableFrom(objectClass) || Short.class.isAssignableFrom(objectClass)) {
                object = (T) randomShort();
            } else if (int.class.isAssignableFrom(objectClass) || Integer.class.isAssignableFrom(objectClass)) {
                object = (T) randomInt();
            } else if (long.class.isAssignableFrom(objectClass) || Long.class.isAssignableFrom(objectClass)) {
                object = (T) randomLong();
            } else if (float.class.isAssignableFrom(objectClass) || Float.class.isAssignableFrom(objectClass)) {
                object = (T) randomFloat();
            } else if (double.class.isAssignableFrom(objectClass) || Double.class.isAssignableFrom(objectClass)) {
                object = (T) randomDouble();
            } else if (String.class.isAssignableFrom(objectClass)) {
                object = (T) randomString();
            } else if (Date.class.isAssignableFrom(objectClass)) {
                object = (T) randomDate();
            } else if (Map.class.isAssignableFrom(objectClass)) {
                object = (T) randomMap((Class<Map>) objectClass, typeClass1, typeClass2);
            } else if (List.class.isAssignableFrom(objectClass)) {
                object = (T) randomList((Class<List>) objectClass, typeClass1);
            } else if (Set.class.isAssignableFrom(objectClass)) {
                object = (T) randomSet((Class<Set>) objectClass, typeClass1);
            } else if (Collection.class.isAssignableFrom(objectClass)) {
                object = (T) randomCollection((Class<Collection>) objectClass, typeClass1);
            } else if (objectClass.isArray()) {
                object = (T) randomArray(objectClass.getComponentType());
            } else if (objectClass.isEnum()) {
                object = (T) randomEnum(objectClass);
            } else {
                object = objectClass.newInstance();

                for (Field field : objectClass.getDeclaredFields()) {
                    if (!java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
                        Class fieldType = field.getType();

                        field.setAccessible(true);

                        if (field.getGenericType() instanceof ParameterizedType) {
                            ParameterizedType paramType = (ParameterizedType) field.getGenericType();
                            Type[] typeArgs = paramType.getActualTypeArguments();

                            if (typeArgs.length == 1) {
                                if (typeArgs[0] instanceof ParameterizedType) {
                                    // TODO: HANDLE NESTED PARAM TYPE
                                } else {
                                    field.set(object, randomObject(fieldType, (Class<?>) typeArgs[0]));
                                }
                            } else if (typeArgs.length == 2) {
                                field.set(object,
                                        randomObject(fieldType, (Class<?>) typeArgs[0], (Class<?>) typeArgs[1]));
                            }
                        } else {
                            field.set(object, randomObject(fieldType));
                        }
                    }
                }
            }
        } catch (Exception ex) {
            //LOG.error("Exception while building the random object", ex);
        }

        return object;
    }

    public static <T> T randomEnum(Class<T> enumClass) {
        T[] enums = enumClass.getEnumConstants();
        return enums[RandomUtils.nextInt(enums.length)];
    }

    public static <T> T[] randomArray(Class<T> arrayClass) {
        List<T> arrayList = new ArrayList<T>();
        for (int i = 0; i <= RandomUtils.nextInt(3); i++) {
            arrayList.add(randomObject(arrayClass));
        }

        return (T[]) arrayList.toArray();
    }

    public static <T extends Map<V, W>, V, W> T randomMap(Class<T> setClass, Class<V> keyClass,
            Class<W> valueClass) {
        T mapObject = null;
        try {
            mapObject = setClass.newInstance();

            for (int i = 0; i <= RandomUtils.nextInt(3); i++) {
                mapObject.put(randomObject(keyClass), randomObject(valueClass));
            }
        } catch (Exception ex) {
            //LOG.error("Exception while building the random map", ex);
        }
        return mapObject;
    }

    public static <T extends Set<V>, V> T randomSet(Class<T> setClass, Class<V> valueClass) {
        T setObject = null;
        try {
            setObject = setClass.newInstance();

            for (int i = 0; i <= RandomUtils.nextInt(3); i++) {
                setObject.add(randomObject(valueClass));
            }
        } catch (Exception ex) {
            //LOG.error("Exception while building the random set", ex);
        }
        return setObject;
    }

    public static <T extends List<V>, V> T randomList(Class<T> listClass, Class<V> valueClass) {
        T listObject = null;
        try {
            listObject = listClass.newInstance();
            for (int i = 0; i <= RandomUtils.nextInt(3); i++) {
                listObject.add(randomObject(valueClass));
            }
        } catch (Exception ex) {
            //LOG.error("Exception while building the random list", ex);
        }
        return listObject;
    }

    public static <T extends Collection<V>, V> T randomCollection(Class<T> listClass, Class<V> valueClass) {
        T collectionObject = null;
        try {
            collectionObject = listClass.newInstance();
            for (int i = 0; i <= RandomUtils.nextInt(3); i++) {
                collectionObject.add(randomObject(valueClass));
            }
        } catch (Exception ex) {
            //LOG.error("Exception while building the random collection", ex);
        }
        return collectionObject;
    }

    public static Boolean randomBoolean() {
        return RandomUtils.nextBoolean();
    }

    public static Byte randomByte() {
        return (byte) (Byte.MIN_VALUE + RandomUtils.nextInt(Byte.MAX_VALUE - Byte.MIN_VALUE));
    }

    public static Character randomChar() {
        return (char) (Character.MIN_VALUE + RandomUtils.nextInt(Character.MAX_VALUE - Character.MIN_VALUE));
    }

    public static Short randomShort() {
        return (short) (Short.MIN_VALUE + RandomUtils.nextInt(Short.MAX_VALUE - Short.MIN_VALUE));
    }

    public static Integer randomInt() {
        return RandomUtils.nextInt();
    }

    public static Long randomLong() {
        return RandomUtils.nextLong();
    }

    public static Float randomFloat() {
        return RandomUtils.nextFloat();
    }

    public static Double randomDouble() {
        return RandomUtils.nextDouble();
    }

    public static String randomString() {
        return RandomStringUtils.randomAlphanumeric(32);
    }

    public static Date randomDate() {
        return new Date();
    }
}