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