private UIStyleFamily buildFamily(String family, UISkin skin) {
UIStyleFamily baseFamily = skin.getFamily(family);
UIStyle baseStyle = new UIStyle(skin.getDefaultStyleFor(family));
if (!family.isEmpty()) {
UIStyleFragment fragment = baseStyles.get(family);
fragment.applyTo(baseStyle);
}
Set<StyleKey> inheritedStyleKey = Sets.newLinkedHashSet();
for (Class<? extends UIWidget> widget : baseFamily.getWidgets()) {
inheritedStyleKey.add(new StyleKey(widget, "", ""));
for (String part : baseFamily.getPartsFor(widget)) {
inheritedStyleKey.add(new StyleKey(widget, part, ""));
for (String mode : baseFamily.getModesFor(widget, part)) {
inheritedStyleKey.add(new StyleKey(widget, part, mode));
}
}
}
Map<Class<? extends UIWidget>, Table<String, String, UIStyle>> familyStyles = Maps.newHashMap();
Map<StyleKey, UIStyleFragment> styleLookup = elementStyles.row(family);
Map<StyleKey, UIStyleFragment> baseStyleLookup =
(family.isEmpty()) ? Maps.<StyleKey, UIStyleFragment>newHashMap() : elementStyles.row("");
for (StyleKey styleKey :
Sets.union(Sets.union(styleLookup.keySet(), baseStyleKeys), inheritedStyleKey)) {
UIStyle elementStyle =
new UIStyle(baseSkin.getStyleFor(family, styleKey.element, styleKey.part, styleKey.mode));
baseStyles.get("").applyTo(elementStyle);
baseStyles.get(family).applyTo(elementStyle);
List<Class<? extends UIWidget>> inheritanceTree =
ReflectionUtil.getInheritanceTree(styleKey.element, UIWidget.class);
applyStylesForInheritanceTree(
inheritanceTree, "", "", elementStyle, styleLookup, baseStyleLookup);
if (!styleKey.part.isEmpty()) {
applyStylesForInheritanceTree(
inheritanceTree, styleKey.part, "", elementStyle, styleLookup, baseStyleLookup);
}
if (!styleKey.mode.isEmpty()) {
applyStylesForInheritanceTree(
inheritanceTree,
styleKey.part,
styleKey.mode,
elementStyle,
styleLookup,
baseStyleLookup);
}
Table<String, String, UIStyle> elementTable = familyStyles.get(styleKey.element);
if (elementTable == null) {
elementTable = HashBasedTable.create();
familyStyles.put(styleKey.element, elementTable);
}
elementTable.put(styleKey.part, styleKey.mode, elementStyle);
}
return new UIStyleFamily(baseStyle, familyStyles);
}
public OwnersReport updatedWith(OwnersReport other) {
SetMultimap<TargetNode<?>, Path> updatedOwners = TreeMultimap.create(owners);
updatedOwners.putAll(other.owners);
return new OwnersReport(
updatedOwners,
Sets.intersection(inputsWithNoOwners, other.inputsWithNoOwners),
Sets.union(nonExistentInputs, other.nonExistentInputs),
Sets.union(nonFileInputs, other.nonFileInputs));
}
private final void invalidate(
IFileSpecification fileSpec,
Collection<ICompilationUnit> compilationUnits,
Map<ICompilerProject, Set<ICompilationUnit>> cusToUpdate) {
mxmlDataManager.invalidate(fileSpec);
// Tell the SWC manager the SWC file is invalid.
getSWCManager().remove(new File(fileSpec.getPath()));
if (compilationUnits.size() == 0) return;
Set<ICompilationUnit> unitsToInvalidate = new HashSet<ICompilationUnit>();
unitsToInvalidate.addAll(compilationUnits);
Set<ICompilationUnit> unitsToClean =
Sets.<ICompilationUnit>union(
DependencyGraph.computeInvalidationSet(unitsToInvalidate),
getCompilationUnitsDependingOnMissingDefinitions(unitsToInvalidate));
notifyInvalidationListener(unitsToClean);
// Do the actual invalidation
Map<ICompilerProject, Set<File>> invalidatedSWCFiles =
new HashMap<ICompilerProject, Set<File>>();
for (ICompilationUnit compilationUnit : unitsToClean) {
boolean clearCUFileScope = unitsToInvalidate.contains(compilationUnit);
compilationUnit.clean(invalidatedSWCFiles, cusToUpdate, clearCUFileScope);
}
// invalidate any library files in the project
for (Map.Entry<ICompilerProject, Set<File>> e : invalidatedSWCFiles.entrySet()) {
if (e.getKey() instanceof IASProject)
((IASProject) e.getKey()).invalidateLibraries(e.getValue());
}
}
@Test
public void union_of_sets_guava() {
Set<String> totalFriends = Sets.union(yourFriends, myFriends);
assertEquals(16, totalFriends.size());
}
public PnfsCreateEntryMessage(String path, int uid, int gid, int mode, Set<FileAttribute> attr) {
super(
path,
EnumSet.copyOf(
Sets.union(
attr,
EnumSet.of(
OWNER,
OWNER_GROUP,
MODE,
TYPE,
SIZE,
CREATION_TIME,
ACCESS_TIME,
MODIFICATION_TIME,
CHANGE_TIME,
PNFSID,
STORAGEINFO,
ACCESS_LATENCY,
RETENTION_POLICY))));
_path = path;
_uid = uid;
_gid = gid;
_mode = mode;
}
@Override
public PlanNode visitIndexSource(IndexSourceNode node, RewriteContext<Set<Symbol>> context) {
List<Symbol> newOutputSymbols =
node.getOutputSymbols()
.stream()
.filter(context.get()::contains)
.collect(toImmutableList());
Set<Symbol> newLookupSymbols =
node.getLookupSymbols()
.stream()
.filter(context.get()::contains)
.collect(toImmutableSet());
Set<Symbol> requiredAssignmentSymbols = context.get();
if (!node.getEffectiveTupleDomain().isNone()) {
Set<Symbol> requiredSymbols =
Maps.filterValues(
node.getAssignments(),
in(node.getEffectiveTupleDomain().getDomains().get().keySet()))
.keySet();
requiredAssignmentSymbols = Sets.union(context.get(), requiredSymbols);
}
Map<Symbol, ColumnHandle> newAssignments =
Maps.filterKeys(node.getAssignments(), in(requiredAssignmentSymbols));
return new IndexSourceNode(
node.getId(),
node.getIndexHandle(),
node.getTableHandle(),
newLookupSymbols,
newOutputSymbols,
newAssignments,
node.getEffectiveTupleDomain());
}
public static String translateImplication(
SymbolicConstraint leftHandSide, SymbolicConstraint rightHandSide) {
KILtoSMTLib leftTransformer = new KILtoSMTLib(true);
KILtoSMTLib rightTransformer = new KILtoSMTLib(false);
String leftExpression = ((SMTLibTerm) leftHandSide.accept(leftTransformer)).expression();
String rightExpression = ((SMTLibTerm) rightHandSide.accept(rightTransformer)).expression();
StringBuilder sb = new StringBuilder();
sb.append(
getSortAndFunctionDeclarations(
leftHandSide.termContext().definition(),
Sets.union(leftTransformer.variables(), rightTransformer.variables())));
sb.append(getAxioms(leftHandSide.termContext().definition()));
sb.append(getConstantDeclarations(leftTransformer.variables()));
sb.append("(assert (and ");
sb.append(leftExpression);
sb.append(" (not ");
Set<Variable> rightHandSideOnlyVariables =
Sets.difference(rightTransformer.variables(), leftTransformer.variables());
if (!rightHandSideOnlyVariables.isEmpty()) {
sb.append("(exists (");
sb.append(getQuantifiedVariables(rightHandSideOnlyVariables));
sb.append(") ");
}
sb.append(rightExpression);
if (!rightHandSideOnlyVariables.isEmpty()) {
sb.append(")");
}
sb.append(")))");
return sb.toString();
}
/**
* Helper to add srcs and deps Soy files to a SoyFileSet builder. Also does sanity checks.
*
* @param sfsBuilder The SoyFileSet builder to add to.
* @param inputPrefix The input path prefix to prepend to all the file paths.
* @param srcs The srcs from the --srcs flag. Exactly one of 'srcs' and 'args' must be nonempty.
* @param args The old-style srcs from the command line (that's how they were specified before we
* added the --srcs flag). Exactly one of 'srcs' and 'args' must be nonempty.
* @param deps The deps from the --deps flag, or empty list if not applicable.
* @param exitWithErrorFn A function that exits with an error message followed by a usage message.
*/
static void addSoyFilesToBuilder(
Builder sfsBuilder,
String inputPrefix,
Collection<String> srcs,
Collection<String> args,
Collection<String> deps,
Collection<String> indirectDeps,
Function<String, Void> exitWithErrorFn) {
if (srcs.isEmpty() && args.isEmpty()) {
exitWithErrorFn.apply("Must provide list of source Soy files (--srcs).");
}
if (!srcs.isEmpty() && !args.isEmpty()) {
exitWithErrorFn.apply(
"Found source Soy files from --srcs and from args (please use --srcs only).");
}
// Create Set versions of each of the arguments, and de-dupe. If something is included as
// multiple file kinds, we'll keep the strongest one; a file in both srcs and deps will be a
// src, and one in both deps and indirect_deps will be a dep.
// TODO(gboyer): Maybe stop supporting old style (srcs from command line args) at some point.
Set<String> srcsSet = ImmutableSet.<String>builder().addAll(srcs).addAll(args).build();
Set<String> depsSet = Sets.difference(ImmutableSet.copyOf(deps), srcsSet);
Set<String> indirectDepsSet =
Sets.difference(ImmutableSet.copyOf(indirectDeps), Sets.union(srcsSet, depsSet));
for (String src : srcsSet) {
sfsBuilder.addWithKind(new File(inputPrefix + src), SoyFileKind.SRC);
}
for (String dep : depsSet) {
sfsBuilder.addWithKind(new File(inputPrefix + dep), SoyFileKind.DEP);
}
for (String dep : indirectDepsSet) {
sfsBuilder.addWithKind(new File(inputPrefix + dep), SoyFileKind.INDIRECT_DEP);
}
}
// TODO(user): Handle separate_revisions! (an 'svn commit' per exported change)
@Override
public DraftRevision putCodebase(Codebase c) throws WritingError {
c.checkProjectSpace(config.getProjectSpace());
// Filter out files that either start with .svn or have .svn after a slash, plus the repo
// config's ignore_file_res.
List<String> ignoreFilePatterns =
ImmutableList.<String>builder()
.addAll(config.getIgnoreFileRes())
.add("(^|.*/)\\.svn(/.*|$)")
.build();
Set<String> codebaseFiles = c.getRelativeFilenames();
Set<String> writerFiles =
Utils.filterByRegEx(
Utils.makeFilenamesRelative(
AppContext.RUN.fileSystem.findFiles(rootDirectory), rootDirectory),
ignoreFilePatterns);
Set<String> union = Sets.union(codebaseFiles, writerFiles);
for (String filename : union) {
putFile(filename, c);
}
return new SvnDraftRevision(rootDirectory);
}
private Set<Long> getTimestampsToSweep(
Cell cell,
Collection<Long> timestamps /* start timestamps */,
@Modified Map<Long, Long> startTsToCommitTs,
@Output Set<Cell> sentinelsToAdd,
long sweepTimestamp,
boolean sweepLastCommitted,
SweepStrategy sweepStrategy) {
Set<Long> uncommittedTimestamps = Sets.newHashSet();
SortedSet<Long> committedTimestampsToSweep = Sets.newTreeSet();
long maxStartTs = TransactionConstants.FAILED_COMMIT_TS;
boolean maxStartTsIsCommitted = false;
for (long startTs : timestamps) {
long commitTs = ensureCommitTimestampExists(startTs, startTsToCommitTs);
if (startTs > maxStartTs && commitTs < sweepTimestamp) {
maxStartTs = startTs;
maxStartTsIsCommitted = commitTs != TransactionConstants.FAILED_COMMIT_TS;
}
// Note: there could be an open transaction whose start timestamp is equal to
// sweepTimestamp; thus we want to sweep all cells such that:
// (1) their commit timestamp is less than sweepTimestamp
// (2) their start timestamp is NOT the greatest possible start timestamp
// passing condition (1)
if (commitTs > 0 && commitTs < sweepTimestamp) {
committedTimestampsToSweep.add(startTs);
} else if (commitTs == TransactionConstants.FAILED_COMMIT_TS) {
uncommittedTimestamps.add(startTs);
}
}
if (committedTimestampsToSweep.isEmpty()) {
return uncommittedTimestamps;
}
if (sweepStrategy == SweepStrategy.CONSERVATIVE && committedTimestampsToSweep.size() > 1) {
// We need to add a sentinel if we are removing a committed value
sentinelsToAdd.add(cell);
}
if (sweepLastCommitted && maxStartTsIsCommitted) {
return Sets.union(uncommittedTimestamps, committedTimestampsToSweep);
}
return Sets.union(
uncommittedTimestamps,
committedTimestampsToSweep.subSet(0L, committedTimestampsToSweep.last()));
}
@Test
public void whenCalculateUnionOfSets_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b', 'c');
final Set<Character> second = ImmutableSet.of('b', 'c', 'd');
final Set<Character> union = Sets.union(first, second);
assertThat(union, containsInAnyOrder('a', 'b', 'c', 'd'));
}
static ImmutableSet<EnumType> union(ImmutableSet<EnumType> s1, ImmutableSet<EnumType> s2) {
if (s1.isEmpty()) {
return s2;
}
if (s2.isEmpty() || s1.equals(s2)) {
return s1;
}
return Sets.union(s1, s2).immutableCopy();
}
/**
* Lee las clasificaciones del usuario y del plugin de sus respectivos ficheros xml y devuelve la
* union de ambas.
*
* @return conjunto que contiene las clasificaciones de usuario y del plugin
*/
protected static Set<Classification> readAllClassificationsFromFiles() {
final Set<Classification> pluginClassifications =
AbstractCatalog.getClassificationsFromFile(
PluginClassificationsCatalog.PLUGIN_CLASSIFICATION_TYPES_FILE, false);
final Set<Classification> userClassifications =
AbstractCatalog.getClassificationsFromFile(
PluginClassificationsCatalog.USER_CLASSIFICATION_TYPES_FILE, true);
return Sets.union(pluginClassifications, userClassifications);
}
@Override
public Response rmdir(String path, Map<Byte, Long> instanceMap) throws TException {
path = makePathAbsolute(path);
Set<Byte> parts = oracle.partitionsOf(path);
Set<Byte> parentParts = oracle.partitionsOf(Paths.dirname(path));
Set<Byte> involvedPartitions = Sets.union(parts, parentParts);
Command cmd = newCommand(CommandType.RMDIR, involvedPartitions, instanceMap);
RmdirCmd rmdir = new RmdirCmd(path, parentParts, parts);
cmd.setRmdir(rmdir);
replica.submitCommand(cmd);
Response r = new Response(replica.getInstanceMap());
return r;
}
public boolean isTypeImmutable(String desc) {
Type type = Type.getType(desc);
if (IMMUTABLE_TYPE_SORTS.contains(type.getSort())) {
return true;
}
if (type.getSort() != Type.OBJECT) {
return false;
}
if (Sets.union(EXTERNAL_IMMUTABLE_CLASSES, immutableClasses).contains(type.getInternalName())) {
return true;
}
return false;
}
@Override
public Response mknod(
String path, int mode, int rdev, int uid, int gid, Map<Byte, Long> instanceMap)
throws TException {
path = makePathAbsolute(path);
Set<Byte> parts = oracle.partitionsOf(path);
Set<Byte> parentParts = oracle.partitionsOf(Paths.dirname(path));
Set<Byte> involvedPartitions = Sets.union(parts, parentParts);
Command cmd = newCommand(CommandType.MKNOD, involvedPartitions, instanceMap);
MknodCmd mknod = new MknodCmd(path, mode, uid, gid, parentParts, parts);
cmd.setMknod(mknod);
replica.submitCommand(cmd);
Response r = new Response(replica.getInstanceMap());
return r;
}
public Set<OPMProcess> findNextProcessesToExecute(OPMProcess process) {
final List<OPMProcess> followingProcesses =
OPDExecutionAnalysis.calculateFollowingProcesses(opdDag, process);
final Set<OPMProcess> retVal = Sets.newHashSet();
for (OPMProcess followingProcess : followingProcesses) {
Set<OPMProcess> requiredProcesses =
OPDExecutionAnalysis.calculateRequiredProcesses(opdDag, followingProcess);
if (Sets.difference(requiredProcesses, Sets.union(skippedProcesses, executedProcesses)).size()
== 0) {
retVal.add(followingProcess);
}
}
return retVal;
}
@Override
public Response symlink(String target, String path, Map<Byte, Long> instanceMap)
throws TException {
path = makePathAbsolute(path);
target = makePathAbsolute(target);
Set<Byte> parts = oracle.partitionsOf(path);
Set<Byte> parentParts = oracle.partitionsOf(Paths.dirname(path));
Set<Byte> involvedPartitions = Sets.union(parts, parentParts);
Command cmd = newCommand(CommandType.SYMLINK, involvedPartitions, instanceMap);
SymlinkCmd symlink = new SymlinkCmd(target, path, parentParts, parts);
cmd.setSymlink(symlink);
replica.submitCommand(cmd);
Response r = new Response(replica.getInstanceMap());
return r;
}
/**
* Returns the count of squares reachable by the first player
*
* @param grid
* @param startingLoc
* @return
*/
public static boolean getConnectedSquareCount(GridChar grid, int startingLoc) {
// int oldCount = (1+getConnectedSquareCountOld(grid,startingLoc) );
// The boolean means it is player 1, the connected square co
Set<Pair<Integer, Boolean>> visitedNodes = Sets.newHashSet();
LinkedList<Pair<Integer, Boolean>> toVisit = new LinkedList<>();
toVisit.add(new ImmutablePair<>(startingLoc, true));
while (!toVisit.isEmpty()) {
Pair<Integer, Boolean> loc = toVisit.poll();
if (visitedNodes.contains(loc)) continue;
visitedNodes.add(loc);
for (Direction dir : Direction.values()) {
Integer childIdx = grid.getIndex(loc.getLeft(), dir);
if (childIdx == null) continue;
char sq = grid.getEntry(childIdx);
if (sq == '#' || sq == 'K' || sq == 'T') continue;
toVisit.add(new ImmutablePair<>(childIdx, !loc.getRight()));
}
}
Set<Integer> fpPoints = Sets.newHashSet();
Set<Integer> spPoints = Sets.newHashSet();
for (Pair<Integer, Boolean> p : visitedNodes) {
if (p.getRight()) fpPoints.add(p.getLeft());
else spPoints.add(p.getLeft());
}
Set<Integer> shared = Sets.intersection(fpPoints, spPoints);
Set<Integer> union = Sets.union(fpPoints, spPoints);
if (!shared.isEmpty()) {
return (union.size() + 1) % 2 == 0;
} else {
// log.debug("size {} size {}", fpPoints.size(), spPoints.size());
return spPoints.size() < fpPoints.size();
}
// return (countFP + countSP + 1) % 2 == 0;
}
@Override
public double distance(Histogram unknownHistogram, Histogram knownHistogram) {
Set<Event> events = Sets.union(unknownHistogram.uniqueEvents(), knownHistogram.uniqueEvents());
double distance = 0.0, sumNumer = 0.0, sumDenom = 0.0;
for (Event event : events) {
double known = knownHistogram.relativeFrequency(event);
double unknown = unknownHistogram.relativeFrequency(event);
sumNumer += Math.abs(unknown - known);
sumDenom += unknown + known;
}
distance = sumNumer / sumDenom;
return distance;
}
private void go() {
while (true) {
madeProgress = false;
for (ClassNode klass : allClasses.values()) {
analyzeClass(klass);
}
if (!madeProgress) {
break;
}
}
immutableClasses =
ImmutableSet.copyOf(
Sets.difference(
allClasses.keySet(),
Sets.union(trulyMutableClasses, classesWithMutableDescendents)));
}
@Override
public double distance(Histogram unknownHistogram, Histogram knownHistogram)
throws DistanceCalculationException {
Set<Event> events = Sets.union(unknownHistogram.uniqueEvents(), knownHistogram.uniqueEvents());
double distance = 0.0, sumNumer = 0.0, sumUnknown = 0.0, sumKnown = 0.0;
for (Event event : events) {
sumNumer +=
unknownHistogram.relativeFrequency(event) * knownHistogram.relativeFrequency(event);
sumUnknown += unknownHistogram.relativeFrequency(event);
sumKnown += knownHistogram.relativeFrequency(event);
}
distance =
Math.sqrt(2 - 2 * (sumNumer / Math.sqrt(sumUnknown * sumUnknown * sumKnown * sumKnown)));
return distance;
}
private UIStyleFamily buildFamily(String family, UIStyle defaultStyle) {
UIStyle baseStyle = new UIStyle(defaultStyle);
if (!family.isEmpty()) {
UIStyleFragment fragment = baseStyles.get(family);
fragment.applyTo(baseStyle);
}
Map<Class<? extends UIWidget>, Table<String, String, UIStyle>> familyStyles = Maps.newHashMap();
Map<StyleKey, UIStyleFragment> styleLookup = elementStyles.row(family);
Map<StyleKey, UIStyleFragment> baseStyleLookup =
(family.isEmpty()) ? Maps.<StyleKey, UIStyleFragment>newHashMap() : elementStyles.row("");
for (StyleKey styleKey : Sets.union(styleLookup.keySet(), baseStyleKeys)) {
UIStyle elementStyle = new UIStyle(baseStyle);
List<Class<? extends UIWidget>> inheritanceTree =
ReflectionUtil.getInheritanceTree(styleKey.element, UIWidget.class);
applyStylesForInheritanceTree(
inheritanceTree, "", "", elementStyle, styleLookup, baseStyleLookup);
if (!styleKey.part.isEmpty()) {
applyStylesForInheritanceTree(
inheritanceTree, styleKey.part, "", elementStyle, styleLookup, baseStyleLookup);
}
if (!styleKey.mode.isEmpty()) {
applyStylesForInheritanceTree(
inheritanceTree,
styleKey.part,
styleKey.mode,
elementStyle,
styleLookup,
baseStyleLookup);
}
Table<String, String, UIStyle> elementTable = familyStyles.get(styleKey.element);
if (elementTable == null) {
elementTable = HashBasedTable.create();
familyStyles.put(styleKey.element, elementTable);
}
elementTable.put(styleKey.part, styleKey.mode, elementStyle);
}
return new UIStyleFamily(baseStyle, familyStyles);
}
private boolean isRegion(BasicBlock entry, BasicBlock exit) {
// 2 cases
// Entry does not dominates Exit
// Entry dominates Exit
if (!getDomInfo().dominates(entry, exit)) {
// Exit has to be the only element in the dominance frontier of Entry.
// In this case the only edges leaving the region end at Exit
if (!Collections.singleton(exit).containsAll(getDomInfo().getDominanceFrontierOf2(entry))) {
return false;
}
} else {
// Only basic blocks that are part of the dominance frontier of Exit
// are allowed to be element of the dominance frontier of Entry
if (!Sets.union(getDomInfo().getDominanceFrontierOf2(exit), Collections.singleton(entry))
.containsAll(getDomInfo().getDominanceFrontierOf2(entry))) {
return false;
}
// Basic blocks of the dominance frontier of Entry can only be reached
// from Entry through a path passing Exit. To show this the isCommonDomFrontier
// function is used. isCommonDomFrontier ( BB, Entry, Exit) checks if there exists a path
// from Entry to BB that does not pass Exit. This is done by checking
// for every predecessor of BB, that if it is dominated by Entry it is
// also dominated by Exit.
for (BasicBlock bb : getDomInfo().getDominanceFrontierOf2(entry)) {
if (!isCommonDomFrontier(bb, entry, exit)) {
return false;
}
}
// It has still to be shown that there are no edges entering the region.
// As all basic blocks are dominated by Entry the only case where edges
// enter the region is if Exit is dominated by Entry and has back edges
// pointing into the region. These back edges will point to basic blocks
// dominated by Entry but not by Exit. So the dominance frontier of Exit
// is not allowed to contain any basic blocks that are dominated by Entry
for (BasicBlock bb : getDomInfo().getDominanceFrontierOf2(exit)) {
if (getDomInfo().strictlyDominates(entry, bb)) {
return false;
}
}
}
return true;
}
// This method needs the nominal types because otherwise a property may become
// optional by mistake after the join.
// joinPropsLoosely doesn't need that, because we don't create optional props
// on loose types.
private static PersistentMap<String, Property> joinProps(
Map<String, Property> props1,
Map<String, Property> props2,
NominalType nom1,
NominalType nom2) {
PersistentMap<String, Property> newProps = PersistentMap.create();
for (String pname : Sets.union(props1.keySet(), props2.keySet())) {
Property prop1 = getProp(props1, nom1, pname);
Property prop2 = getProp(props2, nom2, pname);
Property newProp = null;
if (prop1 == null) {
newProp = prop2.withOptional();
} else if (prop2 == null) {
newProp = prop1.withOptional();
} else {
newProp = Property.join(prop1, prop2);
}
newProps = newProps.with(pname, newProp);
}
return newProps;
}
private void updateGeneratedJobs(
final AbstractBuild<?, ?> build, BuildListener listener, Set<GeneratedJob> freshJobs)
throws IOException {
// Update Project
Set<GeneratedJob> generatedJobs =
extractGeneratedObjects(build.getProject(), GeneratedJobsAction.class);
Set<GeneratedJob> added = Sets.difference(freshJobs, generatedJobs);
Set<GeneratedJob> existing = Sets.intersection(generatedJobs, freshJobs);
Set<GeneratedJob> removed = Sets.difference(generatedJobs, freshJobs);
logItems(listener, "Adding items", added);
logItems(listener, "Existing items", existing);
logItems(listener, "Removing items", removed);
// Update unreferenced jobs
for (GeneratedJob removedJob : removed) {
Item removedItem =
getLookupStrategy().getItem(build.getProject(), removedJob.getJobName(), Item.class);
if (removedItem != null && removedJobAction != RemovedJobAction.IGNORE) {
if (removedJobAction == RemovedJobAction.DELETE) {
try {
removedItem.delete();
} catch (InterruptedException e) {
listener.getLogger().println(String.format("Delete item failed: %s", removedJob));
if (removedItem instanceof AbstractProject) {
listener.getLogger().println(String.format("Disabling item instead: %s", removedJob));
((AbstractProject) removedItem).disable();
}
}
} else {
if (removedItem instanceof AbstractProject) {
((AbstractProject) removedItem).disable();
}
}
}
}
updateGeneratedJobMap(build.getProject(), Sets.union(added, existing), removed);
}
public static int countLoadedChunks(
ICommandSender sender, EntityPlayerMP player, boolean details, LoadedChunksVisitor visitor) {
MinecraftServer server = ForgeTools.server;
int total = 0;
for (WorldServer s : server.worldServers) {
World tmp = ((World) s);
ImmutableSetMultimap<ChunkCoordIntPair, ForgeChunkManager.Ticket> forcedChunks =
tmp.getPersistentChunks();
Set loadedChunks = new LinkedHashSet<ChunkCoordIntPair>();
for (ChunkCoordIntPair c : forcedChunks.keys()) {
for (ForgeChunkManager.Ticket t : forcedChunks.get(c)) {
loadedChunks = Sets.union(t.getChunkList(), loadedChunks);
}
}
total += loadedChunks.size();
boolean playerInWorld =
(player != null) ? s.getWorldInfo().equals(player.worldObj.getWorldInfo()) : false;
visitor.visit(sender, player, details, playerInWorld, s, loadedChunks.size());
}
return total;
}
@Override
public void buildTransitiveClosure(Set<QueryTarget> targets, int maxDepth)
throws QueryException, InterruptedException {
// Filter QueryTargets that are build targets and not yet present in the build target graph.
Set<BuildTarget> graphTargets = getTargetsFromNodes(graph.getNodes());
Set<BuildTarget> newBuildTargets = new HashSet<>();
for (QueryTarget target : targets) {
if (target instanceof QueryBuildTarget) {
BuildTarget buildTarget = ((QueryBuildTarget) target).getBuildTarget();
if (!graphTargets.contains(buildTarget)) {
newBuildTargets.add(buildTarget);
}
}
}
if (!newBuildTargets.isEmpty()) {
buildGraphForBuildTargets(Sets.union(newBuildTargets, graphTargets));
for (BuildTarget buildTarget : getTargetsFromNodes(graph.getNodes())) {
if (!buildTargetToQueryTarget.containsKey(buildTarget)) {
buildTargetToQueryTarget.put(buildTarget, QueryBuildTarget.of(buildTarget));
}
}
}
}
@Activate
public void activate() {
localNodeId = clusterService.getLocalNode().id();
// load database configuration
File databaseDefFile = new File(PARTITION_DEFINITION_FILE);
log.info("Loading database definition: {}", databaseDefFile.getAbsolutePath());
Map<String, Set<NodeInfo>> partitionMap;
try {
DatabaseDefinitionStore databaseDefStore = new DatabaseDefinitionStore(databaseDefFile);
if (!databaseDefFile.exists()) {
createDefaultDatabaseDefinition(databaseDefStore);
}
partitionMap = databaseDefStore.read().getPartitions();
} catch (IOException e) {
throw new IllegalStateException("Failed to load database config", e);
}
String[] activeNodeUris =
partitionMap
.values()
.stream()
.reduce((s1, s2) -> Sets.union(s1, s2))
.get()
.stream()
.map(this::nodeToUri)
.toArray(String[]::new);
String localNodeUri = nodeToUri(NodeInfo.of(clusterService.getLocalNode()));
Protocol protocol = new CopycatCommunicationProtocol(clusterService, clusterCommunicator);
ClusterConfig clusterConfig =
new ClusterConfig()
.withProtocol(protocol)
.withElectionTimeout(electionTimeoutMillis(activeNodeUris))
.withHeartbeatInterval(heartbeatTimeoutMillis(activeNodeUris))
.withMembers(activeNodeUris)
.withLocalMember(localNodeUri);
CopycatConfig copycatConfig =
new CopycatConfig()
.withName("onos")
.withClusterConfig(clusterConfig)
.withDefaultSerializer(new DatabaseSerializer())
.withDefaultExecutor(
Executors.newSingleThreadExecutor(
new NamedThreadFactory("copycat-coordinator-%d")));
coordinator = new DefaultClusterCoordinator(copycatConfig.resolve());
DatabaseConfig inMemoryDatabaseConfig =
newDatabaseConfig(BASE_PARTITION_NAME, newInMemoryLog(), activeNodeUris);
inMemoryDatabase =
coordinator.getResource(
inMemoryDatabaseConfig.getName(),
inMemoryDatabaseConfig
.resolve(clusterConfig)
.withSerializer(copycatConfig.getDefaultSerializer())
.withDefaultExecutor(copycatConfig.getDefaultExecutor()));
List<Database> partitions =
partitionMap
.entrySet()
.stream()
.map(
entry -> {
String[] replicas =
entry.getValue().stream().map(this::nodeToUri).toArray(String[]::new);
return newDatabaseConfig(entry.getKey(), newPersistentLog(), replicas);
})
.map(
config -> {
Database db =
coordinator.getResource(
config.getName(),
config
.resolve(clusterConfig)
.withSerializer(copycatConfig.getDefaultSerializer())
.withDefaultExecutor(copycatConfig.getDefaultExecutor()));
return db;
})
.collect(Collectors.toList());
partitionedDatabase = new PartitionedDatabase("onos-store", partitions);
CompletableFuture<Void> status =
coordinator
.open()
.thenCompose(
v ->
CompletableFuture.allOf(inMemoryDatabase.open(), partitionedDatabase.open())
.whenComplete(
(db, error) -> {
if (error != null) {
log.error("Failed to initialize database.", error);
} else {
log.info("Successfully initialized database.");
}
}));
Futures.getUnchecked(status);
transactionManager = new TransactionManager(partitionedDatabase, consistentMapBuilder());
partitionedDatabase.setTransactionManager(transactionManager);
eventDispatcher =
Executors.newSingleThreadExecutor(
groupedThreads("onos/store/manager", "map-event-dispatcher"));
queuePollExecutor =
Executors.newFixedThreadPool(4, groupedThreads("onos/store/manager", "queue-poll-handler"));
clusterCommunicator.<String>addSubscriber(
QUEUE_UPDATED_TOPIC,
data -> new String(data, Charsets.UTF_8),
name -> {
DefaultDistributedQueue q = queues.get(name);
if (q != null) {
q.tryPoll();
}
},
queuePollExecutor);
log.info("Started");
}
private BLANCResult scoreSets(
final Iterable<Set<Object>> predicted, final Iterable<Set<Object>> gold) {
final Multimap<Object, Set<Object>> predictedItemToGroup =
CollectionUtils.makeSetElementsToContainersMultimap(predicted);
final Multimap<Object, Set<Object>> goldItemToGroup =
CollectionUtils.makeSetElementsToContainersMultimap(gold);
final Set<Object> keyItems = goldItemToGroup.keySet();
final Set<Object> responseItems = predictedItemToGroup.keySet();
final ImmutableSet<Object> itemsInBoth =
Sets.intersection(keyItems, responseItems).immutableCopy();
// |C_k \cap C_r|
int corefLinksInBoth = 0;
// |C_k|
int corefLinksInKey = 0;
// |C_r|
int corefLinksInResponse = 0;
// |N_K \cap N_r|
int nonCorefInBoth = 0;
// |N_k|
int nonCorefLinksInKey = 0;
// |N_r|
int nonCorefLinksInResponse = 0;
final Set<Object> allItems = Sets.union(responseItems, keyItems).immutableCopy();
for (final Object item : allItems) {
final boolean inKey = keyItems.contains(item);
final boolean inResponse = responseItems.contains(item);
final Collection<Set<Object>> predictedClusters = predictedItemToGroup.get(item);
final Collection<Set<Object>> goldClusters = goldItemToGroup.get(item);
final Predicate<Object> SELF_ADJUSTMENT_FILTER;
if (useSelfEdges) {
SELF_ADJUSTMENT_FILTER = Predicates.alwaysTrue();
} else {
SELF_ADJUSTMENT_FILTER = not(equalTo(item));
}
final int selfAdjustment = useSelfEdges ? 0 : -1;
final ImmutableSet<Object> predictedNeighbors =
FluentIterable.from(concat(predictedClusters)).filter(SELF_ADJUSTMENT_FILTER).toSet();
final ImmutableSet<Object> goldNeighbors =
FluentIterable.from(concat(goldClusters)).filter(SELF_ADJUSTMENT_FILTER).toSet();
// The contribution for this item is the size of the intersection
// of the gold and predicted neighbor sets.
corefLinksInBoth += Sets.intersection(predictedNeighbors, goldNeighbors).size();
corefLinksInResponse += predictedNeighbors.size();
corefLinksInKey += goldNeighbors.size();
if (inKey) {
nonCorefLinksInKey += keyItems.size() - goldNeighbors.size() + selfAdjustment;
}
if (inResponse) {
nonCorefLinksInResponse +=
responseItems.size() - predictedNeighbors.size() + selfAdjustment;
}
if (inKey && inResponse) {
final ImmutableSet<Object> neighborsInEither =
Sets.union(predictedNeighbors, goldNeighbors).immutableCopy();
// -1 = don't count this item itself as a link
nonCorefInBoth += Sets.difference(itemsInBoth, neighborsInEither).size() + selfAdjustment;
}
}
return BLANCResult.fromSetCounts(
keyItems.equals(responseItems),
corefLinksInBoth,
corefLinksInKey,
corefLinksInResponse,
nonCorefInBoth,
nonCorefLinksInKey,
nonCorefLinksInResponse);
}
