java.util.LinkedHashSet Java Examples

public DecisionTreeModelInfo getModelInfo(final DecisionTreeRegressionModel decisionTreeModel, final DataFrame df) {
    final DecisionTreeModelInfo treeInfo = new DecisionTreeModelInfo();

    Node rootNode = decisionTreeModel.rootNode();
    treeInfo.setRoot( DecisionNodeAdapterUtils.adaptNode(rootNode));

    final Set<String> inputKeys = new LinkedHashSet<String>();
    inputKeys.add(decisionTreeModel.getFeaturesCol());
    inputKeys.add(decisionTreeModel.getLabelCol());
    treeInfo.setInputKeys(inputKeys);

    final Set<String> outputKeys = new LinkedHashSet<String>();
    outputKeys.add(decisionTreeModel.getPredictionCol());
    treeInfo.setOutputKeys(outputKeys);

    return treeInfo;
}
 

private static Set<ConsumeMediaTypeExpression> parseExpressions(String[] consumes, @Nullable String[] headers) {
	Set<ConsumeMediaTypeExpression> result = new LinkedHashSet<>();
	if (headers != null) {
		for (String header : headers) {
			HeaderExpression expr = new HeaderExpression(header);
			if ("Content-Type".equalsIgnoreCase(expr.name) && expr.value != null) {
				for (MediaType mediaType : MediaType.parseMediaTypes(expr.value)) {
					result.add(new ConsumeMediaTypeExpression(mediaType, expr.isNegated));
				}
			}
		}
	}
	for (String consume : consumes) {
		result.add(new ConsumeMediaTypeExpression(consume));
	}
	return result;
}
 

/**
 * Derives common super class from the super name mapping passed in to the constructor.
 * @param type1 the internal name of a class.
 * @param type2 the internal name of another class.
 * @return the internal name of the common super class of the two given classes
 * @throws NullPointerException if any argument is {@code null}
 */
@Override
protected String getCommonSuperClass(final String type1, final String type2) {
    Validate.notNull(type1);
    Validate.notNull(type2);
    
    infoRepo.getInformation(type1);
    LinkedHashSet<String> type1Hierarchy = flattenHierarchy(type1);
    LinkedHashSet<String> type2Hierarchy = flattenHierarchy(type2);
    
    for (String testType1 : type1Hierarchy) {
        for (String testType2 : type2Hierarchy) {
            if (testType1.equals(testType2)) {
                return testType1;
            }
        }
    }
    
    return "java/lang/Object"; // is this correct behaviour? shouldn't both type1 and type2 ultimately contain Object?
}
 

/** 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 = new LinkedHashSet<>();
  for (ImmutableBitSet bitSet : bitSets) {
    builder.add(Arrays.asList(bitSet, ImmutableBitSet.of()));
  }
  Set<ImmutableBitSet> flattenedBitSets = new LinkedHashSet<>();
  for (List<ImmutableBitSet> o : EnumeratorUtils.product(builder)) {
    flattenedBitSets.add(ImmutableBitSet.union(o));
  }
  return ImmutableList.copyOf(flattenedBitSets);
}
 

/**
 * Adds a listener to the listener provider.
 *
 * @param listener The listener to add.
 *
 * @throws NullPointerException Thrown if the listener object is null.
 * @throws IllegalStateException Thrown if the listener is already managed by the listener
 *         provider.
 */
public void addListener(final T listener) {
  Preconditions.checkNotNull(listener, "Internal Error: Listener cannot be null");

  if (m_listeners == null) {
    synchronized (this) {
      if (m_listeners == null) {
        m_listeners = new LinkedHashSet<WeakReference<T>>();
      }
    }
  }

  synchronized (m_listeners) {
    if (!m_listeners.add(new ComparableReference(listener))) {
      // throw new IllegalStateException(String.format(
      // "Internal Error: Listener '%s' can not be added more than once.", listener));
    }
  }
}
 

/**
 * gets a set of all define and require blocks from a given file.
 *
 * @param file
 * @return
 */
