## Uses of Class
org.biojava.bio.BioException

Packages that use BioException
org.biojava.bio.alignment: Classes to generate and describe sequence alignments.
org.biojava.bio.annodb: Databases of generic structured data (annotation) objects.
org.biojava.bio.chromatogram: Interfaces and classes for chromatogram data, as produced by DNA sequencing equipment.
org.biojava.bio.dist: Probability distributions over Alphabets.
org.biojava.bio.dp: HMM and Dynamic Programming Algorithms.
org.biojava.bio.dp.onehead
org.biojava.bio.dp.twohead
org.biojava.bio.gui: Graphical interfaces for biojava objects.
org.biojava.bio.molbio: The classes and interfaces in this package cover common molecular biological techniques such as restriction digests and PCR.
org.biojava.bio.program.das: Development client for the Distributed Annotation System.
org.biojava.bio.program.das.dasalignment: request alignments via DAS
org.biojava.bio.program.formats: Experimental parsers using the tagvalue framework.
org.biojava.bio.program.gff: GFF manipulation.
org.biojava.bio.program.gff3: Support for reading and writing GFF3.
org.biojava.bio.program.homologene: Support classes for Homologene data.
org.biojava.bio.program.indexdb: A flat-file ascii index of ascii flat files as per the OBDA specification.
org.biojava.bio.program.phred: Parser for Phred output
org.biojava.bio.program.sax.blastxml: Parsers for the XML output from NCBI blast.
org.biojava.bio.program.ssaha: SSAHA sequence searching API.
org.biojava.bio.program.ssbind: Creation of objects from SAX events using the BioJava BlastLikeDataSetCollection DTD.
org.biojava.bio.program.unigene: Objects for representing Unigene clusters.
org.biojava.bio.program.xff: Event-driven parsing system for the Extensible Feature Format (XFF).
org.biojava.bio.proteomics: Utilities to aid in performing various physical analysis of proteins.
org.biojava.bio.proteomics.aaindex: Classes and interfaces to load Amino Acid Index database files.
org.biojava.bio.search: Interfaces and classes for representing sequence similarity search results.
org.biojava.bio.seq: Classes and interfaces for defining biological sequences and informatics objects.
org.biojava.bio.seq.db: Collections of biological sequence data.
org.biojava.bio.seq.db.biofetch: Client for the OBDA BioFetch protocol.
org.biojava.bio.seq.db.biosql: General purpose Sequence storage in a relational database.
org.biojava.bio.seq.db.flat: Support for OBDA flatfile databases.
org.biojava.bio.seq.distributed: Sequences and SequenceDBs which are composed from data taken from a number of data sources.
org.biojava.bio.seq.homol: The classes and interfaces for defining sequence similarity and honology.
org.biojava.bio.seq.impl: Standard in-memory implementations of `Sequence` and `Feature`.
org.biojava.bio.seq.io: Classes and interfaces for processing and producing flat-file representations of sequences.
org.biojava.bio.seq.projection: Code for projecting Feature objects and systematically altering their properties.
org.biojava.bio.structure: Interfaces and classes for protein structure (PDB).
org.biojava.bio.structure.io: Input and Output of Structures
org.biojava.bio.symbol: Representation of the Symbols that make up a sequence, and locations within them.
org.biojava.bio.taxa: Taxonomy object for representing species information.
org.biojava.directory: Open Bio Sequence Database Access (OBDA) registry support.
org.biojava.utils.automata
org.biojava.utils.math: Mathematical utility classes.
org.biojava.utils.regex: This package is used to perform regular expression searches of SymbolLists defined in arbitrary Alphabets.
org.biojava.utils.walker
org.biojavax.bio: Classes to represent biological entities and their relationships.
org.biojavax.bio.db: Interactions between biojavax objects and a DB.
org.biojavax.bio.db.biosql: Interface between biojava and biosql databases
org.biojavax.bio.db.ncbi: Interfaces to NCBI data.
org.biojavax.bio.seq: Rich implementations of Sequences, Locations and Features.
org.biojavax.bio.seq.io: Classes to support the I/O of RichSequence and Bioentry objects.

Uses of BioException in org.biojava.bio.alignment

Methods in org.biojava.bio.alignment that throw BioException
`void` `FlexibleAlignment.addSequence(AlignmentElement ae)` add a new a alignment usings a location to the reference sequence.
`void` `ARAlignment.addSequence(AlignmentElement ae)`
`List<Alignment>` `NeedlemanWunsch.alignAll(SequenceIterator source, SequenceDB subjectDB)`
`String` `NeedlemanWunsch.getAlignmentString()`
`static SubstitutionMatrix` `SubstitutionMatrix.getSubstitutionMatrix(BufferedReader reader)` This constructor can be used to guess the alphabet of this substitution matrix.
`short` `SubstitutionMatrix.getValueAt(Symbol row, Symbol col)` There are some substitution matrices containing more columns than lines.
`SubstitutionMatrix` `SubstitutionMatrix.normalizeMatrix()` With this method you can get a “normalized” `SubstitutionMatrix` object; however, since this implementation uses an short matrix, the normalized matrix will be scaled by ten.

Constructors in org.biojava.bio.alignment that throw BioException
`FlexibleAlignment(List seqList)` construct this object with the reference sequence which can either be a gappedSymbolList or not label in all cases refers to an object that holds the display name (generally just a String).
`SimpleAlignmentElement(Object label, SymbolList seq, Location loc)`
`SubstitutionMatrix(File file)` This constructor can be used to guess the alphabet of this substitution matrix.
`SubstitutionMatrix(FiniteAlphabet alpha, File matrixFile)` This constructs a `SubstitutionMatrix` object that contains two `Map` data structures having BioJava symbols as keys and the value being the index of the matrix containing the substitution score.
`SubstitutionMatrix(FiniteAlphabet alpha, String matrixString, String name)` With this constructor it is possible to construct a SubstitutionMatrix object from a substitution matrix file.

Uses of BioException in org.biojava.bio.annodb

Constructors in org.biojava.bio.annodb that throw BioException
`IndexedAnnotationDB(String dbName, File storeLoc, Index2Model model, List toIndex, int maxKeyLen, AnnotationType schema, IndexedAnnotationDB.ParserListenerFactory plFactory)` Create a new IndexedAnnotationDB.

Uses of BioException in org.biojava.bio.chromatogram

Subclasses of BioException in org.biojava.bio.chromatogram
`class` `UnsupportedChromatogramFormatException` Exception indicating that some provided data does not represent a supported chromatogram format.

Uses of BioException in org.biojava.bio.dist

Methods in org.biojava.bio.dist that throw BioException
`static boolean` `DistributionTools.areEmissionSpectraEqual(Distribution[] a, Distribution[] b)` Compares the emission spectra of two distribution arrays.
`static boolean` `DistributionTools.areEmissionSpectraEqual(Distribution a, Distribution b)` Compares the emission spectra of two distributions.

Uses of BioException in org.biojava.bio.dp

Subclasses of BioException in org.biojava.bio.dp
`class` `IllegalTransitionException` This exception indicates that there is no transition between two states.

Methods in org.biojava.bio.dp that throw BioException
`Sequence` `WeightMatrixAnnotator.annotate(Sequence seq)`
`void` `SimpleHMMTrainer.completeCycle()`
`void` `HMMTrainer.completeCycle()` indicate that a cycle of training is completed and the emission/transition matrices should be updated.
`DP` `DPFactory.createDP(MarkovModel model)`
`DP` `DPFactory.DefaultFactory.createDP(MarkovModel model)`
`DPMatrix` `DP.forwardsBackwards(SymbolList[] symList, ScoreType scoreType)`
`StatePath` `DP.generate(int length)` Generates an alignment from a model.
`static WeightMatrix` `XmlMarkovModel.readMatrix(Element root)`
`static MarkovModel` `XmlMarkovModel.readModel(Element root)`
`void` `WMAsMM.registerWithTrainer(ModelTrainer modelTrainer)`
`void` `Trainable.registerWithTrainer(ModelTrainer mt)` Perform any registration that is necessary with mt.
`State[]` `DP.stateList(MarkovModel mm)`
`void` `TrainingAlgorithm.train(SequenceDB db, double nullWeight, StoppingCriteria stopper)` Trains the sequences in db untill stopper says to finnish.
`void` `AbstractTrainer.train(SequenceDB db, double nullModelWeight, StoppingCriteria stopper)` Trains the sequences in db until stopper says to finnish.

Uses of BioException in org.biojava.bio.dp.onehead

Constructors in org.biojava.bio.dp.onehead that throw BioException
`SingleDP(MarkovModel model)`

Uses of BioException in org.biojava.bio.dp.twohead

Methods in org.biojava.bio.dp.twohead that throw BioException
`CellCalculatorFactory` `CellCalculatorFactoryMaker.make(DP dp)`

Constructors in org.biojava.bio.dp.twohead that throw BioException
`PairwiseDP(MarkovModel mm, CellCalculatorFactoryMaker ccfm)`

Uses of BioException in org.biojava.bio.gui

Methods in org.biojava.bio.gui that throw BioException
`void` `FeatureTree.setSequenceDB(SequenceDB db)` Use this method to provide the sequences for the tree to work with.

Uses of BioException in org.biojava.bio.molbio

Methods in org.biojava.bio.molbio that throw BioException
`int[]` `RestrictionEnzyme.getUpstreamCut()` `getUpstreamCut` returns the cut site upstream of the recognition site.
`int` `RestrictionEnzyme.getUpstreamEndType()` `getUpstreamEndType` returns the double-stranded end type produced by the secondary (upstream) cut.

Uses of BioException in org.biojava.bio.program.das

Methods in org.biojava.bio.program.das that throw BioException
`void` `DASSequence.addAnnotationSource(URL dataSourceURL)`
`void` `DAS.addDasURL(URL dasURL)`
`SequenceDB` `ReferenceServer.getDB()`
`DistDataSource` `ReferenceServer.getDistDataSource()`
`DistDataSource` `DataSource.getDistDataSource()`
`Sequence` `DASSequenceDB.getSequence(String id)`
`SequenceDBLite` `DASSequenceDBProvider.getSequenceDB(Map config)`
`protected SymbolList` `DASSequence.getSymbols()`
`static Set` `DAS.getTypes(URL dasURL)`
`Feature` `DASSequence.realizeFeature(FeatureHolder dest, Feature.Template temp)`
`void` `DASSequence.removeAnnotationSource(URL dataSourceURL)`

Constructors in org.biojava.bio.program.das that throw BioException
`DASSequenceDB(URL dataSourceURL)`

Uses of BioException in org.biojava.bio.program.das.dasalignment

Subclasses of BioException in org.biojava.bio.program.das.dasalignment
`class` `DASException` An exception of one of the DAS classes.

Uses of BioException in org.biojava.bio.program.formats

Methods in org.biojava.bio.program.formats that throw BioException
`static Format` `FormatTools.getFormat(String formatName)` Attempt to find aformat for a format identifer string.

Uses of BioException in org.biojava.bio.program.gff

Methods in org.biojava.bio.program.gff that throw BioException
`static SequenceDB` `GFFTools.annotateSequences(SequenceDB seqs, GFFEntrySet ents)` Annotates all sequences in a sequence DB with features from a GFF entry set.
`protected SimpleGFFRecord` `SequencesAsGFF.createGFFRecord(Feature feature, String id)` Internal method to create a GFFRecord from an individual Feature.
`protected GFFRecord` `GFFParser.createRecord(GFFDocumentHandler handler, List aList, String rest, String comment)` Actually turns a list of tokens, some value string and a comment into a GFFRecord and informs handler.
`protected void` `SequencesAsGFF.doPreProcessSequence(Sequence seq, GFFDocumentHandler handler, String id)` Emit any per-sequence header information.
`protected void` `SequencesAsGFF.doProcessFeature(Feature feature, GFFDocumentHandler handler, String id)` Internal method to process an individual Feature.
`protected void` `SequencesAsGFF.doProcessSequence(Sequence seq, GFFDocumentHandler handler, String id)` Internal method to process an individual Sequence.
`static GFFEntrySet` `GFFTools.gffFromSeqDB(SequenceDB seqDB)` Creates a GFFEntrySet containing one entry for each feature on each sequence of a SequenceDB.
`static GFFEntrySet` `GFFTools.gffFromSequence(Sequence seq)` Creates a GFFEntrySet containing one entry for each feature on a sequence.
`void` `GFFWriter.invalidEnd(String token, NumberFormatException nfe)`
`void` `GFFWriter.invalidFrame(String token, NumberFormatException nfe)`
`void` `GFFWriter.invalidScore(String token, NumberFormatException nfe)`
`void` `GFFWriter.invalidStart(String token, NumberFormatException nfe)`
`void` `GFFWriter.invalidStrand(String token)`
`void` `GFFParser.parse(BufferedReader bReader, GFFDocumentHandler handler)` Informs handler of each line of gff read from bReader.
`void` `GFFParser.parse(BufferedReader bReader, GFFDocumentHandler handler, String locator)` Informs handler of each line of GFF read from bReader
`void` `SequencesAsGFF.processDB(SequenceDB seqDB, GFFDocumentHandler handler)` Process all Sequences within a SequenceDB, informing handler of any suitable features.
`void` `SequencesAsGFF.processSequence(Sequence seq, GFFDocumentHandler handler)` Process an individual Sequence, informing handler of any suitable features.
`static GFFEntrySet` `GFFTools.readGFF(BufferedReader gffIn)` Read all GFF entries from a buffered reader.
`static GFFEntrySet` `GFFTools.readGFF(BufferedReader gffIn, GFFRecordFilter recFilt)` Read all GFF entries matching a filter from a buffered reader.
`static GFFEntrySet` `GFFTools.readGFF(File inFile)` Reads a `GFFEntrySet` from a file with no filtering.
`static GFFEntrySet` `GFFTools.readGFF(File inFile, GFFRecordFilter recFilt)` Reads a GFFEntrySet from a file with the specified filter.
`static GFFEntrySet` `GFFTools.readGFF(String fileName)` Deprecated. use: readGff(File)
`static GFFEntrySet` `GFFTools.readGFF(String fileName, GFFRecordFilter recFilt)` Deprecated. use: readGff(File,GFFRecordFilter)

Uses of BioException in org.biojava.bio.program.gff3

Methods in org.biojava.bio.program.gff3 that throw BioException
`protected GFF3Record` `GFF3Parser.createRecord(GFF3DocumentHandler handler, List aList, String rest, String comment, Ontology ontology, Ontology fallBack)` Actually turns a list of tokens, some value string and a comment into a GFF3Record and informs handler.
`void` `GFF3Parser.parse(BufferedReader bReader, GFF3DocumentHandler handler, Ontology ontology)` Informs handler of each line of gff read from bReader.
`void` `GFF3Parser.parse(BufferedReader bReader, GFF3DocumentHandler handler, Ontology ontology, String locator)` Informs handler of each line of GFF read from bReader

Uses of BioException in org.biojava.bio.program.homologene

Subclasses of BioException in org.biojava.bio.program.homologene
`class` `DuplicateTaxonException`

Uses of BioException in org.biojava.bio.program.indexdb

Methods in org.biojava.bio.program.indexdb that throw BioException
`BioStore` `BioStoreFactory.createBioStore()` `createBioStore` creates a `BioStore` reflecting the current state of the factory and returns a reference to it.
`Record` `IndexStore.get(String id)` `get` returns a record specified by a primary identifier.
`List` `IndexStore.get(String id, String namespace)` `get` returns a list of `Record`s by searching against the primary identifiers if the namespace argument is equal to the primary namespace or otherwise by searching the secondary namespaces.
`List` `BioStore.get(String id, String namespace)`
`static void` `IndexTools.indexEmbl(String name, File location, File[] seqFiles, int alphabetIdentifier)` `indexEmbl` indexes DNA, RNA or protein EMBL format sequence files on ID as primary identifier and AC as secondary.
`static void` `IndexTools.indexFasta(String name, File location, File[] seqFiles, int alphabetIdentifier)` `indexFasta` indexes DNA, RNA or protein Fasta format sequence files on primary identifier.
`static void` `IndexTools.indexGenbank(String name, File location, File[] seqFiles, int alphabetIdentifier)` `indexGenbank` indexes DNA, RNA or protein Genbank format sequence files on LOCUS as primary identifier and ACCESSION as secondary.
`static void` `IndexTools.indexSwissprot(String name, File location, File[] seqFiles)` `indexSwissprot` indexes Swissprot format protein sequence files on ID as primary identifier.

Constructors in org.biojava.bio.program.indexdb that throw BioException
`BioStore(File location, boolean cache)` Creates a new `BioStore` flatfile index at the specified location with the specified caching behaviour.

Uses of BioException in org.biojava.bio.program.phred

Methods in org.biojava.bio.program.phred that throw BioException
`static void` `PhredTools.writePhredQuality(OutputStream qual, OutputStream seq, SequenceDB db)` Writes Phred quality data in a Fasta type format.

Uses of BioException in org.biojava.bio.program.sax.blastxml

Constructors in org.biojava.bio.program.sax.blastxml that throw BioException
`BlastXMLParserFacade()`

Uses of BioException in org.biojava.bio.program.ssaha

Methods in org.biojava.bio.program.ssaha that throw BioException
`DataStore` `NIODataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)`
`DataStore` `MappedDataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)`
`DataStore` `DataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)` Build a new DataStore.
`DataStore` `CompactedDataStoreFactory.buildDataStore(File storeFile, SequenceDB seqDB, Packing packing, int wordLength, int threshold)`
`DataStore` `CompactedDataStoreFactory.buildDataStore(File storeFile, SequenceStreamer streamer, Packing packing, int wordLength, int stepSize, int threshold)`
`void` `SequenceStreamer.reset()`
`void` `SequenceStreamer.streamNext(SeqIOListener listener)`
`void` `SequenceStreamer.SequenceDBStreamer.streamNext(SeqIOListener listener)`
`void` `SequenceStreamer.FileStreamer.streamNext(SeqIOListener listener)`

Uses of BioException in org.biojava.bio.program.ssbind

Methods in org.biojava.bio.program.ssbind that throw BioException
`protected Sequence` `ViewSequenceFactory.makeQueryViewSequence(String queryID)`
`SeqSimilaritySearchResult` `BlastLikeSearchBuilder.makeSearchResult()`
`protected Sequence` `ViewSequenceFactory.makeSubjectViewSequence(String subjectID)`
`static FiniteAlphabet` `AlphabetResolver.resolveAlphabet(String identifier)` `resolveAlphabet` returns an appropriate `Alphabet` for an arbitrary identifier.

Uses of BioException in org.biojava.bio.program.unigene

Methods in org.biojava.bio.program.unigene that throw BioException
`UnigeneCluster` `UnigeneDB.addCluster(UnigeneCluster cluster)` Add a cluster to a database.
`static UnigeneDB` `UnigeneTools.createUnigene(URL dbURL)` Create a new UnigeneDB instance referred to by a URL.
`UnigeneDB` `UnigeneFactory.createUnigene(URL unigeneURL)`
`UnigeneDB` `SQLUnigeneFactory.createUnigene(URL dbURL)`
`UnigeneDB` `FlatFileUnigeneFactory.createUnigene(URL unigeneLoc)`
`static UnigeneFactory` `UnigeneTools.findFactory(URL dbURL)` Find the UnigeneFactory that can accept a URL.
`UnigeneCluster` `UnigeneDB.getCluster(String clusterID)` Fetch a cluster by its cluster id.
`static UnigeneDB` `UnigeneTools.loadUnigene(URL dbURL)` Load a UnigeneDB instance referred to by a URL.
`UnigeneDB` `UnigeneFactory.loadUnigene(URL unigeneURL)`
`UnigeneDB` `SQLUnigeneFactory.loadUnigene(URL dbURL)`
`UnigeneDB` `FlatFileUnigeneFactory.loadUnigene(URL unigeneLoc)`

Uses of BioException in org.biojava.bio.program.xff

Methods in org.biojava.bio.program.xff that throw BioException
`static void` `XFFTools.annotateXFF(File xffFile, Sequence sequence)`
`static void` `XFFTools.annotateXFF(File xffFile, Sequence sequence, Annotation ann)`
`static Sequence` `XFFTools.readXFF(File xffFile, String seqID)`
`static Sequence` `XFFTools.readXFF(File xffFile, String seqID, FiniteAlphabet alpha)`

Uses of BioException in org.biojava.bio.proteomics

