Bio::DB::HIV::HIVQueryHelper man page on Fedora

Man page or keyword search:  
man Server   31170 pages
apropos Keyword Search (all sections)
Output format
Fedora logo
[printable version]

Bio::DB::HIV::HIVQueryUsereContributed Perl DocBio::DB::HIV::HIVQueryHelper(3)

NAME
       Bio::DB::HIV::HIVQueryHelper - Routines and packages used by
       Bio::DB::HIV and Bio::DB::Query::HIVQuery

SYNOPSIS
	 Used in Bio::DB::Query::HIVQuery. No need to use directly.

DESCRIPTION
       "Bio::DB::HIV::HIVQueryHelper" contains a number of packages for use by
       Bio::DB::Query::HIVQuery. Package "HIVSchema" parses the
       "lanl-schema.xml" file, and allows access to it in the context of the
       relational database it represents (see APPENDIX for excruciating
       detail). Packages "QRY", "R", and "Q" together create the query string
       parser that enables NCBI-like queries to be understood by
       "Bio::DB::Query::HIVQuery". They provide objects and operators to
       perform and simplify logical expressions involving "AND", "OR", and
       "()" and return hash structures that can be handled by
       "Bio::DB::Query::HIVQuery" routines.

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 the
       Bioperl mailing list.  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 of
       the bugs and their resolution. Bug reports can be submitted via the
       web:

	 http://bugzilla.open-bio.org/

AUTHOR - Mark A. Jensen
       Email maj@fortinbras.us