public Set<JSCallExpression> getAllImportBlocks(PsiFile file)
{
    final Set<JSCallExpression> listOfDefinesOrRequiresToVisit = new LinkedHashSet<JSCallExpression>();
    JSRecursiveElementVisitor defineOrRequireVisitor = new JSRecursiveElementVisitor() {
        @Override
        public void visitJSCallExpression(JSCallExpression expression)
        {
            if(expression != null && expression.getMethodExpression() != null &&
                    (expression.getMethodExpression().getText().equals("define") || expression.getMethodExpression().getText().equals("require")))
            {
                listOfDefinesOrRequiresToVisit.add(expression);
            }
            super.visitJSCallExpression(expression);
        }
    };

    file.accept(defineOrRequireVisitor);

    return listOfDefinesOrRequiresToVisit;
}
 

private Set<String> validateExtends(Class<?>[] additionalExtends){
    Class<?> extendTemporal;
    boolean errorValidate = Boolean.FALSE;
    Set<String> additionalExtendsList = new LinkedHashSet<>();
    for (int i = 0; i < additionalExtends.length; i++) {
        extendTemporal = additionalExtends[i];
        SDLogger.addAdditionalExtend(extendTemporal.getName());

        if (!extendTemporal.isInterface()) {
            SDLogger.addError( String.format("'%s' is not a interface!", extendTemporal.getName()));
            errorValidate = Boolean.TRUE;
        } else {
            additionalExtendsList.add(extendTemporal.getName());
        }
    }

    if (errorValidate) {
        return null;
    }

    return additionalExtendsList;
}
 

private static Collection<JInternalFrame> getAllFrames(Container parent) {
    int i, count;
    Collection<JInternalFrame> results = new LinkedHashSet<>();
    count = parent.getComponentCount();
    for (i = 0; i < count; i++) {
        Component next = parent.getComponent(i);
        if (next instanceof JInternalFrame) {
            results.add((JInternalFrame) next);
        } else if (next instanceof JInternalFrame.JDesktopIcon) {
            JInternalFrame tmp = ((JInternalFrame.JDesktopIcon) next).getInternalFrame();
            if (tmp != null) {
                results.add(tmp);
            }
        } else if (next instanceof Container) {
            results.addAll(getAllFrames((Container) next));
        }
    }
    return results;
}
 

@Override
public List<Alleles> getSampleVariants() {
    List<Alleles> sampleVariantAlleles = Collections.unmodifiableList(sampleVariantsProvider.getSampleVariants(this));
    
    if (this.alleles == null) {
        //set alleles here

        LinkedHashSet<Allele> variantAlleles = new LinkedHashSet<Allele>(2);

        for (Alleles alleles2 : sampleVariantAlleles) {
            for (Allele allele : alleles2) {
                if (allele != allele.ZERO) {
                    variantAlleles.add(allele);
                }
            }
        }

        this.alleles = Alleles.createAlleles(new ArrayList<Allele>(variantAlleles));


    }
    return sampleVariantAlleles;
}
 

@Override
public Set<String> getResourcePaths(String path) {
    if (path.startsWith("/")) {
        path = path.substring(1);
    }
    String relativePath = path;

    Pattern pattern;
    if (path.isEmpty()) {
        pattern = Pattern.compile("^((?:META-INF/resources/|)[^/]+(?:/|$))");
    } else {
        pattern = Pattern.compile(String.format("^((?:META-INF/resources/%1$s|%1$s)/[^/]+(?:/|$))", relativePath));
    }


    return startupContext.resources.stream()
        .filter(p -> p.startsWith("META-INF/resources/" + relativePath) || p.startsWith(relativePath))
        .map(p -> {
            Matcher matcher = pattern.matcher(p);
            matcher.find();
            return matcher.group(1);
        })
        .collect(Collectors.toCollection(LinkedHashSet::new));
}
 

