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

FreeBSD Manual Pages

  
 
  

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

NAME
       Bio::Structure::IO - Handler for	Structure Formats

SYNOPSIS
	   use Bio::Structure::IO;

	   $in	= Bio::Structure::IO->new(-file	=> "inputfilename",
					  -format => 'pdb');

	   while ( my $struc = $in->next_structure() ) {
	      print "Structure ", $struc->id, "	number of models: ",
		    scalar $struc->model,"\n";
	   }

DESCRIPTION
       Bio::Structure::IO is a handler module for the formats in the
       Structure::IO set (e.g. Bio::Structure::IO::pdb). It is the officially
       sanctioned way of getting at the	format objects,	which most people
       should use.

       The Bio::Structure::IO system can be thought of like biological file
       handles.	 They are attached to filehandles with smart formatting	rules
       (e.g. PDB format) and can either	read or	write structure	objects
       (Bio::Structure objects,	or more	correctly, Bio::Structure::StructureI
       implementing objects, of	which Bio::Structure is	one such object). If
       you want	to know	what to	do with	a Bio::Structure object, read
       Bio::Structure.

       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	Structure::IO object instance is
       configured for either input or output. A	specific example of a stream
       object is the Bio::Structure::IO::pdb object.

       Each stream object has functions

	  $stream->next_structure();

       and

	  $stream->write_structure($struc);

       also

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

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

	   use Bio::Structure::IO;

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

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

       and

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

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

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

       -file
	   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:

	      $strucIO = Bio::Structure::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.

       -format
	   Specify the format of the file.  Supported formats include:

	      pdb	  Protein Data Bank 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, PDB format is assumed.

	   The format name is case insensitive.	 'PDB',	'Pdb' and 'pdb'	are
	   all supported.

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

       This constructor	behaves	like new(), but	returns	a tied filehandle
       rather than a Bio::Structure::IO	object.	 You can read structures 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	structure objects into an array	like this:

	 @structures = <$fh>;

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

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

   $structure =	$structIO->next_structure()
       Fetch the next structure	from the stream.

   $structIO->write_structure($struc [,$another_struc,...])
       Write the specified structure(s)	to the stream.

   TIEHANDLE(),	READLINE(), PRINT()
       These provide the tie interface.	 See perltie for more details.

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

	 bioperl-l@bioperl.org			- General discussion
	 http://bioperl.org/wiki/Mailing_lists	- About	the mailing lists

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

       bioperl-l@bioperl.org

       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
       web:

	 https://github.com/bioperl/bioperl-live/issues

AUTHORS	- Ewan Birney, Lincoln Stein, Kris Boulez
       Email birney@ebi.ac.uk, lstein@cshl.org,	kris.boulez@algonomics.com

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

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

   newFh
	Title	: newFh
	Usage	: $fh =	Bio::Structure::IO->newFh(-file=>$filename,-format=>'Format')
	Function: does a new() followed	by an fh()
	Example	: $fh =	Bio::Structure::IO->newFh(-file=>$filename,-format=>'Format')
		  $structure = <$fh>;	# read a structure object
		  print	$fh $structure;	# write	a structure object
	Returns	: filehandle tied to the Bio::Structure::IO::Fh	class
	Args	:

   fh
	Title	: fh
	Usage	: $obj->fh
	Function:
	Example	: $fh =	$obj->fh;      # make a	tied filehandle
		  $structure = <$fh>;	# read a structure object
		  print	$fh $structure;	# write	a structure object
	Returns	: filehandle tied to the Bio::Structure::IO::Fh	class
	Args	:

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

   next_structure
	Title	: next_structure
	Usage	: $structure = stream->next_structure
	Function: Reads	the next structure object from the stream and returns a
		  Bio::Structure::Entry	object.

		  Certain driver modules may encounter entries in the stream that
		  are either misformatted or that use syntax not yet understood
		  by the driver. If such an incident is	recoverable, e.g., by
		  dismissing a feature of a feature table or some other	non-mandatory
		  part of an entry, the	driver will issue a warning. In	the case
		  of a non-recoverable situation an exception will be thrown.
		  Do not assume	that you can resume parsing the	same stream after
		  catching the exception. Note that you	can always turn	recoverable
		  errors into exceptions by calling $stream->verbose(2)	(see
		  Bio::RootI POD page).
	Returns	: a Bio::Structure::Entry object
	Args	: none

   write_structure
	Title	: write_structure
	Usage	: $stream->write_structure($structure)
	Function: writes the $structure	object into the	stream
	Returns	: 1 for	success	and 0 for error
	Args	: Bio::Structure object

   _load_format_module
	Title	: _load_format_module
	Usage	: *INTERNAL Structure::IO stuff*
	Function: Loads	up (like use) a	module at run time on demand
	Example	:
	Returns	:
	Args	:

   _concatenate_lines
	Title	: _concatenate_lines
	Usage	: $s = _concatenate_lines($line, $continuation_line)
	Function: Private. Concatenates	two strings assuming that the second stems
		  from a continuation line of the first. Adds a	space between both
		  unless the first ends	with a dash.

		  Takes	care of	either arg being empty.
	Example	:
	Returns	: A string.
	Args	:

   _filehandle
	Title	: _filehandle
	Usage	: $obj->_filehandle($newval)
	Function: This method is deprecated. Call _fh()	instead.
	Example	:
	Returns	: value	of _filehandle
	Args	: newvalue (optional)

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

perl v5.24.1			  2017-07-08		 Bio::Structure::IO(3)

NAME | SYNOPSIS | DESCRIPTION | CONSTRUCTORS | OBJECT METHODS | FEEDBACK | AUTHORS - Ewan Birney, Lincoln Stein, Kris Boulez | APPENDIX

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Bio::Structure::IO&sektion=3&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help