Methods in org.biojava.bio.proteomics that throw BioException
`void` `Digest.addDigestFeatures()` Adds peptides as features to the Sequence in this class.
`static Protease` `ProteaseManager.createProtease(String cleaveRes, boolean endoProtease, String name)`
`static Protease` `ProteaseManager.createProtease(String cleaveRes, boolean endoProtease, String notCleaveRes, String name)`
`static Protease` `ProteaseManager.createProtease(SymbolList cleaveRes, boolean endoProtease, String name)`
`static Protease` `ProteaseManager.createProtease(SymbolList cleaveRes, boolean endoProtease, SymbolList notCleaveRes, String name)` Creates and registers a new Protease.
`static double` `IsoelectricPointCalc.getIsoelectricPoint(SymbolList peptide)` Static public method to compute the pI for a polypeptide in denaturating and reduced conditions with both free ends.
`double` `IsoelectricPointCalc.getPI(SymbolList peptide, boolean hasFreeNTerm, boolean hasFreeCTerm)` Computes isoelectric point of specified peptide.
`static Protease` `ProteaseManager.getProteaseByName(String proteaseName)` Gets a Protease instance by name.
`static Protease` `Protease.getProteaseByName(String proteaseName)` Retrieves a reference to the named Protease.
`static void` `ProteaseManager.registerProtease(Protease prot)` Registers a protease and ensures its flyweight status

Constructors in org.biojava.bio.proteomics that throw BioException
`Protease(String cleavageRes, boolean endoProtease)` Deprecated. Creating a Protease with this constructor will not register it with the ProteaseManager (use ProteaseManager.createProtease())
`Protease(String cleaveRes, boolean endoProtease, String notCleaveRes)` Deprecated. Creating a Protease with this constructor will not register it with the ProteaseManager (use ProteaseManager.createProtease())
`Protease(SymbolList cleaveRes, boolean endoProtease, SymbolList notCleaveRes)` Deprecated. Creating a Protease with this constructor will not register it with the ProteaseManager (use ProteaseManager.createProtease())

Uses of BioException in org.biojava.bio.proteomics.aaindex

Methods in org.biojava.bio.proteomics.aaindex that throw BioException
`SymbolPropertyTable` `SymbolPropertyTableIterator.nextTable()` Returns the next `SymbolPropertyTable` object.
`SymbolPropertyTable` `AAindexStreamReader.nextTable()` Returns the next `SymbolPropertyTable` object.

Constructors in org.biojava.bio.proteomics.aaindex that throw BioException
`SimpleSymbolPropertyTableDB(SymbolPropertyTableIterator tableIterator)` Initializes the database by copying all symbol property tables from a given iterator into the database.

Uses of BioException in org.biojava.bio.search

Methods in org.biojava.bio.search that throw BioException
`SeqSimilaritySearchResult` `SearchBuilder.makeSearchResult()` The `makeSearchResult` method returns a `SeqSimilaritySearchResult` instance created from accumulated data.
`SeqSimilaritySearchResult` `SeqSimilaritySearcher.search(SymbolList querySeq, SequenceDB db, Map searchParameters)` Using this sequence similarity searcher, search with the given sequence against the given sequence database.

Constructors in org.biojava.bio.search that throw BioException
`FilteringContentHandler(BlastLikeSearchFilter filter)`
`FilteringContentHandler(BlastLikeSearchFilter filter, SearchContentHandler delegate)`

Uses of BioException in org.biojava.bio.seq

Methods in org.biojava.bio.seq that throw BioException
`static void` `SequenceTools.addAllFeatures(Sequence seq, FeatureHolder fh)` Add features to a sequence that contain the same information as all those in a feature holder.
`void` `SimpleFeatureRealizer.addImplementation(Class template, Class impl)` Install a new mapping from a class of Feature.Template to a class of Feature implementations.
`Sequence` `SequenceAnnotator.annotate(Sequence seq)` Return an annotated version of a sequence.
`Feature` `SimpleAssembly.createFeature(Feature.Template temp)`
`Feature` `NewSimpleAssembly.createFeature(Feature.Template temp)`
`Feature` `LazyFeatureHolder.createFeature(Feature.Template template)`
`Feature` `FeatureHolder.createFeature(Feature.Template ft)` Create a new Feature, and add it to this FeatureHolder.
`Feature` `CircularView.createFeature(Feature.Template template)` Over rides ViewSequence to allow the use of locations that have coordinates outside of the sequence length (which are needed to describe locations that overlap the origin of a circular sequence).
`Feature` `AbstractFeatureHolder.createFeature(Feature.Template temp)`
`Feature` `RemoteFeature.getRemoteFeature()` Retrieve the Feature on some assembly Sequence that can represent this RemoteFeature properly.
`Sequence` `SequenceIterator.nextSequence()` Returns the next sequence in the iterator.
`Feature` `SimpleAssembly.realizeFeature(FeatureHolder fh, Feature.Template temp)`
`Feature` `RealizingFeatureHolder.realizeFeature(FeatureHolder parent, Feature.Template template)` Realize a feature template.
`Feature` `NewSimpleAssembly.realizeFeature(FeatureHolder fh, Feature.Template temp)`
`Feature` `SimpleFeatureRealizer.realizeFeature(Sequence seq, FeatureHolder parent, Feature.Template temp)`
`Feature` `FeatureRealizer.realizeFeature(Sequence seq, FeatureHolder parent, Feature.Template template)` Install a feature on the specified sequence.
`void` `LazyFeatureHolder.removeFeature(Feature f)`
`void` `FeatureHolder.removeFeature(Feature f)` Remove a feature from this FeatureHolder.
`void` `AbstractFeatureHolder.removeFeature(Feature f)`
`Feature` `RemoteFeature.Resolver.resolve(RemoteFeature rFeat)` Resolve rFeat.
`static Object` `FilterUtils.visitFilter(FeatureFilter filter, Visitor visitor)` Applies a visitor to a filter, and returns the visitor's result or null.

Uses of BioException in org.biojava.bio.seq.db

Subclasses of BioException in org.biojava.bio.seq.db
`class` `IllegalIDException`

Methods in org.biojava.bio.seq.db that throw BioException
`void` `IndexedSequenceDB.addFile(File seqFile)` Add sequences from a file to the sequence database.
`void` `SequenceDBLite.addSequence(Sequence seq)` Adds a sequence to the database.
`void` `DummySequenceDB.addSequence(Sequence seq)`
`void` `AbstractSequenceDB.addSequence(Sequence seq)`
`void` `TabIndexStore.commit()`
`void` `IndexStore.commit()` Commit the stored indices to permanent storage.
`void` `EmblCDROMIndexStore.commit()` `commit` commits changes.
`void` `BioIndex.commit()`
`protected Sequence` `AnnotatedSequenceDB.doAnnotation(Sequence seq)` Apply the annotation to a sequence.
`Index` `TabIndexStore.fetch(String id)`
`Index` `IndexStore.fetch(String id)` Fetch an Index based upon an ID.
`Index` `EmblCDROMIndexStore.fetch(String id)`
`Index` `BioIndex.fetch(String id)`
`Sequence` `WebSequenceDB.getSequence(String id)` Gets a sequence using its unique ID (eg for GenBank this would be the GI number)
`Sequence` `ViewingSequenceDB.getSequence(String id)`
`Sequence` `SwissprotSequenceDB.getSequence(String id)`
`Sequence` `SubSequenceDB.getSequence(String id)`
`Sequence` `SequenceDBLite.getSequence(String id)` Retrieve a single sequence by its id.
`Sequence` `IndexedSequenceDB.getSequence(String id)`
`Sequence` `GenpeptSequenceDB.getSequence(String id)`
`Sequence` `DummySequenceDB.getSequence(String id)`
`Sequence` `CachingSequenceDB.getSequence(String id)`
`Sequence` `AnnotatedSequenceDB.getSequence(String id)`
`SequenceDB` `GenbankSequenceDB.getSequences(Set list)` Retrieve sequences from a Genbank
`SequenceDB` `GenbankSequenceDB.getSequences(Set list, SequenceDB database)` Retrieve sequences from a Genbank
`void` `SequenceDBLite.removeSequence(String id)` Remove the sequence associated with an ID from the database.
`void` `HashSequenceDB.removeSequence(String id)`
`void` `DummySequenceDB.removeSequence(String id)`
`void` `AbstractSequenceDB.removeSequence(String id)`
`void` `NCBISequenceDB.setDatabase(String dataBase)`
`void` `NCBISequenceDB.setSequenceFormat(SequenceFormat format)`
`void` `TabIndexStore.store(Index indx)`
`void` `IndexStore.store(Index indx)` Add the Index to the store.
`void` `EmblCDROMIndexStore.store(Index index)` `store` adds an `Index` to the store.