private Set<FileObject> computeModuleRoots() {
    Set<FileObject> projectDirectories = new LinkedHashSet<>();
    String[] sourceRoots = sourcePath.getSourceRoots();
    for (String src : sourceRoots) {
        FileObject fo = getFileObject(src);
        if (fo == null) {
            continue;
        }
        Project p = getProject(fo);
        if (p == null) {
            continue;
        }
        projectDirectories.add(p.getProjectDirectory());
    }
    return projectDirectories;
}
 

private LinkedHashSet<Core> convertSolutionsToCores(List<Solution> solutions) {
    LinkedHashSet<Core> cores = new LinkedHashSet<>();
    for (Solution solution: solutions) {
        String comment = solution.getComment();
        Matcher matcher = SIGNAL_PATTERN.matcher(comment);
        String signalName = matcher.find() ? matcher.group(1) : null;
        Core core = new Core(solution.getMainTrace(), solution.getBranchTrace(), signalName);
        boolean isDuplicateCore = cores.contains(core);
        if (!isDuplicateCore) {
            core.setColor(colorGenerator.updateColor());
            cores.add(core);
        }
        if (MpsatVerificationSettings.getDebugCores()) {
            if (signalName == null) {
                LogUtils.logMessage("Encoding conflict:");
            } else {
                LogUtils.logMessage("Encoding conflict for signal '" + signalName + "':");
            }
            LogUtils.logMessage("    Configuration 1: " + solution.getMainTrace());
            LogUtils.logMessage("    Configuration 2: " + solution.getBranchTrace());
            LogUtils.logMessage("    Conflict core" + (isDuplicateCore ? " (duplicate)" : "") + ": " + core);
            LogUtils.logMessage("");
        }
    }
    return cores;
}
 

private void deriveRankingFeatures(RankProfile rankProfile, ModelContext.Properties deployProperties) {
    firstPhaseRanking = rankProfile.getFirstPhaseRanking();
    secondPhaseRanking = rankProfile.getSecondPhaseRanking();
    summaryFeatures = new LinkedHashSet<>(rankProfile.getSummaryFeatures());
    rankFeatures = rankProfile.getRankFeatures();
    rerankCount = rankProfile.getRerankCount();
    matchPhaseSettings = rankProfile.getMatchPhaseSettings();
    numThreadsPerSearch = rankProfile.getNumThreadsPerSearch();
    minHitsPerThread = rankProfile.getMinHitsPerThread();
    numSearchPartitions = rankProfile.getNumSearchPartitions();
    termwiseLimit = rankProfile.getTermwiseLimit().orElse(deployProperties.defaultTermwiseLimit());
    keepRankCount = rankProfile.getKeepRankCount();
    rankScoreDropLimit = rankProfile.getRankScoreDropLimit();
    ignoreDefaultRankFeatures = rankProfile.getIgnoreDefaultRankFeatures();
    rankProperties = new ArrayList<>(rankProfile.getRankProperties());
    derivePropertiesAndSummaryFeaturesFromFunctions(rankProfile.getFunctions());
}
 

@RequiresPermission(permission.CAMERA)
private Set<Integer> getAvailableCameraLensFacing() {
  // Start with all camera directions
  Set<Integer> available = new LinkedHashSet<>(Arrays.asList(LensFacingConverter.values()));

  // If we're bound to a lifecycle, remove unavailable cameras
  if (mCurrentLifecycle != null) {
    if (!hasCameraWithLensFacing(CameraSelector.LENS_FACING_BACK)) {
      available.remove(CameraSelector.LENS_FACING_BACK);
    }

    if (!hasCameraWithLensFacing(CameraSelector.LENS_FACING_FRONT)) {
      available.remove(CameraSelector.LENS_FACING_FRONT);
    }
  }

  return available;
}
 

