@Override public Map<String, HazelcastSession> findByIndexNameAndIndexValue(String indexName, String indexValue) { if (!PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) { return Collections.emptyMap(); } Collection<MapSession> sessions = this.sessions .values(Predicates.equal(PRINCIPAL_NAME_ATTRIBUTE, indexValue)); Map<String, HazelcastSession> sessionMap = new HashMap<>(sessions.size()); for (MapSession session : sessions) { sessionMap.put(session.getId(), new HazelcastSession(session)); } return sessionMap; }
private Predicate eval(Object statement) { if (statement instanceof String) { return equal((String) statement, "true"); } else { return (Predicate) statement; } }
@Override public Predicate create(String attribute, Comparable c) { return equal(attribute, c); } };
@Override public Predicate create(String attribute, Comparable c) { return equal(attribute, c); } };
/** * See {@link com.hazelcast.query.Predicates#equal(String, Comparable)}. */ public static <K, V> Predicate<K, V> equal(String attribute, Comparable value) { return com.hazelcast.query.Predicates.equal(attribute, value); }
private Predicate eval(Object statement) { if (statement instanceof String) { return equal((String) statement, "true"); } else { return (Predicate) statement; } }
private Predicate<?, ?> fromBooleanVariant(Type type, String property) { switch (type) { case TRUE: return Predicates.equal(property, true); case FALSE: return Predicates.equal(property, false); default: throw new InvalidDataAccessApiUsageException(String.format("Logic error for '%s' in query", type)); } }
private Set<Person> getWithName(String name) { Predicate predicate = equal("name", name); return (Set<Person>) personMap.values(predicate); }
private Path getPathInternal(int pathId) { Predicate<String, Path> f = Predicates.equal("pathId", pathId); Collection<Path> entries = pathCache.values(f); if (entries.isEmpty()) { return null; } // check size > 1 ?? return entries.iterator().next(); }
@Override protected Set<Map.Entry<String, Path>> getTypedPathEntries(String root) { Predicate<String, Path> f = Predicates.equal("root", root); Set<Map.Entry<String, Path>> entries = pathCache.entrySet(f); return entries; }
private Predicate<?, ?> fromNullVariant(Type type, String property) { switch (type) { case IS_NULL: return Predicates.equal(property, null); case IS_NOT_NULL: return Predicates.notEqual(property, null); default: throw new InvalidDataAccessApiUsageException(String.format("Logic error for '%s' in query", type)); } }
@Override protected Set<Map.Entry<String, Path>> getTypedPathWithRegex(String regex, String root) { regex = regex.replaceAll("\\{", Matcher.quoteReplacement("\\{")); regex = regex.replaceAll("\\}", Matcher.quoteReplacement("\\}")); Predicate<String, Path> filter = new RegexPredicate("path", regex); if (root != null) { filter = Predicates.and(filter, Predicates.equal("root", root)); } Set<Map.Entry<String, Path>> entries = pathCache.entrySet(filter); return entries; }
private Set<Person> getNotWithName(String name) { Predicate namePredicate = equal("name", name); Predicate predicate = not(namePredicate); return (Set<Person>) personMap.values(predicate); }
public PredicateBuilder isNull() { return addPredicate(Predicates.equal(qb.getAttribute(), null)); }
public PredicateBuilder isNull() { return addPredicate(Predicates.equal(qb.getAttribute(), null)); }
public PredicateBuilder equal(Comparable value) { return addPredicate(Predicates.equal(qb.getAttribute(), value)); }
@TimeStep(prob = 1) public void getByStringIndex(ThreadState state) { String string = state.getUniqueString(); Predicate predicate = Predicates.equal("stringVal", string); Set<Map.Entry<String, DomainObject>> entries = map.entrySet(predicate); throttlingLogger.log(Level.INFO, "GetByStringIndex: " + entries.size() + " entries"); }