Constructors in org.biojava.bio.seq.db that throw BioException
`BioIndex(File indexDirectory)` Load an existing index file.
`BioIndex(File indexDirectory, String namespace, int idLength)`
`SubSequenceDB(SequenceDB parent, Set ids)`
`TabIndexStore(File storeFile, File indexFile, String name, SequenceFormat format, SequenceBuilderFactory sbFactory, SymbolTokenization symbolParser)` Create a new TabIndexStore.

Uses of BioException in org.biojava.bio.seq.db.biofetch

Methods in org.biojava.bio.seq.db.biofetch that throw BioException
`Sequence` `BioFetchSequenceDB.getSequence(String id)`
`SequenceDBLite` `BioFetchSequenceDBProvider.getSequenceDB(Map config)`

Uses of BioException in org.biojava.bio.seq.db.biosql

Methods in org.biojava.bio.seq.db.biosql that throw BioException
`static Taxon` `TaxonSQL.addName(Connection conn, Taxon taxon, String nameClass, String newName)` Deprecated. Adds a new name of the given `nameClass` to the taxon.
`void` `BioSQLSequenceDB.addSequence(Sequence seq)` Deprecated.
`void` `BioSQLSequenceDB.createDummySequence(String id, Alphabet alphabet, int length)` Deprecated.
`static Stack` `TaxonSQL.getChildrenOf(Connection conn, String scientificName)` Deprecated. Returns all children of the specified taxon.
`static Stack` `TaxonSQL.getChildrenOf(Connection conn, Taxon t)` Deprecated. Returns the children as a `Stack` of this given taxon.
`Sequence` `BioSQLSequenceDB.getSequence(int bioentry_id)` Deprecated.
`Sequence` `BioSQLSequenceDB.getSequence(String id)` Deprecated.
`SequenceDBLite` `BioSQLSequenceDBProvider.getSequenceDB(Map config)` Deprecated.
`static Taxon` `TaxonSQL.removeName(Connection conn, DBHelper helper, Taxon taxon, String nameClass, String oldName)` Deprecated. Deletes the specified name from of the taxon from the database.
`void` `BioSQLSequenceDB.removeSequence(String id)` Deprecated.
`static Taxon` `TaxonSQL.removeTaxon(Connection conn, DBHelper helper, String name)` Deprecated. Deletes a taxon specified by one of it's names with all it's different names, annotations and sequences from the database.
`static Taxon` `TaxonSQL.removeTaxon(Connection conn, int ncbi_id, DBHelper helper)` Deprecated. Deletes the taxon given by it's NCBI-Taxon-ID from the database and returns the removed taxon.
`static Taxon` `TaxonSQL.setCommonName(Connection conn, Taxon taxon, String newName)` Deprecated. With this method the common name of the given taxon can be changed or created, if there was none before.

Constructors in org.biojava.bio.seq.db.biosql that throw BioException
`BioSQLSequenceDB(DataSource ds, String biodatabase, boolean create)` Deprecated.
`BioSQLSequenceDB(String dbURL, String dbUser, String dbPass, String biodatabase, boolean create)` Deprecated. Connect to a BioSQL database.
`BioSQLSequenceDB(String dbDriver, String dbURL, String dbUser, String dbPass, String biodatabase, boolean create)` Deprecated. Connect to a BioSQL database.

Uses of BioException in org.biojava.bio.seq.db.flat

Methods in org.biojava.bio.seq.db.flat that throw BioException
`Sequence` `FlatSequenceDB.getSequence(String id)`
`SequenceDBLite` `FlatSequenceDBProvider.getSequenceDB(Map config)`

Constructors in org.biojava.bio.seq.db.flat that throw BioException
`FlatSequenceDB(String location, String dbName)`

Uses of BioException in org.biojava.bio.seq.distributed

Methods in org.biojava.bio.seq.distributed that throw BioException
`FeatureHolder` `SequenceDBDataSource.getFeatures(FeatureFilter ff)`
`FeatureHolder` `GFFDataSource.getFeatures(FeatureFilter ff)`
`FeatureHolder` `DistDataSource.getFeatures(FeatureFilter ff)` Get all features matching a FeatureFilter provided by this DistDataSource.
`FeatureHolder` `SequenceDBDataSource.getFeatures(String id, FeatureFilter ff, boolean recurse)`
`FeatureHolder` `GFFDataSource.getFeatures(String id, FeatureFilter ff, boolean recurse)`
`FeatureHolder` `DistDataSource.getFeatures(String id, FeatureFilter ff, boolean recurse)` Get all features matching a FeatureFilter on a Sequence with an ID and recurse flats.
`Sequence` `SequenceDBDataSource.getSequence(String id)`
`Sequence` `GFFDataSource.getSequence(String id)`
`Sequence` `DistributedSequenceDB.getSequence(String id)`
`Sequence` `DistDataSource.getSequence(String id)` Get a Sequence object for an ID.
`boolean` `SequenceDBDataSource.hasFeatures(String id)`
`boolean` `GFFDataSource.hasFeatures(String id)`
`boolean` `DistDataSource.hasFeatures(String id)` Find out if this DistDataSource can provide features on a sequence with a particular ID.
`boolean` `SequenceDBDataSource.hasSequence(String id)`
`boolean` `GFFDataSource.hasSequence(String id)`
`boolean` `DistDataSource.hasSequence(String id)` Find out if this DistDataSource provides the sequence information for a sequence ID.
`Set` `SequenceDBDataSource.ids(boolean topLevel)`
`Set` `GFFDataSource.ids(boolean topLevel)`
`Set` `DistDataSource.ids(boolean topLevel)` Get the complete set of sequence IDs provided by this DistDataSource.

Uses of BioException in org.biojava.bio.seq.homol

Methods in org.biojava.bio.seq.homol that throw BioException
`void` `SimpleHomology.setAlignment(Alignment alignment)` `setAlignment` sets the alignment which describes the homology.

Uses of BioException in org.biojava.bio.seq.impl