@Override
public StandardScalerModelInfo getModelInfo(final StandardScalerModel from) {
    final StandardScalerModelInfo modelInfo = new StandardScalerModelInfo();
    modelInfo.setMean(from.mean().toArray());
    modelInfo.setStd(from.std().toArray());
    modelInfo.setWithMean(from.getWithMean());
    modelInfo.setWithStd(from.getWithStd());

    Set<String> inputKeys = new LinkedHashSet<String>();
    inputKeys.add(from.getInputCol());
    modelInfo.setInputKeys(inputKeys);

    Set<String> outputKeys = new LinkedHashSet<String>();
    outputKeys.add(from.getOutputCol());
    modelInfo.setOutputKeys(outputKeys);

    return modelInfo;
}
 

@Override
public OAuth2Authentication extractAuthentication(final Map<String, ?> map) {
  final Map<String, String> parameters = new HashMap<>();
  final Set<String> scope = parseScopes(map);
  final Object principal = map.get("name");
  final Authentication user =
      new UsernamePasswordAuthenticationToken(principal, "N/A", defaultAuthorities);
  final String clientId = (String) map.get(CLIENT_ID);
  parameters.put(CLIENT_ID, clientId);
  final Set<String> resourceIds =
      new LinkedHashSet<>(
          map.containsKey(AUD) ? (Collection<String>) map.get(AUD)
              : Collections.<String>emptySet());
  final OAuth2Request request =
      new OAuth2Request(parameters, clientId, null, true, scope, resourceIds, null, null, null);
  return new OAuth2Authentication(request, user);
}
 

private static Set<String> splitAndFilterString(String delimiter, String value) {
    if (value == null) {
        return SetUtils.of();
    }

    return Stream.of(value.split(Pattern.quote(delimiter)))
            .map(String::trim)
            .filter(FunctionalUtils.not(String::isEmpty))
            .collect(Collectors.toCollection(LinkedHashSet::new));
}
 

private static void addSortedBundle(Bundle bundle, Map<String, Bundle> bundles, LinkedHashSet<Bundle> sortedBundles,
                                    LinkedHashSet<String> dependencyStack) {

    String name = bundle.plugin.getName();
    if (dependencyStack.contains(name)) {
        StringBuilder msg = new StringBuilder("Cycle found in plugin dependencies: ");
        dependencyStack.forEach(s -> {
            msg.append(s);
            msg.append(" -> ");
        });
        msg.append(name);
        throw new IllegalStateException(msg.toString());
    }
    if (sortedBundles.contains(bundle)) {
        // already added this plugin, via a dependency
        return;
    }

    dependencyStack.add(name);
    for (String dependency : bundle.plugin.getExtendedPlugins()) {
        Bundle depBundle = bundles.get(dependency);
        if (depBundle == null) {
            throw new IllegalArgumentException("Missing plugin [" + dependency + "], dependency of [" + name + "]");
        }
        addSortedBundle(depBundle, bundles, sortedBundles, dependencyStack);
        assert sortedBundles.contains(depBundle);
    }
    dependencyStack.remove(name);

    sortedBundles.add(bundle);
}
 

private Map<String, Collection<String>> addProperties(Map<String, Collection<String>> propertiesMap, Properties properties) {
	for (Entry<Object, Object> e : properties.entrySet()) {
		Set<String> s = new LinkedHashSet<>();
		s.add((String) e.getValue());
		propertiesMap.put((String) e.getKey(), s);
	}
	return propertiesMap;
}
 

public void put(final String key, final Iterable<String> values) {
	if (!map.containsKey(key))
		map.put(key, new LinkedHashSet());
	for (final String s : values) {
		map.get(key).add(s);
	}
}
 

public Fetch addDocumentMaskedField(String documentMaskedField) {
	if (documentMaskedFields.isEmpty()) {
		documentMaskedFields = new LinkedHashSet<>();
	}

	documentMaskedFields.add(documentMaskedField);
	return this;
}
 

/**
 * Returns an unmodifiable list of all available {@link CronetProvider}s.
 * The providers are returned in no particular order. Some of the returned
 * providers may be in a disabled state and should be enabled by the invoker.
 * See {@link CronetProvider#isEnabled()}.
 *
 * @return the list of available providers.
 */
