private static void collectFiredRules( ListMultimap<String, SimpleRule> firedRules, Rule rule, EvaluationContext context) { Predicate predicate = rule.getPredicate(); if (predicate == null) { throw new InvalidFeatureException(rule); } Boolean status = PredicateUtil.evaluate(predicate, context); if (status == null || !status.booleanValue()) { return; } // End if if (rule instanceof SimpleRule) { SimpleRule simpleRule = (SimpleRule) rule; firedRules.put(simpleRule.getScore(), simpleRule); } else if (rule instanceof CompoundRule) { CompoundRule compoundRule = (CompoundRule) rule; List<Rule> childRules = compoundRule.getRules(); for (Rule childRule : childRules) { collectFiredRules(firedRules, childRule, context); } } }
public void testConstrainedTypePreservingRandomAccessList() { ListMultimap<String, Integer> multimap = MapConstraints.constrainedListMultimap( ArrayListMultimap.<String, Integer>create(), TEST_CONSTRAINT); multimap.put("foo", 1); Map.Entry<String, Collection<Integer>> entry = multimap.asMap().entrySet().iterator().next(); assertTrue(entry.getValue() instanceof List); assertFalse(multimap.entries() instanceof Set); assertTrue(multimap.get("foo") instanceof RandomAccess); }
private ListMultimap<Artifact, DependencyNode> collectDependencyNotFoundData( List<Exception> exceptionList, Class<? extends DependencyNotFoundException> exceptionType) { ListMultimap<Artifact, DependencyNode> artifactNotFoundMap = ArrayListMultimap.create(); ListIterator<Exception> exceptionIterator = exceptionList.listIterator(); while (exceptionIterator.hasNext()) { Exception e = exceptionIterator.next(); if (e.getClass().equals(exceptionType)) { DependencyNode from = exceptionType.cast(e).getDependencyNode(); artifactNotFoundMap.put(exceptionType.cast(e).getMissingArtifact(), from); exceptionIterator.remove(); } } return artifactNotFoundMap; }
/** Test throwing ConcurrentModificationException when a sublist's ancestor's delegate changes. */ public void testSublistConcurrentModificationException() { ListMultimap<String, Integer> multimap = create(); multimap.putAll("foo", asList(1, 2, 3, 4, 5)); List<Integer> list = multimap.get("foo"); ASSERT.that(multimap.get("foo")).hasContentsInOrder(1, 2, 3, 4, 5); List<Integer> sublist = list.subList(0, 5); ASSERT.that(sublist).hasContentsInOrder(1, 2, 3, 4, 5); sublist.clear(); assertTrue(sublist.isEmpty()); multimap.put("foo", 6); try { sublist.isEmpty(); fail("Expected ConcurrentModificationException"); } catch (ConcurrentModificationException expected) { } }
private void init( PName name, PTableType type, long timeStamp, long sequenceNumber, String pkName, List<PColumn> columns, PTableStats stats) { this.name = name; this.type = type; this.timeStamp = timeStamp; this.sequenceNumber = sequenceNumber; this.columnsByName = ArrayListMultimap.create(columns.size(), 1); this.pkName = pkName; List<PColumn> pkColumns = Lists.newArrayListWithExpectedSize(columns.size() - 1); PColumn[] allColumns = new PColumn[columns.size()]; RowKeySchemaBuilder builder = new RowKeySchemaBuilder(); for (int i = 0; i < allColumns.length; i++) { PColumn column = columns.get(i); allColumns[column.getPosition()] = column; PName familyName = column.getFamilyName(); if (familyName == null) { pkColumns.add(column); builder.addField(column); } columnsByName.put(column.getName().getString(), column); } this.pkColumns = ImmutableList.copyOf(pkColumns); this.rowKeySchema = builder.setMinNullable(pkColumns.size()).build(); this.allColumns = ImmutableList.copyOf(allColumns); // Two pass so that column order in column families matches overall column order // and to ensure that column family order is constant int maxExpectedSize = allColumns.length - pkColumns.size(); // Maintain iteration order so that column families are ordered as they are listed Map<PName, List<PColumn>> familyMap = Maps.newLinkedHashMap(); for (PColumn column : allColumns) { PName familyName = column.getFamilyName(); if (familyName != null) { List<PColumn> columnsInFamily = familyMap.get(familyName); if (columnsInFamily == null) { columnsInFamily = Lists.newArrayListWithExpectedSize(maxExpectedSize); familyMap.put(familyName, columnsInFamily); } columnsInFamily.add(column); } } Iterator<Map.Entry<PName, List<PColumn>>> iterator = familyMap.entrySet().iterator(); PColumnFamily[] families = new PColumnFamily[familyMap.size()]; ImmutableMap.Builder<String, PColumnFamily> familyByString = ImmutableMap.builder(); ImmutableSortedMap.Builder<byte[], PColumnFamily> familyByBytes = ImmutableSortedMap.orderedBy(Bytes.BYTES_COMPARATOR); for (int i = 0; i < families.length; i++) { Map.Entry<PName, List<PColumn>> entry = iterator.next(); PColumnFamily family = new PColumnFamilyImpl(entry.getKey(), entry.getValue()); families[i] = family; familyByString.put(family.getName().getString(), family); familyByBytes.put(family.getName().getBytes(), family); } this.families = ImmutableList.copyOf(families); this.familyByBytes = familyByBytes.build(); this.familyByString = familyByString.build(); this.stats = stats; }