Methods in org.biojava.bio.seq.impl that throw BioException
`Feature` `ViewSequence.createFeature(Feature.Template template)`
`Feature` `SubSequence.createFeature(Feature.Template templ)`
`Feature` `SimpleSequence.createFeature(Feature.Template template)`
`Feature` `SimpleGappedSequence.createFeature(Feature.Template templ)`
`Feature` `SimpleFeature.createFeature(Feature.Template temp)`
`Feature` `RevCompSequence.createFeature(Feature.Template ft)` createFeature() will call createFeature() on the underlying Sequence.
`Feature` `LazyFilterFeatureHolder.createFeature(Feature.Template temp)`
`Feature` `DummySequence.createFeature(Feature.Template template)`
`Feature` `SimpleSequence.createFeature(FeatureHolder fh, Feature.Template template)` Deprecated. Please use new 1-arg createFeature instead.
`Feature` `SimpleRemoteFeature.getRemoteFeature()`
`static Feature.Template` `TemplateUtils.instantiateTemplate(Feature feat)` This attempts to divine the 'best' template class for a feature and return a new instance readly for pupulating.
`static Feature.Template` `TemplateUtils.makeTemplate(Feature feat)`
`static void` `TemplateUtils.populate(Feature.Template templ, Feature feat)` This attempts to populate the fields of a template using the publically accessible information in a feature.
`Feature` `ViewSequence.realizeFeature(FeatureHolder parent, Feature.Template template)`
`Feature` `SimpleSequence.realizeFeature(FeatureHolder parent, Feature.Template template)`
`Feature` `SimpleFeature.realizeFeature(FeatureHolder fh, Feature.Template templ)`
`void` `SubSequence.removeFeature(Feature f)`
`void` `SimpleSequence.removeFeature(Feature f)` Remove a feature attached to this sequence.
`void` `SimpleGappedSequence.removeFeature(Feature f)`
`void` `RevCompSequence.removeFeature(Feature f)`
`void` `LazyFilterFeatureHolder.removeFeature(Feature f)`
`void` `DummySequence.removeFeature(Feature feature)`
`Feature` `SimpleRemoteFeature.DBResolver.resolve(RemoteFeature rFeat)`

Uses of BioException in org.biojava.bio.seq.io

Subclasses of BioException in org.biojava.bio.seq.io
`class` `ParseException` ParseException should be thrown to indicate that there was a problem with parsing sequence information.

Methods in org.biojava.bio.seq.io that throw BioException
`ComponentFeature` `SimpleAssemblyBuilder.addComponentSequence(ComponentFeature.Template cft)`
`static void` `SeqIOTools.biojavaToFile(int fileType, OutputStream os, Object biojava)` Deprecated. Converts a Biojava object to the given filetype.
`static void` `SeqIOTools.biojavaToFile(String formatName, String alphabetName, OutputStream os, Object biojava)` Deprecated. Writes a Biojava `SequenceIterator`, `SequenceDB`, `Sequence` or `Aligment` to an `OutputStream`
`void` `FeatureTableParser.endFeature()` Deprecated.
`void` `FeatureTableParser.featureData(String line)` Deprecated.
`static Object` `SeqIOTools.fileToBiojava(int fileType, BufferedReader br)` Deprecated. Reads a file and returns the corresponding Biojava object.
`static Object` `SeqIOTools.fileToBiojava(String formatName, String alphabetName, BufferedReader br)` Deprecated. Reads a file with the specified format and alphabet
`static SequenceBuilderFactory` `SeqIOTools.formatToFactory(SequenceFormat format, Alphabet alpha)` Deprecated. as this essentially duplicates the operation available in the method `identifyBuilderFactory`.
`static FiniteAlphabet` `SeqIOTools.getAlphabet(int identifier)` Deprecated. `getAlphabet` accepts a value which represents a sequence format and returns the relevant `FiniteAlphabet` object.
`static SequenceBuilderFactory` `SeqIOTools.getBuilderFactory(int identifier)` Deprecated. `getBuilderFactory` accepts a value which represents a sequence format and returns the relevant `SequenceBuilderFactory` object.
`static SequenceFormat` `SeqIOTools.getSequenceFormat(int identifier)` Deprecated. `getSequenceFormat` accepts a value which represents a sequence format and returns the relevant `SequenceFormat` object.
`SymbolList` `ChunkedSymbolListFactory.make(SymbolReader sr)` Method to create a Sequence with a SymbolReader.
`Sequence` `SmartSequenceBuilder.makeSequence()`
`Sequence` `SimpleSequenceBuilder.makeSequence()`
`Sequence` `SimpleAssemblyBuilder.makeSequence()`
`Sequence` `SequenceDBSequenceBuilder.makeSequence()` create the sequence
`Sequence` `SequenceBuilderFilter.makeSequence()`
`Sequence` `SequenceBuilderBase.makeSequence()`
`Sequence` `SequenceBuilder.makeSequence()` Return the Sequence object which has been constructed by this builder.
`Sequence` `StreamReader.nextSequence()` Pull the next sequence out of the stream.
`Feature.Template` `EmblLikeLocationParser.parseLocation(String location, Feature.Template theTemplate)` Deprecated. `parseLocation` creates a `Location` from the String and returns a stranded location.
`static SequenceDB` `SeqIOTools.readFasta(InputStream seqFile, Alphabet alpha)` Deprecated. Create a sequence database from a fasta file provided as an input stream.
`boolean` `SequenceFormat.readSequence(BufferedReader reader, SymbolTokenization symParser, SeqIOListener listener)` Read a sequence and pass data on to a SeqIOListener.
`void` `FeatureTableParser.startFeature(String type)` Deprecated.
`void` `MSFAlignmentFormat.write(OutputStream os, Alignment align, int fileType)`
`void` `FastaAlignmentFormat.write(OutputStream os, Alignment align, int fileType)` Writes out the alignment to an FASTA file.
`void` `MSFAlignmentFormat.writeDna(OutputStream os, Alignment align)`
`void` `FastaAlignmentFormat.writeDna(OutputStream os, Alignment align)`
`static void` `SeqIOTools.writeGenpept(OutputStream os, Sequence seq)` Deprecated. Writes a single Sequence to an OutputStream in Genpept format.
`static void` `SeqIOTools.writeGenpept(OutputStream os, SequenceIterator in)` Deprecated. Writes a stream of Sequences to an OutputStream in Genpept format.
`void` `MSFAlignmentFormat.writeProtein(OutputStream os, Alignment align)`
`void` `FastaAlignmentFormat.writeProtein(OutputStream os, Alignment align)`
`static void` `SeqIOTools.writeSwissprot(OutputStream os, Sequence seq)` Deprecated. Writes a single Sequence to an OutputStream in SwissProt format.
`static void` `SeqIOTools.writeSwissprot(OutputStream os, SequenceIterator in)` Deprecated. Writes a stream of Sequences to an OutputStream in SwissProt format.

Constructors in org.biojava.bio.seq.io that throw BioException
`CrossProductTokenization(Alphabet alpha)`

Uses of BioException in org.biojava.bio.seq.projection