public static List<CronetProvider> getAllProviders(Context context) {
    // Use LinkedHashSet to preserve the order and eliminate duplicate providers.
    Set<CronetProvider> providers = new LinkedHashSet<>();
    addCronetProviderFromResourceFile(context, providers);
    addCronetProviderImplByClassName(
            context, PLAY_SERVICES_CRONET_PROVIDER_CLASS, providers, false);
    addCronetProviderImplByClassName(context, GMS_CORE_CRONET_PROVIDER_CLASS, providers, false);
    addCronetProviderImplByClassName(context, NATIVE_CRONET_PROVIDER_CLASS, providers, false);
    addCronetProviderImplByClassName(context, JAVA_CRONET_PROVIDER_CLASS, providers, false);
    return Collections.unmodifiableList(new ArrayList<>(providers));
}
 

/**
 * Remove repeating strings that are appearing in the name.
 * This is done by splitting words (camel case) and using each word once.
 * @param name  The name to compact.
 * @return      The compact name.
 */
public static final String compact(String name) {
    Set<String> parts = new LinkedHashSet<String>();
    for (String part : name.split(SPLITTER_REGEX)) {
        parts.add(part);
    }
    return join(parts,"");
}
 

/**
 * Create a new WebContentGenerator.
 * @param restrictDefaultSupportedMethods {@code true} if this
 * generator should support HTTP methods GET, HEAD and POST by default,
 * or {@code false} if it should be unrestricted
 */
public WebContentGenerator(boolean restrictDefaultSupportedMethods) {
	if (restrictDefaultSupportedMethods) {
		this.supportedMethods = new LinkedHashSet<>(4);
		this.supportedMethods.add(METHOD_GET);
		this.supportedMethods.add(METHOD_HEAD);
		this.supportedMethods.add(METHOD_POST);
	}
	initAllowHeader();
}
 

/** Create a new container cluster for indexing and add it to the Vespa model */
private void createImplicitIndexingCluster(IndexedSearchCluster cluster,
                                           Content content,
                                           ConfigModelContext modelContext,
                                           ApplicationConfigProducerRoot root) {
    String indexerName = cluster.getIndexingClusterName();
    AbstractConfigProducer parent = root.getChildren().get(ContainerModel.DOCPROC_RESERVED_NAME);
    if (parent == null)
        parent = new SimpleConfigProducer(root, ContainerModel.DOCPROC_RESERVED_NAME);
    ApplicationContainerCluster indexingCluster = new ApplicationContainerCluster(parent, "cluster." + indexerName, indexerName, modelContext.getDeployState());
    ContainerModel indexingClusterModel = new ContainerModel(modelContext.withParent(parent).withId(indexingCluster.getSubId()));
    indexingClusterModel.setCluster(indexingCluster);
    modelContext.getConfigModelRepoAdder().add(indexingClusterModel);
    content.ownedIndexingCluster = Optional.of(indexingCluster);

    indexingCluster.addDefaultHandlersWithVip();
    addDocproc(indexingCluster);

    List<ApplicationContainer> nodes = new ArrayList<>();
    int index = 0;
    Set<HostResource> processedHosts = new LinkedHashSet<>();
    for (SearchNode searchNode : cluster.getSearchNodes()) {
        HostResource host = searchNode.getHostResource();
        if (!processedHosts.contains(host)) {
            String containerName = String.valueOf(searchNode.getDistributionKey());
            ApplicationContainer docprocService = new ApplicationContainer(indexingCluster, containerName, index,
                                                                           modelContext.getDeployState().isHosted());
            index++;
            docprocService.useDynamicPorts();
            docprocService.setHostResource(host);
            docprocService.initService(modelContext.getDeployLogger());
            nodes.add(docprocService);
            processedHosts.add(host);
        }
    }
    indexingCluster.addContainers(nodes);

    addIndexingChain(indexingCluster);
    cluster.setIndexingChain(indexingCluster.getDocprocChains().allChains().getComponent(IndexingDocprocChain.NAME));
}
 

