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(); }