@Override protected Void doInBackground() throws Exception { // protein identification id Collection<Comparable> protIdentIds = controller.getIdentificationIds(); // protein identification id and accession buffer Map<Comparable, String> accBuffer = new LinkedHashMap<Comparable, String>(); // protein map Map<String, Protein> proteins = new HashMap<String, Protein>(); try { // iterate over each protein for (Comparable protIdentId : protIdentIds) { // get mapped protein accession String protAcc = controller.getProteinAccession(protIdentId); String protAccVersion = controller.getProteinAccessionVersion(protIdentId); String database = controller.getSearchDatabase(protIdentId); AccessionResolver resolver = new AccessionResolver(protAcc, protAccVersion, database, true); String mappedProtAcc = resolver.isValidAccession() ? resolver.getAccession() : null; if (mappedProtAcc != null) { // get existing protein details Protein protDetails = PrideInspectorCacheManager.getInstance().getProteinDetails(mappedProtAcc); if (protDetails != null) { proteins.put(mappedProtAcc, protDetails); } accBuffer.put(protIdentId, mappedProtAcc); if (accBuffer.size() == MAX_BATCH_DOWNLOAD_SIZE) { // fetch and publish protein details fetchAndPublish(accBuffer, proteins); // clear accession buffer accBuffer.clear(); // clear protein map proteins = new HashMap<String, Protein>(); } } } // this is important for cancelling if (Thread.interrupted()) { throw new InterruptedException(); } if (!accBuffer.isEmpty() || !proteins.isEmpty()) { fetchAndPublish(accBuffer, proteins); } } catch (InterruptedException e) { logger.warn("Protein name download has been cancelled"); } return null; }
public synchronized void removeDataAccessController(DataAccessController controller) { List<DataAccessController> oldControllers, newControllers; int index = controllers.indexOf(controller); if (index >= 0) { oldControllers = new ArrayList<DataAccessController>(controllers); // get the next available controller's index int nextIndex = controllers.size() - 1 > index ? index : index - 1; controllers.remove(controller); if (foregroundController != null && foregroundController.equals(controller)) { setForegroundDataAccessController(nextIndex >= 0 ? controllers.get(nextIndex) : null); } controller.close(); newControllers = new ArrayList<DataAccessController>(controllers); EventBus.publish( new RemoveDataSourceEvent<DataAccessController>(this, oldControllers, newControllers)); } }
/** * Replace one data access controller with another, and retain the position in the * DataAccessMonitor. * * @param original original data access controller * @param replacement replacement data access controller */ public synchronized void replaceDataAccessController( DataAccessController original, DataAccessController replacement) { List<DataAccessController> oldControllers, newControllers; int index = controllers.indexOf(original); if (index >= 0) { oldControllers = new ArrayList<DataAccessController>(controllers); controllers.add(index, replacement); controllers.remove(original); if (foregroundController != null && foregroundController.equals(original)) { setForegroundDataAccessController(replacement); } original.close(); newControllers = new ArrayList<DataAccessController>(controllers); // notify others EventBus.publish( new AddDataSourceEvent<DataAccessController>(this, oldControllers, newControllers)); } else { // add as a new data access controller addDataAccessController(replacement); } }
private void updateComponents() { try { this.removeAll(); if (controller != null) { Collection<Comparable> expIds = controller.getExperimentAccs(); if (expIds == null || expIds.isEmpty()) { this.add(dataSourceTabPane, BorderLayout.CENTER); } else { JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, dataSourceTabPane, expTreeTabPane); splitPane.setOneTouchExpandable(false); splitPane.setDividerSize(0); splitPane.setResizeWeight(0.3); this.add(splitPane, BorderLayout.CENTER); } } this.revalidate(); this.repaint(); } catch (DataAccessException e) { e.printStackTrace(); // To change body of catch statement use File | Settings | File // Templates. } }
/** * Fetch then publish * * @param accs protein accessions * @param proteins protein map * @throws Exception exception while fetching the protein */ private void fetchAndPublish(Map<Comparable, String> accs, Map<String, Protein> proteins) throws Exception { Collection<String> accsToFetch = new HashSet<String>(accs.values()); accsToFetch.removeAll(proteins.keySet()); // fetch protein details Map<String, Protein> results = fetcher.getProteinDetails(accsToFetch); // add results to cache PrideInspectorCacheManager.getInstance().addProteinDetails(results.values()); // add results to protein map proteins.putAll(results); // public results publish(new Tuple<TableContentType, Object>(TableContentType.PROTEIN_DETAILS, proteins)); // protein sequence coverage Map<Comparable, Double> coverageMap = new HashMap<Comparable, Double>(); // peptide fits Map<Tuple<Comparable, Comparable>, Integer> peptideFits = new HashMap<Tuple<Comparable, Comparable>, Integer>(); for (Comparable protIdentId : accs.keySet()) { // protein sequence coverage Double coverage = PrideInspectorCacheManager.getInstance() .getSequenceCoverage(controller.getUid(), protIdentId); if (coverage == null) { String mappedProtAcc = accs.get(protIdentId); // get protein details Protein protein = proteins.get(mappedProtAcc); if (protein != null) { AnnotatedProtein annotatedProtein = new AnnotatedProtein(protein); Collection<Comparable> peptideIds = controller.getPeptideIds(protIdentId); for (Comparable peptideId : peptideIds) { PeptideAnnotation peptide = new PeptideAnnotation(); peptide.setSequence(controller.getPeptideSequence(protIdentId, peptideId)); peptide.setStart(controller.getPeptideSequenceStart(protIdentId, peptideId)); peptide.setEnd(controller.getPeptideSequenceEnd(protIdentId, peptideId)); annotatedProtein.addAnnotation(peptide); } coverage = annotatedProtein.getSequenceCoverage(); coverageMap.put(protIdentId, coverage); // cache the sequence coverage PrideInspectorCacheManager.getInstance() .addSequenceCoverage(controller.getUid(), protIdentId, coverage); } } else { coverageMap.put(protIdentId, coverage); } // peptide fits Collection<Comparable> peptideIdentIds = controller.getPeptideIds(protIdentId); for (Comparable peptideIdentId : peptideIdentIds) { Integer state = PrideInspectorCacheManager.getInstance() .getPeptideFitState(controller.getUid(), protIdentId, peptideIdentId); if (state == null) { String mappedProtAcc = accs.get(protIdentId); // get protein details Protein protein = proteins.get(mappedProtAcc); if (protein != null) { protein = new AnnotatedProtein(protein); } // get peptide sequence String sequence = controller.getPeptideSequence(protIdentId, peptideIdentId); // start and end position int start = controller.getPeptideSequenceStart(protIdentId, peptideIdentId); int end = controller.getPeptideSequenceEnd(protIdentId, peptideIdentId); // peptide present if (protein == null || sequence == null || protein.getSequenceString() == null) { state = PeptideFitState.UNKNOWN; } else { if (protein.hasSubSequenceString(sequence, start, end)) { state = PeptideFitState.STRICT_FIT; } else if (protein.hasSubSequenceString(sequence)) { state = PeptideFitState.FIT; } else { state = PeptideFitState.NOT_FIT; } } PrideInspectorCacheManager.getInstance() .addPeptideFitState(controller.getUid(), protIdentId, peptideIdentId, state); } peptideFits.put(new Tuple<Comparable, Comparable>(protIdentId, peptideIdentId), state); } } // publish sequence coverage results publish( new Tuple<TableContentType, Object>( TableContentType.PROTEIN_SEQUENCE_COVERAGE, coverageMap)); // publish peptide fit result publish(new Tuple<TableContentType, Object>(TableContentType.PEPTIDE_FIT, peptideFits)); }
public synchronized void close() { // ToDo: Exception handling for (DataAccessController controller : controllers) { controller.close(); } }
/** * Check whether the given data access controller is foreground data access controller * * @param controller data access controller * @return boolean true if it is foreground data access controller */ public synchronized boolean isForegroundDataAccessController(DataAccessController controller) { return foregroundController != null && foregroundController.equals(controller); }