public class QuoteNugget extends KnowledgeNugget {
private String quoteSection;
private Integer bookmarkLocation;
private DefaultPersistibleList relevanceAssessments;
private DefaultPersistibleList confidenceAssessments;
private DefaultPersistibleList assessments;
private DefaultPersistibleList interpretations;
private String quote;
private Integer versionNumber;
private InformationSource informationSource;
public ImageIcon icon = oncotcap.util.OncoTcapIcons.getImageIcon("knowledgenugget.jpg");
public QuoteNugget() {
init();
}
public QuoteNugget(oncotcap.util.GUID guid) {
super(guid);
init();
}
private void init() {
Method setter = null;
Method getter = null;
setter = getSetter("setQuoteSection", String.class);
setMethodMap.put("quoteSection", setter);
getter = getGetter("getQuoteSection");
getMethodMap.put("quoteSection", getter);
setter = getSetter("setBookmarkLocation", Integer.class);
setMethodMap.put("bookmarkLocation", setter);
getter = getGetter("getBookmarkLocation");
getMethodMap.put("bookmarkLocation", getter);
setter = getSetter("setRelevanceAssessments", DefaultPersistibleList.class);
setMethodMap.put("relevanceAssessments", setter);
getter = getGetter("getRelevanceAssessments");
getMethodMap.put("relevanceAssessments", getter);
setter = getSetter("setConfidenceAssessments", DefaultPersistibleList.class);
setMethodMap.put("confidenceAssessments", setter);
getter = getGetter("getConfidenceAssessments");
getMethodMap.put("confidenceAssessments", getter);
setter = getSetter("setAssessments", DefaultPersistibleList.class);
setMethodMap.put("assessments", setter);
getter = getGetter("getAssessments");
getMethodMap.put("assessments", getter);
setter = getSetter("setInterpretations", DefaultPersistibleList.class);
setMethodMap.put("interpretations", setter);
getter = getGetter("getInterpretations");
getMethodMap.put("interpretations", getter);
setter = getSetter("setQuote", String.class);
setMethodMap.put("quote", setter);
getter = getGetter("getQuote");
getMethodMap.put("quote", getter);
setter = getSetter("setVersionNumber", Integer.class);
setMethodMap.put("versionNumber", setter);
getter = getGetter("getVersionNumber");
getMethodMap.put("versionNumber", getter);
setter = getSetter("setKeywords", DefaultPersistibleList.class);
setMethodMap.put("keywords", setter);
getter = getGetter("getKeywords");
getMethodMap.put("keywords", getter);
setter = getSetter("setInformationSource", InformationSource.class);
setMethodMap.put("informationSource", setter);
getter = getGetter("getInformationSource");
getMethodMap.put("informationSource", getter);
}
public String getQuoteSection() {
return quoteSection;
}
public Integer getBookmarkLocation() {
return bookmarkLocation;
}
public DefaultPersistibleList getRelevanceAssessments() {
return relevanceAssessments;
}
public DefaultPersistibleList getConfidenceAssessments() {
return confidenceAssessments;
}
public DefaultPersistibleList getAssessments() {
return assessments;
}
public DefaultPersistibleList getInterpretations() {
return interpretations;
}
public String getQuote() {
return quote;
}
public Integer getVersionNumber() {
return versionNumber;
}
public InformationSource getInformationSource() {
return informationSource;
}
public void setQuoteSection(String var) {
quoteSection = var;
}
public void setBookmarkLocation(Integer var) {
bookmarkLocation = var;
}
public void setRelevanceAssessments(java.util.Collection var) {
if (relevanceAssessments == null) relevanceAssessments = new DefaultPersistibleList();
relevanceAssessments.set(var);
}
public void setConfidenceAssessments(java.util.Collection var) {
if (confidenceAssessments == null) confidenceAssessments = new DefaultPersistibleList();
confidenceAssessments.set(var);
}
public void setAssessments(java.util.Collection var) {
if (assessments == null) assessments = new DefaultPersistibleList();
assessments.set(var);
}
public void setInterpretations(java.util.Collection var) {
if (interpretations == null) interpretations = new DefaultPersistibleList();
interpretations.set(var);
}
public void setQuote(String var) {
quote = var;
}
public void setVersionNumber(Integer var) {
versionNumber = var;
}
public void setInformationSource(InformationSource var) {
informationSource = var;
}
public String toString() {
return quote;
}
public Class getPanelClass() {
return QuoteNuggetPanel.class;
}
public String getPrettyName() {
return "Quote Nugget";
}
public ImageIcon getIcon() {
return icon;
}
}
public class Keyword extends AbstractPersistible
implements Droppable,
Editable,
AutoGenEditable,
oncotcap.display.browser.TreeBrowserNode,
Popupable {
/**
* * flavors used by getTransferDataFlavors for Droppable interface * @version July 9, 2003 by
* shirey
*/
private static final DataFlavor[] flavors = {Droppable.droppableData, DataFlavor.stringFlavor};
public String keyword = null;
public Vector children = new Vector();
public DefaultPersistibleList parentKeywords = null;
private ImageIcon icon = oncotcap.util.OncoTcapIcons.getImageIcon("keyword.jpg");
private Hashtable setMethodMap = new Hashtable();
private Hashtable getMethodMap = new Hashtable();
public Vector subordinateKeywords = null;
public DefaultPersistibleList describedInstances;
public static Vector allKeywords = new Vector();
public Keyword(oncotcap.util.GUID guid) {
super(guid);
init();
}
public Keyword() {
init();
}
public Keyword(String keyword) {
init();
setKeyword(keyword);
}
private void init() {
initGetterMap();
initSetterMap();
allKeywords.addElement(this);
initPopupMenu();
}
public void initPopupMenu() {
super.initPopupMenu();
if (getPopupMenu() != null) {
JMenu otherDataSourcesMenu = new JMenu("Other Data Sources");
getPopupMenu().add(otherDataSourcesMenu);
JMenuItem mi;
mi = new JMenuItem("Show Level Lists");
ShowLevelListAction showLevelList = new ShowLevelListAction("Show Level List");
mi.setAction(showLevelList);
getPopupMenu().add(mi);
mi = new JMenuItem("Add Level Lists");
AddLevelListAction addLevelList = new AddLevelListAction("Add Level List");
mi.setAction(addLevelList);
getPopupMenu().add(mi);
mi = new JMenuItem("OMIM");
mi.setActionCommand("goto OMIM");
otherDataSourcesMenu.add(mi);
mi = new JMenuItem("PubMed");
mi.setActionCommand("goto PubMed");
otherDataSourcesMenu.add(mi);
mi = new JMenuItem("NCI Thesaurus");
mi.setActionCommand("goto NCI Thesaurus Advice");
otherDataSourcesMenu.add(mi);
otherDataSourcesMenu.setOpaque(true);
getPopupMenu().setOpaque(true);
getPopupMenu().setLightWeightPopupEnabled(true);
}
}
public static void main(String[] args) {
Keyword t = new Keyword("TEST KEYWORD");
t.update();
oncotcap.Oncotcap.getDataSource().commit();
}
private void initGetterMap() {
Method getter = null;
getter = getGetter("getKeyword");
getMethodMap.put("keyword", getter);
getter = getGetter("getParents");
getMethodMap.put("parentKeyword", getter);
getter = getGetter("getDescribedInstances");
getMethodMap.put("describedInstances", getter);
// getter = getGetter("getSubordinateKeywords");
// getMethodMap.put("subordinateKeywords", getter);
}
private void initSetterMap() {
Method setter = null;
setter = getSetter("setKeyword", String.class);
setMethodMap.put("keyword", setter);
setter = getSetter("setParents", DefaultPersistibleList.class);
setMethodMap.put("parentKeyword", setter);
setter = getSetter("setDescribedInstances", DefaultPersistibleList.class);
setMethodMap.put("describedInstances", setter);
// setter = getSetter("getSubordinateKeywords");
// getMethodMap.put("subordinateKeywords", setter);
}
public void setKeyword(String keyword) {
this.keyword = keyword;
}
public String getKeyword() {
return keyword;
}
// public void setParentKeyword(Keyword keyword) {
// this.parentKeyword = keyword;
// }
public Keyword getParentKeyword() {
return (Keyword) parentKeywords.firstElement();
}
public void setParents(java.util.Collection var) {
if (parentKeywords == null) parentKeywords = new DefaultPersistibleList();
parentKeywords.set(var);
}
public void setPar(Keyword keyword) {
if (!parentKeywords.contains(keyword)) parentKeywords.add(keyword);
}
public void addChild(Keyword keyword) {
if (!children.contains(keyword)) children.add(keyword);
}
public Vector getChildren() {
return (children);
}
public DefaultPersistibleList getDescribedInstances() {
// System.out.println("described instance"
// + describedInstances);
return (describedInstances);
}
public void setDescribedInstances(java.util.Collection var) {
if (describedInstances == null) describedInstances = new DefaultPersistibleList();
describedInstances.set(var);
}
public void addDescribedInstance(Object var) {
if (describedInstances == null) describedInstances = new DefaultPersistibleList();
if (!describedInstances.contains(var)) describedInstances.addElement(var);
// System.out.println("add described instance"
// + describedInstances);
}
public void removeDescribedInstance(Object var) {
// System.out.println("remove described instance"
// + describedInstances);
if (describedInstances != null) describedInstances.removeElement(var);
}
// public void addSubordinateKeyword(Keyword keyword) {
// // System.out.println("addSubordinateKeyword " + keyword);
// if ( subordinateKeywords == null) {
// subordinateKeywords = new Vector();
// }
// subordinateKeywords.addElement(keyword);
// }
// public Vector getSubordinateKeywords() {
// return subordinateKeywords;
// }
public void addSubordinateKeyword(Keyword keyword) {
addChild(keyword);
}
public Vector getSubordinateKeywords() {
return (getChildren());
}
public Iterator getChildrenIterator() {
return (children.iterator());
}
public Iterator getParentIterator() {
return (parentKeywords.iterator());
}
public DefaultPersistibleList getParents() {
return parentKeywords;
}
public boolean isChildOf(Keyword word) {
Iterator parents = getParentIterator();
while (parents.hasNext()) {
Keyword par = (Keyword) parents.next();
if (par == null) return (false);
else if (par.equals(word)) return (true);
else return (par.isChildOf(word));
}
return false;
}
public String toString() {
return (keyword);
// return "The keyword is " + keyword + " the parent is " + parentKeyword;
}
public Collection getConnectedNodes() {
Vector connectedNodes = new Vector();
connectedNodes.addElement(Keyword.class);
return connectedNodes;
}
public Vector getAllChildren() {
return getChildren(this, new Vector());
}
private Vector getChildren(Keyword keyword, Vector allKids) {
allKids.addElement(keyword);
// System.out.println("Addtoallkids " + keyword + " " + allKids );
Vector children = keyword.getChildren();
if (children != null) {
Iterator i = children.iterator();
while (i.hasNext()) {
Keyword child = (Keyword) i.next();
getChildren(child, allKids);
}
}
return allKids;
}
Hashtable getTreeInstances(Keyword rootKeyword) {
// Get all the Keywords the current 'context' from the data source
// and return a vector of them
Hashtable keywordHashtable = new Hashtable();
addKeyword(keywordHashtable, rootKeyword, null);
return keywordHashtable;
}
private void addKeyword(Hashtable table, Keyword word, Keyword parent) {
boolean recurse = true;
if (table.containsKey(word)) recurse = false;
if (parent == null) table.put(word, String.valueOf(-1));
else table.put(word, parent);
if (recurse) {
Iterator it = word.getChildren().iterator();
while (it.hasNext()) {
addKeyword(table, (Keyword) it.next(), word);
}
}
}
/**
* * getTransferData Required for the Droppable interface. Used to * retrieve this object when it
* is being used as a * Transferable (Droppable) object for DnD or * Clipboard operations. *
* * @param DataFlavor the flavor of data that is required. Only * DataFlavor.stringFlavor and
* Droppable.persistible are * supported. * * @returns This object if a persistible DataFlavor is
* asked for or * the toString() result if a stringFlavor is asked for. * * @author shirey July 9,
* 2003
*/
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
if (isDataFlavorSupported(flavor)) {
if (flavor == DataFlavor.stringFlavor) return (toString());
else if (flavor == Droppable.droppableData) return (this);
}
throw (new UnsupportedFlavorException(flavor));
}
/**
* * getTransferDataFlavors Required for the Droppable interface. * Used to get a list of all
* DataFlavors * supported by this object. Only * Droppable.droppableData and *
* DataFlavor.stringFlavor are supported. * * @returns The list of supported DataFlavors. *
* * @author shirey July 9, 2003
*/
public DataFlavor[] getTransferDataFlavors() {
return (flavors);
}
/**
* * isDataFlavorSupported Required for the Droppable interface. * Used to query this object to
* find out if * a particular DataFlavor is supported. * Only Droppable.droppableData and *
* DataFlavor.stringFlavor are supported. * * @param DataFlavor The DataFlavor to compare to the
* supported * flavors. * * @returns true if the flavor is supported, false if it isn't. * @author
* shirey July 9, 2003
*/
public boolean isDataFlavorSupported(DataFlavor flavor) {
for (int n = 0; n < flavors.length; n++) if (flavors[n] == flavor) return (true);
return (false);
}
public boolean dropOn(Object dropOnObject) {
if (dropOnObject instanceof Keyword) {
Keyword parentKeyword = null;
Keyword newParentKeyword = (Keyword) dropOnObject;
// Add child to new parent
newParentKeyword.addChild(this);
// Add new parent to child
setPar(newParentKeyword);
update();
newParentKeyword.update();
return true;
} else if (dropOnObject instanceof PersistibleWithKeywords) {
// System.out.println("droping a keyword on " + dropOnObject);
// THis seems to cause a duplicate entry
addDescribedInstance((PersistibleWithKeywords) dropOnObject);
update();
((PersistibleWithKeywords) dropOnObject).link(this);
((PersistibleWithKeywords) dropOnObject).update();
return true;
}
return false;
}
public void unlink(oncotcap.datalayer.Persistible relatedPersistible) {
if (relatedPersistible instanceof Keyword) {
// System.out.println("removing the keyword p/c" + relatedPersistible);
if (children != null) children.remove(relatedPersistible);
if (parentKeywords != null) parentKeywords.remove(relatedPersistible);
} else {
// System.out.println("removing the keyword described instance"
// + relatedPersistible
// + " from list " + describedInstances);
if (describedInstances != null) describedInstances.remove(relatedPersistible);
}
}
public EditorPanel getEditorPanel() {
EditorPanel thePanel = null;
try {
thePanel = new KeywordPanel();
thePanel.edit(this);
} catch (Exception ea) {
ea.printStackTrace();
}
return (thePanel);
}
public EditorPanel getEditorPanelWithInstance() {
EditorPanel thePanel = null;
try {
thePanel = new KeywordPanel();
thePanel.edit(this);
} catch (Exception ea) {
ea.printStackTrace();
}
return (thePanel);
}
public ImageIcon getIcon() {
return icon;
}
public Method getSetter(String name, Class argName) {
Class[] paramList = new Class[1];
Method setMethod = null;
try {
// System.out.println("setter " + name + " "
// + paramList + " " + argName);
if (argName == DefaultPersistibleList.class) argName = Collection.class;
// System.out.println("setter " + name + " "
// + paramList + " " + argName);
paramList[0] = argName;
setMethod = this.getClass().getMethod(name, paramList);
} catch (Exception ea) {
ea.printStackTrace();
}
return setMethod;
}
public Hashtable getGetterMap() {
return getMethodMap;
}
public Hashtable getSetterMap() {
return setMethodMap;
}
public Method getGetter(String name) {
Method getMethod = null;
try {
getMethod = this.getClass().getMethod(name, (Class[]) null);
} catch (Exception ea) {
ea.printStackTrace();
}
return getMethod;
}
public Method getGetMethod(String name) {
if (name != null) return (Method) getMethodMap.get(name);
else return null;
}
public static Vector extractKeywordFromText(String text) {
// see if there are any existing keywords represented
// in this text
// Get all keywords
Vector extractedKeywords = new Vector();
Iterator keywords = allKeywords.iterator();
while (keywords.hasNext()) {
Keyword keyword = (Keyword) keywords.next();
if (text != null
&& keyword.toString() != null
&& text.toLowerCase().indexOf(keyword.toString().toLowerCase()) > -1) {
extractedKeywords.addElement(keyword);
}
}
return extractedKeywords;
}
public Vector getAssociatedLevelLists() {
Vector levelLists = new Vector();
Vector endPts = CollectionHelper.makeVector("Keyword");
Hashtable keywordParents =
oncotcap.Oncotcap.getDataSource()
.getParentTree(
"Keyword", endPts, CollectionHelper.makeVector(this), TreeDisplayModePanel.ROOT);
// Take each of the parents and get the associated level lists
if (keywordParents.size() <= 0) return levelLists;
Hashtable levelListsHashtable =
oncotcap.Oncotcap.getDataSource()
.getInstanceTree(
"EnumLevelList",
new Vector(),
makeLevelListFilter(keywordParents),
TreeDisplayModePanel.ROOT);
for (Enumeration e = keywordParents.keys(); e.hasMoreElements(); ) {
System.out.println("Keyword.getAssociatedLevelLists: " + e.nextElement());
}
// Collect all the level lists from the hashtable
Vector selectedItems = CollectionHelper.makeVector(keyword);
for (Enumeration e = levelListsHashtable.keys(); e.hasMoreElements(); ) {
Object obj = e.nextElement();
if (obj instanceof EnumLevelList) {
levelLists.addElement(obj);
}
}
return levelLists;
}
private OncFilter makeLevelListFilter(Hashtable keywords) {
// Create a filter
OncFilter filter = new OncFilter(false);
OncTreeNode rootNode = filter.getRootNode();
OncTreeNode orNode = new OncTreeNode(TcapLogicalOperator.OR, Persistible.DO_NOT_SAVE);
OncTreeNode keywordNode;
for (Enumeration e = keywords.keys(); e.hasMoreElements(); ) {
Object obj = e.nextElement();
if (obj instanceof Keyword) orNode.add(new OncTreeNode(obj, (Persistible.DO_NOT_SAVE)));
}
rootNode.add(orNode);
return filter;
}
public static EnumDefinition dropKeywordCreateEnum(
EnumDefinition enumDefinition, Keyword keyword, boolean saveEnum) {
if (enumDefinition == null) {
enumDefinition = new EnumDefinition(keyword.toString(), saveEnum);
}
enumDefinition.setKeyword(keyword);
return enumDefinition;
}
public static EnumDefinition dropKeywordCreateEnum(Keyword keyword, boolean saveEnum) {
EnumDefinition enumDefinition = new EnumDefinition(keyword.toString(), saveEnum);
enumDefinition.setKeyword(keyword);
return enumDefinition;
}
}
