/** * Converts the form field values in the <tt>ffValuesIter</tt> into a caps string. * * @param ffValuesIter the {@link Iterator} containing the form field values. * @param capsBldr a <tt>StringBuilder</tt> to which the caps string representing the form field * values is to be appended */ private static void formFieldValuesToCaps(Iterator<String> ffValuesIter, StringBuilder capsBldr) { SortedSet<String> fvs = new TreeSet<String>(); while (ffValuesIter.hasNext()) fvs.add(ffValuesIter.next()); for (String fv : fvs) capsBldr.append(fv).append('<'); }
/** * Constructs a new instance of {@code TreeSet} containing the elements of the specified SortedSet * and using the same Comparator. * * @param set the SortedSet of elements to add. */ public TreeSet(SortedSet<E> set) { this(set.comparator()); Iterator<E> it = set.iterator(); while (it.hasNext()) { add(it.next()); } }
public static void RetrieveTrainMatrix() { try { BufferedReader flrdr = new BufferedReader( new FileReader("D:\\IR\\Assignment7\\Pytest\\part2\\output\\train_matrix.txt")); String line = ""; int doc_count = 0; while ((line = flrdr.readLine()) != null) { SortedSet<Integer> word_ids = new TreeSet<Integer>(); int val_count = 0; String[] key_value = line.split(" :: "); key_value[1] = key_value[1].substring(1, key_value[1].length() - 2); String[] values = key_value[1].split(","); FeatureNode[] node = new FeatureNode[values.length]; for (String val : values) word_ids.add(Integer.parseInt(val.trim())); for (int val : word_ids) node[val_count++] = new FeatureNode(val, 1); if (spam_docs.contains(key_value[0].trim())) ylable[doc_count] = 1; else ylable[doc_count] = 0; train_matrix[doc_count++] = node; } flrdr.close(); } catch (Exception e) { e.printStackTrace(); System.exit(0); } }
/** * Since the segmentations are disjoint, the total set of differentially expressed segments is the * union of the sets of differentially expressed segments in each segmentation. * * @param c1 * @param c2 * @return */ public SortedSet<DifferentialKey> differentialRegions(int c1, int c2) { SortedSet<DifferentialKey> keys = new TreeSet<DifferentialKey>(); for (InputSegmentation iseg : segmentations) { keys.addAll(differentialRegions(iseg, c1, c2)); } return keys; }
/** * O(N) Determine if this set is equal to other. Two sets are equal if they have exactly the same * elements. The order of the elements does not matter. <br> * pre: none * * @param other the object to compare to this set * @return true if other is a Set and has the same elements as this set */ public boolean equals(Object other) { // Calling object cannot be null so if other is null then the two objects // cannot be equal if (other == null) return false; if (!(other instanceof ISet<?>)) return false; // At this point we KNOW that other is a non-null ISet object ISet<?> otherSet = (ISet<?>) other; // we know E is a Comparable, but we don't know if // otherSet is a SortedSet. // local var of correct type so we only have to cast once SortedSet<?> otherSortedSet; // do we need to create a new SortedSet based on otherSet or is otherSet // really a SortedSet? if (!(otherSet instanceof SortedSet<?>)) return super.equals(otherSet); else otherSortedSet = (SortedSet<?>) otherSet; if (otherSortedSet.size() != this.size()) return false; else { for (int x = 0; x < this.size(); x++) { if (!(this.myCon.get(x).equals(otherSortedSet.myCon.get(x)))) return false; } return true; } }
/** Set the contents of the field selector list. */ private void setupFieldSelector() { fieldListModel.clear(); SortedSet<String> contents = new TreeSet<String>(); for (String s : metaData) { if (s.startsWith(Globals.SELECTOR_META_PREFIX)) { contents.add(s.substring(Globals.SELECTOR_META_PREFIX.length())); } } if (contents.size() == 0) { // if nothing was added, put the default fields (as described in the help) fieldListModel.addElement("author"); fieldListModel.addElement("journal"); fieldListModel.addElement("keywords"); fieldListModel.addElement("publisher"); } else { for (String s : contents) { fieldListModel.addElement(s); } } if (currentField == null) { // if dialog is created for the whole database, // select the first field to avoid confusions in GUI usage fieldList.setSelectedIndex(0); } else { // a specific field has been chosen at the constructur // select this field int i = fieldListModel.indexOf(currentField); if (i != -1) { // field has been found in list, select it fieldList.setSelectedIndex(i); } } }
@SuppressWarnings("EmptyCatchBlock") static void ensureNotDirectlyModifiable(SortedSet<Integer> unmod) { try { unmod.add(4); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } try { unmod.remove(4); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } try { unmod.addAll(Collections.singleton(4)); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } try { Iterator<Integer> iterator = unmod.iterator(); iterator.next(); iterator.remove(); fail("UnsupportedOperationException expected"); } catch (UnsupportedOperationException expected) { } }
public List<Locale> getAvailableLanguages() { Locale[] locales = Locale.getAvailableLocales(); Map<String, Locale> localeMap = new HashMap<String, Locale>(); // remove all variants for (Locale locale : locales) { if (isTranslationsOnly() && !ArrayUtils.contains(config.getAvailableTranslations(), locale.getLanguage())) { continue; } if (localeMap.containsKey(locale.getLanguage()) && locale.getDisplayName().indexOf('(') != -1) { continue; } localeMap.put(locale.getLanguage(), locale); } SortedSet<Locale> localeSet = new TreeSet<Locale>(new LocaleComparator(LocaleComparator.CompareType.LANGUAGE)); for (Locale locale : localeMap.values()) { localeSet.add(locale); } return new ArrayList<Locale>(localeSet); }
/** @tests java.util.TreeSet#add(java.lang.Object) */ public void test_addLjava_lang_Object() { // Test for method boolean java.util.TreeSet.add(java.lang.Object) ts.add(new Integer(-8)); assertTrue("Failed to add Object", ts.contains(new Integer(-8))); ts.add(objArray[0]); assertTrue("Added existing element", ts.size() == objArray.length + 1); }
/** * Gets the unique read groups in the table * * @param report the GATKReport containing the table with RecalUtils.READGROUP_REPORT_TABLE_TITLE * @return the unique read groups */ private static SortedSet<String> getReadGroups(final GATKReport report) { final GATKReportTable reportTable = report.getTable(RecalUtils.READGROUP_REPORT_TABLE_TITLE); final SortedSet<String> readGroups = new TreeSet<String>(); for (int i = 0; i < reportTable.getNumRows(); i++) readGroups.add(reportTable.get(i, RecalUtils.READGROUP_COLUMN_NAME).toString()); return readGroups; }
public String toString() { String s = new String(); SortedSet antecedent = getAntecedent(); Iterator it2 = antecedent.iterator(); SortedSet consequence = getConsequence(); Iterator it3 = consequence.iterator(); while (it2.hasNext()) { String itemCourantant = it2.next().toString(); s = s + (itemCourantant = itemCourantant + " "); } String itemCourantcons; for (s = s + " --> "; it3.hasNext(); s = s + itemCourantcons + " ") itemCourantcons = it3.next().toString(); s = s + "\t\t"; s = s + "(S = "; String sup = Double.toString((double) (int) (getSupport() * 100D) / 100D); s = s + sup; s = s + "% ; "; s = s + "C = "; String c = Double.toString((double) (int) (getConfiance() * 100D) / 100D); s = s + c; s = s + ")"; return s; }
private void bes(Graph graph) { TetradLogger.getInstance().log("info", "** BACKWARD EQUIVALENCE SEARCH"); initializeArrowsBackward(graph); while (!sortedArrows.isEmpty()) { Arrow arrow = sortedArrows.first(); sortedArrows.remove(arrow); Node x = arrow.getX(); Node y = arrow.getY(); clearArrow(x, y); if (!validDelete(arrow.getHOrT(), arrow.getNaYX(), graph)) { continue; } List<Node> h = arrow.getHOrT(); double bump = arrow.getBump(); delete(x, y, h, graph, bump); score += bump; rebuildPattern(graph); storeGraph(graph); initializeArrowsBackward( graph); // Rebuilds Arrows from scratch each time. Fast enough for backwards. } }
@Test public void testCompareByName() throws Exception { final Category cat1 = context.mock(Category.class, "cat1"); final Category cat2 = context.mock(Category.class, "cat2"); context.checking( new Expectations() { { allowing(cat1).getRank(); will(returnValue(0)); allowing(cat1).getName(); will(returnValue("name 2")); allowing(cat1).getCategoryId(); will(returnValue(1L)); allowing(cat2).getRank(); will(returnValue(0)); allowing(cat2).getName(); will(returnValue("name 1")); } }); final SortedSet<Category> set = new TreeSet<Category>(new CategoryRankNameComparator()); set.addAll(Arrays.asList(cat1, cat2)); final List<Category> list = new ArrayList<Category>(set); assertTrue(cat2 == list.get(0)); assertTrue(cat1 == list.get(1)); }
public static void main(String[] args) throws Exception { // TODO Auto-generated method stub Date startTime = new Date(); String fname = "p079_keylog.txt"; FileReader fr = new FileReader(fname); BufferedReader br = new BufferedReader(fr); SortedSet<String> slines = new TreeSet<String>(); String line = ""; while ((line = br.readLine()) != null) { slines.add(line); } String start = slines.first().split("")[0]; String ans = ""; for (String l : slines) { // System.out.println(l); for (String l2 : slines) { if (l2.contains(start) && l2.indexOf(start) > 0) start = l2.split("")[0]; } } ans += start; // System.out.println(ans); for (int i = 0; i < 10; i++) { start = (getNext(slines, start)); if (start == null) break; ans += start; // System.out.println(ans); } Date endTime = new Date(); System.out.println(ans + " in " + (endTime.getTime() - startTime.getTime()) + " ms."); }
static SortedSet<TypeColorEntry> fromPainter(myjava.gui.syntax.Painter painter) { Token.Type[] types = Token.Type.values(); SortedSet<TypeColorEntry> entries = new TreeSet<>(); for (Token.Type type : types) { entries.add(new TypeColorEntry(type, painter.fromType(type))); } return entries; }
public List<File> getAffectedPaths() { final SortedSet<FilePath> set = myIdx.getAffectedPaths(); final List<File> result = new ArrayList<File>(set.size()); for (FilePath path : set) { result.add(path.getIOFile()); } return result; }
@Override protected Integer detectCurrentVersionNumber() throws IOException { SortedSet<CueballFilePath> localBases = Cueball.getBases(localPartitionRoot); if (localBases.size() > 0) { return localBases.last().getVersion(); } else { return null; } }
private Set<Sector> getNeighbors(Sector[] sectors) { SortedSet<Sector> neighbors = new TreeSet<Sector>(ELEMENT_ORDER); for (Sector s : sectors) { if (s != null) { neighbors.add(s); } } return neighbors; }
/** @return the repeatable scripts that failed during the last database update */ protected SortedSet<ExecutedScript> getRepeatableScriptsThatFailedDuringLastUpdate() { SortedSet<ExecutedScript> failedExecutedScripts = new TreeSet<ExecutedScript>(); for (ExecutedScript script : executedScriptInfoSource.getExecutedScripts()) { if (!script.isSuccessful() && script.getScript().isRepeatable()) { failedExecutedScripts.add(script); } } return failedExecutedScripts; }
/** @tests java.util.TreeSet#iterator() */ public void test_iterator() { // Test for method java.util.Iterator java.util.TreeSet.iterator() SortedSet s = db.createTreeSet("test"); s.addAll(ts); Iterator i = ts.iterator(); Set as = new HashSet(Arrays.asList(objArray)); while (i.hasNext()) as.remove(i.next()); assertEquals("Returned incorrect iterator", 0, as.size()); }
@Test public void simpleQueryWithRangeTombstoneTest() throws Exception { Table table = Table.open(KSNAME); ColumnFamilyStore cfs = table.getColumnFamilyStore(CFNAME); // Inserting data String key = "k1"; RowMutation rm; ColumnFamily cf; rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); for (int i = 0; i < 40; i += 2) add(rm, i, 0); rm.apply(); cfs.forceBlockingFlush(); rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); cf = rm.addOrGet(CFNAME); delete(cf, 10, 22, 1); rm.apply(); cfs.forceBlockingFlush(); rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); for (int i = 1; i < 40; i += 2) add(rm, i, 2); rm.apply(); cfs.forceBlockingFlush(); rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); cf = rm.addOrGet(CFNAME); delete(cf, 19, 27, 3); rm.apply(); // We don't flush to test with both a range tomsbtone in memtable and in sstable QueryPath path = new QueryPath(CFNAME); // Queries by name int[] live = new int[] {4, 9, 11, 17, 28}; int[] dead = new int[] {12, 19, 21, 24, 27}; SortedSet<ByteBuffer> columns = new TreeSet<ByteBuffer>(cfs.getComparator()); for (int i : live) columns.add(b(i)); for (int i : dead) columns.add(b(i)); cf = cfs.getColumnFamily(QueryFilter.getNamesFilter(dk(key), path, columns)); for (int i : live) assert isLive(cf, cf.getColumn(b(i))) : "Column " + i + " should be live"; for (int i : dead) assert !isLive(cf, cf.getColumn(b(i))) : "Column " + i + " shouldn't be live"; // Queries by slices cf = cfs.getColumnFamily( QueryFilter.getSliceFilter(dk(key), path, b(7), b(30), false, Integer.MAX_VALUE)); for (int i : new int[] {7, 8, 9, 11, 13, 15, 17, 28, 29, 30}) assert isLive(cf, cf.getColumn(b(i))) : "Column " + i + " should be live"; for (int i : new int[] {10, 12, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}) assert !isLive(cf, cf.getColumn(b(i))) : "Column " + i + " shouldn't be live"; }
/** * The earliest start date of this research staff. * * @return the active date */ @Transient public Date getActiveDate() { SortedSet<Date> dates = new TreeSet<Date>(); for (SiteResearchStaff srs : this.getSiteResearchStaffs()) { Date activeDate = srs.getActiveDate(); if (activeDate != null) dates.add(activeDate); } if (dates.size() > 0) return dates.first(); else return null; }
public static IFilter getFilter(SlicePredicate predicate, AbstractType<?> comparator) { if (predicate.column_names != null) { final SortedSet<ByteBuffer> columnNameSet = new TreeSet<ByteBuffer>(comparator); columnNameSet.addAll(predicate.column_names); return new NamesQueryFilter(columnNameSet); } SliceRange range = predicate.slice_range; return new SliceQueryFilter(range.start, range.finish, range.reversed, range.count); }
// assumes o is in satisfiers \ exceptions private int getIndexInPOPApp(ObjectSet satisfiers, Set exceptions, Object o) { SortedSet exceptionIndices = new TreeSet(); for (Iterator iter = exceptions.iterator(); iter.hasNext(); ) { Object exception = iter.next(); exceptionIndices.add(new Integer(satisfiers.indexOf(exception))); } int origIndex = satisfiers.indexOf(o); int numExceptionsBefore = exceptionIndices.headSet(new Integer(origIndex)).size(); return (origIndex - numExceptionsBefore); }
@Override public Map<Class<?>, Set<EventHandler>> findAllSubscribers(Object listener) { Map<Class<?>, Set<EventHandler>> found = HandlerFinder.ANNOTATED.findAllSubscribers(listener); Map<Class<?>, Set<EventHandler>> sorted = new HashMap<Class<?>, Set<EventHandler>>(); for (Map.Entry<Class<?>, Set<EventHandler>> entry : found.entrySet()) { SortedSet<EventHandler> handlers = new TreeSet<EventHandler>(handlerComparator); handlers.addAll(entry.getValue()); sorted.put(entry.getKey(), handlers); } return sorted; }
/** * Returns a new {@link GapAwareTrackingToken} instance based on the given {@code index} and * collection of {@code gaps}. * * @param index the highest global sequence number of events up until (and including) this * tracking token * @param gaps global sequence numbers of events that have not been seen yet even though these * sequence numbers are smaller than the current index. These missing sequence numbers may be * filled in later when those events get committed to the store or may never be filled in if * those events never get committed. * @return a new tracking token from given index and gaps */ public static GapAwareTrackingToken newInstance(long index, Collection<Long> gaps) { if (gaps.isEmpty()) { return new GapAwareTrackingToken(index, Collections.emptySortedSet()); } SortedSet<Long> gapSet = new TreeSet<>(gaps); Assert.isTrue( gapSet.last() < index, () -> String.format( "Gap indices [%s] should all be smaller than head index [%d]", gaps, index)); return new GapAwareTrackingToken(index, gapSet); }
private String privilegesAsString(Set<Privilege> privileges) { SortedSet<Privilege> sortedPrivileges = new TreeSet<Privilege>( new Comparator<Privilege>() { @Override public int compare(Privilege p1, Privilege p2) { return p1.ordinal() - p2.ordinal(); } }); sortedPrivileges.addAll(privileges); return sortedPrivileges.toString().replaceAll(" ", ""); }
private SSLContext createSSLContext(LDAPConnectionHandlerCfg config) throws DirectoryException { try { DN keyMgrDN = config.getKeyManagerProviderDN(); KeyManagerProvider<?> keyManagerProvider = DirectoryServer.getKeyManagerProvider(keyMgrDN); if (keyManagerProvider == null) { logger.error(ERR_NULL_KEY_PROVIDER_MANAGER, keyMgrDN, friendlyName); disableAndWarnIfUseSSL(config); keyManagerProvider = new NullKeyManagerProvider(); // The SSL connection is unusable without a key manager provider } else if (!keyManagerProvider.containsAtLeastOneKey()) { logger.error(ERR_INVALID_KEYSTORE, friendlyName); disableAndWarnIfUseSSL(config); } final SortedSet<String> aliases = new TreeSet<>(config.getSSLCertNickname()); final KeyManager[] keyManagers; if (aliases.isEmpty()) { keyManagers = keyManagerProvider.getKeyManagers(); } else { final Iterator<String> it = aliases.iterator(); while (it.hasNext()) { if (!keyManagerProvider.containsKeyWithAlias(it.next())) { logger.error(ERR_KEYSTORE_DOES_NOT_CONTAIN_ALIAS, aliases, friendlyName); it.remove(); } } if (aliases.isEmpty()) { disableAndWarnIfUseSSL(config); } keyManagers = SelectableCertificateKeyManager.wrap( keyManagerProvider.getKeyManagers(), aliases, friendlyName); } DN trustMgrDN = config.getTrustManagerProviderDN(); TrustManagerProvider<?> trustManagerProvider = DirectoryServer.getTrustManagerProvider(trustMgrDN); if (trustManagerProvider == null) { trustManagerProvider = new NullTrustManagerProvider(); } SSLContext sslContext = SSLContext.getInstance(SSL_CONTEXT_INSTANCE_NAME); sslContext.init(keyManagers, trustManagerProvider.getTrustManagers(), null); return sslContext; } catch (Exception e) { logger.traceException(e); ResultCode resCode = DirectoryServer.getServerErrorResultCode(); LocalizableMessage message = ERR_CONNHANDLER_SSL_CANNOT_INITIALIZE.get(getExceptionMessage(e)); throw new DirectoryException(resCode, message, e); } }
@Test public void initConstructor() { WatchListItem watchListItem1 = new WatchListItem("AAPL"); WatchListItem watchListItem2 = new WatchListItem("ORCL"); SortedSet<WatchListItem> techList = new TreeSet<WatchListItem>(); techList.add(watchListItem1); techList.add(watchListItem2); WatchList watchList = new WatchList("technology", techList); watchList.getItems().add(watchListItem1); watchList.getItems().add(watchListItem2); }
/** * Returns all supported sample rates. * * @return an array of sample rates, in Hertz, never <code>null</code>. */ public Integer[] getSampleRates() { final String rawValue = this.properties.get(DEVICE_SAMPLERATES); final String[] values = rawValue.split(",\\s*"); final SortedSet<Integer> result = new TreeSet<Integer>( NumberUtils.<Integer>createNumberComparator(false /* aSortAscending */)); for (String value : values) { result.add(Integer.valueOf(value.trim())); } return result.toArray(new Integer[result.size()]); }