## org.biojava.bio.seq.io
Class ChunkedSymbolListFactory

    java.lang.Object
      org.biojava.bio.seq.io.ChunkedSymbolListFactory

    public class ChunkedSymbolListFactory

extends Object

class that makes ChunkedSymbolLists with the chunks implemented as SymbolLists themselves.

The advantage is that those SymbolLists can be packed implementations.

You can build a SequenceBuilderFactory to create a packed chunked sequence from an input file without making an intermediate symbol list with:-

     public class PackedChunkedListFactory implements SequenceBuilderFactory
     {
       public SequenceBuilder makeSequenceBuilder()
       {
         return new SequenceBuilderBase() {
           private ChunkedSymbolListFactory chunker = new ChunkedSymbolListFactory(new PackedSymbolListFactory(true));

           // deal with symbols
           public void addSymbols(Alphabet alpha, Symbol[] syms, int pos, int len)
             throws IllegalAlphabetException
           {
             chunker.addSymbols(alpha, syms, pos, len);
           }

           // make the sequence
           public Sequence makeSequence()
           {
             try {
               // make the SymbolList
               SymbolList symbols = chunker.makeSymbolList();
               seq = new SimpleSequence(symbols, uri, name, annotation);

               // call superclass method
               return super.makeSequence();
             }
             catch (IllegalAlphabetException iae) {
               throw new BioError("couldn't create symbol list");
             }
           }
         };
       }
     }

Then reading in FASTA files can be done with something like:-

     SequenceIterator seqI = new StreamReader(br, new FastaFormat(),
         DNATools.getDNA().getTokenization("token"),
         new PackedChunkedListFactory() );

Blend to suit taste.

Alternatively, you can input Symbols to the factory with addSymbols make the sequence eventually with makeSymbolList.

NOTE: An improvement has been introduced where an internal default SymbolList factory is used for small sequences. This implementation allows for faster SymbolList creation and access for small sequences while allowing a more space-efficient implementation to be selected for large sequences.

NOTE: This class is inherantly not threadsafe. You should create one instance for each symbol list you wish to manufacture, and then you should throw that instance away.

Author:
  David Huen

Constructor Summary
`ChunkedSymbolListFactory(SymbolListFactory symListFactory)`
`ChunkedSymbolListFactory(SymbolListFactory userSymListFactory, int threshold)`

Method Summary
`void` `addSymbols(Alphabet alfa, Symbol[] syms, int pos, int len)` tool to construct the SymbolList by adding Symbols.
`SymbolList` `make(SymbolReader sr)` Method to create a Sequence with a SymbolReader.
`SymbolList` `makeSymbolList()` Converts accumulated Symbols to a SymbolList
`void` `useSuppliedSymListFactory()` Call this to convert from default SymbolList implementation to user-supplied implementation.

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

Constructor Detail

### ChunkedSymbolListFactory

    public ChunkedSymbolListFactory(SymbolListFactory symListFactory)

Parameters:
  `symListFactory` - class which produces the SymbolLists that are used to store the chunked symbols.

### ChunkedSymbolListFactory

    public ChunkedSymbolListFactory(SymbolListFactory userSymListFactory,
                                    int threshold)

Parameters:
  `userSymListFactory` - User-supplied class which produces the SymbolLists that are used to store the chunked symbols (only used when the chunked list to be created is larger than threshold.
  `threshold` - the size of the SymbolList beyond which the userSymListFactory is used. Below that, the internal default SymbolList factory is used.

Method Detail

### addSymbols

    public void addSymbols(Alphabet alfa,
                           Symbol[] syms,
                           int pos,
                           int len)
                    throws IllegalArgumentException,
                           IllegalAlphabetException

  tool to construct the SymbolList by adding Symbols. Note that this class is not thread-safe. Also, it can only assemble one SymbolList at a time. And the composite formed by adding Symbols must not have interstitial missing Symbols.

  Throws:
    `IllegalArgumentException`
    `IllegalAlphabetException`

### useSuppliedSymListFactory

    public void useSuppliedSymListFactory()

  Call this to convert from default SymbolList implementation to user-supplied implementation.

### makeSymbolList

    public SymbolList makeSymbolList()
                              throws IllegalAlphabetException

  Converts accumulated Symbols to a SymbolList

  Throws:
    `IllegalAlphabetException`

### make

    public SymbolList make(SymbolReader sr)
                    throws IOException,
                           IllegalSymbolException,
                           IllegalAlphabetException,
                           BioException

  Method to create a Sequence with a SymbolReader. (does anyone use this???> readme: As of 12/11/03, there are no references to this method in the codebase

  Throws:
    `IOException`
    `IllegalSymbolException`
    `IllegalAlphabetException`
    `BioException`