public Set<String> rolesThatCanOperateOnStage( CruiseConfig cruiseConfig, PipelineConfig pipelineConfig) { PipelineConfigs group = cruiseConfig.findGroupOfPipeline(pipelineConfig); SortedSet<String> roles = new TreeSet<String>(); if (group.hasAuthorizationDefined()) { if (group.hasOperationPermissionDefined()) { roles.addAll(group.getOperateRoleNames()); } } else { roles.addAll(allRoleNames(cruiseConfig)); } return roles; }
static { final SortedSet<String> ecmds = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); ecmds.addAll(Arrays.asList("exit", "done", "quit", "end", "fino")); EXIT_COMMANDS = Collections.unmodifiableSortedSet(ecmds); final SortedSet<String> hcmds = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER); hcmds.addAll(Arrays.asList("help", "helpi", "?")); HELP_COMMANDS = Collections.unmodifiableSet(hcmds); DATE_PATTERN = Pattern.compile("\\d{4}([-\\/])\\d{2}\\1\\d{2}"); // http://regex101.com/r/xB8dR3/1 HELP_MESSAGE = format( "Please enter some data or enter one of the following commands to exit %s", EXIT_COMMANDS); }
@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) { } }
@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)); }
/** * 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; }
@Override public void addAllToDownloadChapter(final Collection<Chapter> chapters) { LOG.trace("Add chapters to download [Chapters=" + chapters + "]"); toDownloadChapters.addAll(chapters); changes.firePropertyChange( ModelProperties.CHAPTER_TO_DOWNLOAD.getPropertyName(), null, toDownloadChapters); }
/** * Constructor * * @param compiledResults is a Map from questions to Pair of predicted response and response * probabilities * @param responseCategories is a sorted set of holding response categories */ public Results( Map<TypeQ, Pair<TypeR, Map<TypeR, Double>>> compiledResults, Set<TypeR> responseCategories) { this.compiledResults = compiledResults; this.responseCategories = responseCategories; sortedQuestions = new TreeSet<TypeQ>(); sortedQuestions.addAll(compiledResults.keySet()); }
/** @tests java.util.TreeSet#addAll(java.util.Collection) */ public void test_addAllLjava_util_Collection() { // Test for method boolean // java.util.TreeSet.addAll(java.util.Collection) SortedSet s = db.createTreeSet("test"); s.addAll(ts); assertTrue("Incorrect size after add", s.size() == ts.size()); Iterator i = ts.iterator(); while (i.hasNext()) assertTrue("Returned incorrect set", s.contains(i.next())); }
/** @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()); }
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); }
public Set<String> usersThatCanOperateOnStage( CruiseConfig cruiseConfig, PipelineConfig pipelineConfig) { SortedSet<String> users = new TreeSet<String>(); PipelineConfigs group = cruiseConfig.findGroupOfPipeline(pipelineConfig); if (group.hasAuthorizationDefined()) { if (group.hasOperationPermissionDefined()) { users.addAll(group.getOperateUserNames()); List<String> roles = group.getOperateRoleNames(); for (Role role : cruiseConfig.server().security().getRoles()) { if (roles.contains(CaseInsensitiveString.str(role.getName()))) { users.addAll(role.usersOfRole()); } } } } else { users.addAll(allUsernames()); } return users; }
@Override protected SortedSet<Long> compute() { SortedSet<Long> index = new TreeSet<>(); try { if (length < threshold) { BufferedAccessFile raf = null; try { raf = new BufferedAccessFile(file, "r"); raf.seek(start); // Add the position for 1st line if (raf.getFilePointer() == 0L) { index.add(raf.getFilePointer()); } while (raf.getFilePointer() < end) { raf.getNextLine(); index.add(raf.getFilePointer()); } } finally { if (raf != null) { raf.close(); } } } else { long start1 = start; long end1 = start + (length / 2); long end2 = end; IndexingTask task1 = new IndexingTask(file, start1, end1, threshold); task1.fork(); IndexingTask task2 = new IndexingTask(file, end1, end2, threshold); index.addAll(task2.compute()); index.addAll(task1.join()); } } catch (IOException ex) { throw new FileReaderException("Error while index file:" + ex.getMessage(), ex); } return index; }
@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; }
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(" ", ""); }
public ParseStoredExpr(Map<String, Map<String, Double>> stored) { storedExpr = stored; SortedSet<String> exptNameSet = new TreeSet<String>(storedExpr.keySet()); SortedSet<String> orfNameSet = new TreeSet<String>(); exptNames = new String[exptNameSet.size()]; int i = 0; for (String exptName : exptNameSet) { exptNames[i++] = exptName; System.out.println(i + ": " + exptNames[i - 1] + " (" + exptName + ")"); orfNameSet.addAll(storedExpr.get(exptName).keySet()); } orfs = new String[orfNameSet.size()]; i = 0; for (String orfName : orfNameSet) { orfs[i++] = orfName; } }
/** @tests java.util.TreeSet#TreeSet(java.util.SortedSet) */ public void test_ConstructorLjava_util_SortedSet() { // Test for method java.util.TreeSet(java.util.SortedSet) ReversedIntegerComparator comp = new ReversedIntegerComparator(); SortedSet myTreeSet = db.createTreeSet("test", comp, null); for (int i = 0; i < objArray.length; i++) myTreeSet.add(objArray[i]); SortedSet anotherTreeSet = db.getTreeSet("test"); anotherTreeSet.addAll(myTreeSet); assertTrue("TreeSet is not correct size", anotherTreeSet.size() == objArray.length); for (int counter = 0; counter < objArray.length; counter++) assertTrue( "TreeSet does not contain correct elements", anotherTreeSet.contains(objArray[counter])); assertEquals( "TreeSet does not answer correct comparator", anotherTreeSet.comparator().getClass(), comp.getClass()); assertEquals( "TreeSet does not use comparator", anotherTreeSet.first(), objArray[objArray.length - 1]); }
/** * Does this match? * * @param token The current token * @param no The token number * @param stack The fork stack... may be used if there are partial matches * @param lookBackStack The reverse stack (ignored) */ public TypeExpr matches(Token token, int no, Stack<MatchFork> stack, List<Token> lookBackStack) { if (matches == null) { if (set) { matches = new TreeSet<WordListEntry>(); WordListSet wls = WordListSet.getWordListSetByName(wordListName); if (wls == null) { throw new IllegalArgumentException("Cannot find word list set %" + wordListName); } for (Map.Entry<String, WordList> entry : wls.getWordListSets()) { matches.addAll(WordListSet.getMatchSet(entry.getKey(), token.termText().toLowerCase())); } // currentMatch = wls.getEntry(token.termText().toLowerCase()); currentMatch = new WordListEntry(new LinkedList<String>()); currentMatch.addWord(token.term().toLowerCase()); } else { matches = new TreeSet<WordListEntry>( WordListSet.getMatchSet(wordListName, token.termText().toLowerCase())); // currentMatch = // WordListSet.getWordListSetByList(wordListName).getEntry(token.termText().toLowerCase()); currentMatch = new WordListEntry(new LinkedList<String>()); currentMatch.addWord(token.term().toLowerCase()); } } else { currentMatch.addWord(token.termText().toLowerCase()); } MatchFork mf = MatchFork.find(stack, no, this); if (mf != null && (mf.used == true || stack.peek() == mf)) { stack.peek().split(no, this); return this; } Iterator<WordListEntry> wleIter = matches.iterator(); while (wleIter.hasNext()) { WordListEntry wle = wleIter.next(); if (wle.equals(currentMatch)) { if (matches.size() > 1 && (stack.empty() || stack.peek().tokenNo < no)) stack.push(new MatchFork(no, this)); return next; } if (!wle.matchable(currentMatch)) wleIter.remove(); } if (matches.isEmpty()) return null; else return this; }
private SargIntervalSequence evaluateUnion(List<SargIntervalSequence> list) { SargIntervalSequence seq = new SargIntervalSequence(); // Toss all entries from each sequence in the list into one big sorted // set. SortedSet<SargInterval> intervals = new TreeSet<SargInterval>(new IntervalComparator()); for (SargIntervalSequence childSeq : list) { intervals.addAll(childSeq.getList()); } // Now, overlapping ranges are consecutive in the set. Merge them by // increasing the upper bound of the first; discard the others. In the // example, [4, 6] and [5, 7) are combined to form [4, 7). (7, 8] is // not merged with the new range because neither range contains the // value 7. // // Input: // 1 2 3 4 5 6 7 8 9 // 1 [1, 3] [-----] // 2 [4, 6] [-----] // 3 [5, 7) [-----) // 4 (7, 8] (--] // // Output: // 1 [1, 3] [-----] // 2 [4, 7) [--------) // 3 (7, 8] (--] SargInterval accumulator = null; for (SargInterval interval : intervals) { // Empty intervals should have been previously filtered out. assert (!interval.isEmpty()); if (accumulator == null) { // The very first interval: start accumulating. accumulator = new SargInterval(factory, getDataType()); accumulator.copyFrom(interval); seq.addInterval(accumulator); continue; } if (accumulator.contains(interval)) { // Just drop new interval because it's already covered // by accumulator. continue; } // Test for overlap. int c = interval.getLowerBound().compareTo(accumulator.getUpperBound()); // If no overlap, test for touching instead. if (c > 0) { if (interval.getLowerBound().isTouching(accumulator.getUpperBound())) { // Force test below to pass. c = -1; } } if (c <= 0) { // Either touching or overlap: grow the accumulator. accumulator.upperBound.copyFrom(interval.getUpperBound()); } else { // Disjoint: start accumulating a new interval accumulator = new SargInterval(factory, getDataType()); accumulator.copyFrom(interval); seq.addInterval(accumulator); } } return seq; }
public void addAll(Object elements[]) { Collection c = Arrays.asList(elements); m_Models.addAll(c); fireContentsChanged(this, 0, getSize()); }
private IndexIterationContext createContext( int nDocs, RandomIndexWriter fromWriter, RandomIndexWriter toWriter, boolean multipleValuesPerDocument, boolean scoreDocsInOrder) throws IOException { IndexIterationContext context = new IndexIterationContext(); int numRandomValues = nDocs / 2; context.randomUniqueValues = new String[numRandomValues]; Set<String> trackSet = new HashSet<String>(); context.randomFrom = new boolean[numRandomValues]; for (int i = 0; i < numRandomValues; i++) { String uniqueRandomValue; do { uniqueRandomValue = _TestUtil.randomRealisticUnicodeString(random()); // uniqueRandomValue = _TestUtil.randomSimpleString(random); } while ("".equals(uniqueRandomValue) || trackSet.contains(uniqueRandomValue)); // Generate unique values and empty strings aren't allowed. trackSet.add(uniqueRandomValue); context.randomFrom[i] = random().nextBoolean(); context.randomUniqueValues[i] = uniqueRandomValue; } RandomDoc[] docs = new RandomDoc[nDocs]; for (int i = 0; i < nDocs; i++) { String id = Integer.toString(i); int randomI = random().nextInt(context.randomUniqueValues.length); String value = context.randomUniqueValues[randomI]; Document document = new Document(); document.add(newTextField(random(), "id", id, Field.Store.NO)); document.add(newTextField(random(), "value", value, Field.Store.NO)); boolean from = context.randomFrom[randomI]; int numberOfLinkValues = multipleValuesPerDocument ? 2 + random().nextInt(10) : 1; docs[i] = new RandomDoc(id, numberOfLinkValues, value, from); for (int j = 0; j < numberOfLinkValues; j++) { String linkValue = context.randomUniqueValues[random().nextInt(context.randomUniqueValues.length)]; docs[i].linkValues.add(linkValue); if (from) { if (!context.fromDocuments.containsKey(linkValue)) { context.fromDocuments.put(linkValue, new ArrayList<RandomDoc>()); } if (!context.randomValueFromDocs.containsKey(value)) { context.randomValueFromDocs.put(value, new ArrayList<RandomDoc>()); } context.fromDocuments.get(linkValue).add(docs[i]); context.randomValueFromDocs.get(value).add(docs[i]); document.add(newTextField(random(), "from", linkValue, Field.Store.NO)); } else { if (!context.toDocuments.containsKey(linkValue)) { context.toDocuments.put(linkValue, new ArrayList<RandomDoc>()); } if (!context.randomValueToDocs.containsKey(value)) { context.randomValueToDocs.put(value, new ArrayList<RandomDoc>()); } context.toDocuments.get(linkValue).add(docs[i]); context.randomValueToDocs.get(value).add(docs[i]); document.add(newTextField(random(), "to", linkValue, Field.Store.NO)); } } final RandomIndexWriter w; if (from) { w = fromWriter; } else { w = toWriter; } w.addDocument(document); if (random().nextInt(10) == 4) { w.commit(); } if (VERBOSE) { System.out.println("Added document[" + docs[i].id + "]: " + document); } } // Pre-compute all possible hits for all unique random values. On top of this also compute all // possible score for // any ScoreMode. IndexSearcher fromSearcher = newSearcher(fromWriter.getReader()); IndexSearcher toSearcher = newSearcher(toWriter.getReader()); for (int i = 0; i < context.randomUniqueValues.length; i++) { String uniqueRandomValue = context.randomUniqueValues[i]; final String fromField; final String toField; final Map<String, Map<Integer, JoinScore>> queryVals; if (context.randomFrom[i]) { fromField = "from"; toField = "to"; queryVals = context.fromHitsToJoinScore; } else { fromField = "to"; toField = "from"; queryVals = context.toHitsToJoinScore; } final Map<BytesRef, JoinScore> joinValueToJoinScores = new HashMap<BytesRef, JoinScore>(); if (multipleValuesPerDocument) { fromSearcher.search( new TermQuery(new Term("value", uniqueRandomValue)), new Collector() { private Scorer scorer; private SortedSetDocValues docTermOrds; final BytesRef joinValue = new BytesRef(); @Override public void collect(int doc) throws IOException { docTermOrds.setDocument(doc); long ord; while ((ord = docTermOrds.nextOrd()) != SortedSetDocValues.NO_MORE_ORDS) { docTermOrds.lookupOrd(ord, joinValue); JoinScore joinScore = joinValueToJoinScores.get(joinValue); if (joinScore == null) { joinValueToJoinScores.put( BytesRef.deepCopyOf(joinValue), joinScore = new JoinScore()); } joinScore.addScore(scorer.score()); } } @Override public void setNextReader(AtomicReaderContext context) throws IOException { docTermOrds = FieldCache.DEFAULT.getDocTermOrds(context.reader(), fromField); } @Override public void setScorer(Scorer scorer) { this.scorer = scorer; } @Override public boolean acceptsDocsOutOfOrder() { return false; } }); } else { fromSearcher.search( new TermQuery(new Term("value", uniqueRandomValue)), new Collector() { private Scorer scorer; private BinaryDocValues terms; private Bits docsWithField; private final BytesRef spare = new BytesRef(); @Override public void collect(int doc) throws IOException { terms.get(doc, spare); BytesRef joinValue = spare; if (joinValue.length == 0 && !docsWithField.get(doc)) { return; } JoinScore joinScore = joinValueToJoinScores.get(joinValue); if (joinScore == null) { joinValueToJoinScores.put( BytesRef.deepCopyOf(joinValue), joinScore = new JoinScore()); } joinScore.addScore(scorer.score()); } @Override public void setNextReader(AtomicReaderContext context) throws IOException { terms = FieldCache.DEFAULT.getTerms(context.reader(), fromField, true); docsWithField = FieldCache.DEFAULT.getDocsWithField(context.reader(), fromField); } @Override public void setScorer(Scorer scorer) { this.scorer = scorer; } @Override public boolean acceptsDocsOutOfOrder() { return false; } }); } final Map<Integer, JoinScore> docToJoinScore = new HashMap<Integer, JoinScore>(); if (multipleValuesPerDocument) { if (scoreDocsInOrder) { AtomicReader slowCompositeReader = SlowCompositeReaderWrapper.wrap(toSearcher.getIndexReader()); Terms terms = slowCompositeReader.terms(toField); if (terms != null) { DocsEnum docsEnum = null; TermsEnum termsEnum = null; SortedSet<BytesRef> joinValues = new TreeSet<BytesRef>(BytesRef.getUTF8SortedAsUnicodeComparator()); joinValues.addAll(joinValueToJoinScores.keySet()); for (BytesRef joinValue : joinValues) { termsEnum = terms.iterator(termsEnum); if (termsEnum.seekExact(joinValue)) { docsEnum = termsEnum.docs(slowCompositeReader.getLiveDocs(), docsEnum, DocsEnum.FLAG_NONE); JoinScore joinScore = joinValueToJoinScores.get(joinValue); for (int doc = docsEnum.nextDoc(); doc != DocIdSetIterator.NO_MORE_DOCS; doc = docsEnum.nextDoc()) { // First encountered join value determines the score. // Something to keep in mind for many-to-many relations. if (!docToJoinScore.containsKey(doc)) { docToJoinScore.put(doc, joinScore); } } } } } } else { toSearcher.search( new MatchAllDocsQuery(), new Collector() { private SortedSetDocValues docTermOrds; private final BytesRef scratch = new BytesRef(); private int docBase; @Override public void collect(int doc) throws IOException { docTermOrds.setDocument(doc); long ord; while ((ord = docTermOrds.nextOrd()) != SortedSetDocValues.NO_MORE_ORDS) { docTermOrds.lookupOrd(ord, scratch); JoinScore joinScore = joinValueToJoinScores.get(scratch); if (joinScore == null) { continue; } Integer basedDoc = docBase + doc; // First encountered join value determines the score. // Something to keep in mind for many-to-many relations. if (!docToJoinScore.containsKey(basedDoc)) { docToJoinScore.put(basedDoc, joinScore); } } } @Override public void setNextReader(AtomicReaderContext context) throws IOException { docBase = context.docBase; docTermOrds = FieldCache.DEFAULT.getDocTermOrds(context.reader(), toField); } @Override public boolean acceptsDocsOutOfOrder() { return false; } @Override public void setScorer(Scorer scorer) {} }); } } else { toSearcher.search( new MatchAllDocsQuery(), new Collector() { private BinaryDocValues terms; private int docBase; private final BytesRef spare = new BytesRef(); @Override public void collect(int doc) { terms.get(doc, spare); JoinScore joinScore = joinValueToJoinScores.get(spare); if (joinScore == null) { return; } docToJoinScore.put(docBase + doc, joinScore); } @Override public void setNextReader(AtomicReaderContext context) throws IOException { terms = FieldCache.DEFAULT.getTerms(context.reader(), toField, false); docBase = context.docBase; } @Override public boolean acceptsDocsOutOfOrder() { return false; } @Override public void setScorer(Scorer scorer) {} }); } queryVals.put(uniqueRandomValue, docToJoinScore); } fromSearcher.getIndexReader().close(); toSearcher.getIndexReader().close(); return context; }
private void init(Set<SessionDataDto> chosenSessions, int width) { int colWidth = calculateWidth(chosenSessions.size(), width); treeStore.clear(); List<ColumnConfig<TreeItem, ?>> columns = new ArrayList<ColumnConfig<TreeItem, ?>>(); // sort sessions by number sessionId SortedSet<SessionDataDto> sortedSet = new TreeSet<SessionDataDto>( new Comparator<SessionDataDto>() { @Override public int compare(SessionDataDto o, SessionDataDto o2) { return (Long.parseLong(o.getSessionId()) - Long.parseLong(o2.getSessionId())) > 0 ? 1 : -1; } }); sortedSet.addAll(chosenSessions); ColumnConfig<TreeItem, String> nameColumn = new ColumnConfig<TreeItem, String>( new MapValueProvider(NAME), (int) (colWidth * METRIC_COLUMN_WIDTH_FACTOR)); nameColumn.setHeader(METRIC); nameColumn.setSortable(false); nameColumn.setMenuDisabled(true); columns.add(nameColumn); for (SessionDataDto session : sortedSet) { ColumnConfig<TreeItem, String> column = new ColumnConfig<TreeItem, String>( new MapValueProvider(SESSION_HEADER + session.getSessionId())); column.setHeader(SESSION_HEADER + session.getSessionId()); column.setWidth(colWidth); column.setSortable(false); column.setCell( new AbstractCell<String>() { @Override public void render(Context context, String value, SafeHtmlBuilder sb) { if (value != null) { sb.appendHtmlConstant(value); } } }); column.setMenuDisabled(true); column.setColumnTextStyle( new SafeStyles() { @Override public String asString() { return WHITE_SPACE_NORMAL; } }); columns.add(column); } ColumnModel<TreeItem> cm = new ColumnModel<TreeItem>(columns); treeGrid = new NoIconsTreeGrid(treeStore, cm, nameColumn); treeGrid.addBeforeCollapseHandler( new BeforeCollapseItemEvent.BeforeCollapseItemHandler<TreeItem>() { @Override public void onBeforeCollapse(BeforeCollapseItemEvent<TreeItem> event) { event.setCancelled(true); } }); treeGrid.setAutoExpand(true); treeGrid.getView().setStripeRows(true); treeGrid.setMinColumnWidth(MIN_COLUMN_WIDTH); treeGrid.setAllowTextSelection(true); treeGrid.getView().setForceFit(true); treeStore.addStoreAddHandler( new StoreAddEvent.StoreAddHandler<TreeItem>() { @Override public void onAdd(StoreAddEvent<TreeItem> event) { for (TreeItem item : event.getItems()) { treeGrid.setExpanded(item, true); } } }); if (webClientProperties.isUserCommentEditAvailable()) { treeGrid.addCellDoubleClickHandler( new CellDoubleClickEvent.CellDoubleClickHandler() { @Override public void onCellClick(CellDoubleClickEvent event) { TreeItem item = treeGrid.findNode(treeGrid.getTreeView().getRow(event.getRowIndex())).getModel(); if (item.getKey().equals(USER_COMMENT) && event.getCellIndex() > 0) { SessionDataDto currentSession = defineCurrentSession(event); userCommentBox.popUp( currentSession, item.get(SESSION_HEADER + currentSession.getSessionId()), item); } } }); } if (webClientProperties.isTagsAvailable()) { treeGrid.addCellDoubleClickHandler( new CellDoubleClickEvent.CellDoubleClickHandler() { @Override public void onCellClick(CellDoubleClickEvent event) { TreeItem item = treeGrid.findNode(treeGrid.getTreeView().getRow(event.getRowIndex())).getModel(); if (item.getKey().equals(SESSION_TAGS) && event.getCellIndex() > 0) { SessionDataDto currentSession = defineCurrentSession(event); if (allTagsLoadComplete) tagBox.popUpForEdit(currentSession, item, allTags); } } }); } add(treeGrid); }
private void buildToJson(PropertyWrapper pWrap, OJAnnotatedClass annotatedClass, OJBlock block) { // This is very important to be a sorted set. The get and options method need to return the meta // data in the same order. // This allows the client to merge them easily SortedSet<Classifier> sortedConcreteImplementations = new TreeSet<Classifier>( new Comparator<Classifier>() { @Override public int compare(Classifier o1, Classifier o2) { return o1.getName().compareTo(o2.getName()); } }); // For derived unions only show tabs for each property that makes up the union. if (pWrap.isDerivedUnion()) { List<Property> subsettingProperties = ModelLoader.INSTANCE.findSubsettingProperties(pWrap.getProperty()); for (Property subsettingProperty : subsettingProperties) { sortedConcreteImplementations.addAll( UmlgClassOperations.getConcreteImplementations( (Classifier) subsettingProperty.getType())); } } else { // For non derived union show all concrete implementations sortedConcreteImplementations = UmlgClassOperations.getConcreteImplementations((Classifier) pWrap.getType()); } Set<Classifier> concreteImplementationsFrom = UmlgClassOperations.getConcreteImplementations((Classifier) pWrap.getOwningType()); if (!concreteImplementationsFrom.isEmpty()) { annotatedClass.addToImports(UmlgGenerationUtil.ToJsonUtil); // block get reassigned for the meta data if statement OJBlock returnBlock = block; block.addToStatements("StringBuilder json = new StringBuilder()"); block.addToStatements("json.append(\"[\")"); int count = 1; // For meta data, put where one is navigating to first, then where on is // navigating from // This is consistent with navigating to a entity with a vertex where // there is no navigating from. // i.e. the first meta data in the array is the entity navigating to. for (Classifier concreteClassifierTo : sortedConcreteImplementations) { annotatedClass.addToImports(UmlgClassOperations.getPathName(concreteClassifierTo)); if (pWrap.isOne()) { block.addToStatements("json.append(\"{\\\"data\\\": \")"); } else { block.addToStatements("json.append(\"{\\\"data\\\": [\")"); } if (pWrap.isOne()) { OJIfStatement ifOneInstanceOf = new OJIfStatement( "parentResource." + pWrap.getter() + "() != null && parentResource." + pWrap.getter() + "().getClass() == " + UmlgClassOperations.getPathName(concreteClassifierTo).getLast() + ".class"); ifOneInstanceOf.addToThenPart( "json.append(" + UmlgGenerationUtil.ToJsonUtil.getLast() + ".toJsonWithoutCompositeParent(parentResource." + pWrap.getter() + "()))"); ifOneInstanceOf.addToElsePart("json.append(\"null\")"); block.addToStatements(ifOneInstanceOf); } else { block.addToStatements( "json.append(" + UmlgGenerationUtil.ToJsonUtil.getLast() + ".toJsonWithoutCompositeParent(parentResource." + pWrap.getter() + "().select(new " + UmlgGenerationUtil.BooleanExpressionEvaluator.getCopy() .addToGenerics(UmlgClassOperations.getPathName(pWrap.getType())) .getLast() + "() {\n @Override\n public Boolean evaluate(" + UmlgClassOperations.getPathName(pWrap.getType()).getLast() + " e) {\n return e.getClass() == " + UmlgClassOperations.getPathName(concreteClassifierTo).getLast() + ".class;\n }\n })))"); annotatedClass.addToImports(UmlgGenerationUtil.BooleanExpressionEvaluator); } annotatedClass.addToImports(UmlgClassOperations.getPathName(pWrap.getType())); if (pWrap.isOne()) { block.addToStatements("json.append(\",\")"); } else { block.addToStatements("json.append(\"],\")"); } block.addToStatements("json.append(\" \\\"meta\\\" : {\")"); block.addToStatements( "json.append(\"\\\"qualifiedName\\\": \\\"" + pWrap.getQualifiedName() + "\\\"\")"); block.addToStatements( "json.append(\",\\\"qualifiedNameFrom\\\": \\\"\" + parentResource.getQualifiedName() + \"\\\"\")"); block.addToStatements( "json.append(\",\\\"qualifiedNameTo\\\": \\\"" + concreteClassifierTo.getQualifiedName() + "\\\"\")"); block.addToStatements("json.append(\"}\")"); if (sortedConcreteImplementations.size() != 1 && count != sortedConcreteImplementations.size()) { block.addToStatements("json.append(\"}, \")"); } block = returnBlock; count++; } returnBlock.addToStatements("json.append(\"}]\")"); returnBlock.addToStatements( "return new " + UmlgRestletGenerationUtil.JsonRepresentation.getLast() + "(json.toString())"); } else { // TODO not thought through block.addToStatements("return null"); } }
private void buildToJsonForOption( PropertyWrapper pWrap, OJAnnotatedClass annotatedClass, OJBlock block) { SortedSet<Classifier> concreteImplementations = new TreeSet<Classifier>( new Comparator<Classifier>() { @Override public int compare(Classifier o1, Classifier o2) { return o1.getName().compareTo(o2.getName()); } }); // For derived unions only show tabs for each property that makes up the union. if (pWrap.isDerivedUnion()) { List<Property> subsettingProperties = ModelLoader.INSTANCE.findSubsettingProperties(pWrap.getProperty()); for (Property subsettingProperty : subsettingProperties) { concreteImplementations.addAll( UmlgClassOperations.getConcreteImplementations( (Classifier) subsettingProperty.getType())); } } else { // For non derived union show all concrete implementations concreteImplementations = UmlgClassOperations.getConcreteImplementations((Classifier) pWrap.getType()); } Set<Classifier> concreteImplementationsFrom = UmlgClassOperations.getConcreteImplementations((Classifier) pWrap.getOwningType()); if (!concreteImplementationsFrom.isEmpty()) { annotatedClass.addToImports(UmlgGenerationUtil.ToJsonUtil); // blok get reassigned for the meta data if statement OJBlock returnBlock = block; block.addToStatements("StringBuilder json = new StringBuilder()"); block.addToStatements("json.append(\"[\")"); int count = 1; // For meta data, put where one is navigating to first, then where on is // navigating from // This is consistent with navigating to a entity with a vertex where // there is no navigating from. // i.e. the first meta data in the array is the entity navigating to. for (Classifier concreteClassifierTo : concreteImplementations) { annotatedClass.addToImports(UmlgClassOperations.getPathName(concreteClassifierTo)); for (Classifier concreteClassifierFrom : concreteImplementationsFrom) { block.addToStatements("json.append(\"{\")"); block.addToStatements("json.append(\" \\\"meta\\\" : {\")"); block.addToStatements( "json.append(\"\\\"qualifiedName\\\": \\\"" + pWrap.getQualifiedName() + "\\\"\")"); // The execute ocl query resource is only required if the below // visitor is available if (RestletVisitors.containsVisitorForClass(QueryExecuteResourceBuilder.class) && (pWrap .getType() .getQualifiedName() .equals(UmlgRestletGenerationUtil.instanceQueryQualifiedName) || pWrap .getType() .getQualifiedName() .equals(UmlgRestletGenerationUtil.classQueryQualifiedName))) { block.addToStatements( "json.append(\", \\\"oclExecuteUri\\\": \\\"/" + pWrap.getModel().getName() + "/{contextId}/oclExecuteQuery\\\"\")"); } block.addToStatements("json.append(\", \\\"to\\\": \")"); OJBlock conditionBlockFrom = new OJBlock(); annotatedClass.addToImports(UmlgClassOperations.getPathName(concreteClassifierFrom)); conditionBlockFrom.addToStatements( "json.append(" + UmlgClassOperations.propertyEnumName(concreteClassifierTo) + ".asJson())"); conditionBlockFrom.addToStatements("json.append(\", \\\"from\\\": \")"); conditionBlockFrom.addToStatements( "json.append(" + UmlgClassOperations.propertyEnumName(concreteClassifierFrom) + ".asJson())"); annotatedClass.addToImports( UmlgClassOperations.getPathName(concreteClassifierFrom) .append(UmlgClassOperations.propertyEnumName(concreteClassifierFrom))); block.addToStatements(conditionBlockFrom); annotatedClass.addToImports( UmlgClassOperations.getPathName(pWrap.getOwningType()) .append(UmlgClassOperations.propertyEnumName(pWrap.getOwningType()))); annotatedClass.addToImports( UmlgClassOperations.getPathName(concreteClassifierTo) .append(UmlgClassOperations.propertyEnumName(concreteClassifierTo))); if (count++ < (concreteImplementations.size() * concreteImplementationsFrom.size())) { block.addToStatements("json.append(\"}},\")"); } else { block.addToStatements("json.append(\"}}\")"); } } block = returnBlock; } returnBlock.addToStatements("json.append(\"]\")"); returnBlock.addToStatements( "return new " + UmlgRestletGenerationUtil.JsonRepresentation.getLast() + "(json.toString())"); } else { // TODO not thought through block.addToStatements("return null"); } }
public static void main(String[] args) { UnsortedSet<Integer> s1 = new UnsortedSet<Integer>(); for (int i = 1; i <= 10; i++) { s1.add(i); } UnsortedSet<Integer> s2 = new UnsortedSet<Integer>(); for (int i = 5; i < 15; i++) { s2.add(i); } // Test 1: size method System.out.print("Test 1, UnsortedSet size method: "); if (s1.size() == 10) System.out.println("passed"); else System.out.println("failed"); // Test 2: add method System.out.print("Test 2, UnsortedSet add method: "); s1.add(11); if (s1.contains(11)) { System.out.println("passed"); } else { System.out.println("failed"); } // Test 3: toString method System.out.print("Test 3, UnsortedSet toString method: "); if (s1.toString().equals("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)")) { System.out.println("passed"); } else { System.out.println("failed"); } // Test 4: add all method System.out.print("Test 4, UnsortedSet add all method: "); s1.addAll(s2); if (s1.toString().equals("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)")) { System.out.println("passed"); } else { System.out.println("failed"); } // Test 5: remove method System.out.print("Test 5, UnsortedSet remove method: "); for (int i = 11; i < 15; i++) { s1.remove(i); } if (s1.toString().equals("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)")) { System.out.println("passed"); } else { System.out.println("failed"); } // Test 6: clear method System.out.print("Test 6, UnsortedSet clear method: "); s1.clear(); if (s1.size() == 0) { System.out.println("passed"); } else { System.out.println("failed"); } for (int i = 1; i <= 10; i++) { s1.add(i); } // Test 7: contains method System.out.print("Test 7, UnsortedSet contains method: "); if (!s1.contains(999)) { System.out.println("passed"); } else { System.out.println("failed"); } // Test 8: contains all method System.out.print("Test 8, UnsortedSet contains all method: "); if (!s1.containsAll(s2)) System.out.println("passed"); else System.out.println("failed"); // Test 9: union method System.out.print("Test 9, UnsortedSet union method: "); ISet<Integer> s3 = s1.union(s2); if (s3.toString().equals("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)")) System.out.println("passed"); else System.out.println("failed"); // Test 10: difference method System.out.print("Test 10, UnsortedSet difference method: "); s3 = s1.difference(s2); if (s3.toString().equals("(1, 2, 3, 4)")) System.out.println("passed"); else System.out.println("failed"); // Test 11: intersection method System.out.print("Test 11, UnsortedSet intersection method: "); s3 = s2.intersection(s1); if (s3.toString().equals("(5, 6, 7, 8, 9, 10)")) System.out.println("passed"); else System.out.println("failed"); // The following test cases are for sorted set // Test 12: Create a sorted set with unsorted set UnsortedSet<Integer> list1 = new UnsortedSet<Integer>(); list1.add(9); list1.add(3); list1.add(1); list1.add(5); SortedSet<Integer> list2 = new SortedSet<Integer>(list1); System.out.print("Test 12, SortedSet constructor method: "); if (list2.toString().equals("(1, 3, 5, 9)")) System.out.println("passed"); else System.out.println("failed"); // Test 13: add method System.out.print("Test 13, SortedSet add method: "); list2.add(7); if (list2.toString().equals("(1, 3, 5, 7, 9)")) System.out.println("passed"); else System.out.println("failed"); // Test 14: add all method System.out.print("Test 14, SortedSet add all method: "); list1.clear(); list1.add(1); list1.add(3); list1.add(6); list1.add(4); list2.addAll(list1); if (list2.toString().equals("(1, 3, 4, 5, 6, 7, 9)")) System.out.println("passed"); else System.out.println("failed"); // Test 15: remove method System.out.print("Test 15, SortedSet remove method: "); list2.remove(4); list2.remove(6); if (list2.toString().equals("(1, 3, 5, 7, 9)")) System.out.println("passed"); else System.out.println("failed"); // Test 16: clear and size method System.out.print("Test 16, SortedSet clear and size method: "); list2.clear(); if (list2.size() == 0) System.out.println("passed"); else System.out.println("failed"); // Test 17: contains method System.out.print("Test 17, SortedSet contains method: "); list2.add(4); list2.add(2); list2.add(3); list2.add(23); list2.add(9999); if (list2.contains(9999)) System.out.println("passed"); else System.out.println("failed"); // Test 18: contains all method System.out.print("Test 18, SortedSet contains all method: "); if (!list2.containsAll(list1)) System.out.println("passed"); else System.out.println("failed"); // Test 19: union method System.out.print("Test 19, SortedSet union method: "); ISet<Integer> resultList = list2.union(list1); if (resultList.toString().equals("(1, 2, 3, 4, 6, 23, 9999)")) System.out.println("passed"); else System.out.println("failed"); // Test 20: difference method System.out.print("Test 20, SortedSet difference method: "); resultList = list1.difference(list2); if (resultList.toString().equals("(1, 6)")) System.out.println("passed"); else System.out.println("failed"); // Test 21: intersection method System.out.print("Test 21, SortedSet intersection method: "); resultList = list2.intersection(list1); if (resultList.toString().equals("(3, 4)")) System.out.println("passed"); else System.out.println("failed"); // Test 22: minimum method System.out.print("Test 22, SortedSet min method: "); if (list2.min() == 2) System.out.println("passed"); else System.out.println(false); // Test 23: maximum method System.out.print("Test 23, SortedSet max method: "); if (list2.max() == 9999) System.out.println("passed"); else System.out.println("failed"); // Test 24: SortedSet size method System.out.print("Test 24, SortedSet size method: "); if (list2.size() == 5) System.out.println("passed"); else System.out.println("failed"); // Test 25: UnsortedSet size method System.out.print("Test 25, UnsortedSet size method"); if (list1.size() == 4) System.out.println("passed"); else System.out.println("failed"); // CS314 Students. Uncomment this section when ready to // run your experiments try { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); } catch (Exception e) { System.out.println("Unable to change look and feel"); } Scanner sc = new Scanner(System.in); String response = ""; do { largeTest(); System.out.print("Another file? Enter y to do another file: "); response = sc.next(); } while (response != null && response.length() > 0 && response.substring(0, 1).equalsIgnoreCase("y")); }