private Set<MavenArtifact> filterOutExcludedPlugins(Collection<MavenArtifact> artifacts) {
if (exclusions == null) {
return Sets.newLinkedHashSet(artifacts);
}
return Sets.filter(
Sets.newLinkedHashSet(artifacts),
new Predicate<MavenArtifact>() {
@Override
public boolean apply(MavenArtifact a) {
for (String exclusion : exclusions) {
String[] pieces = exclusion.split(":");
if (pieces.length != 2) {
throw new IllegalArgumentException("Invalid exclusion " + exclusion);
}
String groupId = pieces[0];
String artifactId = pieces[1];
if ("*".equals(groupId)) {
if (artifactId.equals(a.getArtifactId())) {
return false;
}
} else {
if (groupId.equals(a.getGroupId()) && artifactId.equals(a.getArtifactId())) {
return false;
}
}
}
return true;
}
});
}
public static void assertOldTestsInNewSuite(Test oldSuite, Test newSuite) {
Set<Class<?>> caseClasses1 = Sets.newLinkedHashSet(collectCaseClasses(oldSuite));
Set<Class<?>> caseClasses2 = Sets.newLinkedHashSet(collectCaseClasses(newSuite));
assertTrue(
"Old tests not found in new suite:\n" + Sets.difference(caseClasses1, caseClasses2),
caseClasses2.containsAll(caseClasses1));
}
@NotNull
private static Collection<DeclarationDescriptor> filterAndStoreResolutionResult(
@NotNull Collection<LookupResult> lookupResults,
@NotNull JetSimpleNameExpression referenceExpression,
@NotNull BindingTrace trace,
@NotNull JetScope scopeToCheckVisibility,
@NotNull LookupMode lookupMode,
boolean storeResult) {
if (lookupResults.isEmpty()) {
return Collections.emptyList();
}
Collection<DeclarationDescriptor> descriptors = Sets.newLinkedHashSet();
for (LookupResult lookupResult : lookupResults) {
descriptors.addAll(lookupResult.descriptors);
}
Collection<JetScope> possibleResolutionScopes = Lists.newArrayList();
for (LookupResult lookupResult : lookupResults) {
if (!lookupResult.descriptors.isEmpty()) {
possibleResolutionScopes.add(lookupResult.resolutionScope);
}
}
if (possibleResolutionScopes.isEmpty()) {
for (LookupResult lookupResult : lookupResults) {
possibleResolutionScopes.add(lookupResult.resolutionScope);
}
}
Collection<DeclarationDescriptor> filteredDescriptors;
if (lookupMode == LookupMode.ONLY_CLASSES_AND_PACKAGES) {
filteredDescriptors = Collections2.filter(descriptors, CLASSIFIERS_AND_PACKAGE_VIEWS);
} else {
filteredDescriptors = Sets.newLinkedHashSet();
// functions and properties can be imported if lookupResult.packageLevel == true
for (LookupResult lookupResult : lookupResults) {
if (lookupResult.packageLevel) {
filteredDescriptors.addAll(lookupResult.descriptors);
} else {
filteredDescriptors.addAll(
Collections2.filter(lookupResult.descriptors, CLASSIFIERS_AND_PACKAGE_VIEWS));
}
}
}
if (storeResult) {
storeResolutionResult(
descriptors,
filteredDescriptors,
referenceExpression,
possibleResolutionScopes,
trace,
scopeToCheckVisibility);
}
return filteredDescriptors;
}
public <S, P, R, D extends Pda<S, P>> D filterEdges(
Pda<S, P> pda, Traverser<? super Pda<S, P>, S, R> traverser, PdaFactory<D, S, P, S> factory) {
HashStack<TraversalItem<S, R>> trace = new HashStack<TraversalItem<S, R>>();
R previous = traverser.enter(pda, pda.getStart(), null);
if (previous == null)
return factory == null ? null : factory.create(pda.getStart(), pda.getStop());
Map<S, Integer> distances = new NfaUtil().distanceToFinalStateMap(pda);
MappedComparator<S, Integer> distanceComp = new MappedComparator<S, Integer>(distances);
trace.push(newItem(pda, distanceComp, distances, pda.getStart(), previous));
Multimap<S, S> edges = LinkedHashMultimap.create();
HashSet<S> states = Sets.newLinkedHashSet();
HashSet<Pair<S, R>> success = Sets.newLinkedHashSet();
states.add(pda.getStart());
states.add(pda.getStop());
ROOT:
while (!trace.isEmpty()) {
TraversalItem<S, R> current = trace.peek();
while (current.followers.hasNext()) {
S next = current.followers.next();
R item = traverser.enter(pda, next, current.data);
if (item != null) {
if ((next == pda.getStop() && traverser.isSolution(item))
|| success.contains(Tuples.create(next, item))) {
S s = null;
for (TraversalItem<S, R> i : trace) {
if (s != null) edges.put(s, i.state);
states.add(i.state);
success.add(Tuples.create(i.state, i.data));
s = i.state;
}
edges.put(s, next);
} else {
if (trace.push(newItem(pda, distanceComp, distances, next, item))) continue ROOT;
}
}
}
trace.pop();
}
if (factory == null) return null;
D result = factory.create(pda.getStart(), pda.getStop());
Map<S, S> old2new = Maps.newLinkedHashMap();
old2new.put(pda.getStart(), result.getStart());
old2new.put(pda.getStop(), result.getStop());
for (S old : states) {
if (old == pda.getStart() || old == pda.getStop()) continue;
else if (pda.getPop(old) != null) old2new.put(old, factory.createPop(result, old));
else if (pda.getPush(old) != null) old2new.put(old, factory.createPush(result, old));
else old2new.put(old, factory.createState(result, old));
}
for (S old : states) {
List<S> followers = Lists.newArrayList();
for (S f : edges.get(old)) followers.add(old2new.get(f));
factory.setFollowers(result, old2new.get(old), followers);
}
return result;
}
public static void assertSuitesEqual(Test suite1, Test suite2) {
Set<Class<?>> caseClasses1 = Sets.newLinkedHashSet(collectCaseClasses(suite1));
Set<Class<?>> caseClasses2 = Sets.newLinkedHashSet(collectCaseClasses(suite2));
assertTrue(
"New tests not found in old suite:\n" + Sets.difference(caseClasses2, caseClasses1),
caseClasses1.containsAll(caseClasses2));
assertTrue(
"Old tests not found in new suite:\n" + Sets.difference(caseClasses1, caseClasses2),
caseClasses2.containsAll(caseClasses1));
}
@Override
public Collection<EPackageLoadingCallback.EPackageDeclarationSource> findEcoreDeclarations(
Set<String> projects, Set<String> plugins) {
Set<String> analyzed = Sets.newLinkedHashSet();
Set<String> bundlesIDependOn = Sets.newLinkedHashSet();
for (String currentBundle : Iterables.concat(plugins, projects)) {
addDependencies(currentBundle, analyzed, bundlesIDependOn);
}
return getEPackagesDeclaredInBundles(bundlesIDependOn);
}
protected Reservation<? extends RunningInstance> newReservation() {
String region = getRequest() != null ? AWSUtils.findRegionInArgsOrNull(getRequest()) : null;
if (region == null) region = defaultRegion.get();
Reservation<? extends RunningInstance> info =
new Reservation<RunningInstance>(
region, groupNames, instances, ownerId, requesterId, reservationId);
this.groupNames = Sets.newLinkedHashSet();
this.instances = Sets.newLinkedHashSet();
this.ownerId = null;
this.requesterId = null;
this.reservationId = null;
return info;
}
/**
* Computes the cube of bit sets.
*
* <p>For example, <code>rollup({0}, {1})</code> returns <code>({0, 1}, {0}, {})</code>.
*
* <p>Bit sets are not necessarily singletons: <code>rollup({0, 2}, {3, 5})</code> returns <code>
* ({0, 2, 3, 5}, {0, 2}, {})</code>.
*/
@VisibleForTesting
public static ImmutableList<ImmutableBitSet> cube(List<ImmutableBitSet> bitSets) {
// Given the bit sets [{1}, {2, 3}, {5}],
// form the lists [[{1}, {}], [{2, 3}, {}], [{5}, {}]].
final Set<List<ImmutableBitSet>> builder = Sets.newLinkedHashSet();
for (ImmutableBitSet bitSet : bitSets) {
builder.add(Arrays.asList(bitSet, ImmutableBitSet.of()));
}
Set<ImmutableBitSet> flattenedBitSets = Sets.newLinkedHashSet();
for (List<ImmutableBitSet> o : Linq4j.product(builder)) {
flattenedBitSets.add(ImmutableBitSet.union(o));
}
return ImmutableList.copyOf(flattenedBitSets);
}
@GwtIncompatible // unreasonably slow
public void testEntriesIteration() {
@SuppressWarnings("unchecked")
Set<Entry<String, Integer>> set =
Sets.newLinkedHashSet(
asList(
Maps.immutableEntry("foo", 2),
Maps.immutableEntry("foo", 3),
Maps.immutableEntry("bar", 4),
Maps.immutableEntry("bar", 5),
Maps.immutableEntry("foo", 6)));
new IteratorTester<Entry<String, Integer>>(
6, MODIFIABLE, set, IteratorTester.KnownOrder.KNOWN_ORDER) {
private Multimap<String, Integer> multimap;
@Override
protected Iterator<Entry<String, Integer>> newTargetIterator() {
multimap = LinkedHashMultimap.create();
multimap.putAll("foo", asList(2, 3));
multimap.putAll("bar", asList(4, 5));
multimap.putAll("foo", asList(6));
return multimap.entries().iterator();
}
@Override
protected void verify(List<Entry<String, Integer>> elements) {
assertEquals(newHashSet(elements), multimap.entries());
}
}.test();
}
/**
* Create a resource method builder.
*
* <p>The supplied parent resource model builder will be called to register the newly created
* resource method instance as part of the {@link #build()} method invocation.
*
* <p>Note that the {@link #build()} method does not have to be invoked manually as the
* registration will happen automatically as part of the {@link
* org.glassfish.jersey.server.model.Resource.Builder#build()} method invocation.
*
* @param parent parent resource model builder.
*/
Builder(final Resource.Builder parent) {
this.parent = parent;
this.httpMethod = null;
this.consumedTypes = Sets.newLinkedHashSet();
this.producedTypes = Sets.newLinkedHashSet();
this.suspended = false;
this.suspendTimeout = AsyncResponse.NO_TIMEOUT;
this.suspendTimeoutUnit = TimeUnit.MILLISECONDS;
this.encodedParams = false;
this.nameBindings = Sets.newLinkedHashSet();
}
private void writeFile() throws IOException {
LinkedHashSet<String> services = Sets.newLinkedHashSet();
readExistingEntriesInto(services);
copyNewMetaservicesInto(services);
removeBlankLinesIn(services);
writeLinesFrom(services);
}
@NotNull
private static Collection<DeclarationDescriptor> lookupSelectorDescriptors(
@NotNull JetSimpleNameExpression selector,
@NotNull Collection<DeclarationDescriptor> declarationDescriptors,
@NotNull BindingTrace trace,
@NotNull JetScope scopeToCheckVisibility,
@NotNull LookupMode lookupMode,
boolean storeResult) {
Set<LookupResult> results = Sets.newLinkedHashSet();
for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
if (declarationDescriptor instanceof PackageViewDescriptor) {
results.add(
lookupSimpleNameReference(
selector,
((PackageViewDescriptor) declarationDescriptor).getMemberScope(),
lookupMode,
true));
}
if (declarationDescriptor instanceof ClassDescriptor) {
addResultsForClass(results, selector, lookupMode, (ClassDescriptor) declarationDescriptor);
}
}
return filterAndStoreResolutionResult(
results, selector, trace, scopeToCheckVisibility, lookupMode, storeResult);
}
private Volume newVolume() {
Volume volume =
new Volume(
region,
id,
size,
snapshotId,
availabilityZone,
volumeStatus,
createTime,
volumeType,
iops,
encrypted,
attachments);
id = null;
size = 0;
snapshotId = null;
availabilityZone = null;
volumeStatus = null;
createTime = null;
attachments = Sets.newLinkedHashSet();
volumeType = null;
iops = null;
encrypted = false;
return volume;
}
public abstract static class Builder<B extends Builder<B>> extends ResourceType.Builder<B> {
private Set<ResourceAllocationSettingData> items = Sets.newLinkedHashSet();
/** @see RasdItemsList#getItems() */
public B items(Set<ResourceAllocationSettingData> items) {
this.items = checkNotNull(items, "items");
return self();
}
/** @see RasdItemsList#getItems() */
public B item(ResourceAllocationSettingData item) {
this.items.add(checkNotNull(item, "item"));
return self();
}
@Override
public RasdItemsList build() {
RasdItemsList rasdItemsList = new RasdItemsList(this);
return rasdItemsList;
}
public B fromRasdItemsList(RasdItemsList in) {
return fromResourceType(in).items(in.getItems());
}
}
public static class Builder {
private final Set<String> states = Sets.newLinkedHashSet();
// transitions per originating state
private final ListMultimap<String, Transition> outTransitions = ArrayListMultimap.create();
private Builder() {}
public Builder states(String... keys) {
states.addAll(Arrays.asList(keys));
return this;
}
public Builder transition(Transition transition) {
Preconditions.checkArgument(
states.contains(transition.from()),
"Originating state does not exist: " + transition.from());
Preconditions.checkArgument(
states.contains(transition.to()), "Destination state does not exist: " + transition.to());
outTransitions.put(transition.from(), transition);
return this;
}
public StateMachine build() {
Preconditions.checkArgument(!states.isEmpty(), "At least one state is required");
return new StateMachine(this);
}
}
/**
* Parses the search query.
*
* @param query the query.
* @return the result map with query tokens. Never returns null.
* @throws InvalidQueryException if the query contains invalid params.
*/
Map<TokenQueryType, Set<String>> parseQuery(String query) throws InvalidQueryException {
Preconditions.checkArgument(query != null);
query = query.trim();
// If query is empty - return.
if (query.isEmpty()) {
return Collections.emptyMap();
}
String[] tokens = query.split("\\s+");
Map<TokenQueryType, Set<String>> tokensMap = Maps.newEnumMap(TokenQueryType.class);
for (String token : tokens) {
String[] pair = token.split(":");
if (pair.length != 2 || !TokenQueryType.hasToken(pair[0])) {
String msg = "Invalid query param: " + token;
throw new InvalidQueryException(msg);
}
String tokenValue = pair[1];
TokenQueryType tokenType = TokenQueryType.fromToken(pair[0]);
// Verify the orderby param.
if (tokenType.equals(TokenQueryType.ORDERBY)) {
try {
OrderByValueType.fromToken(tokenValue);
} catch (IllegalArgumentException e) {
String msg = "Invalid orderby query value: " + tokenValue;
throw new InvalidQueryException(msg);
}
}
Set<String> valuesPerToken = tokensMap.get(tokenType);
if (valuesPerToken == null) {
valuesPerToken = Sets.newLinkedHashSet();
tokensMap.put(tokenType, valuesPerToken);
}
valuesPerToken.add(tokenValue);
}
return tokensMap;
}
@Override
public Set<PBody> doGetContainedBodies() throws QueryInitializationException {
Set<PBody> bodies = Sets.newLinkedHashSet();
try {
{
PBody body = new PBody(this);
PVariable var_C = body.getOrCreateVariableByName("C");
PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
body.setExportedParameters(
Arrays.<ExportedParameter>asList(new ExportedParameter(body, var_C, "C")));
new ConstantValue(body, var__virtual_0_, 30);
new TypeConstraint(
body,
new FlatTuple(var_C),
new EClassTransitiveInstancesKey(
(EClass) getClassifierLiteral("http://school.ecore", "Course")));
new TypeConstraint(
body,
new FlatTuple(var_C, var__virtual_1_),
new EStructuralFeatureInstancesKey(
getFeatureLiteral("http://school.ecore", "Course", "weight")));
new Equality(body, var__virtual_1_, var__virtual_0_);
bodies.add(body);
}
// to silence compiler error
if (false) throw new IncQueryException("Never", "happens");
} catch (IncQueryException ex) {
throw processDependencyException(ex);
}
return bodies;
}
public class CompositeBuildTaskDelegate extends DefaultTask {
private String build;
private Set<String> tasks = Sets.newLinkedHashSet();
@Input
public String getBuild() {
return build;
}
public void setBuild(String build) {
this.build = build;
}
@Input
public Collection<String> getTasks() {
return tasks;
}
public void addTask(String task) {
this.tasks.add(task);
}
@TaskAction
public void executeTasksInOtherBuild() {
IncludedBuilds includedBuilds = getServices().get(IncludedBuilds.class);
IncludedBuildExecuter builder = getServices().get(IncludedBuildExecuter.class);
IncludedBuild includedBuild = includedBuilds.getBuild(build);
BuildIdentifier buildId = new DefaultBuildIdentifier(includedBuild.getName());
// sourceBuild is currently always root build in a composite
builder.execute(new DefaultBuildIdentifier(":", true), buildId, tasks);
}
}
private Set<Integer> loadObjects(
final List<Identifiable> proxy, final Map<Integer, RpslObject> loadedObjects) {
final StringBuilder queryBuilder = new StringBuilder();
final List<Integer> objectIds = Lists.newArrayListWithExpectedSize(proxy.size());
for (final Identifiable identifiable : proxy) {
final Integer objectId = identifiable.getObjectId();
if (loadedObjects.containsKey(objectId)) {
continue;
}
if (identifiable instanceof RpslObject) {
loadedObjects.put(objectId, (RpslObject) identifiable);
} else {
if (queryBuilder.length() > 0) {
// UNION ALL is much faster than IN
queryBuilder.append(" UNION ALL ");
}
queryBuilder.append(
""
+ "SELECT object_id, object "
+ "FROM last "
+ "WHERE object_id = ? "
+ "AND sequence_id != 0");
objectIds.add(objectId);
}
}
final List<RpslObject> rpslObjects =
jdbcTemplate.query(
queryBuilder.toString(),
new PreparedStatementSetter() {
@Override
public void setValues(final PreparedStatement ps) throws SQLException {
for (int i = 0; i < objectIds.size(); i++) {
ps.setInt(i + 1, objectIds.get(i));
}
}
},
new RpslObjectRowMapper());
for (final RpslObject rpslObject : rpslObjects) {
loadedObjects.put(rpslObject.getObjectId(), rpslObject);
}
if (proxy.size() == loadedObjects.size()) {
return Collections.emptySet();
}
final Set<Integer> differences = Sets.newLinkedHashSet();
for (final Identifiable identifiable : proxy) {
final Integer objectId = identifiable.getObjectId();
if (!loadedObjects.containsKey(objectId)) {
differences.add(objectId);
}
}
return differences;
}
public Set<DropDownObject> getProgramsAsDropDownList() {
Set<DropDownObject> programs = Sets.newLinkedHashSet();
for (ProgramDto pdto : programDtos) {
programs.add(new DropDownObject(pdto.getProgramId().toString(), pdto.getName()));
}
return programs;
}
/**
* Holds statistics of the load on a load balancer (SLB).
*
* @author Dies Koper
*/
@XmlRootElement(name = "loadstatistics")
public class LoadStatistics {
private Set<Group> groups = Sets.newLinkedHashSet();
/** @return the groups */
public Set<Group> getGroups() {
return groups == null ? ImmutableSet.<Group>of() : ImmutableSet.copyOf(groups);
}
@Override
public int hashCode() {
return Objects.hashCode(groups);
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
LoadStatistics that = LoadStatistics.class.cast(obj);
return Objects.equal(this.groups, that.groups);
}
@Override
public String toString() {
return Objects.toStringHelper(this).omitNullValues().add("groups", groups).toString();
}
}
@NotNull
public static Collection<String> collectPythonPath(
@Nullable Module module, boolean addContentRoots, boolean addSourceRoots) {
Collection<String> pythonPathList = Sets.newLinkedHashSet();
if (module != null) {
Set<Module> dependencies = new HashSet<Module>();
ModuleUtilCore.getDependencies(module, dependencies);
if (addContentRoots) {
addRoots(pythonPathList, ModuleRootManager.getInstance(module).getContentRoots());
for (Module dependency : dependencies) {
addRoots(pythonPathList, ModuleRootManager.getInstance(dependency).getContentRoots());
}
}
if (addSourceRoots) {
addRoots(pythonPathList, ModuleRootManager.getInstance(module).getSourceRoots());
for (Module dependency : dependencies) {
addRoots(pythonPathList, ModuleRootManager.getInstance(dependency).getSourceRoots());
}
}
addLibrariesFromModule(module, pythonPathList);
addRootsFromModule(module, pythonPathList);
for (Module dependency : dependencies) {
addLibrariesFromModule(dependency, pythonPathList);
addRootsFromModule(dependency, pythonPathList);
}
}
return pythonPathList;
}
/** @author Adrian Cole */
public class InternetServicesHandler extends HandlerWithResult<Set<InternetService>> {
@Resource protected Logger logger = Logger.NULL;
private final InternetServiceHandler handler;
Set<InternetService> result = Sets.newLinkedHashSet();
@Inject
public InternetServicesHandler(InternetServiceHandler handler) {
this.handler = handler;
}
@Override
public Set<InternetService> getResult() {
return result;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
handler.startElement(uri, localName, qName, attributes);
}
public void endElement(String uri, String name, String qName) {
handler.endElement(uri, name, qName);
if (qName.equals("InternetService")) {
result.add(handler.getResult());
}
}
public void characters(char ch[], int start, int length) {
handler.characters(ch, start, length);
}
}
@GET
@Produces(MediaType.APPLICATION_JSON)
@Timed
@UnitOfWork
public Set<Orchestration> getAll() {
return Sets.newLinkedHashSet(dao.findAll());
}
public LinkedHashSet<Path> scan(FileSystem fs, Path filePath, Set<String> consumedFiles) {
LinkedHashSet<Path> pathSet = Sets.newLinkedHashSet();
try {
LOG.debug("Scanning {} with pattern {}", filePath, this.filePatternRegexp);
FileStatus[] files = fs.listStatus(filePath);
for (FileStatus status : files) {
Path path = status.getPath();
String filePathStr = path.toString();
if (consumedFiles.contains(filePathStr)) {
continue;
}
if (ignoredFiles.contains(filePathStr)) {
continue;
}
if (acceptFile(filePathStr)) {
LOG.debug("Found {}", filePathStr);
pathSet.add(path);
} else {
// don't look at it again
ignoredFiles.add(filePathStr);
}
}
} catch (FileNotFoundException e) {
LOG.warn("Failed to list directory {}", filePath, e);
} catch (IOException e) {
throw new RuntimeException(e);
}
return pathSet;
}
@Override
@SuppressWarnings("StringEquality")
public DefaultBuildInvocations buildAll(String modelName, Project project) {
if (!canBuild(modelName)) {
throw new GradleException("Unknown model name " + modelName);
}
DefaultProjectIdentifier projectIdentifier = getProjectIdentifier(project);
// construct task selectors
List<LaunchableGradleTaskSelector> selectors = Lists.newArrayList();
Map<String, LaunchableGradleTaskSelector> selectorsByName = Maps.newTreeMap(Ordering.natural());
Set<String> visibleTasks = Sets.newLinkedHashSet();
findTasks(project, selectorsByName, visibleTasks);
for (String selectorName : selectorsByName.keySet()) {
LaunchableGradleTaskSelector selector = selectorsByName.get(selectorName);
selectors.add(
selector
.setName(selectorName)
.setTaskName(selectorName)
.setProjectIdentifier(projectIdentifier)
.setDisplayName(selectorName + " in " + project + " and subprojects.")
.setPublic(visibleTasks.contains(selectorName)));
}
// construct project tasks
List<LaunchableGradleTask> projectTasks = tasks(project);
// construct build invocations from task selectors and project tasks
return new DefaultBuildInvocations()
.setSelectors(selectors)
.setTasks(projectTasks)
.setProjectIdentifier(projectIdentifier);
}
@NotNull
private static LookupResult lookupSimpleNameReference(
@NotNull JetSimpleNameExpression referenceExpression,
@NotNull JetScope outerScope,
@NotNull LookupMode lookupMode,
boolean packageLevel) {
Name referencedName = referenceExpression.getReferencedNameAsName();
Collection<DeclarationDescriptor> descriptors = Sets.newLinkedHashSet();
PackageViewDescriptor packageDescriptor = outerScope.getPackage(referencedName);
if (packageDescriptor != null) {
descriptors.add(packageDescriptor);
}
ClassifierDescriptor classifierDescriptor = outerScope.getClassifier(referencedName);
if (classifierDescriptor != null) {
descriptors.add(classifierDescriptor);
}
if (lookupMode == LookupMode.EVERYTHING) {
descriptors.addAll(outerScope.getFunctions(referencedName));
descriptors.addAll(outerScope.getProperties(referencedName));
VariableDescriptor localVariable = outerScope.getLocalVariable(referencedName);
if (localVariable != null) {
descriptors.add(localVariable);
}
}
return new LookupResult(descriptors, outerScope, packageLevel);
}
/**
* {@inheritDoc}
*
* @see
* org.eclipse.acceleo.common.utils.IAcceleoCrossReferenceProvider#getInverseReferences(org.eclipse.emf.ecore.EObject)
*/
public Set<EObject> getInverseReferences(EObject eObject) {
final Set<EObject> result = Sets.newLinkedHashSet();
for (EStructuralFeature.Setting setting : crossReferencer.getInverseReferences(eObject)) {
result.add(setting.getEObject());
}
return result;
}
private Variance calculateArgumentProjectionKindFromSuper(
@NotNull TypeProjection argument,
@NotNull List<TypeProjectionAndVariance> projectionsFromSuper) {
Set<Variance> projectionKindsInSuper = Sets.newLinkedHashSet();
for (TypeProjectionAndVariance projectionAndVariance : projectionsFromSuper) {
projectionKindsInSuper.add(projectionAndVariance.typeProjection.getProjectionKind());
}
Variance defaultProjectionKind = argument.getProjectionKind();
if (projectionKindsInSuper.size() == 0) {
return defaultProjectionKind;
} else if (projectionKindsInSuper.size() == 1) {
Variance projectionKindInSuper = projectionKindsInSuper.iterator().next();
if (defaultProjectionKind == INVARIANT || defaultProjectionKind == projectionKindInSuper) {
return projectionKindInSuper;
} else {
reportError(
"Incompatible projection kinds in type arguments of super methods' return types: "
+ projectionsFromSuper
+ ", defined in current: "
+ argument);
return defaultProjectionKind;
}
} else {
reportError(
"Incompatible projection kinds in type arguments of super methods' return types: "
+ projectionsFromSuper);
return defaultProjectionKind;
}
}
public void lanucher() {
Set<Service> services = Sets.newLinkedHashSet();
/** 节点管理服务 */
GatewayServerStartService tcpService =
(GatewayServerStartService) D3Context.getBean("gatewayServerStartService");
services.add(tcpService);
serviceManager = new ServiceManager(services);
serviceManager.addListener(
new Listener() {
@Override
public void failure(Service service) {}
@Override
public void healthy() {
System.out.println("all service has been started");
}
@Override
public void stopped() {}
},
MoreExecutors.sameThreadExecutor());
serviceManager.startAsync();
}
