NOT AND Predicate

@see #nand(com.google.common.base.Predicate, com.google.common.base.Predicate)
@param components the operator arguments
@return the predicate
170665
@Beta
    @SafeVarargs
    public static <T> Predicate<T> nand(Predicate<? super T>... components) {
        return com.google.common.base.Predicates.not(com.google.common.base.Predicates.and(components));
    }
91468
public boolean negates( IAssertion other)
    {
    AssertNotLess assertion =
      other != null && other.getClass().equals( AssertNotLess.class)
      ? (AssertNotLess) other
      : null;

    return
      assertion != null
      && assertion.getProperty().equals( getProperty())
      && assertion.getBound() == getBound();
    }
454275
public Container andNot(Container x) {
    if (x instanceof ArrayContainer) {
      return andNot((ArrayContainer) x);
    } else if (x instanceof BitmapContainer) {
      return andNot((BitmapContainer) x);
    }
    return andNot((RunContainer) x);
  }
500644
public static <S> Feature<S,Boolean> not(Feature<? super S, Boolean> feature) {
        return FeatureExpressions.not(feature);
    }
1258409
public static Path pathFromComponents(String[] components) {
        if (null == components || components.length == 0) {
            return null;
        }
        return new PathImpl(pathStringFromComponents(components));
    }
776465
public static <T> ElementMatcher.Junction<T> not(ElementMatcher<? super T> matcher) {
        return new NegatingMatcher<T>(matcher);
    }
718610
public static<T> Filter<T> not(final Filter<T> filter) {
		return new AbstractFilter<T>() {
			@Override
			public boolean apply(final T x) {
				return ! filter.apply(x);
			}

			@Override
			public String toString() {
				return "(not " + filter + ")";
			}

			@Override
			public Filter<T> copy() {
				return not(filter.copy());
			}
		};
	}
233705
@GwtIncompatible("incompatible method")
    private static boolean arrayMemberEquals(final Class<?> componentType, final Object o1, final Object o2) {
        if (componentType.isAnnotation()) {
            return annotationArrayMemberEquals((Annotation[]) o1, (Annotation[]) o2);
        }
        if (componentType.equals(Byte.TYPE)) {
            return Arrays.equals((byte[]) o1, (byte[]) o2);
        }
        if (componentType.equals(Short.TYPE)) {
            return Arrays.equals((short[]) o1, (short[]) o2);
        }
        if (componentType.equals(Integer.TYPE)) {
            return Arrays.equals((int[]) o1, (int[]) o2);
        }
        if (componentType.equals(Character.TYPE)) {
            return Arrays.equals((char[]) o1, (char[]) o2);
        }
        if (componentType.equals(Long.TYPE)) {
            return Arrays.equals((long[]) o1, (long[]) o2);
        }
        if (componentType.equals(Float.TYPE)) {
            return Arrays.equals((float[]) o1, (float[]) o2);
        }
        if (componentType.equals(Double.TYPE)) {
            return Arrays.equals((double[]) o1, (double[]) o2);
        }
        if (componentType.equals(Boolean.TYPE)) {
            return Arrays.equals((boolean[]) o1, (boolean[]) o2);
        }
        return Arrays.equals((Object[]) o1, (Object[]) o2);
    }
465127
Optional<PackingPlan.InstancePlan> removeAnyInstanceOfComponent(String component) {
    Optional<PackingPlan.InstancePlan> instancePlan = getAnyInstanceOfComponent(component);
    if (instancePlan.isPresent()) {
      PackingPlan.InstancePlan plan = instancePlan.get();
      this.instances.remove(plan);
      return instancePlan;
    }
    return Optional.absent();
  }
329499
public Predicate<T> negate() {
        return new Predicate<T>() {
            @Override
            public boolean test( T input ) {
                return !Predicate.this.test(input);
            }

            @Override
            public Predicate<T> negate() {
                return Predicate.this;
            }
        };
    }
696998
@Beta
    public static <T> Predicate<T> nand(Predicate<? super T> first, Predicate<? super T> second) {
        return com.google.common.base.Predicates.not(com.google.common.base.Predicates.and(first, second));
    }
406721
@NonNull
  public static Term tuple(@NonNull Term... components) {
    return tuple(Arrays.asList(components));
  }
862093
public void setComponents(java.util.Collection<ResourcePathComponent> components) {
        if (components == null) {
            this.components = null;
            return;
        }

        this.components = new java.util.ArrayList<ResourcePathComponent>(components);
    }
760657
@NotNull
    public OptionalDouble filterNot(@NotNull DoublePredicate predicate) {
        return filter(DoublePredicate.Util.negate(predicate));
    }
1361622
public Set<ComponentDto> selectComponentsByQualifiers(DbSession dbSession, Set<String> qualifiers) {
    checkArgument(!qualifiers.isEmpty(), "Qualifiers cannot be empty");
    return new HashSet<>(mapper(dbSession).selectComponentsByQualifiers(qualifiers));
  }
788283
public static <T1, T2> BiPredicate<T1, T2> not(BiPredicate<T1, T2> predicate) {
        dbc.precondition(predicate != null, "cannot negate a null predicate");
        return predicate.negate();
    }
958682
public static Predicate not(final Predicate childPredicate) {
        return new Predicate() {
            public void init(AbstractSqlCreator creator) {
                childPredicate.init(creator);
            }
            public String toSql() {
                return "not (" + childPredicate.toSql() + ")";
            }
        };
    }