private Collection<?> deserializeCollection( ModuleDescriptor module, CollectionType collectionType,
                                             ArrayValue value ) throws IOException
{
    Collection<?> collection = collectionType.isSet() ? new LinkedHashSet( value.size() )
                                                      : new ArrayList( value.size() );
    for( Value element : value.list() )
    {
        collection.add( doDeserialize( module, collectionType.collectedType(), element ) );
    }
    return collection;
}
 

/**
 * Perform a search to find how many documents there are in total and then choose random pages
 * and return a set of the quandl codes containing the first code in each page.  The idea here is to
 * give us a representative sample of the datasets available.
 * @param session the quandll session
 * @param resultProcessor a result processor to either save the results or check them
 * @return a randmly sampled set of quandl codes.
 */
private Set<String> sampleSearch(final ClassicQuandlSessionInterface session, final ResultProcessor resultProcessor) {
  SearchResult result = session.search(SearchRequest.Builder.ofAll().build()); // return all available data sets.
  final int totalDocs = result.getTotalDocuments();
  final int docsPerPage = result.getDocumentsPerPage();
  final int totalPages = totalDocs / docsPerPage;
  Set<String> quandlCodes = new LinkedHashSet<String>();
  for (int i = 0; i < _numRequests; i++) {
    int pageRequired = _random.nextInt(totalPages % MAX_PAGE);
    SearchRequest req = SearchRequest.Builder.ofQuery("").withPageNumber(pageRequired).build();
    System.out.println("About to run " + req);
    int retries = 0;
    SearchResult searchResult = null;
    do {
      try {
        searchResult = session.search(req);
        resultProcessor.processResult(searchResult);
        if (searchResult.getMetaDataResultList().size() > 0) {
          MetaDataResult metaDataResult = searchResult.getMetaDataResultList().get(0);
          if (metaDataResult.getQuandlCode() != null) {
            quandlCodes.add(metaDataResult.getQuandlCode());
          } else {
            s_logger.error("Meta data result (for req {}) returned without embedded Quandl code, result was {}", req, metaDataResult);
          }
        } else {
          s_logger.error("No results on page {}, skipping", pageRequired);
        }
      } catch (QuandlRuntimeException qre) {
        retries++;
      }
    } while (searchResult == null && retries < 1);
    if (searchResult == null) {
      s_logger.error("Giving up on this page request (" + pageRequired + ")");
    }
  }
  return quandlCodes;
}
 

public BaseViewHolder(final View view) {
    super(view);
    this.views = new SparseArray<>();
    this.childClickViewIds = new LinkedHashSet<>();
    this.itemChildLongClickViewIds = new LinkedHashSet<>();
    this.nestViews = new HashSet<>();
    convertView = view;


}
 

private static Collection<String> createRequestSubprotocols(
        Collection<String> subprotocols)
{
    LinkedHashSet<String> sp = new LinkedHashSet<>(subprotocols.size(), 1);
    for (String s : subprotocols) {
        if (s.trim().isEmpty() || !isValidName(s)) {
            throw illegal("Bad subprotocol syntax: " + s);
        }
        if (!sp.add(s)) {
            throw illegal("Duplicating subprotocol: " + s);
        }
    }
    return Collections.unmodifiableCollection(sp);
}
 

private void mockMethod1() throws Exception {
    when(method1Skeleton.getMethodName()).thenReturn(METHOD_1);
    when(method1Skeleton.getMethodArguments(objectClass)).thenReturn(METHOD_1_ARGUMENTS);
    when(method1Skeleton.getMethod(objectClass, data, METHOD1_CONTENT)).thenReturn(METHOD1_FULL_METHOD);
    when(method1.getMethodSkeleton()).thenReturn(method1Skeleton);

    when(method1Content.getLibrariesToImport(data)).thenReturn(new LinkedHashSet<String>());
    when(method1Content.getMethodContent(objectClass, data)).thenReturn(METHOD1_CONTENT);
    when(method1.getMethodContent()).thenReturn(method1Content);
}