<p>
Creates an <i>operation expression</i> on the specified target object.
</p>

@param target the target object on which the expression will execute
@return an operator, ready for chaining
963657
public static <T> Level0ArrayOperator<BigDecimal[],BigDecimal> on(final BigDecimal[] target) {
        return onArrayOf(Types.BIG_DECIMAL, target);
    }
332961
public <T> DynamicJdbcMapper<T> newMapper(final Class<T> target) {
		return newMapper((Type) target);
	}
483575
public void ifeq(String target) throws IOException
    {
        if (wideIndex)
        {
            out.writeByte(NOT_IFEQ);
            out.writeShort(WIDEFIXOFFSET);
            Branch branch = createBranch(target);
            out.writeByte(GOTO_W);
            out.writeInt(branch);
        }
        else
        {
            Branch branch = createBranch(target);
            out.writeOpCode(IFEQ);
            out.writeShort(branch);
        }
    }
1365753
public void addConfiguredTarget(final TargetDef target) {
    if (target == null) {
      throw new NullPointerException("target");
    }
    target.setProject(getProject());
    this.targetPlatforms.addElement(target);
  }
808253
@SuppressWarnings("unchecked")
	private <T> T execOperator(Element element, Object scope, Meta meta, Format... format) throws IOException {
		Operator operator = factory.geInstance(meta.opcode);
		return (T) operator.exec(element, scope, meta.operand, format.length == 1 ? format[0] : null);
	}
494537
public static <T> Level0ArrayOperator<BigInteger[],BigInteger> onArray(final BigInteger[] target) {
        return onArrayOf(Types.BIG_INTEGER, target);
    }
743650
public static <T> Level0ArrayOperator<Calendar[],Calendar> on(final Calendar[] target) {
        return onArrayOf(Types.CALENDAR, target);
    }
912720
public static PolygonExpression<Polygon> polygonOperation(Operator op, Expression<?>... args) {
        return new PolygonOperation<Polygon>(Polygon.class, op, args);
    }
723723
public void execute(T target) throws Throwable
    {
        try
        {
            for (Invokation invokation : queue)
            {
                invokation.invoke(target);
            }
        }
        catch (InvocationTargetException ex)
        {
            throw ex.getCause();
        }
        catch (ReflectiveOperationException ex)
        {
            throw new RuntimeException(ex);
        }
    }
26932
public void ifge(String target) throws IOException
    {
        if (wideIndex)
        {
            out.writeByte(NOT_IFGE);
            out.writeShort(WIDEFIXOFFSET);
            Branch branch = createBranch(target);
            out.writeByte(GOTO_W);
            out.writeInt(branch);
        }
        else
        {
            Branch branch = createBranch(target);
            out.writeOpCode(IFGE);
            out.writeShort(branch);
        }
    }
1060191
public static <T> Level0SetOperator<Set<T>,T> on(final Set<T> target) {
        return onSet(target);
    }
619151
public static <T> Predicate<T> equalTo(@Nullable T target) {
		return target == null ? isNull() : t -> Objects.equals(t, target);
	}
587658
public static <T> Level0ArrayOperator<Character[],Character> on(final char[] target) {
        return onArrayOf(Types.CHARACTER, ArrayUtils.toObject(target));
    }
66230
public boolean doOnWith(final String command, final String target, final String value) {
		LOG.info("Performing | " + command + " | " + target + " | " + value + " |");
		return executeDoCommand(command, new String[] { unalias(target), unalias(value) });
	}
778665
public <T> Predicate<T> in (final Collection<? extends T> target)
    {
        return new Predicate<T>() {
            public boolean apply (T arg) {
                try {
                    return target.contains(arg);
                } catch (NullPointerException e) {
                    return false;
                } catch (ClassCastException e) {
                    return false;
                }
            }
        };
    }
1303719
public <T> T inject(Class<T> targetClass, T targetObject) {
		try {
			doInject(targetClass, targetObject);
			return targetObject;
		} catch (ReflectiveOperationException e) {
			throw new RuntimeException(e);
		}
	}
242220
public static PointExpression<Point> pointOperation(Operator op, Expression<?>... args) {
        return new PointOperation<Point>(Point.class, op, args);
    }