Methods in org.biojava.bio.seq.projection that throw BioException
`Feature` `ReparentContext.createFeature(Feature.Template projTempl)`
`Feature` `ProjectionContext.createFeature(Feature.Template projTempl)` Create a projected feature with properties matching the template.
`Feature` `ProjectedFeatureHolder.createFeature(Feature.Template templ)`
`Feature` `ProjectedFeature.createFeature(Feature.Template temp)`
`Feature` `ReparentContext.createFeature(Feature f, Feature.Template projTempl)`
`Feature` `ProjectionContext.createFeature(Feature projParent, Feature.Template projTempl)` Create a new projected feature.
`void` `ReparentContext.removeFeature(Feature dyingChild)`
`void` `ProjectionContext.removeFeature(Feature dyingChild)` Remove the dying child.
`void` `ProjectedFeatureHolder.removeFeature(Feature dyingChild)`
`void` `ProjectedFeature.removeFeature(Feature f)`
`void` `ReparentContext.removeFeature(Feature f, Feature f2)`
`void` `ProjectionContext.removeFeature(Feature projParent, Feature dyingChild)` Remove the dying child.

Uses of BioException in org.biojava.bio.structure

Subclasses of BioException in org.biojava.bio.structure
`class` `StructureException` An exception during the parsing of a PDB file.

Uses of BioException in org.biojava.bio.structure.io

Subclasses of BioException in org.biojava.bio.structure.io
`class` `PDBParseException` An exception during the parsing of a PDB file.

Methods in org.biojava.bio.structure.io that throw BioException
`static SubstitutionMatrix` `SeqRes2AtomAligner.getSubstitutionMatrix(FiniteAlphabet alphabet)`

Uses of BioException in org.biojava.bio.symbol

Subclasses of BioException in org.biojava.bio.symbol
`class` `IllegalAlphabetException` The exception to indicate that an invalid alphabet has been used.
`class` `IllegalSymbolException` The exception to indicate that a symbol is not valid within a context.

Methods in org.biojava.bio.symbol that throw BioException
`static AlphabetIndex` `AlphabetManager.getAlphabetIndex(Symbol[] syms)` Get an indexer for an array of symbols.
`SymbolTokenization` `SoftMaskedAlphabet.getTokenization(String type)`
`SymbolTokenization` `DoubleAlphabet.SubDoubleAlphabet.getTokenization(String name)`
`SymbolTokenization` `Alphabet.getTokenization(String name)` Get a SymbolTokenization by name.
`SymbolTokenization` `AbstractAlphabet.getTokenization(String name)`
`static void` `AlphabetManager.loadAlphabets(InputSource is)` Load additional Alphabets, defined in XML format, into the AlphabetManager's registry.
`static MergeLocation` `MergeLocation.mergeLocations(List componentLocations)` Static Factory method for getting an instance of a `MergeLocation`
`static MergeLocation` `MergeLocation.mergeLocations(Location locA, Location locB)`
`void` `CodonPrefFilter.put(CodonPref codonPref)` handles storage of a CodonPref object
`void` `CodonPrefFilter.ByName.put(CodonPref codonPref)`
`void` `CodonPrefFilter.EverythingToXML.put(CodonPref codonPref)`
`static CodonPref[]` `CodonPrefTools.readFromXML(InputStream prefStream)`
`static void` `CodonPrefTools.readFromXML(InputStream prefStream, CodonPrefFilter filter)` read an CodonPref XML stream and handle it with a CodonPrefFilter object.
`static CodonPref` `CodonPrefTools.readFromXML(InputStream prefStream, String name)` reads a specified CodonPref from an file.
`static void` `CodonPrefTools.writeToXML(CodonPref codonPref, PrintWriter writer)` write out a specified CodonPref object in XML format.

Uses of BioException in org.biojava.bio.taxa

Subclasses of BioException in org.biojava.bio.taxa
`class` `CircularReferenceException` Deprecated. replaced by classes in `org.biojavax.bio.taxa`

Uses of BioException in org.biojava.directory

Methods in org.biojava.directory that throw BioException
`SequenceDBLite` `Registry.getDatabase(String dbName)` `getDatabase` retrieves a database instance known by a name `String`.
`SequenceDBLite` `SequenceDBProvider.getSequenceDB(Map config)` Get a sequence database.

Uses of BioException in org.biojava.utils.automata

Subclasses of BioException in org.biojava.utils.automata
`class` `AutomatonException` An exception thrown by classes of this package.

Uses of BioException in org.biojava.utils.math

Methods in org.biojava.utils.math that throw BioException
`static double` `BinarySearch.solve(double min, double max, double tolerance, ComputeObject obj)` method that will attempt solving the equation.

Uses of BioException in org.biojava.utils.regex

Subclasses of BioException in org.biojava.utils.regex
`class` `RegexException` An exception thrown by classes of this package.

Uses of BioException in org.biojava.utils.walker

Methods in org.biojava.utils.walker that throw BioException
`Walker` `WalkerFactory.getWalker(Visitor visitor)` Get a Walker that is customosed to a particular visitor.

Uses of BioException in org.biojavax.bio

Methods in org.biojavax.bio that throw BioException
`BioEntry` `BioEntryIterator.nextBioEntry()`

Uses of BioException in org.biojavax.bio.db

Methods in org.biojavax.bio.db that throw BioException
`void` `HashBioEntryDB.addBioEntry(BioEntry seq)` Add a BioEntry, the name of the BioEntry will be used as the ID
`void` `BioEntryDBLite.addBioEntry(BioEntry seq)` Adds a sequence to the database.
`void` `AbstractRichSequenceDB.addBioEntry(BioEntry seq)`
`void` `AbstractBioEntryDB.addBioEntry(BioEntry seq)`
`protected void` `HashBioEntryDB.addBioEntry(String id, BioEntry seq)`
`void` `RichSequenceDBLite.addRichSequence(RichSequence seq)` Adds a sequence to the database.
`void` `HashRichSequenceDB.addRichSequence(RichSequence seq)` Add a sequence.
`void` `AbstractRichSequenceDB.addRichSequence(RichSequence seq)`
`protected void` `HashRichSequenceDB.addRichSequence(String id, RichSequence seq)`
`void` `AbstractRichSequenceDB.addSequence(Sequence seq)`
`BioEntry` `HashBioEntryDB.getBioEntry(String id)`
`BioEntry` `BioEntryDBLite.getBioEntry(String id)` Retrieve a single BioEntry by its id.
`BioEntry` `AbstractRichSequenceDB.getBioEntry(String id)`
`BioEntryDB` `HashBioEntryDB.getBioEntrys(Set ids)`
`BioEntryDB` `BioEntryDBLite.getBioEntrys(Set ids)` Retrieve multiple BioEntry by their ids.
`BioEntryDB` `AbstractRichSequenceDB.getBioEntrys(Set ids)`
`BioEntryDB` `HashBioEntryDB.getBioEntrys(Set ids, BioEntryDB db)`
`BioEntryDB` `BioEntryDBLite.getBioEntrys(Set ids, BioEntryDB db)` Retrieve multiple BioEntry into a specific sequence database.
`BioEntryDB` `AbstractRichSequenceDB.getBioEntrys(Set ids, BioEntryDB db)`
`RichSequence` `RichSequenceDBLite.getRichSequence(String id)` Retrieve a single RichSequence by its id.
`RichSequence` `HashRichSequenceDB.getRichSequence(String id)`
`RichSequenceDB` `RichSequenceDBLite.getRichSequences(Set ids)` Retrieve multiple RichSequence by its id.
`RichSequenceDB` `HashRichSequenceDB.getRichSequences(Set ids)`
`RichSequenceDB` `RichSequenceDBLite.getRichSequences(Set ids, RichSequenceDB db)` Retrieve multiple RichSequence into a specific sequence database.
`RichSequenceDB` `HashRichSequenceDB.getRichSequences(Set ids, RichSequenceDB db)`
`Sequence` `AbstractRichSequenceDB.getSequence(String id)`
`void` `HashBioEntryDB.removeBioEntry(String id)`
`void` `BioEntryDBLite.removeBioEntry(String id)` Remove the BioEntry associated with an ID from the database.
`void` `AbstractRichSequenceDB.removeBioEntry(String id)`
`void` `AbstractBioEntryDB.removeBioEntry(String id)`
`void` `RichSequenceDBLite.removeRichSequence(String id)` Remove the RichSequence associated with an ID from the database.
`void` `AbstractRichSequenceDB.removeRichSequence(String id)`
`void` `HashRichSequenceDB.removeSequence(String id)`
`void` `AbstractRichSequenceDB.removeSequence(String id)`

