## org.biojava.bio.symbol
Class SingletonAlphabet

    java.lang.Object
      org.biojava.utils.AbstractChangeable
          org.biojava.bio.symbol.AbstractAlphabet
              org.biojava.bio.symbol.SingletonAlphabet

All Implemented Interfaces:
  Serializable, Annotatable, Alphabet, FiniteAlphabet, Changeable

    public class SingletonAlphabet

extends AbstractAlphabet
implements FiniteAlphabet, Serializable

An alphabet that contains a single atomic symbol.

Author:
  Matthew Pocock
See Also:
  Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface org.biojava.bio.Annotatable
`Annotatable.AnnotationForwarder`

Field Summary

Fields inherited from class org.biojava.bio.symbol.AbstractAlphabet
`serialVersionUID`

Fields inherited from interface org.biojava.bio.symbol.Alphabet
`EMPTY_ALPHABET, PARSERS, SYMBOLS`

Fields inherited from interface org.biojava.bio.Annotatable
`ANNOTATION`

Constructor Summary
`SingletonAlphabet(AtomicSymbol sym)`

Method Summary
`void` `addSymbolImpl(AtomicSymbol sym)`
`protected boolean` `containsImpl(AtomicSymbol s)`
`List` `getAlphabets()` Return an ordered List of the alphabets which make up a compound alphabet.
`Annotation` `getAnnotation()` Should return the associated annotation object.
`String` `getName()` Get the name of the alphabet.
`protected AtomicSymbol` `getSymbolImpl(List symList)`
`SymbolTokenization` `getTokenization(String name)` Get a SymbolTokenization by name.
`Iterator` `iterator()` Retrieve an Iterator over the AtomicSymbols in this FiniteAlphabet.
`void` `removeSymbol(Symbol sym)` Remove a symbol from this alphabet.
`int` `size()` The number of symbols in the alphabet.

Methods inherited from class org.biojava.bio.symbol.AbstractAlphabet
`addSymbol, contains, getAmbiguity, getAmbiguityImpl, getGapSymbol, getSymbol, putTokenization, readResolve, toString, validate`

Methods inherited from class org.biojava.utils.AbstractChangeable
`addChangeListener, addChangeListener, generateChangeSupport, getChangeSupport, hasListeners, hasListeners, isUnchanging, removeChangeListener, removeChangeListener`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.biojava.bio.symbol.FiniteAlphabet
`addSymbol`

Methods inherited from interface org.biojava.bio.symbol.Alphabet
`contains, getAmbiguity, getGapSymbol, getSymbol, validate`

Methods inherited from interface org.biojava.utils.Changeable
`addChangeListener, addChangeListener, isUnchanging, removeChangeListener, removeChangeListener`

Constructor Detail

### SingletonAlphabet

    public SingletonAlphabet(AtomicSymbol sym)

Method Detail

### getAlphabets

    public List getAlphabets()

  Description copied from interface: `Alphabet`
  Return an ordered List of the alphabets which make up a compound alphabet. For simple alphabets, this will return a singleton list of itself. The returned list should be immutable.

  Specified by:
    `getAlphabets` in interface `Alphabet`
  Returns:
    a List of alphabets

### containsImpl

    protected boolean containsImpl(AtomicSymbol s)

  Specified by:
    `containsImpl` in class `AbstractAlphabet`

### getName

    public String getName()

  Description copied from interface: `Alphabet`
  Get the name of the alphabet.

  Specified by:
    `getName` in interface `Alphabet`
  Returns:
    the name as a string.

### getTokenization

    public SymbolTokenization getTokenization(String name)
                                       throws NoSuchElementException

  Description copied from interface: `Alphabet`

  Get a SymbolTokenization by name.

  The parser returned is guaranteed to return Symbols and SymbolLists that conform to this alphabet.

  Every alphabet should have a SymbolTokenzation under the name 'token' that uses the symbol token characters to translate a string into a SymbolList. Likewise, there should be a SymbolTokenization under the name 'name' that uses symbol names to identify symbols. Any other names may also be defined, but the behaviour of the returned SymbolTokenization is not defined here.

  A SymbolTokenization under the name 'default' should be defined for all sequences, that determines the behavior when printing out a sequence. Standard behavior is to define the 'token' SymbolTokenization as default if it exists, else to define the 'name' SymbolTokenization as the default, but others are possible.

  Specified by:
    `getTokenization` in interface `Alphabet`
  Overrides:
    `getTokenization` in class `AbstractAlphabet`
  Parameters:
    `name` - the name of the parser
  Returns:
    a parser for that name
  Throws:
    `NoSuchElementException` - if the name is unknown

### iterator

    public Iterator iterator()

  Description copied from interface: `FiniteAlphabet`
  Retrieve an Iterator over the AtomicSymbols in this FiniteAlphabet.

  Each AtomicSymbol as for which this.contains(as) is true will be returned exactly once by this iterator in no specified order.

  Specified by:
    `iterator` in interface `FiniteAlphabet`
  Returns:
    an Iterator over the contained AtomicSymbol objects

### size

    public int size()

  Description copied from interface: `FiniteAlphabet`
  The number of symbols in the alphabet.

  Specified by:
    `size` in interface `FiniteAlphabet`
  Returns:
    the size of the alphabet

### getAnnotation

    public Annotation getAnnotation()

  Description copied from interface: `Annotatable`
  Should return the associated annotation object.

  Specified by:
    `getAnnotation` in interface `Annotatable`
  Returns:
    an Annotation object, never null

### addSymbolImpl

    public void addSymbolImpl(AtomicSymbol sym)
                       throws IllegalSymbolException

  Specified by:
    `addSymbolImpl` in class `AbstractAlphabet`
  Throws:
    `IllegalSymbolException`

### removeSymbol

    public void removeSymbol(Symbol sym)
                      throws IllegalSymbolException

  Description copied from interface: `FiniteAlphabet`
  Remove a symbol from this alphabet.

  If the symbol matches multiple AtomicSymbols, then each matching symbol it will be removed.

  Specified by:
    `removeSymbol` in interface `FiniteAlphabet`
  Parameters:
    `sym` - the Symbol to removeintGot
  Throws:
    `IllegalSymbolException` - if the symbol is null, or if for any reason it can't be removed

### getSymbolImpl

    protected AtomicSymbol getSymbolImpl(List symList)
                                  throws IllegalSymbolException

  Specified by:
    `getSymbolImpl` in class `AbstractAlphabet`
  Throws:
    `IllegalSymbolException`