Returns the result of (delegate == target1) && (delegate == target2) && ... && (delegate == targetN)

@param targets
@return
767189
public boolean all(Object... targets) {
		if (null == targets) { return null == this.delegate; }
		
		for (Object target : targets) {
			if (null == target) { if (null != this.delegate) { return false; } continue; }
			if (target != this.delegate) { return false; }
		}
		
		return true;
	}
619151
public static <T> Predicate<T> equalTo(@Nullable T target) {
		return target == null ? isNull() : t -> Objects.equals(t, target);
	}
302304
public static Betner betnNext(String target, String leftSameWithRight) {
		return betn(target).betweenNext(leftSameWithRight);
	}
951972
public static final Enumeration<String> getAvailableVariants(String source,
                                                         String target) {
        return registry.getAvailableVariants(source, target);
    }
849353
public static <T, U extends Unifiable<? super T>> Choice<Unifier> unifyList(
      Unifier unifier, @Nullable List<U> toUnify, @Nullable final List<? extends T> targets) {
    return unifyList(unifier, toUnify, targets, /* allowVarargs= */ false);
  }
575688
public Set<String> setEscapeJava(final Set<?> target) {
        if (target == null) {
            return null;
        }
        final Set<String> result = new LinkedHashSet<String>(target.size() + 2);
        for (final Object element : target) {
            result.add(escapeJava(element));
        }
        return result;
    }
995661
@SuppressWarnings("unchecked")
	public static <T, I> List<T> asList(I... target) {
		return (List<T>) Arrays.asList(asArray(target));
	}
496656
protected static List<Long> mergeCounts(List<Long> baseCounts, List<Long> targetCounts,
            Map<Integer, Integer> resultMapping)
    {
        int countNum = resultMapping.size();
        List<Long> mergedCounts = new ArrayList<>(countNum);
        for (int count = 0; count < countNum; count++)
        {
            mergedCounts.add(0L);
        }

        for (Entry<Integer, Integer> resultEntry : resultMapping.entrySet())
        {
            mergedCounts.set(resultEntry.getKey(), baseCounts.get(resultEntry.getKey())
                    + targetCounts.get(resultEntry.getValue()));
        }

        return mergedCounts;
    }
501751
public static <T> Level0ArrayOperator<Double[],Double> on(final double[] target) {
        return onArrayOf(Types.DOUBLE, ArrayUtils.toObject(target));
    }
1099460
@Override
    public double[] get(double[] target) {
        if ((target == null) || (target.length != 16)) {
            target = new double[16];
        }
        target[0] = m00;
        target[1] = m01;
        target[2] = m02;
        target[3] = m03;

        target[4] = m10;
        target[5] = m11;
        target[6] = m12;
        target[7] = m13;

        target[8] = m20;
        target[9] = m21;
        target[10] = m22;
        target[11] = m23;

        target[12] = m30;
        target[13] = m31;
        target[14] = m32;
        target[15] = m33;

        return target;
    }
871069
public boolean matches(String target, int start, int end) {
		return this.matches(target, start, end, (Match) null);
	}
405962
public void setTargets(java.util.Collection<Target> targets) {
        if (targets == null) {
            this.targets = null;
            return;
        }

        this.targets = new java.util.ArrayList<Target>(targets);
    }
825462
function(target) {

        for (var i$2 = 1; i$2 < arguments.length; i$2 += 3) {

            var desc$0 = Object.getOwnPropertyDescriptor(arguments[i$2 + 1], "_");
            mergeProperty(target, arguments[i$2], desc$0, true);

            if (i$2 + 2 < arguments.length)
                mergeProperties(target, arguments[i$2 + 2], true);
        }

        return target;
    }
494537
public static <T> Level0ArrayOperator<BigInteger[],BigInteger> onArray(final BigInteger[] target) {
        return onArrayOf(Types.BIG_INTEGER, target);
    }
798985
public static <T extends AbstractJaxb> List<T> getDescendants(T target,
            List<T> resultList, String clazz) {
        return execute(target, resultList, null, clazz);
    }
911067
public boolean has(int... values) {
		long p = pur(values[0]);
		for (int i = 1, l = values.length; i < l; i++) {
			p += pur(values[i]);
		}
		return p == (this.delegate & p);
	}
109696
public Enumeration<String> getAvailableVariants(String source, String target) {
        CaseInsensitiveString cisrc = new CaseInsensitiveString(source);
        CaseInsensitiveString citrg = new CaseInsensitiveString(target);
        Map<CaseInsensitiveString, List<CaseInsensitiveString>> targets = specDAG.get(cisrc);
        if (targets == null) {
            return new IDEnumeration(null);
        }
        List<CaseInsensitiveString> variants = targets.get(citrg);
        if (variants == null) {
            return new IDEnumeration(null);
        }
        return new IDEnumeration(Collections.enumeration(variants));
    }