Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
Bio::Variation::IO(3) User Contributed Perl DocumentationBio::Variation::IO(3)

       Bio::Variation::IO - Handler for	sequence variation IO Formats

	   use Bio::Variation::IO;

	   $in	= Bio::Variation::IO->new(-file	=> "inputfilename" ,
					  -format => 'flat');
	   $out	= Bio::Variation::IO->new(-file	=> ">outputfilename" ,
					  -format => 'xml');

	   while ( my $seq = $in->next() ) {

	 # or

	   use Bio::Variation::IO;

	   #input file format can be read from the file	extension (dat|xml)
	   $in	= Bio::Variation::IO->newFh(-file => "inputfilename");
	   $out	= Bio::Variation::IO->newFh(-format => 'xml');

	   # World's shortest flat<->xml format	converter:
	   print $out $_ while <$in>;

       Bio::Variation::IO is a handler module for the formats in the Variation
       IO set (eg, Bio::Variation::IO::flat). It is the	officially sanctioned
       way of getting at the format objects, which most	people should use.

       The structure, conventions and most of the code is inherited from
       Bio::SeqIO module. The main difference is that instead of using methods
       next_seq	and write_seq, you drop	'_seq' from the	method names.

       The idea	is that	you request a stream object for	a particular format.
       All the stream objects have a notion of an internal file	that is	read
       from or written to. A particular	SeqIO object instance is configured
       for either input	or output. A specific example of a stream object is
       the Bio::Variation::IO::flat object.

       Each stream object has functions





	  $stream->type() # returns 'INPUT' or 'OUTPUT'

       As an added bonus, you can recover a filehandle that is tied to the
       SeqIO object, allowing you to use the standard <> and print operations
       to read and write sequence objects:

	   use Bio::Variation::IO;

	   $stream = Bio::Variation::IO->newFh(-format => 'flat');
	   # read from standard	input

	   while ( $seq	= <$stream> ) {
		  # do something with $seq


	   print $stream $seq; # when stream is	in output mode

       This makes the simplest ever reformatter


	   $format1 = shift;
	   $format2 = shift;

	   use Bio::Variation::IO;

	   $in	= Bio::Variation::IO->newFh(-format => $format1	);
	   $out	= Bio::Variation::IO->newFh(-format => $format2	);

	   print $out $_ while <$in>;

	  $seqIO = Bio::Variation::IO->new(-file => 'filename',	  -format=>$format);
	  $seqIO = Bio::Variation::IO->new(-fh	 => \*FILEHANDLE, -format=>$format);
	  $seqIO = Bio::Variation::IO->new(-format => $format);

       The new() class method constructs a new Bio::Variation::IO object.  The
       returned	object can be used to retrieve or print	BioSeq objects.	new()
       accepts the following parameters:

	   A file path to be opened for	reading	or writing.  The usual Perl
	   conventions apply:

	      'file'	   # open file for reading
	      '>file'	   # open file for writing
	      '>>file'	   # open file for appending
	      '+<file'	   # open file read/write
	      'command |'  # open a pipe from the command
	      '| command'  # open a pipe to the	command

       -fh You may provide new() with a	previously-opened filehandle.  For
	   example, to read from STDIN:

	      $seqIO = Bio::Variation::IO->new(-fh => \*STDIN);

	   Note	that you must pass filehandles as references to	globs.

	   If neither a	filehandle nor a filename is specified,	then the
	   module will read from the @ARGV array or STDIN, using the familiar
	   <> semantics.

	   Specify the format of the file.  Supported formats include:

	      flat	  pseudo EMBL format
	      xml	  seqvar xml format

	   If no format	is specified and a filename is given, then the module
	   will	attempt	to deduce it from the filename.	 If this is
	   unsuccessful, Fasta format is assumed.

	   The format name is case insensitive.	 'FLAT', 'Flat'	and 'flat' are
	   all supported.

	  $fh =	Bio::Variation::IO->newFh(-fh	=> \*FILEHANDLE, -format=>$format);
	  $fh =	Bio::Variation::IO->newFh(-format => $format);
	  # etc.

	  $out = Bio::Variation::IO->newFh( '-FORMAT' => 'flat');
	  print	$out $seqDiff;

       This constructor	behaves	like new(), but	returns	a tied filehandle
       rather than a Bio::Variation::IO	object.	 You can read sequences	from
       this object using the familiar <> operator, and write to	it using
       print().	 The usual array and $_	semantics work.	 For example, you can
       read all	sequence objects into an array like this:

	 @mutations = <$fh>;

       Other operations, such as read(), sysread(), write(), close(), and
       printf()	are not	supported.

       See below for more detailed summaries.  The main	methods	are:

   $sequence = $seqIO->next()
       Fetch the next sequence from the	stream.

   $seqIO->write($sequence [,$another_sequence,...])
       Write the specified sequence(s) to the stream.

       These provide the tie interface.	 See perltie for more details.

   Mailing Lists
       User feedback is	an integral part of the	evolution of this and other
       Bioperl modules.	Send your comments and suggestions preferably to the
       Bioperl mailing lists  Your participation is much appreciated.			- General discussion	- About	the mailing lists

       Please direct usage questions or	support	issues to the mailing list:

       rather than to the module maintainer directly. Many experienced and
       reponsive experts will be able look at the problem and quickly address
       it. Please include a thorough description of the	problem	with code and
       data examples if	at all possible.

   Reporting Bugs
       Report bugs to the Bioperl bug tracking system to help us keep track
       the bugs	and their resolution.  Bug reports can be submitted via	the

AUTHOR - Heikki	Lehvaslaiho
       Email:  heikki-at-bioperl-dot-org

       The rest	of the documentation details each of the object	methods.
       Internal	methods	are usually preceded with a _

	Title	: new
	Usage	: $stream = Bio::Variation::IO->new(-file => $filename,	-format	=> 'Format')
	Function: Returns a new	seqstream
	Returns	: A Bio::Variation::IO::Handler	initialised with the appropriate format
	Args	: -file	=> $filename
		  -format => format
		  -fh => filehandle to attach to

	Title	: format
	Usage	: $format = $stream->format()
	Function: Get the variation format
	Returns	: variation format
	Args	: none

	Title	: next
	Usage	: $seqDiff = $stream->next
	Function: reads	the next $seqDiff object from the stream
	Returns	: a Bio::Variation::SeqDiff object
	Args	:

	Title	: write
	Usage	: $stream->write($seq)
	Function: writes the $seq object into the stream
	Returns	: 1 for	success	and 0 for error
	Args	: Bio::Variation::SeqDiff object

	Title	: _guess_format
	Usage	: $obj->_guess_format($filename)
	Example	:
	Returns	: guessed format of filename (lower case)
	Args	:

perl v5.32.0			  2020-01-06		 Bio::Variation::IO(3)


Want to link to this manual page? Use this URL:

home | help