@Override public Point newLocation() { Preconditions.checkNotNull(wish); // [stas] just for fun return new Point( natural() .sortedCopy( ImmutableList.of( wish.getX(), 0, sizeRetriever.windowSize().getWidth() - sizeRetriever.getComponentsSize().getWidth())) .get(1), Ordering.natural() .sortedCopy( Arrays.asList( natural() .min( Lists.asList( sizeRetriever.windowSize().getHeight() - sizeRetriever.getMaxElementSize().getHeight(), Collections2.transform( lowest, new Function<Point, Integer>() { @Override public Integer apply(Point input) { return input.getY(); } }) .toArray(new Integer[] {}))) - (lowest.isEmpty() ? 0 : sizeRetriever.getMaxElementSize().getHeight()), natural() .max( Lists.asList( Point.HIGHEST.getY(), Collections2.transform( highest, new Function<Point, Integer>() { @Override public Integer apply(Point input) { return input.getY(); } }) .toArray(new Integer[] {}))) + (highest.isEmpty() ? 0 : sizeRetriever.getMaxElementSize().getHeight()), wish.getY())) .get(1)); }
@Override public Collection<Target> getReverseDeps(Iterable<Target> targets) { Set<Target> result = CompactHashSet.create(); Map<Target, Collection<Target>> rawReverseDeps = getRawReverseDeps(targets); warnIfMissingTargets(targets, rawReverseDeps.keySet()); CompactHashSet<Target> visited = CompactHashSet.create(); Set<Label> keys = CompactHashSet.create( Collections2.transform(rawReverseDeps.keySet(), TARGET_LABEL_FUNCTION)); for (Collection<Target> parentCollection : rawReverseDeps.values()) { for (Target parent : parentCollection) { if (visited.add(parent)) { if (parent instanceof Rule && dependencyFilter != DependencyFilter.ALL_DEPS) { for (Label label : getAllowedDeps((Rule) parent)) { if (keys.contains(label)) { result.add(parent); } } } else { result.add(parent); } } } } return result; }
public static CSVBinding getBinding(final String column, final String field, Set<String> cols) { CSVBinding cb = new CSVBinding(); cb.field = field; cb.column = column; if (cols == null || cols.isEmpty()) { if (cb.column == null) cb.column = field; return cb; } for (String col : cols) { if (cb.bindings == null) cb.bindings = Lists.newArrayList(); cb.bindings.add(CSVBinding.getBinding(field + "." + col, col, null)); } cb.update = true; cb.search = Joiner.on(" AND ") .join( Collections2.transform( cols, new Function<String, String>() { @Override public String apply(String input) { return String.format("self.%s = :%s_%s_", input, field, input); } })); return cb; }
@Test public void write_onPatchWithInnerObject_fullyWritesInnerObject() { TestData original = new TestData(); TestData updated = new TestData(); updated.setInnerData(new InnerTestData()); Patch<TestData> patch = MakePatch.from(original).to(updated).with(new ReflectivePatchCalculator<>()); JsonObject json = toJson(patch); assertTrue(json.has("innerData")); assertTrue(json.get("innerData").isJsonObject()); JsonObject innerJson = json.get("innerData").getAsJsonObject(); Collection<String[]> fields = Collections2.transform( innerJson.entrySet(), entry -> new String[] {entry.getKey(), entry.getValue().getAsString()}); assertThat( fields, containsInAnyOrder( new String[] {"json-name-alias", "inner-named-value"}, new String[] {"name1", "inner-value-1"}, new String[] {"name2", "inner-value-2"})); }
@NotNull private Collection<PsiElement> getDeclarationsByDescriptor( @NotNull DeclarationDescriptor declarationDescriptor) { Collection<PsiElement> declarations; if (declarationDescriptor instanceof PackageViewDescriptor) { final PackageViewDescriptor aPackage = (PackageViewDescriptor) declarationDescriptor; Collection<JetFile> files = trace.get(BindingContext.PACKAGE_TO_FILES, aPackage.getFqName()); if (files == null) { return Collections .emptyList(); // package can be defined out of Kotlin sources, e. g. in library or Java // code } declarations = Collections2.transform( files, new Function<JetFile, PsiElement>() { @Override public PsiElement apply(@Nullable JetFile file) { assert file != null : "File is null for aPackage " + aPackage; return file.getPackageDirective().getNameIdentifier(); } }); } else { declarations = Collections.singletonList( BindingContextUtils.descriptorToDeclaration( trace.getBindingContext(), declarationDescriptor)); } return declarations; }
@Override public void execute() throws MojoExecutionException, MojoFailureException { StaticLoggerBinder.getSingleton().setMavenLog(this.getLog()); try { final List<Artifact> artifacts = getListOfArtifacts(); LOG.debug("artifacts={}", artifacts); final ArrayList<File> files = new ArrayList<File>(Collections2.transform(artifacts, toFileFunction)); final ArrayList<String> hashBaseNames = new ArrayList<String>(Collections2.transform(files, toBomStringFunction)); addHashEntryForPom(hashBaseNames); writeResults(hashBaseNames); } catch (IOException ex) { throw new MojoExecutionException(ex.toString(), ex); } }
/** * 从待执行队列中获取所有有资格执行的作业上下文. * * @param ineligibleJobContexts 无资格执行的作业上下文 * @return 有资格执行的作业上下文集合 */ public Collection<JobContext> getAllEligibleJobContexts( final Collection<JobContext> ineligibleJobContexts) { if (!regCenter.isExisted(ReadyNode.ROOT)) { return Collections.emptyList(); } Collection<String> ineligibleJobNames = Collections2.transform( ineligibleJobContexts, new Function<JobContext, String>() { @Override public String apply(final JobContext input) { return input.getJobConfig().getJobName(); } }); List<String> jobNames = regCenter.getChildrenKeys(ReadyNode.ROOT); List<JobContext> result = new ArrayList<>(jobNames.size()); for (String each : jobNames) { if (ineligibleJobNames.contains(each)) { continue; } Optional<CloudJobConfiguration> jobConfig = configService.load(each); if (!jobConfig.isPresent()) { regCenter.remove(ReadyNode.getReadyJobNodePath(each)); continue; } if (!runningService.isJobRunning(each) || JobExecutionType.DAEMON == jobConfig.get().getJobExecutionType()) { result.add(JobContext.from(jobConfig.get(), ExecutionType.READY)); } } return result; }
public List<HLocale> suggestLocales(final String query) { if (allLocales == null) { allLocales = localeServiceImpl.getAllJavaLanguages(); } Collection<LocaleId> filtered = Collections2.filter( allLocales, new Predicate<LocaleId>() { @Override public boolean apply(LocaleId input) { return input.getId().startsWith(query); } }); return new ArrayList<HLocale>( Collections2.transform( filtered, new Function<LocaleId, HLocale>() { @Override public HLocale apply(@Nullable LocaleId from) { return new HLocale(from); } })); }
public DescribeAlarmsForMetricResponseType describeAlarmsForMetric( DescribeAlarmsForMetricType request) throws CloudWatchException { DescribeAlarmsForMetricResponseType reply = request.getReply(); final Context ctx = Contexts.lookup(); try { // IAM Action Check checkActionPermission(PolicySpec.CLOUDWATCH_DESCRIBEALARMSFORMETRIC, ctx); final OwnerFullName ownerFullName = ctx.getUserFullName(); final String accountId = ownerFullName.getAccountNumber(); final Map<String, String> dimensionMap = TransformationFunctions.DimensionsToMap.INSTANCE.apply( validateDimensions(request.getDimensions())); final String metricName = validateMetricName(request.getMetricName(), true); final String namespace = validateNamespace(request.getNamespace(), true); final Integer period = validatePeriod(request.getPeriod(), false); final Statistic statistic = validateStatistic(request.getStatistic(), false); final Units unit = validateUnits(request.getUnit(), true); Collection<AlarmEntity> results = AlarmManager.describeAlarmsForMetric( accountId, dimensionMap, metricName, namespace, period, statistic, unit); MetricAlarms metricAlarms = new MetricAlarms(); metricAlarms.setMember( Lists.newArrayList( Collections2.<AlarmEntity, MetricAlarm>transform( results, TransformationFunctions.AlarmEntityToMetricAlarm.INSTANCE))); reply.getDescribeAlarmsForMetricResult().setMetricAlarms(metricAlarms); } catch (Exception ex) { handleException(ex); } return reply; }
@GET @Path("/{serverName}/segments") @Produces(MediaType.APPLICATION_JSON) public Response getServerSegments( @PathParam("serverName") String serverName, @QueryParam("full") String full) { Response.ResponseBuilder builder = Response.status(Response.Status.OK); DruidServer server = serverInventoryView.getInventoryValue(serverName); if (server == null) { return Response.status(Response.Status.NOT_FOUND).build(); } if (full != null) { return builder.entity(server.getSegments().values()).build(); } return builder .entity( Collections2.transform( server.getSegments().values(), new Function<DataSegment, String>() { @Override public String apply(DataSegment segment) { return segment.getIdentifier(); } })) .build(); }
private String getRemoveSql() { if (this.removeSql != null) { return this.removeSql; } synchronized (this) { if (this.removeSql != null) { return this.removeSql; } this.removeColumns = new AbstractColumn[this.pkColumns.size()]; this.pkColumns.values().toArray(this.removeColumns); final Collection<String> restrictions = Collections2.transform( this.pkColumns.values(), new Function<AbstractColumn, String>() { @Override public String apply(AbstractColumn input) { return input.getName() + " = ?"; } }); return this.removeSql = "DELETE FROM " + this.getQName() + " WHERE " + Joiner.on(" AND ").join(restrictions); } }
/** {@inheritDoc} */ @Override public String toString() { final String columns = Joiner.on(", ") .join( Collections2.transform( this.getColumns(), new Function<AbstractColumn, String>() { @Override public String apply(AbstractColumn input) { final StringBuffer out = new StringBuffer(); out.append(input instanceof PkColumn ? "ID [" : "COL ["); out.append("name="); out.append(input.getName()); out.append(", type="); out.append(input.getSqlType()); out.append("]"); return out.toString(); } })); return "Table [owner=" + this.entity.getName() // + ", name=" + this.getQName() // + ", columns=[" + columns + "]]"; }
@Override public Collection<PyThreadInfo> getThreads() { cleanOtherDebuggers(); List<PyThreadInfo> threads = collectAllThreads(); if (myOtherDebuggers.size() > 0) { // here we add process id to thread name in case there are more then one process return Collections.unmodifiableCollection( Collections2.transform( threads, new Function<PyThreadInfo, PyThreadInfo>() { @Override public PyThreadInfo apply(PyThreadInfo t) { String threadName = ThreadRegistry.threadName(t.getName(), t.getId()); PyThreadInfo newThread = new PyThreadInfo( t.getId(), threadName, t.getFrames(), t.getStopReason(), t.getMessage()); newThread.updateState(t.getState(), t.getFrames()); return newThread; } })); } else { return Collections.unmodifiableCollection(threads); } }
public void testMultiPackageFunction() { myFixture.configureByText( JetFileType.INSTANCE, "package test.testing\n" + "fun other(v : Int) = 12\n" + "fun other(v : String) {}"); StubPackageMemberDeclarationProvider provider = new StubPackageMemberDeclarationProvider( new FqName("test.testing"), getProject(), GlobalSearchScope.projectScope(getProject())); List<JetNamedFunction> other = Lists.newArrayList(provider.getFunctionDeclarations(Name.identifier("other"))); Collection<String> functionTexts = Collections2.transform( other, new Function<JetNamedFunction, String>() { @Override public String apply(JetNamedFunction function) { return function.getText(); } }); assertSize(2, other); assertTrue(functionTexts.contains("fun other(v : Int) = 12")); assertTrue(functionTexts.contains("fun other(v : String) {}")); }
@Override public GetTablespaceListResponse getAllTablespaces(RpcController controller, NullProto request) throws ServiceException { rlock.lock(); try { // retrieves tablespaces from catalog store final List<TablespaceProto> tableSpaces = Lists.newArrayList(store.getTablespaces()); // retrieves tablespaces from linked meta data tableSpaces.addAll( Collections2.transform( linkedMetadataManager.getTablespaces(), new Function<Pair<String, URI>, TablespaceProto>() { @Override public TablespaceProto apply(Pair<String, URI> input) { return TablespaceProto.newBuilder() .setSpaceName(input.getFirst()) .setUri(input.getSecond().toString()) .build(); } })); return GetTablespaceListResponse.newBuilder() .setState(OK) .addAllTablespace(tableSpaces) .build(); } catch (Throwable t) { printStackTraceIfError(LOG, t); throw new ServiceException(t); } finally { rlock.unlock(); } }
@Override public String toString() { String fsList = Joiner.on(", ") .join( Collections2.transform( Collections2.filter( this.getFiles(), new Predicate<StoreFile>() { public boolean apply(StoreFile sf) { return sf.getReader() != null; } }), new Function<StoreFile, String>() { public String apply(StoreFile sf) { return StringUtils.humanReadableInt( (sf.getReader() == null) ? 0 : sf.getReader().length()); } })); return "regionName=" + regionName + ", storeName=" + storeName + ", fileCount=" + this.getFiles().size() + ", fileSize=" + StringUtils.humanReadableInt(totalSize) + ((fsList.isEmpty()) ? "" : " (" + fsList + ")") + ", priority=" + priority + ", time=" + timeInNanos; }
@SuppressWarnings("unchecked") private void addAuditLogEntries(Feed feed, Integer maxResults, Integer startIndex) { FeedData feedData = getFeedData(maxResults, startIndex); addTotalEntriesMarkup(feed, feedData.totalEntries); addStartIndexMarkup(feed, feedData.startIndex); // add links to next and previous pages if any exist, and to first/last pages int nextPageStartIndex = feedData.startIndex + feedData.maxResults; int previousPageStartIndex = max(feedData.startIndex - feedData.maxResults, 0); int firstPageStartIndex = 0; int lastPageStartIndex = (int) Math.floor((feedData.totalEntries - 1) / feedData.maxResults) * feedData.maxResults; if (nextPageStartIndex < feedData.totalEntries) { addLink( feed, uriBuilder.buildAuditLogFeedUri(feedData.maxResults, nextPageStartIndex), "next"); addLink( feed, uriBuilder.buildAuditLogFeedUri(feedData.maxResults, lastPageStartIndex), "last"); } if (feedData.startIndex > 0) { addLink( feed, uriBuilder.buildAuditLogFeedUri(feedData.maxResults, firstPageStartIndex), "first"); addLink( feed, uriBuilder.buildAuditLogFeedUri(feedData.maxResults, previousPageStartIndex), "previous"); } // transform AuditLogEntry elements to rome Entry elements and add to the feed feed.getEntries() .addAll(Collections2.transform(feedData.entries, auditLogEntryToFeedEntryFn())); }
/* * ************************** REFUNDS ******************************** */ @GET @Path("/{accountId:" + UUID_PATTERN + "}/" + REFUNDS) @Produces(APPLICATION_JSON) public Response getRefunds( @PathParam("accountId") final String accountId, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, PaymentApiException { final TenantContext tenantContext = context.createContext(request); final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), tenantContext); final List<Refund> refunds = paymentApi.getAccountRefunds(account, tenantContext); final List<RefundJson> result = new ArrayList<RefundJson>( Collections2.transform( refunds, new Function<Refund, RefundJson>() { @Override public RefundJson apply(Refund input) { // TODO Return adjusted items and audits return new RefundJson(input, null, null); } })); return Response.status(Status.OK).entity(result).build(); }
private Iterator<Resource> getFilesFromParams() throws IOException { System.err.printf( "%s system property not specified, using 'dir'" + " parameter from configuration file\n", DIR_PROPERTY); String resource = (String) getConfigParameterValue("dir"); String suffix = (String) getConfigParameterValue("suffix"); if (resource != null) { System.err.printf("Reading files from classpath directory: %s\n", resource); Reflections reflections = new Reflections( new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage("")) .setScanners(new ResourcesScanner())); Set<String> files = reflections.getResources(Pattern.compile(".*\\." + suffix)); Collection<Resource> resources = Collections2.transform(files, new StringToResourceFunction("/")); final Pattern p = Pattern.compile("^" + resource); Collection<Resource> filtered = Collections2.filter( resources, new Predicate<Resource>() { @Override public boolean apply(Resource input) { Matcher m = p.matcher(input.name); return m.find(); } }); return filtered.iterator(); } else { throw new IOException(String.format("Parameter 'dir' must be specified")); } }
@Override public void setAdditionalDefaultGroups(Set<String> groupNames) { try { if (groupNames == null) return; final Map<String, Role> nameToRole = Maps.uniqueIndex(roleService.loadAll(), Roles.roleToNameFunction()); final List<String> groupIds = Lists.newArrayList( Collections2.transform( groupNames, new Function<String, String>() { @Nullable @Override public String apply(@Nullable String groupName) { if (groupName == null || !nameToRole.containsKey(groupName)) { return null; } return nameToRole.get(groupName).getId(); } })); fields.put(ADDITIONAL_DEFAULT_GROUPS, groupIds); } catch (NotFoundException e) { LOG.error("Unable to convert group names to ids", e); throw new IllegalStateException("Unable to convert group names to ids", e); } }
private static Collection<FqName> getJavaClasses( @NotNull final String typeName, @NotNull Project project, final GlobalSearchScope scope) { PsiShortNamesCache cache = PsiShortNamesCache.getInstance(project); PsiClass[] classes = cache.getClassesByName( typeName, new DelegatingGlobalSearchScope(scope) { @Override public boolean contains(@NotNull VirtualFile file) { return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE; } }); return Collections2.transform( Lists.newArrayList(classes), new Function<PsiClass, FqName>() { @Nullable @Override public FqName apply(@Nullable PsiClass javaClass) { assert javaClass != null; return new FqName(javaClass.getQualifiedName()); } }); }
private static Collection<FqName> getJetExtensionFunctions( @NotNull final String referenceName, @NotNull JetSimpleNameExpression expression, @NotNull Project project) { JetShortNamesCache namesCache = JetCacheManager.getInstance(project).getNamesCache(); Collection<DeclarationDescriptor> jetCallableExtensions = namesCache.getJetCallableExtensions( new Condition<String>() { @Override public boolean value(String callableExtensionName) { return callableExtensionName.equals(referenceName); } }, expression, GlobalSearchScope.allScope(project)); return Sets.newHashSet( Collections2.transform( jetCallableExtensions, new Function<DeclarationDescriptor, FqName>() { @Override public FqName apply(@Nullable DeclarationDescriptor declarationDescriptor) { assert declarationDescriptor != null; return DescriptorUtils.getFQName(declarationDescriptor).toSafe(); } })); }
@Override @Transactional(readOnly = true) public List<PropertyValueWithDescriptor> getPropertyValuesWithDescriptor( Entity entity, int entityId) { return Lists.newArrayList( Collections2.filter( Collections2.transform( getPropertyValues(entity, entityId), new Function<PropertyValue, PropertyValueWithDescriptor>() { @Override public PropertyValueWithDescriptor apply(PropertyValue value) { PropertyExtensionDescriptor propertyExtensionDescriptor; try { propertyExtensionDescriptor = extensionManager.getPropertyExtensionDescriptor( value.getExtension(), value.getName()); } catch (PropertyExtensionNotFoundException ex) { propertyExtensionDescriptor = null; } return new PropertyValueWithDescriptor( propertyExtensionDescriptor, value.getValue()); } }), new Predicate<PropertyValueWithDescriptor>() { @Override public boolean apply(PropertyValueWithDescriptor it) { return it.getDescriptor() != null; } })); }
@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + BUNDLES) @Produces(APPLICATION_JSON) public Response getAccountBundles( @PathParam("accountId") final String accountId, @QueryParam(QUERY_EXTERNAL_KEY) final String externalKey, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, SubscriptionApiException { final TenantContext tenantContext = context.createContext(request); final UUID uuid = UUID.fromString(accountId); accountUserApi.getAccountById(uuid, tenantContext); final List<SubscriptionBundle> bundles = (externalKey != null) ? subscriptionApi.getSubscriptionBundlesForAccountIdAndExternalKey( uuid, externalKey, tenantContext) : subscriptionApi.getSubscriptionBundlesForAccountId(uuid, tenantContext); final Collection<BundleJson> result = Collections2.transform( bundles, new Function<SubscriptionBundle, BundleJson>() { @Override public BundleJson apply(final SubscriptionBundle input) { return new BundleJson(input, null, null, null); } }); return Response.status(Status.OK).entity(result).build(); }
/** * @param spec * @param dir */ public static File generateSchema( final BeanModel spec, final String namespaceParam, final File fileOrDir) { final SchemaGenerator gen = newGenerator(fileOrDir); final String namespace = String.format("%s.xml", spec.getCommonNamespace()); final Collection<SchemaElement> elements = Collections2.transform( spec.getDefinitions(), new Function<Definition, SchemaElement>() { @Override public SchemaElement apply(final Definition def) { return new SchemaElement(SchemaContext.getSchemaType(def), SchemaContext.elm(def)); } }); final SchemaContext context = new SchemaContext(spec, namespace, elements); final File schemaFile; // in our case the target directory may actually be the schema file if (fileOrDir.exists() && fileOrDir.isFile()) { schemaFile = fileOrDir; } else { final File subDir = IO.assertDirExists(new File(fileOrDir, namespace.replace('.', '/'))); schemaFile = new File(subDir, "schema.xsd"); } gen.generateFile(context, schemaFile, schemaTemplate); return schemaFile; }
@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + PAYMENT_METHODS) @Produces(APPLICATION_JSON) public Response getPaymentMethods( @PathParam("accountId") final String accountId, @QueryParam(QUERY_PAYMENT_METHOD_PLUGIN_INFO) @DefaultValue("false") final Boolean withPluginInfo, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, PaymentApiException { final TenantContext tenantContext = context.createContext(request); final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), tenantContext); final List<PaymentMethod> methods = paymentApi.getPaymentMethods(account, withPluginInfo, tenantContext); final List<PaymentMethodJson> json = new ArrayList<PaymentMethodJson>( Collections2.transform( methods, new Function<PaymentMethod, PaymentMethodJson>() { @Override public PaymentMethodJson apply(final PaymentMethod input) { return PaymentMethodJson.toPaymentMethodJson(account, input); } })); return Response.status(Status.OK).entity(json).build(); }
@Override public int complete( final String buffer, final int cursor, final List<CharSequence> candidates) { final int idx = buffer.lastIndexOf(SEPARATOR); final Optional<DataSchemaNode> currentNode = getCurrentNode(remoteSchemaContext, buffer); if (currentNode.isPresent() && currentNode.get() instanceof DataNodeContainer) { final Collection<DataSchemaNode> childNodes = ((DataNodeContainer) currentNode.get()).getChildNodes(); final Collection<String> transformed = Collections2.transform( childNodes, new Function<DataSchemaNode, String>() { @Override public String apply(final DataSchemaNode input) { return IOUtil.qNameToKeyString( input.getQName(), mappedModulesNamespace.get(input.getQName().getNamespace()).getLocalName()); } }); fillCandidates(buffer.substring(idx + 1), candidates, transformed); } return idx == -1 ? 0 : idx + 1; }
public static DescribeServicesResponseType describeService(final DescribeServicesType request) { final DescribeServicesResponseType reply = request.getReply(); Topology.touch(request); if (request.getServices().isEmpty()) { final ComponentId compId = (request.getByServiceType() != null) ? ComponentIds.lookup(request.getByServiceType().toLowerCase()) : Empyrean.INSTANCE; final boolean showEventStacks = Boolean.TRUE.equals(request.getShowEventStacks()); final boolean showEvents = Boolean.TRUE.equals(request.getShowEvents()) || showEventStacks; final Function<ServiceConfiguration, ServiceStatusType> transformToStatus = ServiceConfigurations.asServiceStatus(showEvents, showEventStacks); final List<Predicate<ServiceConfiguration>> filters = new ArrayList<Predicate<ServiceConfiguration>>() { { if (request.getByPartition() != null) { Partitions.exists(request.getByPartition()); this.add(Filters.partition(request.getByPartition())); } if (request.getByState() != null) { final Component.State stateFilter = Component.State.valueOf(request.getByState().toUpperCase()); this.add(Filters.state(stateFilter)); } if (!request.getServiceNames().isEmpty()) { this.add(Filters.name(request.getServiceNames())); } this.add(Filters.host(request.getByHost())); this.add( Filters.listAllOrInternal( request.getListAll(), request.getListUserServices(), request.getListInternal())); } }; final Predicate<Component> componentFilter = Filters.componentType(compId); final Predicate<ServiceConfiguration> configPredicate = Predicates.and(filters); List<ServiceConfiguration> replyConfigs = Lists.newArrayList(); for (final Component comp : Components.list()) { if (componentFilter.apply(comp)) { Collection<ServiceConfiguration> acceptedConfigs = Collections2.filter(comp.services(), configPredicate); replyConfigs.addAll(acceptedConfigs); } } ImmutableList<ServiceConfiguration> sortedReplyConfigs = ServiceOrderings.defaultOrdering().immutableSortedCopy(replyConfigs); final Collection<ServiceStatusType> transformedReplyConfigs = Collections2.transform(sortedReplyConfigs, transformToStatus); reply.getServiceStatuses().addAll(transformedReplyConfigs); } else { for (ServiceId s : request.getServices()) { reply.getServiceStatuses().add(TypeMappers.transform(s, ServiceStatusType.class)); } } return reply; }
public Collection<String> getServerNames() { return Collections2.transform( PluginImpl.getInstance().getServers(), new Function<Hypervisor, String>() { public String apply(@Nullable Hypervisor input) { return input.getHypervisorHost(); } }); }
public GroupEventHandlerImpl(FilteredGroupsProvider filteredGroupsProvider) { Preconditions.checkNotNull(filteredGroupsProvider); // filtered groups are treated in a case-insensitive manner. // We convert them all to lowercase for comparison. filteredGroups = ImmutableSet.copyOf( Collections2.transform( filteredGroupsProvider.getGroups(), IdentifierUtils.TO_LOWER_CASE)); }