All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • uk.co.it.modular.beans.InstanceFactories Maven / Gradle / Ivy

    Go to download

    A library to support configurable instantiation and population of classes which implement the Java Beans standard

    There is a newer version: 0.9.2
    Show newest version
    /*
 * Copyright (c) Modular IT Limited.
 */

package uk.co.it.modular.beans;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.math.RandomUtils;
import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
import static org.apache.commons.lang.math.RandomUtils.*;
import static org.apache.commons.lang.time.DateUtils.addSeconds;

/**
 * @author Stewart Bissett
 */
public abstract class InstanceFactories {

	private static final int MAX_STRING_LENGTH = 50;
	private static final int MINUTES_PER_HOUR = 60;
	private static final int HOURS_PER_DAY = 24;
	private static final int DAYS_PER_YEAR = 365;
	private static final int SECONDS_IN_A_YEAR = MINUTES_PER_HOUR * HOURS_PER_DAY * DAYS_PER_YEAR;

	public static  InstanceFactory theValue(final T value) {
		return new InstanceFactory() {

			public T createValue() {
				return value;
			}
		};
	}

	public static InstanceFactory aNullValue() {
		return new InstanceFactory() {

			public Object createValue() {
				return null;
			}
		};
	}

	public static InstanceFactory aRandomString() {
		return new InstanceFactory() {

			public String createValue() {
				return randomAlphanumeric(MAX_STRING_LENGTH);
			}
		};
	}

	public static InstanceFactory aRandomInteger() {
		return new InstanceFactory() {

			public Integer createValue() {
				return Integer.valueOf(nextInt());
			}
		};
	}

	public static InstanceFactory aRandomShort() {
		return new InstanceFactory() {

			public Short createValue() {
				return Short.valueOf((short) nextInt(Short.MAX_VALUE));
			}
		};
	}

	public static InstanceFactory aRandomLong() {
		return new InstanceFactory() {

			public Long createValue() {
				return Long.valueOf(nextLong());
			}
		};
	}

	public static InstanceFactory aRandomDouble() {
		return new InstanceFactory() {

			public Double createValue() {
				return Double.valueOf(nextDouble());
			}
		};
	}

	public static InstanceFactory aRandomFloat() {
		return new InstanceFactory() {

			public Float createValue() {
				return Float.valueOf(nextFloat());
			}
		};
	}

	public static InstanceFactory aRandomBoolean() {
		return new InstanceFactory() {

			public Boolean createValue() {
				return Boolean.valueOf(nextBoolean());
			}
		};
	}

	public static InstanceFactory aRandomDate() {
		return new InstanceFactory() {

			public Date createValue() {
				return addSeconds(new Date(), nextInt(SECONDS_IN_A_YEAR));
			}
		};
	}

	public static InstanceFactory aRandomDecimal() {
		return new InstanceFactory() {

			public BigDecimal createValue() {
				return BigDecimal.valueOf(nextInt()).round(new MathContext(10, RoundingMode.HALF_UP)).movePointLeft(nextInt(5));
			}
		};
	}

	public static InstanceFactory aRandomByte() {
		return new InstanceFactory() {

			public Byte createValue() {
				return (byte) nextInt(Byte.MAX_VALUE);
			}
		};
	}

	public static InstanceFactory aRandomChar() {
		return new InstanceFactory() {

			public Character createValue() {
				return randomAlphabetic(1).charAt(0);
			}
		};
	}

	public static  InstanceFactory aRandomEnum(final Class enumType) {
		return new InstanceFactory() {

			public E createValue() {
				E[] enumerationValues = enumType.getEnumConstants();
				if (enumerationValues.length == 0) {
					return null;
				} else {
					return enumerationValues[nextInt(enumerationValues.length)];
				}
			}
		};
	}

	public static  ArrayFactory aRandomArrayOf(final InstanceFactory typeFactory) {
		return new ArrayFactory() {

			@SuppressWarnings("unchecked")
			public A[] createValue(final Class type, final int size) {
				Object array = Array.newInstance(type, size);
				if (array != null) {
					for (int i = 0; i < size; ++i) {
						Array.set(array, i, typeFactory.createValue());
					}
				}
				return (A[]) array;
			}
		};
	}

	public static  InstanceFactory aNewInstanceOf(final Class type) {
		return new InstanceFactory() {

			public T createValue() {
				try {
					return type.newInstance();
				} catch (Exception e) {
					throw new BeanBuilderException("Failed to instantiate instance of '" + type.getCanonicalName() + "'", e);
				}
			}
		};
	}

	public static  InstanceFactory oneOf(final InstanceFactory... factories) {
		return oneOf(Arrays.asList(factories));
	}

	public static  InstanceFactory oneOf(final Collection> factories) {
		return new InstanceFactory() {

			private final List> candidates = new ArrayList>(factories);

			public T createValue() {
				return candidates.get(nextInt(candidates.size())).createValue();
			}
		};
	}
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy