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"));
}
