private Collection getFilterGroup(Activity activity) {
Object obj =
(FilteredActivity)
activity
.getClass()
.getAnnotation(com / google / android / apps / wallet / filter / FilteredActivity);
if (obj == null) {
throw new IllegalArgumentException(
String.valueOf(activity.getClass().getName())
.concat(" missing FilteredActivity annotation"));
}
if (((FilteredActivity) (obj)).group().equals("NONE")) {
return new ArrayList();
}
if (!activityFilters.containsKey(((FilteredActivity) (obj)).group())) {
activity = String.valueOf(activity.getClass().getName());
obj = ((FilteredActivity) (obj)).group();
String s = String.valueOf(activityFilters.keySet());
throw new IllegalArgumentException(
(new StringBuilder(
String.valueOf(activity).length()
+ 49
+ String.valueOf(obj).length()
+ String.valueOf(s).length()))
.append(activity)
.append(" has invalid group attribute: ")
.append(((String) (obj)))
.append(" valid groups are: ")
.append(s)
.toString());
} else {
return activityFilters.get(((FilteredActivity) (obj)).group());
}
}
@Override
public void serialize(final MapGenerator gen) {
final ListMultimap<String, MultipartItem> items = LinkedListMultimap.create();
for (MultipartItem item : this.getItems()) {
items.put(item.getName(), item);
}
for (final String name : items.keySet()) {
final List<MultipartItem> values = items.get(name);
if (values.size() == 1) {
gen.map(name);
MultipartItemMapper.serialize(gen, values.get(0));
gen.end();
} else {
gen.array(name);
values.forEach(
(item) -> {
gen.map();
MultipartItemMapper.serialize(gen, item);
gen.end();
});
gen.end();
}
}
}
/**
* Remove the targets and rules defined by {@code path} from the cache and recursively remove the
* targets and rules defined by files that transitively include {@code path} from the cache.
*
* @param path The File that has changed.
*/
private synchronized void invalidateDependents(Path path) {
// Normalize path to ensure it hashes equally with map keys.
path = normalize(path);
if (parsedBuildFiles.containsKey(path)) {
if (console.getVerbosity() == Verbosity.ALL) {
console.getStdErr().printf("Parser invalidating %s cache\n", path.toAbsolutePath());
}
// Remove all targets defined by path from cache.
for (Map<String, Object> rawRule : parsedBuildFiles.get(path)) {
BuildTarget target = parseBuildTargetFromRawRule(rawRule);
knownBuildTargets.remove(target);
}
// Remove all rules defined in path from cache.
parsedBuildFiles.removeAll(path);
// All targets have no longer been parsed and cached.
allBuildFilesParsed = false;
}
// Recursively invalidate dependents.
for (Path dependent : buildFileDependents.get(path)) {
if (!dependent.equals(path)) {
invalidateDependents(dependent);
}
}
// Dependencies will be repopulated when files are re-parsed.
buildFileDependents.removeAll(path);
}
public void testInheritedOuterMethod() {
resolveSource(
"Test",
"class Test { class A { void foo() {} } class B extends A { "
+ "class Inner { void test() { foo(); } } } }");
TypeDeclaration aNode = (TypeDeclaration) nodesByType.get(ASTNode.TYPE_DECLARATION).get(1);
TypeDeclaration bNode = (TypeDeclaration) nodesByType.get(ASTNode.TYPE_DECLARATION).get(2);
TypeDeclaration innerNode = (TypeDeclaration) nodesByType.get(ASTNode.TYPE_DECLARATION).get(3);
assertFalse(OuterReferenceResolver.needsOuterReference(aNode.resolveBinding()));
assertFalse(OuterReferenceResolver.needsOuterReference(bNode.resolveBinding()));
assertTrue(OuterReferenceResolver.needsOuterReference(innerNode.resolveBinding()));
// B will need an outer reference to Test so it can initialize its
// superclass A.
List<IVariableBinding> bPath = OuterReferenceResolver.getPath(bNode);
assertNotNull(bPath);
assertEquals(1, bPath.size());
assertEquals(OuterReferenceResolver.OUTER_PARAMETER, bPath.get(0));
// foo() call will need to get to B's scope to call the inherited method.
MethodInvocation fooCall = (MethodInvocation) nodesByType.get(ASTNode.METHOD_INVOCATION).get(0);
List<IVariableBinding> fooPath = OuterReferenceResolver.getPath(fooCall);
assertNotNull(fooPath);
assertEquals(1, fooPath.size());
assertEquals("B", fooPath.get(0).getType().getName());
}
/**
* Using the criteria in {@code parentIdMap}, recursively adds all children under the partition ID
* of {@code parentNode} to {@code parentNode}.
*
* @param parentNode required
* @param parentIdMap the multimap from parent partition ID to list of child criteria
*/
private static void addChildNodes(
ProductPartitionNode parentNode, ListMultimap<Long, AdGroupCriterion> parentIdMap) {
if (parentIdMap.containsKey(parentNode.getProductPartitionId())) {
parentNode = parentNode.asSubdivision();
}
for (AdGroupCriterion adGroupCriterion : parentIdMap.get(parentNode.getProductPartitionId())) {
ProductPartition partition = (ProductPartition) adGroupCriterion.getCriterion();
ProductPartitionNode childNode = parentNode.addChild(partition.getCaseValue());
childNode = childNode.setProductPartitionId(partition.getId());
if (ProductPartitionType.SUBDIVISION.equals(partition.getPartitionType())) {
childNode = childNode.asSubdivision();
} else {
if (adGroupCriterion instanceof BiddableAdGroupCriterion) {
childNode = childNode.asBiddableUnit();
Money cpcBidAmount = getBid((BiddableAdGroupCriterion) adGroupCriterion);
if (cpcBidAmount != null) {
childNode = childNode.setBid(cpcBidAmount.getMicroAmount());
}
} else {
childNode = childNode.asExcludedUnit();
}
}
addChildNodes(childNode, parentIdMap);
}
}
/**
* Returns a new instance of this class based on the collection of ad group criteria provided.
*
* <p>NOTE: If retrieving existing criteria for use with this method, you must include all of the
* fields in {@link #REQUIRED_SELECTOR_FIELDS} in your {@link Selector}.
*
* @param adGroupId the ID of the ad group
* @param biddingStrategyConfig the {@link BiddingStrategyConfiguration} for the ad group
* @param adGroupCriteria the non-null (but possibly empty) list of ad group criteria
* @throws NullPointerException if any argument is null, any element in {@code adGroupCriteria} is
* null, or any required field from {@link #REQUIRED_SELECTOR_FIELDS} is missing from an
* element in {@code adGroupCriteria}
* @throws IllegalArgumentException if {@code adGroupCriteria} does not include the root criterion
* of the product partition tree
*/
public static ProductPartitionTree createAdGroupTree(
Long adGroupId,
BiddingStrategyConfiguration biddingStrategyConfig,
List<AdGroupCriterion> adGroupCriteria) {
Preconditions.checkNotNull(adGroupId, "Null ad group ID");
Preconditions.checkNotNull(biddingStrategyConfig, "Null bidding strategy configuration");
Preconditions.checkNotNull(adGroupCriteria, "Null criteria list");
if (adGroupCriteria.isEmpty()) {
return createEmptyAdGroupTree(adGroupId, biddingStrategyConfig);
}
ListMultimap<Long, AdGroupCriterion> parentIdMap = LinkedListMultimap.create();
for (AdGroupCriterion adGroupCriterion : adGroupCriteria) {
Preconditions.checkNotNull(
adGroupCriterion.getCriterion(), "AdGroupCriterion has a null criterion");
if (adGroupCriterion instanceof BiddableAdGroupCriterion) {
BiddableAdGroupCriterion biddableCriterion = (BiddableAdGroupCriterion) adGroupCriterion;
Preconditions.checkNotNull(
biddableCriterion.getUserStatus(),
"User status is null for criterion ID %s",
biddableCriterion.getCriterion().getId());
if (UserStatus.REMOVED.equals(biddableCriterion.getUserStatus())) {
// Skip REMOVED criteria.
continue;
}
}
if (adGroupCriterion.getCriterion() instanceof ProductPartition) {
ProductPartition partition = (ProductPartition) adGroupCriterion.getCriterion();
parentIdMap.put(partition.getParentCriterionId(), adGroupCriterion);
}
}
return createNonEmptyAdGroupTree(adGroupId, parentIdMap);
}
public void print(
PdfWriter pdfWriter, GroupingContainer groupingContainer, Document document, Locale locale)
throws DocumentException {
if (notPrintOperationAtFirstPage()) {
document.newPage();
}
ListMultimap<String, OrderOperationComponent> titleToOperationComponent =
groupingContainer.getTitleToOperationComponent();
for (String title : titleToOperationComponent.keySet()) {
operationSectionHeader.print(document, title);
int count = 0;
for (OrderOperationComponent orderOperationComponent :
groupingContainer.getTitleToOperationComponent().get(title)) {
count++;
operationOrderSection.print(
pdfWriter,
groupingContainer,
orderOperationComponent.getOrder(),
orderOperationComponent.getOperationComponent(),
document,
locale);
if (count != titleToOperationComponent.get(title).size()) {
if (notPrintOperationAtFirstPage()) {
document.add(Chunk.NEXTPAGE);
}
}
}
}
}
@Override
public PlanNode visitUnion(UnionNode node, RewriteContext<Set<Symbol>> context) {
// Find out which output symbols we need to keep
ImmutableListMultimap.Builder<Symbol, Symbol> rewrittenSymbolMappingBuilder =
ImmutableListMultimap.builder();
for (Symbol symbol : node.getOutputSymbols()) {
if (context.get().contains(symbol)) {
rewrittenSymbolMappingBuilder.putAll(symbol, node.getSymbolMapping().get(symbol));
}
}
ListMultimap<Symbol, Symbol> rewrittenSymbolMapping = rewrittenSymbolMappingBuilder.build();
// Find the corresponding input symbol to the remaining output symbols and prune the subplans
ImmutableList.Builder<PlanNode> rewrittenSubPlans = ImmutableList.builder();
for (int i = 0; i < node.getSources().size(); i++) {
ImmutableSet.Builder<Symbol> expectedInputSymbols = ImmutableSet.builder();
for (Collection<Symbol> symbols : rewrittenSymbolMapping.asMap().values()) {
expectedInputSymbols.add(Iterables.get(symbols, i));
}
rewrittenSubPlans.add(
context.rewrite(node.getSources().get(i), expectedInputSymbols.build()));
}
return new UnionNode(
node.getId(),
rewrittenSubPlans.build(),
rewrittenSymbolMapping,
ImmutableList.copyOf(rewrittenSymbolMapping.keySet()));
}
public void addCell(String parent, String child, String label, Multiplicity m, Sort contents) {
if (parent != null) {
if (!children.containsKey(Sort(parent))) {
// create a fragment label for the parent cell.
cellFragmentLabels.put(
Sort(parent), KLabel(cellLabels.get(Sort(parent)).name() + "-fragment"));
}
if (m != Multiplicity.STAR) {
cellAbsentLabels.put(Sort(child), KLabel("no" + child));
}
if (m == Multiplicity.STAR) {
cellCollectionSorts.put(Sort(child + "Bag"), Sort(child));
}
parents.put(Sort(child), Sort(parent));
children.put(Sort(parent), Sort(child));
levels.put(Sort(child), 1 + levels.get(Sort(parent)));
} else {
levels.put(Sort(child), 0);
}
if (contents != null) {
leafCellTypes.put(Sort(child), contents);
}
multiplicities.put(Sort(child), m);
cellLabels.put(Sort(child), KLabel(label));
}
@GET
@ApiOperation(
value = "Get topology of hosts, schedulers and vms",
response = HostInfo.class,
responseContainer = ResourceList.CLASS_NAME)
@ApiResponses(value = {@ApiResponse(code = 200, message = "Get topology from schedulers")})
public Response get() throws RpcException, InterruptedException, TException, IOException {
List<SchedulerEntry> schedulers = chairmanClient.getSchedulers().getSchedulers();
List<String> agents = new ArrayList<>();
ListMultimap<String, SchedulerRole> schedulerMap = ArrayListMultimap.create();
for (SchedulerEntry entry : schedulers) {
agents.addAll(entry.getRole().getHosts());
schedulerMap.put(entry.getAgent(), entry.getRole());
}
ConcurrentHashMap<String, List<Resource>> resources = new ConcurrentHashMap<>();
CountDownLatch done = new CountDownLatch(agents.size());
for (String agent : agents) {
getAgentResources(resources, done, agent);
}
done.await(32, TimeUnit.SECONDS);
List<HostInfo> result = new ArrayList<>();
for (String agentId : agents) {
List<VmInfo> respondedVms = new ArrayList<>();
for (Resource resource : resources.get(agentId)) {
VmInfo vmInfo = new VmInfo();
vmInfo.setId(resource.getVm().getId());
vmInfo.setState(resource.getVm().getState().toString());
vmInfo.setFlavor(resource.getVm().getFlavor());
respondedVms.add(vmInfo);
}
List<SchedulerInfo> respondedSchedulers = new ArrayList<>();
for (SchedulerRole schedulerRole : schedulerMap.get(agentId)) {
SchedulerInfo schedulerInfo = new SchedulerInfo();
schedulerInfo.setId(schedulerRole.getId());
schedulerInfo.setHosts(schedulerRole.getHosts());
schedulerInfo.setSchedulers(schedulerRole.getSchedulers());
schedulerInfo.setParent(schedulerRole.getParent_id());
respondedSchedulers.add(schedulerInfo);
}
HostInfo hostInfo = new HostInfo();
hostInfo.setId(agentId);
hostInfo.setSchedulers(respondedSchedulers);
hostInfo.setVms(respondedVms);
result.add(hostInfo);
}
return generateResourceListResponse(Response.Status.OK, new ResourceList<>(result));
}
/**
* Remove a listener.
*
* @param key the associated key object
* @param listener the listener to remove
*/
public void removeListner(Object key, UniversalLookupListener listener) {
listeners.get(key).remove(listener);
// Some cleanup
if (listeners.get(key).isEmpty()) {
listeners.removeAll(key);
}
}
/**
* Validate domain service Ids are unique, and that the {@link PostConstruct} method, if present,
* must either take no arguments or take a {@link Map} object), and that the {@link PreDestroy}
* method, if present, must take no arguments.
*
* <p>TODO: there seems to be some duplication/overlap with {@link ServiceInitializer}.
*/
private void validateServices(List<Object> serviceList) {
for (Object service : serviceList) {
final Method[] methods = service.getClass().getMethods();
for (Method method : methods) {
validatePostConstructMethods(service, method);
validatePreDestroyMethods(service, method);
}
}
ListMultimap<String, Object> servicesById = ArrayListMultimap.create();
for (Object service : serviceList) {
String id = ServiceUtil.id(service);
servicesById.put(id, service);
}
for (Entry<String, Collection<Object>> servicesForId : servicesById.asMap().entrySet()) {
String serviceId = servicesForId.getKey();
Collection<Object> services = servicesForId.getValue();
if (services.size() > 1) {
throw new IllegalStateException(
"Service ids must be unique; serviceId '"
+ serviceId
+ "' is declared by domain services "
+ classNamesFor(services));
}
}
}
/** Test for date extraction function in alignment */
@Test
public void testDateExtraction() {
Collection<? extends Cell> cells = alignment.getCells();
Iterator<? extends Cell> it = cells.iterator();
Cell cell = null;
while (it.hasNext()) {
Cell temp = it.next();
if (temp.getTransformationIdentifier()
.equals("eu.esdihumboldt.cst.functions.string.dateextraction")) {
cell = temp;
break;
}
}
ListMultimap<String, ParameterValue> params = cell.getTransformationParameters();
List<ParameterValue> values = params.get("dateFormat");
assertEquals(1, values.size());
String date = values.get(0).as(String.class);
assertEquals("yyyy-MM-dd HH:mm:ss", date);
}
@Test
public void testExecuteConcurrentModification() throws Exception {
String sql = "SELECT * FROM " + DATA_SERVICE_NAME;
DataServiceExecutor executor =
new DataServiceExecutor.Builder(new SQL(sql), dataService, context)
.prepareExecution(false)
.sqlTransGenerator(sqlTransGenerator)
.serviceTrans(serviceTrans)
.genTrans(genTrans)
.build();
final DataServiceExecutor.ExecutionPoint stage = DataServiceExecutor.ExecutionPoint.OPTIMIZE;
final ListMultimap<DataServiceExecutor.ExecutionPoint, Runnable> listenerMap =
executor.getListenerMap();
final Runnable task =
new Runnable() {
@Override
public void run() {
// Remove itself on run
assertTrue(listenerMap.remove(stage, this));
}
};
listenerMap.put(stage, task);
executor.executeQuery();
// Note the error reported to logs
verify(genTrans.getLogChannel())
.logError(anyString(), eq(stage), eq(ImmutableList.of(task)), eq(ImmutableList.of()));
}
/** Test for network expansion function in alignment4 */
@Test
public void testNetworkExpansion1() {
Collection<? extends Cell> cells = alignment4.getCells();
Iterator<? extends Cell> it = cells.iterator();
Cell cell = null;
while (it.hasNext()) {
Cell temp = it.next();
if (temp.getTransformationIdentifier()
.equals("eu.esdihumboldt.cst.functions.geometric.networkexpansion")) {
cell = temp;
break;
}
}
ListMultimap<String, ParameterValue> params = cell.getTransformationParameters();
List<ParameterValue> values = params.get("bufferWidth");
assertEquals(1, values.size());
// size is always 1
String temp = values.get(0).as(String.class);
assertEquals("0.005", temp);
}
/** Test for ordinates to point function in alignment5 */
@Test
public void testOrdinatesToPoint1() {
Collection<? extends Cell> cells = alignment5.getCells();
Iterator<? extends Cell> it = cells.iterator();
Cell cell = null;
while (it.hasNext()) {
Cell temp = it.next();
if (temp.getTransformationIdentifier()
.equals("eu.esdihumboldt.cst.functions.geometric.ordinates_to_point")) {
cell = temp;
break;
}
}
ListMultimap<String, ? extends Entity> src = cell.getSource();
// the parameters were moved to the source entities with the appropriate
// names so get the source entities with name "X"/"Y"
Entity srcX = src.get("X").get(0);
Entity srcY = src.get("Y").get(0);
// check if the source entity has the correct value
assertEquals("HOCHWERT", srcX.getDefinition().getDefinition().getDisplayName());
assertEquals("RECHTSWERT", srcY.getDefinition().getDefinition().getDisplayName());
}
private Path[] createFiles() throws IOException {
int numberOfStreams = Math.max(2, rnd.nextInt(10));
mergeFactor = Math.max(mergeFactor, numberOfStreams);
LOG.info("No of streams : " + numberOfStreams);
Path[] paths = new Path[numberOfStreams];
for (int i = 0; i < numberOfStreams; i++) {
paths[i] = new Path(baseDir, "ifile_" + i + ".out");
FSDataOutputStream out = fs.create(paths[i]);
// write data with RLE
IFile.Writer writer = new IFile.Writer(conf, out, keyClass, valClass, null, null, null, true);
Map<Writable, Writable> data = createData();
for (Map.Entry<Writable, Writable> entry : data.entrySet()) {
writer.append(entry.getKey(), entry.getValue());
originalData.put(entry.getKey(), entry.getValue());
if (rnd.nextInt() % 2 == 0) {
for (int j = 0; j < rnd.nextInt(100); j++) {
// add some duplicate keys
writer.append(entry.getKey(), entry.getValue());
originalData.put(entry.getKey(), entry.getValue());
}
}
}
LOG.info("Wrote " + data.size() + " in " + paths[i]);
data.clear();
writer.close();
out.close();
}
return paths;
}
/** Test for formatted string function in alignment5 */
@Test
public void testFormattedString3() {
Collection<? extends Cell> cells = alignment5.getCells();
Iterator<? extends Cell> it = cells.iterator();
Cell cell = null;
while (it.hasNext()) {
Cell temp = it.next();
if (temp.getTransformationIdentifier().equals("eu.esdihumboldt.hale.align.formattedstring")) {
cell = temp;
break;
}
}
assertNotNull(cell);
ListMultimap<String, ParameterValue> params = cell.getTransformationParameters();
List<ParameterValue> values = params.get("pattern");
assertEquals(1, values.size());
// size is 1
assertEquals("{Grundbuch}:{Nummer}:{Einlage}", values.get(0).getValue());
}
/** @see Alignment#getCells(EntityDefinition, boolean) */
@Override
public Collection<? extends Cell> getCells(
EntityDefinition entityDefinition, boolean includeInherited) {
if (!includeInherited)
return Collections.unmodifiableCollection(cellsPerEntity.get(entityDefinition));
else {
// Set for safety to return each cell only once.
// Duplicates shouldn't happen in usual cases, though.
Collection<Cell> cells = new HashSet<Cell>();
EntityDefinition e = entityDefinition;
do {
cells.addAll(cellsPerEntity.get(e));
if (e.getFilter() != null) {
cells.addAll(
cellsPerEntity.get(
AlignmentUtil.createEntity(
e.getType(), e.getPropertyPath(), e.getSchemaSpace(), null)));
}
TypeDefinition superType = e.getType().getSuperType();
e =
superType == null
? null
: AlignmentUtil.createEntity(
superType, e.getPropertyPath(), e.getSchemaSpace(), e.getFilter());
} while (e != null);
return cells;
}
}
private void reportMissingDependencies(
String type,
ListMultimap<Artifact, DependencyNode> artifactNotFoundMap,
ReportEntryType reportEntryType,
TestSetStats testSuite) {
for (Artifact artifact : sortArtifacts(artifactNotFoundMap.keySet())) {
List<DependencyNode> roots = sortDependencyNodes(artifactNotFoundMap.get(artifact));
if (roots.size() == 1) {
String msg =
"Miss "
+ artifact
+ " in "
+ roots.get(0).getArtifact()
+ " (path "
+ findPathToDependency(artifact, roots.get(0))
+ ")";
reportTestCase(type, reportEntryType, msg, null, testSuite);
} else {
String msg = "Miss " + artifact + " in " + roots.size() + " artifacts ...";
StringBuilder dsc = new StringBuilder();
dsc.append("Miss " + artifact + " in ...");
dsc.append(LINE_SEPARATOR).append(LINE_SEPARATOR);
for (DependencyNode root : roots) {
dsc.append(root.getArtifact() + " (path " + findPathToDependency(artifact, root) + ")");
dsc.append(LINE_SEPARATOR).append(LINE_SEPARATOR);
}
reportTestCase(type, reportEntryType, msg, dsc.toString(), testSuite);
}
}
}
/**
* Tests whether data in valuesIterator matches with sorted input data set.
*
* <p>Returns a list of value counts for each key.
*
* @param valuesIterator
* @return List
* @throws IOException
*/
private List<Integer> verifyIteratorData(ValuesIterator valuesIterator) throws IOException {
boolean result = true;
ArrayList<Integer> sequence = new ArrayList<Integer>();
// sort original data based on comparator
ListMultimap<Writable, Writable> sortedMap =
new ImmutableListMultimap.Builder<Writable, Writable>()
.orderKeysBy(this.correctComparator)
.putAll(originalData)
.build();
Set<Map.Entry<Writable, Writable>> oriKeySet = Sets.newSet();
oriKeySet.addAll(sortedMap.entries());
// Iterate through sorted data and valuesIterator for verification
for (Map.Entry<Writable, Writable> entry : oriKeySet) {
assertTrue(valuesIterator.moveToNext());
Writable oriKey = entry.getKey();
// Verify if the key and the original key are same
if (!oriKey.equals((Writable) valuesIterator.getKey())) {
result = false;
break;
}
int valueCount = 0;
// Verify values
Iterator<Writable> vItr = valuesIterator.getValues().iterator();
for (Writable val : sortedMap.get(oriKey)) {
assertTrue(vItr.hasNext());
// Verify if the values are same
if (!val.equals((Writable) vItr.next())) {
result = false;
break;
}
valueCount++;
}
sequence.add(valueCount);
assertTrue("At least 1 value per key", valueCount > 0);
}
if (expectedTestResult) {
assertTrue(result);
assertFalse(valuesIterator.moveToNext());
getNextFromFinishedIterator(valuesIterator);
} else {
while (valuesIterator.moveToNext()) {
// iterate through all keys
}
getNextFromFinishedIterator(valuesIterator);
assertFalse(result);
}
return sequence;
}
/**
* Returns a combined map of user and group permissions, with group names prefixed by {@link
* AccessControlLists#GROUP_PREFIX}.
*/
public ListMultimap<String, T> getAllPermissions() {
ListMultimap<String, T> tmp = ArrayListMultimap.create();
tmp.putAll(userCache);
for (String group : groupCache.keySet()) {
tmp.putAll(AccessControlLists.GROUP_PREFIX + group, groupCache.get(group));
}
return tmp;
}
/**
* Converts the given multimap of attributes to labels into a multi map of attributes to {@link
* Dependency} objects using the proper configuration transition for each attribute.
*
* @throws IllegalArgumentException if the {@code node} does not refer to a {@link Rule} instance
*/
public final Collection<Dependency> resolveRuleLabels(
TargetAndConfiguration node, ListMultimap<Attribute, LabelAndConfiguration> labelMap) {
Preconditions.checkArgument(node.getTarget() instanceof Rule);
Rule rule = (Rule) node.getTarget();
ListMultimap<Attribute, Dependency> outgoingEdges = ArrayListMultimap.create();
visitRule(rule, labelMap, outgoingEdges);
return outgoingEdges.values();
}
private void processInvalidatedChunks(NetData.NetMessage message) {
for (NetData.InvalidateChunkMessage chunk : message.getInvalidateChunkList()) {
Vector3i chunkPos = NetMessageUtil.convert(chunk.getPos());
remoteWorldProvider.invalidateChunks(chunkPos);
awaitingChunkReadyBlockUpdates.removeAll(chunkPos);
awaitingChunkReadyBiomeUpdates.removeAll(chunkPos);
}
}
@Override
public ListMultimap<String, ParameterValue> getConfiguration() {
ListMultimap<String, ParameterValue> result = ArrayListMultimap.create(selected.size(), 1);
for (Entry<FunctionParameterDefinition, Boolean> entry : selected.entrySet())
result.put(entry.getKey().getName(), new ParameterValue(entry.getValue().toString()));
return result;
}
@Override
public void clearCells() {
// clear all cells except base alignment cells
cells.removeIf(cell -> !(cell instanceof BaseAlignmentCell));
cellsPerEntity.values().removeIf(cell -> !(cell instanceof BaseAlignmentCell));
cellsPerSourceType.values().removeIf(cell -> !(cell instanceof BaseAlignmentCell));
cellsPerTargetType.values().removeIf(cell -> !(cell instanceof BaseAlignmentCell));
idToCell.values().removeIf(cell -> !(cell instanceof BaseAlignmentCell));
typeCells.removeIf(cell -> !(cell instanceof BaseAlignmentCell));
}
@Test
public void checkResult() throws Exception {
final BenchmarkResult result = runTest();
System.out.println(result);
System.out.println(result.csvMatches());
System.out.println(result.csvTimes());
final ListMultimap<RailwayQuery, Integer> allMatches = result.getLastRunResult().getMatches();
collector.checkThat(allMatches.get(RailwayQuery.SWITCHSET).get(0), Matchers.equalTo(5));
}
/**
* Merge with another validation report
*
* @param other the report to merge with
*/
public void mergeWith(final ValidationReport other) {
if (fatal) return;
if (other.fatal) {
msgMap.clear();
fatal = true;
}
msgMap.putAll(other.msgMap);
}
/**
* Add one validation message to the report
*
* @param message the message
* @return true if the added message is fatal, or if {@link #fatal} is already {@code true}
*/
public boolean addMessage(final Message message) {
if (fatal) return true;
if (message.isFatal()) {
fatal = true;
msgMap.clear();
}
msgMap.put(path, message);
return fatal;
}
/** Builds a new {@code CellCollection} by removing all the given cell labels. */
public Term removeAll(Set<CellLabel> removeLabels) {
Builder builder = builder();
cells
.keySet()
.stream()
.filter(label -> !removeLabels.contains(label))
.forEach(label -> builder.addAll(cells.get(label)));
builder.concatenate(collectionVariables);
return builder.build();
}
