Java Predicates.alwaysFalse方法代码示例

import com.google.common.base.Predicates; //导入方法依赖的package包/类
/**
 * Creates a new configuration instance.
 *
 * @param profileId Unique profile identifier.
 */
public OIDCCoreProtocolConfiguration(@Nonnull @NotEmpty final String profileId) {
    super(profileId);
    authenticationFlows = Collections.emptySet();
    postAuthenticationFlows = Collections.emptyList();
    defaultAuthenticationContexts = Collections.emptyList();
    nameIDFormatPrecedence = Collections.emptyList();
    signIDTokensPredicate = Predicates.alwaysTrue();
    pairwiseSubject = Predicates.alwaysFalse();
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
public void testFilteredEntriesObjectPredicate() {
  Map<String, Integer> unfiltered = createUnfiltered();
  unfiltered.put("cat", 3);
  unfiltered.put("dog", 2);
  unfiltered.put("horse", 5);
  Predicate<Object> predicate = Predicates.alwaysFalse();
  Map<String, Integer> filtered
      = Maps.filterEntries(unfiltered, predicate);
  assertTrue(filtered.isEmpty());
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
public CraftiniumForgeTileEntity() {
    this.input = new ItemStackHandler(1);
    this.output = new SelectiveItemStackHandler(1, Predicates.alwaysFalse());
    this.fuel = new SelectiveItemStackHandler(1, TileEntityFurnace::isItemFuel);
    this.furnaceBurnTime = 0;
    this.currentItemBurnTime = 0;
    this.cookTime = 0;
    this.totalCookTime = 0;
    this.divisor = 1;
    this.brokenByCreative = false;
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
/**
 * Builds a classifier based on previous allow/match decisions.
 * This may be reused after a call to build and subsequent calls to
 * allow/match methods will not affect previously built classifiers.
 */
public FragmentClassifier build() {
  Predicate<? super Optional<String>> fragmentClassifier = this.fragmentPred;
  UrlClassifier asRelativeUrlClassifier = this.asRelativeUrlPred;
  if (fragmentClassifier == null) {
    fragmentClassifier = Predicates.alwaysFalse();
  }
  if (asRelativeUrlClassifier == null) {
    asRelativeUrlClassifier = MATCH_NO_URLS;
  }
  return new FragmentClassifierImpl(fragmentClassifier, asRelativeUrlClassifier);
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
/**
 * Builds a classifier based on previous allow/match decisions.
 * This may be reused after a call to build and subsequent calls to
 * allow/match methods will not affect previously built classifiers.
 */
public AuthorityClassifier build() {
  ImmutableSet<Inet4Address> ipv4Set = ipv4s.build();
  ImmutableSet<Inet6Address> ipv6Set = ipv6s.build();
  ImmutableSet<InternetDomainName> domainNameSet = domainNames.build();
  HostGlobMatcher hostGlobMatcher = new HostGlobMatcher(hostGlobs.build());
  int[] allowedPortsSorted;
  {
    ImmutableSet<Integer> allowedPortIntSet = allowedPorts.build();
    int n = allowedPortIntSet.size();
    allowedPortsSorted = new int[n];
    Iterator<Integer> allowedPortIt = allowedPortIntSet.iterator();
    for (int i = 0; i < n; ++i) {
      allowedPortsSorted[i] = allowedPortIt.next();
    }
    Arrays.sort(allowedPortsSorted);
  }
  Predicate<? super Integer> portClassifier =
      allowedPortsSorted.length == 0  // No exclusion specified
      ? Predicates.alwaysTrue()
      : Predicates.alwaysFalse();
  if (this.allowedPortClassifier != null) {
    portClassifier = this.allowedPortClassifier;
  }
  UserInfoClassifier userInfoClassifier =
      this.allowedUserInfoClassifier != null
      ? this.allowedUserInfoClassifier
      : UserInfoClassifiers.NO_PASSWORD_BUT_USERNAME_IF_ALLOWED_BY_SCHEME;
  return new AuthorityClassifierImpl(
      ipv4Set,
      ipv6Set,
      domainNameSet,
      hostGlobMatcher,
      matchesAnyHost,
      allowedPortsSorted,
      portClassifier,
      userInfoClassifier);
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
/**
 * If a port matcher is specified we assume default ports based on
 * scheme, so matching ports (80, 443) matches http://example.com/
 * but not https://example.com/ and https://example.com:80/ but not
 * https://example.com:10000/
 */
public AuthorityClassifierBuilder port(
    Predicate<? super Integer> portIsAllowed) {
  Preconditions.checkNotNull(portIsAllowed);
  if (allowedPortClassifier == null) {
    allowedPortClassifier = portIsAllowed;
  } else if (portIsAllowed != Predicates.alwaysFalse()) {  // x || false -> x
    allowedPortClassifier = Predicates.or(
        allowedPortClassifier, portIsAllowed);
  }
  return this;
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
public static <T extends Entity> Predicate<T> getTeamCollisionPredicate(final Entity entityIn)
{
    final Team team = entityIn.getTeam();
    final Team.CollisionRule team$collisionrule = team == null ? Team.CollisionRule.ALWAYS : team.getCollisionRule();
    Predicate<?> ret = team$collisionrule == Team.CollisionRule.NEVER ? Predicates.alwaysFalse() : Predicates.and(NOT_SPECTATING, new Predicate<Entity>()
    {
        public boolean apply(@Nullable Entity p_apply_1_)
        {
            if (!p_apply_1_.canBePushed())
            {
                return false;
            }
            else if (!entityIn.world.isRemote || p_apply_1_ instanceof EntityPlayer && ((EntityPlayer)p_apply_1_).isUser())
            {
                Team team1 = p_apply_1_.getTeam();
                Team.CollisionRule team$collisionrule1 = team1 == null ? Team.CollisionRule.ALWAYS : team1.getCollisionRule();

                if (team$collisionrule1 == Team.CollisionRule.NEVER)
                {
                    return false;
                }
                else
                {
                    boolean flag = team != null && team.isSameTeam(team1);
                    return (team$collisionrule == Team.CollisionRule.HIDE_FOR_OWN_TEAM || team$collisionrule1 == Team.CollisionRule.HIDE_FOR_OWN_TEAM) && flag ? false : team$collisionrule != Team.CollisionRule.HIDE_FOR_OTHER_TEAMS && team$collisionrule1 != Team.CollisionRule.HIDE_FOR_OTHER_TEAMS || flag;
                }
            }
            else
            {
                return false;
            }
        }
    });
    return (Predicate<T>)ret;
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
public static List<TF2Attribute> getAllPassibleAttributesForUpgradeStation() {
	List<TF2Attribute> list = new ArrayList<>();
	for (TF2Attribute attr : attributes)
		if (attr != null && attr.canApply != Predicates.<ItemStack>alwaysFalse() && attr.state == State.POSITIVE)
			for (int i = 0; i < attr.weight; i++)
				list.add(attr);
	return list;
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
public static <T extends Entity> Predicate<T> getTeamCollisionPredicate(final Entity entityIn)
{
    final Team team = entityIn.getTeam();
    final Team.CollisionRule team$collisionrule = team == null ? Team.CollisionRule.ALWAYS : team.getCollisionRule();
    Predicate<?> ret = team$collisionrule == Team.CollisionRule.NEVER ? Predicates.alwaysFalse() : Predicates.and(NOT_SPECTATING, new Predicate<Entity>()
    {
        public boolean apply(@Nullable Entity p_apply_1_)
        {
            if (!p_apply_1_.canBePushed())
            {
                return false;
            }
            else if (!entityIn.worldObj.isRemote || p_apply_1_ instanceof EntityPlayer && ((EntityPlayer)p_apply_1_).isUser())
            {
                Team team1 = p_apply_1_.getTeam();
                Team.CollisionRule team$collisionrule1 = team1 == null ? Team.CollisionRule.ALWAYS : team1.getCollisionRule();

                if (team$collisionrule1 == Team.CollisionRule.NEVER)
                {
                    return false;
                }
                else
                {
                    boolean flag = team != null && team.isSameTeam(team1);
                    return (team$collisionrule == Team.CollisionRule.HIDE_FOR_OWN_TEAM || team$collisionrule1 == Team.CollisionRule.HIDE_FOR_OWN_TEAM) && flag ? false : team$collisionrule != Team.CollisionRule.HIDE_FOR_OTHER_TEAMS && team$collisionrule1 != Team.CollisionRule.HIDE_FOR_OTHER_TEAMS || flag;
                }
            }
            else
            {
                return false;
            }
        }
    });
    return (Predicate<T>)ret;
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
@Override
public Predicate<Response> unassessedFilter() {
  return Predicates.alwaysFalse();
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
@Override
public Predicate<Response> unassessedFilter() {
  // unassessed answers cannot be linked
  return Predicates.alwaysFalse();
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
public Context(int expectedNumRelations) {
    this(expectedNumRelations, Predicates.<Symbol>alwaysFalse());
}
 

import com.google.common.base.Predicates; //导入方法依赖的package包/类
/**
 * Builds a classifier based on previous allow/match decisions.
 * This may be reused after a call to build and subsequent calls to
 * allow/match methods will not affect previously built classifiers.
 */
public QueryClassifier build() {
  ImmutableSet<String> mayKeySet = mayKeys.build();
  Predicate<? super String> mayKeyClassifier;
  if (mayClassifier != null) {
    mayKeyClassifier = mayClassifier;
  } else if (mayKeySet.isEmpty()) {
      // If nothing specified, assume permissive.
    mayKeyClassifier = Predicates.alwaysTrue();
  } else {
    // If a set specified, defer to the set.
    mayKeyClassifier = Predicates.<String>alwaysFalse();
  }

  ImmutableSet<String> onceKeySet = onceKeys.build();
  Predicate<? super String> onceKeyClassifier;
  if (onceClassifier != null) {
    onceKeyClassifier = onceClassifier;
  } else {
    onceKeyClassifier = Predicates.<String>alwaysFalse();
  }

  ImmutableSet<String> mustKeySet = mustKeys.build();
  ImmutableMap<String, Predicate<? super Optional<String>>> valueClassifierMap =
      ImmutableMap.copyOf(valueClassifiers);

  // If something may appear once or must appear, then it may appear.
  if (!Predicates.alwaysTrue().equals(mayKeyClassifier)) {
    if (!Predicates.alwaysFalse().equals(onceKeyClassifier)) {
      mayKeyClassifier = Predicates.or(mayKeyClassifier, onceKeyClassifier);
    }
    mayKeySet = ImmutableSet.<String>builder()
        .addAll(mayKeySet)
        .addAll(onceKeySet)
        .addAll(mustKeySet)
        .build();
  }

  return new QueryClassifierImpl(
      mayKeySet,
      mayKeyClassifier,
      onceKeySet,
      onceKeyClassifier,
      mustKeySet,
      valueClassifierMap);
}