Bio/SeqIO.pm

   1 # BioPerl module for Bio::SeqIO
   2 #
   3 # Please direct questions and support issues to <bioperl-l@bioperl.org>
   4 #
   5 # Cared for by Ewan Birney <birney@ebi.ac.uk>
   6 #       and Lincoln Stein  <lstein@cshl.org>
   7 #
   8 # Copyright Ewan Birney
   9 #
  10 # You may distribute this module under the same terms as perl itself
  11 #
  12 # _history
  13 # October 18, 1999  Largely rewritten by Lincoln Stein
  14
  15 # POD documentation - main docs before the code
  16
  17 =head1 NAME
  18
  19 Bio::SeqIO - Handler for SeqIO Formats
  20
  21 =head1 SYNOPSIS
  22
  23     use Bio::SeqIO;
  24
  25     $in  = Bio::SeqIO->new(-file => "inputfilename" ,
  26                            -format => 'Fasta');
  27     $out = Bio::SeqIO->new(-file => ">outputfilename" ,
  28                            -format => 'EMBL');
  29
  30     while ( my $seq = $in->next_seq() ) {
  31             $out->write_seq($seq);
  32     }
  33
  34   # Now, to actually get at the sequence object, use the standard Bio::Seq
  35   # methods (look at Bio::Seq if you don't know what they are)
  36
  37     use Bio::SeqIO;
  38
  39     $in  = Bio::SeqIO->new(-file => "inputfilename" ,
  40                            -format => 'genbank');
  41
  42     while ( my $seq = $in->next_seq() ) {
  43        print "Sequence ",$seq->id, " first 10 bases ",
  44              $seq->subseq(1,10), "\n";
  45     }
  46
  47
  48   # The SeqIO system does have a filehandle binding. Most people find this
  49   # a little confusing, but it does mean you can write the world's
  50   # smallest reformatter
  51
  52     use Bio::SeqIO;
  53
  54     $in  = Bio::SeqIO->newFh(-file => "inputfilename" ,
  55                              -format => 'Fasta');
  56     $out = Bio::SeqIO->newFh(-format => 'EMBL');
  57
  58     # World's shortest Fasta<->EMBL format converter:
  59     print $out $_ while <$in>;
  60
  61
  62 =head1 DESCRIPTION
  63
  64 Bio::SeqIO is a handler module for the formats in the SeqIO set (eg,
  65 Bio::SeqIO::fasta). It is the officially sanctioned way of getting at
  66 the format objects, which most people should use.
  67
  68 The Bio::SeqIO system can be thought of like biological file handles.
  69 They are attached to filehandles with smart formatting rules (eg,
  70 genbank format, or EMBL format, or binary trace file format) and
  71 can either read or write sequence objects (Bio::Seq objects, or
  72 more correctly, Bio::SeqI implementing objects, of which Bio::Seq is
  73 one such object). If you want to know what to do with a Bio::Seq
  74 object, read L<Bio::Seq>.
  75
  76 The idea is that you request a stream object for a particular format.
  77 All the stream objects have a notion of an internal file that is read
  78 from or written to. A particular SeqIO object instance is configured
  79 for either input or output. A specific example of a stream object is
  80 the Bio::SeqIO::fasta object.
  81
  82 Each stream object has functions
  83
  84    $stream->next_seq();
  85
  86 and
  87
  88    $stream->write_seq($seq);
  89
  90 As an added bonus, you can recover a filehandle that is tied to the
  91 SeqIO object, allowing you to use the standard E<lt>E<gt> and print
  92 operations to read and write sequence objects:
  93
  94     use Bio::SeqIO;
  95
  96     $stream = Bio::SeqIO->newFh(-format => 'Fasta',
  97                                 -fh     => \*ARGV);
  98     # read from standard input or the input filenames
  99
 100     while ( $seq = <$stream> ) {
 101           # do something with $seq
 102     }
 103
 104 and
 105
 106     print $stream $seq; # when stream is in output mode
 107
 108 This makes the simplest ever reformatter
 109
 110     #!/usr/bin/perl
 111     use strict;
 112     my $format1 = shift;
 113     my $format2 = shift || die
 114        "Usage: reformat format1 format2 < input > output";
 115
 116     use Bio::SeqIO;
 117
 118     my $in  = Bio::SeqIO->newFh(-format => $format1, -fh => \*ARGV );
 119     my $out = Bio::SeqIO->newFh(-format => $format2 );
 120     # Note: you might want to quote -format to keep older
 121     # perl's from complaining.
 122
 123     print $out $_ while <$in>;
 124
 125
 126 =head1 CONSTRUCTORS
 127
 128 =head2 Bio::SeqIO-E<gt>new()
 129
 130    $seqIO = Bio::SeqIO->new(-file => 'filename',   -format=>$format);
 131    $seqIO = Bio::SeqIO->new(-fh   => \*FILEHANDLE, -format=>$format);
 132    $seqIO = Bio::SeqIO->new(-format => $format);
 133
 134 The new() class method constructs a new Bio::SeqIO object.  The
 135 returned object can be used to retrieve or print Seq objects. new()
 136 accepts the following parameters:
 137
 138 =over 5
 139
 140 =item -file
 141
 142 A file path to be opened for reading or writing.  The usual Perl
 143 conventions apply:
 144
 145    'file'       # open file for reading
 146    '>file'      # open file for writing
 147    '>>file'     # open file for appending
 148    '+<file'     # open file read/write
 149    'command |'  # open a pipe from the command
 150    '| command'  # open a pipe to the command
 151
 152 =item -fh
 153
 154 You may provide new() with a previously-opened filehandle.  For
 155 example, to read from STDIN:
 156
 157    $seqIO = Bio::SeqIO->new(-fh => \*STDIN);
 158
 159 Note that you must pass filehandles as references to globs.
 160
 161 If neither a filehandle nor a filename is specified, then the module
 162 will read from the @ARGV array or STDIN, using the familiar E<lt>E<gt>
 163 semantics.
 164
 165 A string filehandle is handy if you want to modify the output in the
 166 memory, before printing it out. The following program reads in EMBL
 167 formatted entries from a file and prints them out in fasta format with
 168 some HTML tags:
 169
 170   use Bio::SeqIO;
 171   use IO::String;
 172   my $in  = Bio::SeqIO->new(-file => "emblfile",
 173                             -format => 'EMBL');
 174   while ( my $seq = $in->next_seq() ) {
 175       # the output handle is reset for every file
 176       my $stringio = IO::String->new($string);
 177       my $out = Bio::SeqIO->new(-fh => $stringio,
 178                                 -format => 'fasta');
 179       # output goes into $string
 180       $out->write_seq($seq);
 181       # modify $string
 182       $string =~ s|(>)(\w+)|$1<font color="Red">$2</font>|g;
 183       # print into STDOUT
 184       print $string;
 185   }
 186
 187 =item -format
 188
 189 Specify the format of the file.  Supported formats include fasta,
 190 genbank, embl, swiss (SwissProt), Entrez Gene and tracefile formats
 191 such as abi (ABI) and scf. There are many more, for a complete listing
 192 see the SeqIO HOWTO (L<http://bioperl.open-bio.org/wiki/HOWTO:SeqIO>).
 193
 194 If no format is specified and a filename is given then the module will
 195 attempt to deduce the format from the filename suffix. If there is no
 196 suffix that Bioperl understands then it will attempt to guess the
 197 format based on file content. If this is unsuccessful then SeqIO will
 198 throw a fatal error.
 199
 200 The format name is case-insensitive: 'FASTA', 'Fasta' and 'fasta' are
 201 all valid.
 202
 203 Currently, the tracefile formats (except for SCF) require installation
 204 of the external Staden "io_lib" package, as well as the
 205 Bio::SeqIO::staden::read package available from the bioperl-ext
 206 repository.
 207
 208 =item -alphabet
 209
 210 Sets the alphabet ('dna', 'rna', or 'protein'). When the alphabet is
 211 set then Bioperl will not attempt to guess what the alphabet is. This
 212 may be important because Bioperl does not always guess correctly.
 213
 214 =item -flush
 215
 216 By default, all files (or filehandles) opened for writing sequences
 217 will be flushed after each write_seq() (making the file immediately
 218 usable).  If you do not need this facility and would like to marginally
 219 improve the efficiency of writing multiple sequences to the same file
 220 (or filehandle), pass the -flush option '0' or any other value that
 221 evaluates as defined but false:
 222
 223   my $gb = Bio::SeqIO->new(-file   => "<gball.gbk",
 224                            -format => "gb");
 225   my $fa = Bio::SeqIO->new(-file   => ">gball.fa",
 226                            -format => "fasta",
 227                            -flush  => 0); # go as fast as we can!
 228   while($seq = $gb->next_seq) { $fa->write_seq($seq) }
 229
 230
 231 =back
 232
 233 =head2 Bio::SeqIO-E<gt>newFh()
 234
 235    $fh = Bio::SeqIO->newFh(-fh => \*FILEHANDLE, -format=>$format);
 236    $fh = Bio::SeqIO->newFh(-format => $format);
 237    # etc.
 238
 239 This constructor behaves like new(), but returns a tied filehandle
 240 rather than a Bio::SeqIO object.  You can read sequences from this
 241 object using the familiar E<lt>E<gt> operator, and write to it using
 242 print().  The usual array and $_ semantics work.  For example, you can
 243 read all sequence objects into an array like this:
 244
 245   @sequences = <$fh>;
 246
 247 Other operations, such as read(), sysread(), write(), close(), and
 248 printf() are not supported.
 249
 250 =head1 OBJECT METHODS
 251
 252 See below for more detailed summaries.  The main methods are:
 253
 254 =head2 $sequence = $seqIO-E<gt>next_seq()
 255
 256 Fetch the next sequence from the stream, or nothing if no more.
 257
 258 =head2 $seqIO-E<gt>write_seq($sequence [,$another_sequence,...])
 259
 260 Write the specified sequence(s) to the stream.
 261
 262 =head2 TIEHANDLE(), READLINE(), PRINT()
 263
 264 These provide the tie interface.  See L<perltie> for more details.
 265
 266 =head1 FEEDBACK
 267
 268 =head2 Mailing Lists
 269
 270 User feedback is an integral part of the evolution of this and other
 271 Bioperl modules. Send your comments and suggestions preferably to one
 272 of the Bioperl mailing lists.
 273
 274 Your participation is much appreciated.
 275
 276   bioperl-l@bioperl.org                  - General discussion
 277   http://bioperl.org/wiki/Mailing_lists  - About the mailing lists
 278
 279 =head2 Support
 280
 281 Please direct usage questions or support issues to the mailing list:
 282
 283  bioperl-l@bioperl.org
 284
 285 rather than to the module maintainer directly. Many experienced and
 286 responsive experts will be able look at the problem and quickly
 287 address it. Please include a thorough description of the problem
 288 with code and data examples if at all possible.
 289
 290 =head2 Reporting Bugs
 291
 292 Report bugs to the Bioperl bug tracking system to help us keep track
 293 the bugs and their resolution.  Bug reports can be submitted via the
 294 web:
 295
 296   https://redmine.open-bio.org/projects/bioperl/
 297
 298 =head1 AUTHOR - Ewan Birney, Lincoln Stein
 299
 300 Email birney@ebi.ac.uk
 301       lstein@cshl.org
 302
 303 =head1 APPENDIX
 304
 305 The rest of the documentation details each of the object
 306 methods. Internal methods are usually preceded with a _
 307
 308 =cut
 309
 310 #' Let the code begin...
 311
 312 package Bio::SeqIO;
 313
 314 use strict;
 315
 316 use Bio::Factory::FTLocationFactory;
 317 use Bio::Seq::SeqBuilder;
 318 use Bio::Tools::GuessSeqFormat;
 319 use Symbol;
 320
 321 use base qw(Bio::Root::Root Bio::Root::IO Bio::Factory::SequenceStreamI);
 322
 323 my %valid_alphabet_cache;
 324
 325 =head2 new
 326
 327  Title   : new
 328  Usage   : $stream = Bio::SeqIO->new(-file => $filename,
 329                                      -format => 'Format')
 330  Function: Returns a new sequence stream
 331  Returns : A Bio::SeqIO stream initialised with the appropriate format
 332  Args    : Named parameters:
 333              -file => $filename
 334              -fh => filehandle to attach to
 335              -format => format
 336
 337            Additional arguments may be used to set factories and
 338            builders involved in the sequence object creation. None of
 339            these must be provided, they all have reasonable defaults.
 340              -seqfactory   the Bio::Factory::SequenceFactoryI object
 341              -locfactory   the Bio::Factory::LocationFactoryI object
 342              -objbuilder   the Bio::Factory::ObjectBuilderI object
 343
 344 See L<Bio::SeqIO::Handler>
 345
 346 =cut
 347
 348 my $entry = 0;
 349
 350 sub new {
 351         my ($caller,@args) = @_;
 352         my $class = ref($caller) || $caller;
 353
 354         # or do we want to call SUPER on an object if $caller is an
 355         # object?
 356         if( $class =~ /Bio::SeqIO::(\S+)/ ) {
 357                 my ($self) = $class->SUPER::new(@args);
 358                 $self->_initialize(@args);
 359                 return $self;
 360         } else {
 361
 362                 my %param = @args;
 363                 @param{ map { lc $_ } keys %param } = values %param; # lowercase keys
 364
 365                 unless( defined $param{-file} ||
 366                         defined $param{-fh}   ||
 367                         defined $param{-string} ) {
 368                     $class->throw("file argument provided, but with an undefined value")
 369                         if exists $param{'-file'};
 370                     $class->throw("fh argument provided, but with an undefined value")
 371                         if exists $param{'-fh'};
 372                     $class->throw("string argument provided, but with an undefined value")
 373                         if exists($param{'-string'});
 374                     # $class->throw("No file, fh, or string argument provided"); # neither defined
 375                 }
 376
 377         my $format = $param{'-format'} ||
 378             $class->_guess_format( $param{-file} || $ARGV[0] );
 379
 380         if( ! $format ) {
 381             if ($param{-file}) {
 382                 $format = Bio::Tools::GuessSeqFormat->new(-file => $param{-file}||$ARGV[0] )->guess;
 383             } elsif ($param{-fh}) {
 384                 $format = Bio::Tools::GuessSeqFormat->new(-fh => $param{-fh}||$ARGV[0] )->guess;
 385             }
 386         }
 387     # changed 1-3-11; no need to print out an empty string (only way this
 388     # exception is triggered) - cjfields
 389     $class->throw("Could not guess format from file/fh") unless $format;
 390         $format = "\L$format";  # normalize capitalization to lower case
 391
 392     if ($format =~ /-/) {
 393         ($format, my $variant) = split('-', $format, 2);
 394         push @args, (-variant => $variant);
 395     }
 396         return unless( $class->_load_format_module($format) );
 397         return "Bio::SeqIO::$format"->new(@args);
 398     }
 399 }
 400
 401 =head2 newFh
 402
 403  Title   : newFh
 404  Usage   : $fh = Bio::SeqIO->newFh(-file=>$filename,-format=>'Format')
 405  Function: does a new() followed by an fh()
 406  Example : $fh = Bio::SeqIO->newFh(-file=>$filename,-format=>'Format')
 407            $sequence = <$fh>;   # read a sequence object
 408            print $fh $sequence; # write a sequence object
 409  Returns : filehandle tied to the Bio::SeqIO::Fh class
 410  Args    :
 411
 412 See L<Bio::SeqIO::Fh>
 413
 414 =cut
 415
 416 sub newFh {
 417   my $class = shift;
 418   return unless my $self = $class->new(@_);
 419   return $self->fh;
 420 }
 421
 422 =head2 fh
 423
 424  Title   : fh
 425  Usage   : $obj->fh
 426  Function:
 427  Example : $fh = $obj->fh;      # make a tied filehandle
 428            $sequence = <$fh>;   # read a sequence object
 429            print $fh $sequence; # write a sequence object
 430  Returns : filehandle tied to Bio::SeqIO class
 431  Args    : none
 432
 433 =cut
 434
 435
 436 sub fh {
 437   my $self = shift;
 438   my $class = ref($self) || $self;
 439   my $s = Symbol::gensym;
 440   tie $$s,$class,$self;
 441   return $s;
 442 }
 443
 444 # _initialize is chained for all SeqIO classes
 445
 446 sub _initialize {
 447         my($self, @args) = @_;
 448
 449         # flush is initialized by the Root::IO init
 450
 451         my ($seqfact,$locfact,$objbuilder, $alphabet) =
 452           $self->_rearrange([qw(SEQFACTORY
 453                               LOCFACTORY
 454                               OBJBUILDER
 455                   ALPHABET)
 456                                                           ], @args);
 457
 458         $locfact = Bio::Factory::FTLocationFactory->new(-verbose => $self->verbose)
 459           if ! $locfact;
 460         $objbuilder = Bio::Seq::SeqBuilder->new(-verbose => $self->verbose)
 461           unless $objbuilder;
 462         $self->sequence_builder($objbuilder);
 463         $self->location_factory($locfact);
 464
 465         # note that this should come last because it propagates the sequence
 466         # factory to the sequence builder
 467         $seqfact && $self->sequence_factory($seqfact);
 468
 469     #bug 2160
 470     $alphabet && $self->alphabet($alphabet);
 471
 472
 473         # initialize the IO part
 474         $self->_initialize_io(@args);
 475 }
 476
 477 =head2 next_seq
 478
 479  Title   : next_seq
 480  Usage   : $seq = stream->next_seq
 481  Function: Reads the next sequence object from the stream and returns it.
 482
 483            Certain driver modules may encounter entries in the stream
 484            that are either misformatted or that use syntax not yet
 485            understood by the driver. If such an incident is
 486            recoverable, e.g., by dismissing a feature of a feature
 487            table or some other non-mandatory part of an entry, the
 488            driver will issue a warning. In the case of a
 489            non-recoverable situation an exception will be thrown.  Do
 490            not assume that you can resume parsing the same stream
 491            after catching the exception. Note that you can always turn
 492            recoverable errors into exceptions by calling
 493            $stream->verbose(2).
 494
 495  Returns : a Bio::Seq sequence object, or nothing if no more sequences
 496            are available
 497
 498  Args    : none
 499
 500 See L<Bio::Root::RootI>, L<Bio::Factory::SeqStreamI>, L<Bio::Seq>
 501
 502 =cut
 503
 504 sub next_seq {
 505    my ($self, $seq) = @_;
 506    $self->throw("Sorry, you cannot read from a generic Bio::SeqIO object.");
 507 }
 508
 509 =head2 write_seq
 510
 511  Title   : write_seq
 512  Usage   : $stream->write_seq($seq)
 513  Function: writes the $seq object into the stream
 514  Returns : 1 for success and 0 for error
 515  Args    : Bio::Seq object
 516
 517 =cut
 518
 519 sub write_seq {
 520     my ($self, $seq) = @_;
 521     $self->throw("Sorry, you cannot write to a generic Bio::SeqIO object.");
 522 }
 523
 524
 525 =head2 alphabet
 526
 527  Title   : alphabet
 528  Usage   : $self->alphabet($newval)
 529  Function: Set/get the molecule type for the Seq objects to be created.
 530  Example : $seqio->alphabet('protein')
 531  Returns : value of alphabet: 'dna', 'rna', or 'protein'
 532  Args    : newvalue (optional)
 533  Throws  : Exception if the argument is not one of 'dna', 'rna', or 'protein'
 534
 535 =cut
 536
 537 sub alphabet {
 538    my ($self, $value) = @_;
 539
 540    if ( defined $value) {
 541                 $value = lc $value;
 542                 unless ($valid_alphabet_cache{$value}) {
 543                         # instead of hard-coding the allowed values once more, we check by
 544                         # creating a dummy sequence object
 545                         eval {
 546                                 require Bio::PrimarySeq;
 547                                 my $seq = Bio::PrimarySeq->new('-verbose' => $self->verbose,
 548                                                                                                                  '-alphabet' => $value);
 549                         };
 550                         if ($@) {
 551                                 $self->throw("Invalid alphabet: $value\n. See Bio::PrimarySeq for allowed values.");
 552                         }
 553                         $valid_alphabet_cache{$value} = 1;
 554                 }
 555                 $self->{'alphabet'} = $value;
 556    }
 557    return $self->{'alphabet'};
 558 }
 559
 560 =head2 _load_format_module
 561
 562  Title   : _load_format_module
 563  Usage   : *INTERNAL SeqIO stuff*
 564  Function: Loads up (like use) a module at run time on demand
 565  Example :
 566  Returns :
 567  Args    :
 568
 569 =cut
 570
 571 sub _load_format_module {
 572         my ($self, $format) = @_;
 573         my $module = "Bio::SeqIO::" . $format;
 574         my $ok;
 575
 576         eval {
 577                 $ok = $self->_load_module($module);
 578         };
 579         if ( $@ ) {
 580                 print STDERR <<END;
 581 $self: $format cannot be found
 582 Exception $@
 583 For more information about the SeqIO system please see the SeqIO docs.
 584 This includes ways of checking for formats at compile time, not run time
 585 END
 586                 ;
 587         }
 588         return $ok;
 589 }
 590
 591 =head2 _concatenate_lines
 592
 593  Title   : _concatenate_lines
 594  Usage   : $s = _concatenate_lines($line, $continuation_line)
 595  Function: Private. Concatenates two strings assuming that the second stems
 596            from a continuation line of the first. Adds a space between both
 597            unless the first ends with a dash.
 598
 599            Takes care of either arg being empty.
 600  Example :
 601  Returns : A string.
 602  Args    :
 603
 604 =cut
 605
 606 sub _concatenate_lines {
 607         my ($self, $s1, $s2) = @_;
 608
 609         $s1 .= " " if($s1 && ($s1 !~ /-$/) && $s2);
 610         return ($s1 ? $s1 : "") . ($s2 ? $s2 : "");
 611 }
 612
 613 =head2 _filehandle
 614
 615  Title   : _filehandle
 616  Usage   : $obj->_filehandle($newval)
 617  Function: This method is deprecated. Call _fh() instead.
 618  Example :
 619  Returns : value of _filehandle
 620  Args    : newvalue (optional)
 621
 622 =cut
 623
 624 sub _filehandle {
 625     my ($self,@args) = @_;
 626     return $self->_fh(@args);
 627 }
 628
 629 =head2 _guess_format
 630
 631  Title   : _guess_format
 632  Usage   : $obj->_guess_format($filename)
 633  Function: guess format based on file suffix
 634  Example :
 635  Returns : guessed format of filename (lower case)
 636  Args    :
 637  Notes   : formats that _filehandle() will guess include fasta,
 638            genbank, scf, pir, embl, raw, gcg, ace, bsml, swissprot,
 639            fastq and phd/phred
 640
 641 =cut
 642
 643 sub _guess_format {
 644    my $class = shift;
 645    return unless $_ = shift;
 646    return 'abi'     if /\.ab[i1]$/i;
 647    return 'ace'     if /\.ace$/i;
 648    return 'alf'     if /\.alf$/i;
 649    return 'bsml'    if /\.(bsm|bsml)$/i;
 650    return 'ctf'     if /\.ctf$/i;
 651    return 'embl'    if /\.(embl|ebl|emb|dat)$/i;
 652         return 'entrezgene' if /\.asn$/i;
 653    return 'exp'     if /\.exp$/i;
 654    return 'fasta'   if /\.(fasta|fast|fas|seq|fa|fsa|nt|aa|fna|faa)$/i;
 655    return 'fastq'   if /\.fastq$/i;
 656    return 'gcg'     if /\.gcg$/i;
 657    return 'genbank' if /\.(gb|gbank|genbank|gbk|gbs)$/i;
 658    return 'phd'     if /\.(phd|phred)$/i;
 659    return 'pir'     if /\.pir$/i;
 660    return 'pln'     if /\.pln$/i;
 661    return 'qual'    if /\.qual$/i;
 662    return 'raw'     if /\.txt$/i;
 663    return 'scf'     if /\.scf$/i;
 664    return 'swiss'   if /\.(swiss|sp)$/i;
 665
 666    # from Strider 1.4 Release Notes: The file name extensions used by
 667    # Strider 1.4 are ".xdna", ".xdgn", ".xrna" and ".xprt" for DNA,
 668    # DNA Degenerate, RNA and Protein Sequence Files, respectively
 669    return 'strider' if /\.(xdna|xdgn|xrna|xprt)$/i;
 670
 671    return 'ztr'     if /\.ztr$/i;
 672 }
 673
 674 sub DESTROY {
 675         my $self = shift;
 676         $self->close();
 677 }
 678
 679 sub TIEHANDLE {
 680         my ($class,$val) = @_;
 681         return bless {'seqio' => $val}, $class;
 682 }
 683
 684 sub READLINE {
 685         my $self = shift;
 686         return $self->{'seqio'}->next_seq() unless wantarray;
 687         my (@list, $obj);
 688         push @list, $obj while $obj = $self->{'seqio'}->next_seq();
 689         return @list;
 690 }
 691
 692 sub PRINT {
 693         my $self = shift;
 694         $self->{'seqio'}->write_seq(@_);
 695 }
 696
 697 =head2 sequence_factory
 698
 699  Title   : sequence_factory
 700  Usage   : $seqio->sequence_factory($seqfactory)
 701  Function: Get/Set the Bio::Factory::SequenceFactoryI
 702  Returns : Bio::Factory::SequenceFactoryI
 703  Args    : [optional] Bio::Factory::SequenceFactoryI
 704
 705 =cut
 706
 707 sub sequence_factory{
 708    my ($self,$obj) = @_;
 709    if( defined $obj ) {
 710                 if( ! ref($obj) || ! $obj->isa('Bio::Factory::SequenceFactoryI') ) {
 711                         $self->throw("Must provide a valid Bio::Factory::SequenceFactoryI object to ".ref($self)."::sequence_factory()");
 712                 }
 713                 $self->{'_seqio_seqfactory'} = $obj;
 714                 my $builder = $self->sequence_builder();
 715                 if($builder && $builder->can('sequence_factory') &&
 716                         (! $builder->sequence_factory())) {
 717                         $builder->sequence_factory($obj);
 718                 }
 719    }
 720    $self->{'_seqio_seqfactory'};
 721 }
 722
 723 =head2 object_factory
 724
 725  Title   : object_factory
 726  Usage   : $obj->object_factory($newval)
 727  Function: This is an alias to sequence_factory with a more generic name.
 728  Example :
 729  Returns : value of object_factory (a scalar)
 730  Args    : on set, new value (a scalar or undef, optional)
 731
 732 =cut
 733
 734 sub object_factory{
 735         return shift->sequence_factory(@_);
 736 }
 737
 738 =head2 sequence_builder
 739
 740  Title   : sequence_builder
 741  Usage   : $seqio->sequence_builder($seqfactory)
 742  Function: Get/Set the Bio::Factory::ObjectBuilderI used to build sequence
 743            objects.
 744
 745            If you do not set the sequence object builder yourself, it
 746            will in fact be an instance of L<Bio::Seq::SeqBuilder>, and
 747            you may use all methods documented there to configure it.
 748
 749  Returns : a Bio::Factory::ObjectBuilderI compliant object
 750  Args    : [optional] a Bio::Factory::ObjectBuilderI compliant object
 751
 752 =cut
 753
 754 sub sequence_builder{
 755         my ($self,$obj) = @_;
 756         if( defined $obj ) {
 757                 if( ! ref($obj) || ! $obj->isa('Bio::Factory::ObjectBuilderI') ) {
 758                         $self->throw("Must provide a valid Bio::Factory::ObjectBuilderI object to ".ref($self)."::sequence_builder()");
 759                 }
 760                 $self->{'_object_builder'} = $obj;
 761         }
 762         $self->{'_object_builder'};
 763 }
 764
 765 =head2 location_factory
 766
 767  Title   : location_factory
 768  Usage   : $seqio->location_factory($locfactory)
 769  Function: Get/Set the Bio::Factory::LocationFactoryI object to be used for
 770            location string parsing
 771  Returns : a Bio::Factory::LocationFactoryI implementing object
 772  Args    : [optional] on set, a Bio::Factory::LocationFactoryI implementing
 773            object.
 774
 775 =cut
 776
 777 sub location_factory{
 778         my ($self,$obj) = @_;
 779         if( defined $obj ) {
 780                 if( ! ref($obj) || ! $obj->isa('Bio::Factory::LocationFactoryI') ) {
 781                         $self->throw("Must provide a valid Bio::Factory::LocationFactoryI" .
 782                                                          " object to ".ref($self)."->location_factory()");
 783                 }
 784                 $self->{'_seqio_locfactory'} = $obj;
 785         }
 786         $self->{'_seqio_locfactory'};
 787 }
 788
 789 1;
 790