private ImmutableTreeSet(SortedSet<T> sortedSet) { this.delegate = (T[]) sortedSet.toArray(); this.comparator = sortedSet.comparator(); }
private SortedSet<DataPoint> applyTopScore(SortedSet<DataPoint> points, int topScore) { SortedSet<DataPoint> s = new TreeSet<>(); DataPoint[] arr = points.toArray(new DataPoint[] {}); for (int i = arr.length - 1; i >= (arr.length - topScore); i--) { s.add(arr[i]); } return s; }
public static <T> ImmutableSortedSet<T> newSet(SortedSet<? super T> set) { return new ImmutableTreeSet<>((T[]) set.toArray(), set.comparator(), true); }
public static <T> ImmutableSortedSet<T> newSet(SortedSet<? super T> set) { return new ImmutableTreeSet<>((T[]) set.toArray(), set.comparator(), true); }
/** * @return a list of region names hosted on the system */ public String[] listAllRegionPaths() { if (distrRegionMap.values().size() == 0) { return ManagementConstants.NO_DATA_STRING; } // Sort region paths SortedSet<String> regionPathsSet = new TreeSet<>(); for (DistributedRegionBridge bridge : distrRegionMap.values()) { regionPathsSet.add(bridge.getFullPath()); } String[] regionPaths = new String[regionPathsSet.size()]; regionPaths = regionPathsSet.toArray(regionPaths); regionPathsSet.clear(); return regionPaths; }
public String[] listSubRegionPaths(boolean recursive) { SortedSet<String> subregionPaths = new TreeSet<String>(); Set<Region<?, ?>> subregions = region.subregions(recursive); for (Region<?, ?> region : subregions) { subregionPaths.add(region.getFullPath()); } return subregionPaths.toArray(new String[subregionPaths.size()]); }
/** * Lists the sub regions of the GemFire {@link Region} represented by this * {@link DistributedRegionMXBean}. If <code>recursive</code> is <code>true</code>, will return * sub-regions by traversing recursively. * * @param recursive if <code>true</code>, recursively traverses to find sub regions. * @return String array of sub region paths */ public String[] listSubRegionPaths(boolean recursive) { String[] subRegionPathsArr = new String[0]; Collection<RegionMXBean> proxies = mapOfProxy.values(); // Need to go through all proxies as different proxies could have different sub-regions if (proxies != null && !proxies.isEmpty()) { SortedSet<String> subRegionPaths = new TreeSet<String>(); for (RegionMXBean regionMXBean : proxies) { String[] listSubRegionPaths = regionMXBean.listSubregionPaths(recursive); subRegionPaths.addAll(Arrays.asList(listSubRegionPaths)); // Little cosly, but how can it be // avoided? } subRegionPathsArr = subRegionPaths.toArray(subRegionPathsArr); } return subRegionPathsArr; }
/** * Factory method to create a transforming sorted set that will transform * existing contents of the specified sorted set. * <p> * If there are any elements already in the set being decorated, they * will be transformed by this method. * Contrast this with {@link #transformingSortedSet(SortedSet, Transformer)}. * * @param <E> the element type * @param set the set to decorate, must not be null * @param transformer the transformer to use for conversion, must not be null * @return a new transformed {@link SortedSet} * @throws NullPointerException if set or transformer is null * @since 4.0 */ public static <E> TransformedSortedSet<E> transformedSortedSet(final SortedSet<E> set, final Transformer<? super E, ? extends E> transformer) { final TransformedSortedSet<E> decorated = new TransformedSortedSet<>(set, transformer); if (set.size() > 0) { @SuppressWarnings("unchecked") // set is type E final E[] values = (E[]) set.toArray(); // NOPMD - false positive for generics set.clear(); for (final E value : values) { decorated.decorated().add(transformer.transform(value)); } } return decorated; }
protected String printMock(List<ServerAndLoad> balancedCluster) { SortedSet<ServerAndLoad> sorted = new TreeSet<>(balancedCluster); ServerAndLoad[] arr = sorted.toArray(new ServerAndLoad[sorted.size()]); StringBuilder sb = new StringBuilder(sorted.size() * 4 + 4); sb.append("{ "); for (int i = 0; i < arr.length; i++) { if (i != 0) { sb.append(" , "); } sb.append(arr[i].getServerName().getHostname()); sb.append(":"); sb.append(arr[i].getLoad()); } sb.append(" }"); return sb.toString(); }
members = (ValueMemberAnalysis[]) m.toArray(members);
LockInfo[] locks = lockSet.toArray(new LockInfo[lockSet.size()]); if(LOG.isTraceEnabled()) { LOG.trace("Locks to check(full): ");
/** * Return the set of {@link PropertyDescriptor}s from the wrapped {@link BeanInfo} * object as well as {@code PropertyDescriptor}s for each non-void returning setter * method found during construction. * @see #ExtendedBeanInfo(BeanInfo) */ public PropertyDescriptor[] getPropertyDescriptors() { return this.propertyDescriptors.toArray(new PropertyDescriptor[this.propertyDescriptors.size()]); }
private static Comparable[] toArray( SortedSet<Comparable> keySet, boolean hasNull) { int size = keySet.size(); if (hasNull) { size++; } Comparable[] keys = keySet.toArray(new Comparable[size]); if (hasNull) { keys[size - 1] = RolapUtil.sqlNullValue; } return keys; }
private static String[] normalizeNames(final String[] names) { SortedSet<String> normalizedNames = new TreeSet<>(); for (String name : names) { normalizedNames.add(name.toUpperCase()); } return normalizedNames.toArray(new String[normalizedNames.size()]); } }
private ComboBox buildCheckstyleVersionComboBox() { SortedSet<String> versions = checkstyleProjectService.getSupportedVersions(); SortedSet<String> reversedVersions = new TreeSet<>(Collections.reverseOrder(versions.comparator())); reversedVersions.addAll(versions); String[] supportedVersions = reversedVersions.toArray(new String[reversedVersions.size()]); return new ComboBox(supportedVersions); }
String[] tags = tagset.toArray(new String[tagset.size()]); StringBuilder sb = new StringBuilder(); int minColumnSize = Integer.MIN_VALUE;
classToInstance.put(t.getClass(), t); orderedTypes = types.toArray(new PDataType[types.size()]);
protected List<MediaTypeDetails> getMediaTypes() { MediaTypeRegistry registry = TikaResource.getConfig().getMediaTypeRegistry(); Map<MediaType, Parser> parsers = ((CompositeParser) TikaResource.getConfig().getParser()).getParsers(); List<MediaTypeDetails> types = new ArrayList<TikaMimeTypes.MediaTypeDetails>(registry.getTypes().size()); for (MediaType type : registry.getTypes()) { MediaTypeDetails details = new MediaTypeDetails(); details.type = type; details.aliases = registry.getAliases(type).toArray(new MediaType[0]); MediaType supertype = registry.getSupertype(type); if (supertype != null && !MediaType.OCTET_STREAM.equals(supertype)) { details.supertype = supertype; } Parser p = parsers.get(type); if (p != null) { if (p instanceof CompositeParser) { p = ((CompositeParser) p).getParsers().get(type); } details.parser = p.getClass().getName(); } types.add(details); } return types; }
private int computeHashCode() { int hash = 42; hash = Util.hash(hash, schemaName); hash = Util.hash(hash, schemaChecksum); hash = Util.hash(hash, cubeName); hash = Util.hash(hash, measureName); for (SegmentColumn col : getSortedColumns()) { hash = Util.hash(hash, col.columnExpression); if (col.values != null) { hash = Util.hashArray(hash, col.values.toArray()); } } for (SegmentColumn col : getSortedRegions()) { hash = Util.hash(hash, col.columnExpression); if (col.values != null) { hash = Util.hashArray(hash, col.values.toArray()); } } hash = Util.hash(hash, compoundPredicates); return hash; }
Entry[] e = entries.toArray(new Entry[0]); for (int i = 0; i < entries.size(); i++) { if (i == e.length - 1 || (e[i].getOutputPosition().getLine() == outputLine