CONTRIBUTORS
       Mark A. Jensen

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

   HIVSchema -	objects/methods to manipulate a version of the LANL HIV DB
       schema
       HIVSchema SYNOPSIS

	   $schema = new HIVSchema( 'lanl-schema.xml' );
	   @tables = $schema->tables;
	   @validFields = $schema->fields;
	   @validAliases = $schema->aliases;
	   @query_aliases_for_coreceptor = $schema->aliases( 'SEQ_SAMple.SSAM_second_receptor' );
	   $pk_for_SequenceEntry = $schema->primarykey('SequenceEntry');    # returns 'SequenceEntry.SE_id'
	   $fk_for_SEQ_SAMple_to_SequenceEntry =
		     $schema->foreignkey('SEQ_SAMple', 'SequenceEntry');    # returns 'SEQ_SAMple.SSAM_SE_id'

	   $table = $schema->tablepart('SEQ_SAMple.SSAM_badseq');	    # returns 'SEQ_SAMple'
	   $column = $schema->columnpart('SEQ_SAMple.SSAM_badseq');	    # returns 'SSAM_badseq'

       HIVSchema DESCRIPTION

       HIVSchema methods are used in Bio::DB::Query::HIVQuery for table,
       column, primary/foreign key manipulations based on the observed Los
       Alamos HIV Sequence Database (LANL DB) naming conventions for their CGI
       parameters. The schema is contained in an XML file ("lanl-schema.xml")
       which is read into an HIVSchema object, in turn a property of the
       HIVQuery object. HIVSchema methods are used to build correct cgi
       queries in a way that attempts to preserve the context of the
       relational database the query parameters represent.

       HIVSchema CONSTRUCTOR

       HIVSchema::new

	Title	: new
	Usage	: $schema = new HIVSchema( "lanl-schema.xml ");
	Function:
	Example :
	Returns : an HIVSchema object
	Args	: XML filename

       HIVSchema INSTANCE METHODS

       HIVSchema tables

	Title	: tables
	Usage	: $schema->tables()
	Function: get all table names in schema
	Example :
	Returns : array of table names
	Args	: none

       HIVSchema columns

	Title	: columns
	Usage	: $schema->columns( [$tablename] );
	Function: return array of columns for specified table, or all columns in
		  schema, if called w/o args
	Example :
	Returns :
	Args	: tablename or fieldname string

       HIVSchema fields

	Title	: fields
	Usage	: $schema->fields();
	Function: return array of all fields in schema, in format "table.column"
	Example :
	Returns : array of all fields
	Args	: none

       HIVSchema options

	Title	: options
	Usage	: $schema->options(@fieldnames)
	Function: get array of options (i.e., valid match data strings) available
		  to specified field
	Example :
	Returns : array of match data strings
	Args	: [array of] fieldname string[s] in "table.column" format

       HIVSchema aliases

	Title	: aliases
	Usage	: $schema->aliases(@fieldnames)
	Function: get array of aliases to specified field[s]
	Example :
	Returns : array of valid query aliases for fields as spec'd in XML file
	Args	: [an array of] fieldname[s] in "table.column" format

       HIVSchema ankh

	Title	: ankh (annotation key hash)
	Usage	: $schema->ankh(@fieldnames)
	Function: return a hash translating fields to annotation keys for the
		  spec'd fields.
		  (Annotation keys are used for parsing the tab-delimited response
		  to Bio::DB::Query::HIVQuery::_do_lanl_request.)
	Example :
	Returns : hash ref
	Args	: [an array of] fieldname[s] in "table.column" format

       HIVSchema tablepart

	Title	: tablepart (alias: tbl)
	Usage	: $schema->tbl(@fieldnames)
	Function: return the portion of the fieldname[s] that refer to the
		  db table
	Example : $schema->tbl('SequenceEntry.SE_id'); # returns 'SequenceEntry'
	Returns : table name as string
	Args	: [an array of] fieldname[s] in "table.column" format

       HIVSchema columnpart

	Title	: columnpart (alias: col)
	Usage	: $schema->col(@fieldnames)
	Function: return the portion of the fieldname[s] that refer to the
		  db column
	Example : $schema->col('SequenceEntry.SE_id'); # returns 'SE_id'
	Returns : column name as string
	Args	: [an array of] fieldname[s] in "table.column" format

       HIVSchema primarykey

	Title	: primarykey [alias: pk]
	Usage	: $schema->pk(@tablenames);
	Function: return the primary key of the specified table[s], as judged by
		  the syntax of the table's[s'] fieldnames
	Example : $schema->pk('SequenceEntry') # returns 'SequenceEntry.SE_id'
	Returns : primary key fieldname[s] in "table.column" format, or null if
		  no pk exists
	Args	: [an array of] table name[s] (fieldnames are ok, table part used)

       HIVSchema foreignkey

	Title	: foreignkey [alias: fk]
	Usage	: $schema->fk($intable [, $totable])
	Function: return foreign key fieldname in table $intable referring to
		  table $totable, or all foreign keys in $intable if $totable
		  unspec'd
	Example : $schema->fk('AUthor', 'SequenceEntry'); # returns 'AUthor_AU_SE_id'
	Returns : foreign key fieldname[s] in "table.column" format
	Args	: tablename [, optional foreign table name] (fieldnames are ok,
		  table part used)

       HIVSchema foreigntable

	Title	: foreigntable [alias ftbl]
	Usage	: $schema->ftbl( @foreign_key_fieldnames );
	Function: return tablename of table that foreign keys points to
	Example : $schema->ftbl( 'AUthor.AU_SE_id' ); # returns 'SequenceEntry'
	Returns : tablename
	Args	: [an array of] fieldname[s] in "table.column" format

       HIVSchema find_join

	Title	: find_join
	Usage	: $sch->find_join('Table1', 'Table2')
	Function: Retrieves a set of foreign and primary keys (in table.column
		  format) that represents a join path from Table1 to Table2
	Example :
	Returns : an array of keys (as table.column strings) -or- an empty
		  array if Table1 == Table2 -or- undef if no path exists
	Args	: two table names as strings

       HIVSchema _find_join_guts

	Title	: _find_join_guts
	Usage	: $sch->_find_join_guts($table1, $table2, $stackref, \$found, $reverse)
		  (call with $stackref = [], $found=0)
	Function: recursive guts of find_join
	Example :
	Returns : if a path is found, $found==1 and @$stackref contains the keys
		  in table.column format representing the path; if a path is not
		  found, $found == 0 and @$stackref contains garbage
	Args	: $table1, $table2 : table names as strings
		  $stackref : an arrayref to an empty array
		  \$found   : a scalar ref to the value 0
		  $rev : if $rev==1, the arrays of table names will be reversed;
			 this can give a shorter path if cycles exist in the
			 schema graph

       HIVSchema loadSchema

	Title	: loadHIVSchema [alias: loadSchema]
	Usage	: $schema->loadSchema( $XMLfilename )
	Function: read (LANL DB) schema spec from XML
	Example : $schema->loadSchema('lanl-schema.xml');
	Returns : hashref to schema data
		  Keys are fieldnames in "table.column" format.
		  Each value is a hashref with the following properties:
		  {name}    : HIVWEB 'table.column' format fieldname,
			      can be used directly in the cgi query
		  {aliases} : ref to array containing valid aliases/shortcuts for
			      {name}; can be used in routines creating the HTML query
		  {options} : ref to array containing valid matchdata for this field
			      can be used directly in the HTML query
		  {ankey}   : contains the annotation key for this field used with
			      Bioperl annotation objects
		  {..attr..}: ..value_of_attr.. for this field (app-specific metadata)
	Args	:

       HIVSchema _sfieldh

	Title	: _sfieldh
	Usage	: $schema->_sfieldh($fieldname)
	Function: get hashref to the specified field hash
	Example :
	Returns : hashref
	Args	: fieldname in "table.column" format

   Class QRY -	a query algebra for HIVQuery
       QRY SYNOPSIS

	 $Q = new QRY(
		      new R(
			     new Q('coreceptor', 'CXCR4'),
			     new Q('country', 'ZA')
			    )
		      );
	 QRY::Eq(QRY::And($Q, $Q), $Q);			    # returns 1
	 QRY::Eq(QRY::Or($Q, $Q), $Q);			    # returns 1
	 $Q2 = $Q1->clone;
	 $Q2 = new QRY(
		       new R(
			      new Q( 'coreceptor', 'CCR5' ),
			      new Q( 'country', 'ZA')
			     )
		      );
	 (QRY::And($Q, $Q2))->isnull;			    # returns 1
	 $Q3 = QRY::Or($Q, $Q2);
	 print $Q3->A;					    # prints '(CCR5 CXCR4)[coreceptor] (ZA)[country]'

       QRY DESCRIPTION

       The QRY package provides a query parser for Bio::DB::Query::HIVQuery.
       Currently, the parser supports AND, OR, and () operations. The
       structure of the LANL cgi makes it tricky to perform NOTs, though this
       could be implemented if the desire were great.

       Two class methods do the work. "QRY::_parse_q" does a first-pass parse
       of the query string. "QRY::_make_q" interprets the parse tree as
       returned by "QRY::_parse_q" and produces an array of hash structures
       that can be used directly by "Bio::DB::Query::HIVQuery" query execution
       methods. Validation of query fields and options is performed at the
       "Bio::DB::Query::HIVQuery" level, not here.

       "QRY" objects are collections of "R" (or request) objects, which are in
       turn collections of "Q" (or atomic query) objects. "Q" objects
       represent a query on a single field, with match data options "OR"ed
       together, e.g. "(A B)[subtype]". "R" objects collect "Q" objects that
       could be processed in a single HTTP request; i.e., a set of atomic
       queries each having different fields "AND"ed together, such as

	 (A B)[subtype] AND ('CCR5')[coreceptor] AND (US CA)[country]

       The "QRY" object collects "R"s that cannot be reduced (through logical
       operations) to a single HTTP request, e.g.

	 ((C)[subtype] AND (SI)[phenotype]) OR ( (D)[subtype] AND (NSI)[phenotype] ),

       which cannot be got in one go through the current LANL cgi
       implementation (as far as I can tell). The parser will simplify
       something like

	 ((C)[subtype] AND (SI)[phenotype]) OR ((C)[subtype] AND (NSI)[phenotype])

       to the single request

	 (C)[subtype] AND (NSI SI)[phenotype]

       however.

       The operators "&" and "|" are overloaded to "QRY::And" and "QRY::Or",
       to get Perl precedence and grouping for free. "bool" is overloaded to
       get symbolic tests such as "if ($QRY) {stuff}". "==" is overloaded with
       "QRY::Eq" for convenience. No overloading is done for "R" or "Q".

       QRY _make_q

	Title	: _make_q
	Usage	: QRY::_make_q($parsetree)
	Function: creates hash structures suitable for HIVQuery from parse tree
		  returned by QRY::_parse_q
	Example :
	Returns : array of hashrefs of query specs
	Args	: a hashref

       QRY _make_q_guts

	Title	: _make_q_guts (Internal class method)
	Usage	: _make_q_guts($ptree, $q_expr, $qarry, $anarry)
	Function: traverses the parse tree returned from QRY::_parse_q, checking
		  syntax and creating HIVQuery-compliant query structures
	Example :
	Returns :
	Args	: $parse_tree (hashref), $query_expression (scalar string ref),
		  $query_array (array ref : stack for returning query structures),
		  $annotation_array (array ref : stack for returning annotation
		  fields)

       QRY _parse_q

	Title	: _parse_q
	Usage	: QRY::_parse_q($query_string)
	Function: perform first pass parse of a query string with some syntax
		  checking, return a parse tree suitable for QRY::_make_q
	Example : QRY::_parse_q(" to[be] OR (not to)[be] ");
	Returns : hashref
	Args	: query string

       QRY CONSTRUCTOR

       QRY Constructor

	Title	: QRY constructor
	Usage	: $QRY = new QRY()
	Function:
	Example :
	Returns :
	Args	: array of R objects, optional

       QRY INSTANCE METHODS

       QRY requests

	Title	: requests
	Usage	: $QRY->requests
	Function: get/set array of requests comprising this QRY object
	Example :
	Returns :
	Args	: array of class R objects

       QRY put_requests

	Title	: put_requests
	Usage	: $QRY->put_request(@R)
	Function: add object of class R to $QRY
	Example :
	Returns :
	Args	: [an array of] of class R object[s]

       QRY isnull

	Title	: isnull
	Usage	: $QRY->isnull
	Function: test if QRY object is null
	Example :
	Returns : 1 if null, 0 otherwise
	Args	:

       QRY A

	Title	: A
	Usage	: print $QRY->A
	Function: get a string representation of QRY object
	Example :
	Returns : string scalar
	Args	:

       QRY len

	Title	: len
	Usage	: $QRY->len
	Function: get number of class R objects contained by QRY object
	Example :
	Returns : scalar
	Args	:

       QRY clone

	Title	: clone
	Usage	: $QRY2 = $QRY1->clone;
	Function: create and return a clone of the object
	Example :
	Returns : object of class QRY
	Args	:

       QRY CLASS METHODS

       QRY Or

	Title	: Or
	Usage	: $QRY3 = QRY::Or($QRY1, $QRY2)
	Function: logical OR for QRY objects
	Example :
	Returns : a QRY object
	Args	: two class QRY objects

       QRY And

	Title	: And
	Usage	: $QRY3 = QRY::And($QRY1, $QRY2)
	Function: logical AND for QRY objects
	Example :
	Returns : a QRY object
	Args	: two class QRY objects

       QRY Bool

	Title	: Bool
	Usage	: QRY::Bool($QRY1)
	Function: allows symbolic testing of QRY object when bool overloaded
	Example : do {stuff} if $QRY1 *same as* do {stuff} if !$QRY1->isnull
	Returns :
	Args	: a class QRY object

       QRY Eq

	Title	: Eq
	Usage	: QRY::Eq($QRY1, $QRY2)
	Function: test if R objects in two QRY objects are the same
		  (irrespective of order)
	Example :
	Returns : 1 if equal, 0 otherwise
	Args	: two class QRY objects

   Class R - request objects for QRY algebra
       R SYNOPSIS

	 $R = new R( $q1, $q2 );
	 $R->put_atoms($q3);
	 $R->del_atoms('coreceptor', 'phenotype');
	 return $R->clone;
	 $R1 = new R( new Q('subtype', 'B') );
	 $R2 = new R( new Q('subtype', 'B C'),
		      new Q('country', 'US') );
	 R::Eq( (R::And($R1, $R2))[0],
		new R( new Q('subtype', 'B' ),
		       new Q('country', 'US') ));		  # returns 1
	 QRY::Eq( new QRY(R::Or($R1, $R2)), new QRY($R1, $R2) );  # returns 1
	 R::In( (R::And($R1, $R2))[0], $R1 );			  # returns 1

       R DESCRIPTION

       Class R objects contain a list of atomic queries (class Q objects).
       Each class R object represents a single HTTP request to the LANL DB.
       When converted to a DB query, the class Q objects contained by an R
       object are effectively "AND"ed.

       R CONSTRUCTOR

       R constructor

	Title	: R constructor
	Usage	: $R = new R()
	Function: create a new R (request) object
	Example :
	Returns : class R (request) object
	Args	: optional, array of class Q objects

       R INSTANCE METHODS

       R len

	Title	: len
	Usage	: $R->len
	Function: get number of class Q objects contained in R object
	Example :
	Returns : scalar
	Args	:

       R atoms

	Title	: atoms
	Usage	: $R->atoms( [optional $field])
	Function: get array of class Q (atomic query) objects in class R object
	Example : $R->atoms(); $R->atoms('coreceptor')
	Returns : array of class Q objects (all Qs or those corresponding to $field
		  if present)
	Args	: optional, scalar string

       R fields

	Title	: fields
	Usage	: $R->fields
	Function: get array of fields of all Q objects contained in $R
	Example :
	Returns : array of scalars
	Args	:

       R put_atoms

	Title	: put_atoms
	Usage	: $R->put_atoms( @q )
	Function: AND an atomic query (class Q object) to the class R object's list
	Example :
	Returns : void
	Args	: an [array of] class Q object[s]

       R del_atoms

	Title	: del_atoms
	Usage	: $R->del_atoms( @qfields )
	Function: removes class Q objects from R object's list according to the
		  field names given in arguments
	Example :
	Returns : the class Q objects deleted
	Args	: scalar array of field names

       R isnull

	Title	: isnull
	Usage	: $R->isnull
	Function: test if class R object is null
	Example :
	Returns : 1 if null, 0 otherwise
	Args	:

       R A

	Title	: A
	Usage	: print $R->A
	Function: get a string representation of class R object
	Example :
	Returns : string scalar
	Args	:

       R clone

	Title	: clone
	Usage	: $R2 = $R1->clone;
	Function: create and return a clone of the object
	Example :
	Returns : object of class R
	Args	:

       R CLASS METHODS

       R In

	Title	: In
	Usage	: R::In($R1, $R2)
	Function: tests whether the query represented by $R1 would return a subset
		  of items returned by the query represented by $R2
	Example : print "R2 gets those and more" if R::In($R1, $R2);
	Returns : 1 if R1 is subset of R2, 0 otherwise
	Args	: two class R objects

       R And

	Title	: And
	Usage	: @Rresult = R::And($R1, $R2)
	Function: logical AND for R objects
	Example :
	Returns : an array containing class R objects
	Args	: two class R objects

       R Or

	Title	: Or
	Usage	: @Rresult = R::Or($R1, $R2)
	Function: logical OR for R objects
	Example :
	Returns : an array containing class R objects
	Args	: two class R objects

       R Eq

	Title	: Eq
	Usage	: R::Eq($R1, $R2)
	Function: test if class Q objects in two R objects are the same
		  (irrespective of order)
	Example :
	Returns : 1 if equal, 0 otherwise
	Args	: two class R objects

   Class Q -  atomic query objects for QRY algebra
       Q SYNOPSIS

	   $q = new Q('coreceptor', 'CXCR4 CCR5');
	   $u = new Q('coreceptor', 'CXCR4');
	   $q->fld;				    # returns 'coreceptor'
	   $q->dta;				    # returns 'CXCR4 CCR5'
	   print $q->A;				    # prints '(CXCR4 CCR5)[coreceptor]
	   Q::qeq($q, $u);			    # returns 0
	   Q::qeq( Q::qor($q, $q), $q );	    # returns 1
	   Q::qin($u, $q)			    # returns 1
	   Q::qeq(Q::qand($u, $q), $u );	    # returns 1

       Q DESCRIPTION

       Class Q objects represent atomic queries, that can be described by a
       single LANL cgi parameter=value pair. Class R objects (requests) are
       built from class Qs. The logical operations at the higher levels ("QRY,
       R") ultimately depend on the lower level operations on Qs: "qeq, qin,
       qand, qor".

       Q CONSTRUCTOR

       Q constructor

	Title	: Q constructor
	Usage	: $q = new Q($field, $data)
	Function: create a new Q (atomic query) object
	Example :
	Returns : class Q object
	Args	: optional $field, $data strings

       Q INSTANCE METHODS

       Q isnull

	Title	: isnull
	Usage	: $q->isnull
	Function: test if class Q object is null
	Example :
	Returns : 1 if null, 0 otherwise
	Args	:

       Q fld

	Title	: fld
	Usage	: $q->fld($field)
	Function: get/set fld (field name) property
	Example :
	Returns : scalar
	Args	: scalar

       Q dta

	Title	: dta
	Usage	: $q->dta($data)
	Function: get/set dta (whsp-separated data string) property
	Example :
	Returns : scalar
	Args	: scalar

       Q A

	Title	: A
	Usage	: print $q->A
	Function: get a string representation of class Q object
	Example :
	Returns : string scalar
	Args	:

       Q clone

	Title	: clone
	Usage	: $q2 = $q1->clone;
	Function: create and return a clone of the object
	Example :
	Returns : object of class Q
	Args	:

       Q CLASS METHODS

       Q qin

	Title	: qin
	Usage	: Q::qin($q1, $q2)
	Function: tests whether the query represented by $q1 would return a subset
		  of items returned by the query represented by $q2
	Example : print "q2 gets those and more" if Q::qin($q1, $q2);
	Returns : 1 if q1 is subset of q2, 0 otherwise
	Args	: two class Q objects

       Q qeq

	Title	: qeq
	Usage	: Q::qeq($q1, $q2)
	Function: test if fld and dta properties in two class Q objects are the same
		  (irrespective of order)
	Example :
	Returns : 1 if equal, 0 otherwise
	Args	: two class Q objects

       Q qor

	Title	: qor
	Usage	: @qresult = Q::qor($q1, $q2)
	Function: logical OR for Q objects
	Example :
	Returns : an array of class Q objects
	Args	: two class Q objects

       Q qand

	Title	: qand
	Usage	: @qresult = Q::And($q1, $q2)
	Function: logical AND for R objects
	Example :
	Returns : an array of class Q objects
	Args	: two class Q objects

       Q INTERNALS

       Q unique

	Title	: unique
	Usage	: @ua = unique(@a)
	Function: return contents of @a with duplicates removed
	Example :
	Returns :
	Args	: an array

   Additional tools for Bio::AnnotationCollectionI
       Bio::AnnotationCollectionI SYNOPSIS (additional methods)

	   $seq->annotation->put_value('patient_id', 1401)
	   $seq->annotation->get_value('patient_ids')			# returns 1401
	   $seq->annotation->put_value('patient_group', 'MassGenH')
	   $seq->annotation->put_value(['clinical', 'cd4count'], 503);
	   $seq->annotation->put_value(['clinical', 'virus_load'], 150805);
	   foreach ( qw( cd4count virus_load ) ) {
	       $blood_readings{$_} = $seq->annonation->get_value(['clinical', $_]);
	   }

       Bio::AnnotationCollectionI DESCRIPTION (additional methods)

       "get_value()" and "put_value" allow easy creation of and access to an
       annotation collection tree with nodes of Bio::Annotation::SimpleValue.
       These methods obiviate direct accession of the SimpleValue objects.

   get_value
	Title	: get_value
	Usage	: $ac->get_value($tagname) -or-
		  $ac->get_value( $tag_level1, $tag_level2,... )
	Function: access the annotation value assocated with the given tags
	Example :
	Returns : a scalar
	Args	: an array of tagnames that descend into the annotation tree

   put_value
	Title	: put_value
	Usage	: $ac->put_value($tagname, $value) -or-
		  $ac->put_value([$tag_level1, $tag_level2, ...], $value) -or-
		  $ac->put_value( [$tag_level1, $tag_level2, ...] )
	Function: create a node in an annotation tree, and assign a scalar value to it
		  if a value is specified
	Example :
	Returns : scalar or a Bio::AnnotationCollection object
	Args	: $tagname, $value scalars (can be specified as -KEYS=>$tagname,
		  -VALUE=>$value) -or-
		  \@tagnames, $value (or as -KEYS=>\@tagnames, -VALUE=>$value )
	Note	: If intervening nodes do not exist, put_value creates them, replacing
		  existing nodes. So if $ac->put_value('x', 10) was done, then later,
		  $ac->put_value(['x', 'y'], 20), the original value of 'x' is trashed,
		  and $ac->get_value('x') will now return the annotation collection
		  with tagname 'y'.

   get_keys
	Title	: get_keys
	Usage	: $ac->get_keys($tagname_level_1, $tagname_level_2,...)
	Function: Get an array of tagnames underneath the named tag nodes
	Example : # prints the values of the members of Category 1...
		  print map { $ac->get_value($_) } $ac->get_keys('Category 1') ;
	Returns : array of tagnames or empty list if the arguments represent a leaf
	Args	: [array of] tagname[s]

perl v5.14.1			  2011-07-22   Bio::DB::HIV::HIVQueryHelper(3)
[top]

List of man pages available for Fedora

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net