How to use

createHelper

method

in

net.sf.cglib.proxy.Enhancer

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the no-arg constructor of the superclass.
 * @return a new instance
 */
public Object create() {
  classOnly = false;
  argumentTypes = null;
  return createHelper();
}

/**
 * Generate a new class if necessary and return it without creating a new instance.
 * This ignores any callbacks that have been set.
 * To create a new instance you will have to use reflection, and methods
 * called during the constructor will not be intercepted. To avoid this problem,
 * use the multi-arg <code>create</code> method.
 * @see #create(Class[], Object[])
 */
public Class createClass() {
  classOnly = true;
  return (Class)createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the no-arg constructor of the superclass.
 * @return a new instance
 */
public Object create() {
  classOnly = false;
  argumentTypes = null;
  return createHelper();
}

/**
 * Generate a new class if necessary and return it without creating a new instance.
 * This ignores any callbacks that have been set.
 * To create a new instance you will have to use reflection, and methods
 * called during the constructor will not be intercepted. To avoid this problem,
 * use the multi-arg <code>create</code> method.
 * @see #create(Class[], Object[])
 */
public Class createClass() {
  classOnly = true;
  return (Class)createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the constructor of the superclass matching the <code>argumentTypes</code>
 * parameter, with the given arguments.
 * @param argumentTypes constructor signature
 * @param arguments compatible wrapped arguments to pass to constructor
 * @return a new instance
 */
public Object create(Class[] argumentTypes, Object[] arguments) {
  classOnly = false;
  if (argumentTypes == null || arguments == null || argumentTypes.length != arguments.length) {
    throw new IllegalArgumentException("Arguments must be non-null and of equal length");
  }
  this.argumentTypes = argumentTypes;
  this.arguments = arguments;
  return createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the constructor of the superclass matching the <code>argumentTypes</code>
 * parameter, with the given arguments.
 * @param argumentTypes constructor signature
 * @param arguments compatible wrapped arguments to pass to constructor
 * @return a new instance
 */
public Object create(Class[] argumentTypes, Object[] arguments) {
  classOnly = false;
  if (argumentTypes == null || arguments == null || argumentTypes.length != arguments.length) {
    throw new IllegalArgumentException("Arguments must be non-null and of equal length");
  }
  this.argumentTypes = argumentTypes;
  this.arguments = arguments;
  return createHelper();
}

/**
 * Generate a new class if necessary and return it without creating a new instance.
 * This ignores any callbacks that have been set.
 * To create a new instance you will have to use reflection, and methods
 * called during the constructor will not be intercepted. To avoid this problem,
 * use the multi-arg <code>create</code> method.
 * @see #create(Class[], Object[])
 */
public Class createClass() {
  classOnly = true;
  return (Class)createHelper();
}

/**
 * Generate a new class if necessary and return it without creating a new instance.
 * This ignores any callbacks that have been set.
 * To create a new instance you will have to use reflection, and methods
 * called during the constructor will not be intercepted. To avoid this problem,
 * use the multi-arg <code>create</code> method.
 * @see #create(Class[], Object[])
 */
public Class createClass() {
  classOnly = true;
  return (Class)createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the no-arg constructor of the superclass.
 * @return a new instance
 */
public Object create() {
  classOnly = false;
  argumentTypes = null;
  return createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the no-arg constructor of the superclass.
 * @return a new instance
 */
public Object create() {
  classOnly = false;
  argumentTypes = null;
  return createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the no-arg constructor of the superclass.
 * @return a new instance
 */
public Object create() {
  classOnly = false;
  argumentTypes = null;
  return createHelper();
}

/**
 * Generate a new class if necessary and return it without creating a new instance.
 * This ignores any callbacks that have been set.
 * To create a new instance you will have to use reflection, and methods
 * called during the constructor will not be intercepted. To avoid this problem,
 * use the multi-arg <code>create</code> method.
 * @see #create(Class[], Object[])
 */
public Class createClass() {
  classOnly = true;
  return (Class)createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the constructor of the superclass matching the <code>argumentTypes</code>
 * parameter, with the given arguments.
 * @param argumentTypes constructor signature
 * @param arguments compatible wrapped arguments to pass to constructor
 * @return a new instance
 */
public Object create(Class[] argumentTypes, Object[] arguments) {
  classOnly = false;
  if (argumentTypes == null || arguments == null || argumentTypes.length != arguments.length) {
    throw new IllegalArgumentException("Arguments must be non-null and of equal length");
  }
  this.argumentTypes = argumentTypes;
  this.arguments = arguments;
  return createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the constructor of the superclass matching the <code>argumentTypes</code>
 * parameter, with the given arguments.
 * @param argumentTypes constructor signature
 * @param arguments compatible wrapped arguments to pass to constructor
 * @return a new instance
 */
public Object create(Class[] argumentTypes, Object[] arguments) {
  classOnly = false;
  if (argumentTypes == null || arguments == null || argumentTypes.length != arguments.length) {
    throw new IllegalArgumentException("Arguments must be non-null and of equal length");
  }
  this.argumentTypes = argumentTypes;
  this.arguments = arguments;
  return createHelper();
}

/**
 * Generate a new class if necessary and uses the specified
 * callbacks (if any) to create a new object instance.
 * Uses the constructor of the superclass matching the <code>argumentTypes</code>
 * parameter, with the given arguments.
 * @param argumentTypes constructor signature
 * @param arguments compatible wrapped arguments to pass to constructor
 * @return a new instance
 */
public Object create(Class[] argumentTypes, Object[] arguments) {
  classOnly = false;
  if (argumentTypes == null || arguments == null || argumentTypes.length != arguments.length) {
    throw new IllegalArgumentException("Arguments must be non-null and of equal length");
  }
  this.argumentTypes = argumentTypes;
  this.arguments = arguments;
  return createHelper();
}