Uses of BioException in org.biojavax.bio.db.biosql

Methods in org.biojavax.bio.db.biosql that throw BioException
`void` `BioSQLBioEntryDB._addBioEntry(BioEntry seq)`
`void` `BioSQLBioEntryDB.addBioEntry(BioEntry seq)`
`void` `BioSQLRichSequenceDB.addRichSequence(RichSequence seq)`
`RichSequence` `BioSQLRichSequenceDB.fullyLoadRichSequence(RichSequence id)`
`BioEntry` `BioSQLBioEntryDB.getBioEntry(String id)`
`BioEntryDB` `BioSQLBioEntryDB.getBioEntrys(Set ids)`
`BioEntryDB` `BioSQLBioEntryDB.getBioEntrys(Set ids, BioEntryDB db)`
`RichSequence` `BioSQLRichSequenceDB.getRichSequence(String id)`
`RichSequenceDB` `BioSQLRichSequenceDB.getRichSequences(Set ids)`
`RichSequenceDB` `BioSQLRichSequenceDB.getRichSequences(Set ids, RichSequenceDB db)`
`void` `BioSQLBioEntryDB.removeBioEntry(String id)`
`void` `BioSQLRichSequenceDB.removeRichSequence(String id)`

Uses of BioException in org.biojavax.bio.db.ncbi

Methods in org.biojavax.bio.db.ncbi that throw BioException
`RichSequence` `GenpeptRichSequenceDB.getRichSequence(String id)` Given the appropriate Genbank ID, return the matching RichSequence object.
`RichSequence` `GenbankRichSequenceDB.getRichSequence(String id)` Given the appropriate Genbank ID, return the matching RichSequence object.
`RichSequence` `GenpeptRichSequenceDB.getRichSequence(String id, Namespace nsp)` Given the appropriate Genbank ID, return the matching RichSequence object.
`RichSequence` `GenbankRichSequenceDB.getRichSequence(String id, Namespace nsp)` Given the appropriate Genbank ID, return the matching RichSequence object.
`RichSequenceDB` `GenpeptRichSequenceDB.getRichSequences(Set list)` Retrieve rich sequences from a Genbank
`RichSequenceDB` `GenbankRichSequenceDB.getRichSequences(Set list)` Retrieve rich sequences from a Genbank
`RichSequenceDB` `GenpeptRichSequenceDB.getRichSequences(Set list, RichSequenceDB database)` Retrieve rich sequences from a Genbank
`RichSequenceDB` `GenbankRichSequenceDB.getRichSequences(Set list, RichSequenceDB database)` Retrieve rich sequences from a Genbank

Uses of BioException in org.biojavax.bio.seq

Methods in org.biojavax.bio.seq that throw BioException
`Feature` `ThinRichSequence.createFeature(Feature.Template ft)` Create a new Feature, and add it to this FeatureHolder.
`Feature` `SimpleRichFeature.createFeature(Feature.Template ft)` Create a new Feature, and add it to this FeatureHolder.
`static RichSequence` `RichSequence.Tools.createRichSequence(Namespace ns, String name, String seqString, Alphabet alpha)` Create a new RichSequence in the specified namespace.
`static RichSequence` `RichSequence.Tools.createRichSequence(String name, String seqString, Alphabet alpha)` Create a new RichSequence in the default namespace.
`static RichSequence` `RichSequence.Tools.createRichSequence(String namespace, String name, String seqString, Alphabet alpha)` Create a new RichSequence in the specified namespace.
`RichSequence` `RichSequenceIterator.nextRichSequence()`
`static RichSequenceIterator` `RichSequence.IOTools.readHashedFastaDNA(BufferedInputStream is, Namespace ns)` Iterate over the sequences in an FASTA-format stream of DNA sequences.
`void` `ThinRichSequence.removeFeature(Feature f)` Remove a feature from this FeatureHolder.
`void` `SimpleRichFeature.removeFeature(Feature f)` Remove a feature from this FeatureHolder.
`protected void` `ThinRichSequence.setAlphabetName(String alphaname)`
`protected void` `SimpleRichSequence.setAlphabetName(String alphaname)`
`protected void` `SimpleRichSequence.setStringSequence(String seq)`

Uses of BioException in org.biojavax.bio.seq.io

Methods in org.biojavax.bio.seq.io that throw BioException
`RichSequence` `SimpleRichSequenceBuilder.makeRichSequence()` Build a RichSequence.
`RichSequence` `RichSequenceBuilder.makeRichSequence()` Build a RichSequence.
`Sequence` `SimpleRichSequenceBuilder.makeSequence()` Return the Sequence object which has been constructed by this builder.
`Sequence` `RichSequenceBuilder.makeSequence()` Return the Sequence object which has been constructed by this builder. Implementations of this for a RichSequenceBuilder should delegate to makeRichSequence() and return only RichSequence objects.
`BioEntry` `RichStreamReader.nextBioEntry()`
`BioEntry` `HashedFastaIterator.nextBioEntry()`
`RichSequence` `RichStreamReader.nextRichSequence()`
`RichSequence` `HashedFastaIterator.nextRichSequence()`
`Sequence` `RichStreamReader.nextSequence()` Returns the next sequence in the iterator.
`Sequence` `HashedFastaIterator.nextSequence()`
`boolean` `RichSequenceFormat.readRichSequence(BufferedReader reader, SymbolTokenization symParser, RichSeqIOListener listener, Namespace ns)` Reads a sequence from the given buffered reader using the given tokenizer to parse sequence symbols.

Constructors in org.biojavax.bio.seq.io that throw BioException
`HashedFastaIterator(BufferedInputStream is, Alphabet alpha, Namespace ns)`