use Bio::Tools::Infernal;
  my $parser = Bio::Tools::Infernal->new(-file => $rna_output,
                                        -motiftag => 'misc_binding'
                                        -desctag => 'Lysine riboswitch',
                                        -cm    => 'RF00168',
                                        -rfam  =>  'RF00168',
                                        -minscore => 20);
  #parse the results, get a Bio::SeqFeature::FeaturePair
  while( my $motif = $parser->next_prediction) {
    # do something here
  }

  Data            SeqFeature::FeaturePair         Note
  --------------------------------------------------------------------------
  primary tag     $sf->primary_tag                Rfam ID (if passed to new())
  start           $sf->start                      Based on CM length
  end             $sf->end                        Based on CM length
  score           $sf->score                      Bit score
  strand          $sf->strand                     0 (CM does not have a strand)
  seqid           $sf->seq_id                     Rfam ID (if passed to new())
  display name    $sf->feature1->display_name     CM name (if passed to new())
  source          $sf->feature1->source tag      'Infernal' followed by version

  Data            SeqFeature::FeaturePair         Note
  ------------------------------------------------------------------
  start           $sf->hstart
  end             $sf->hend
  score(bits)     $sf->hscore
  strand          $sf->hstrand
  seqid           $sf->hseqid
  Primary Tag     $sf->hprimary_tag
  Source Tag      $sf->hsource_tag

   secstructure - entire description line (in case the regex used for
                  sequence ID doesn't adequately catch the name
   model        - name of the descriptor file (may include path to file)
   midline      - contains structural information from the descriptor
                  used as a query
   hit          - sequence of motif, separated by spaces according to
                  matches to the structure in the descriptor (in
                  SecStructure).
   seqname      - raw sequence name (for downstream parsing if needed)

  my($self,@args) = @_;
  $self->warn('Use of this module is deprecated.  Use Bio::SearchIO::infernal instead');  
  $self->SUPER::_initialize(@args);
  my ($motiftag,$desctag,$srctag,$rfam,$cm,$ms,$ver) =
        $self->SUPER::_rearrange([qw(MOTIFTAG
                                    DESCTAG
                                    SRCTAG
                                    RFAM
                                    CM
                                    MINSCORE
                                    VERSION
                                 )],@args);
  $self->motif_tag(defined $motiftag ? $motiftag : $MotifTag);
  $self->source_tag(defined $srctag ? $srctag : $SrcTag);
  $self->desc_tag(defined $desctag ? $desctag : $DescTag);
  $cm        && $self->covariance_model($cm);
  $rfam      && $self->rfam($rfam);
  $self->program_version(defined $ver ? $ver : $DEFAULT_VERSION);
  $self->minscore(defined $ms ? $ms : $MINSCORE);

    my $self = shift;

    return $self->{'motif_tag'} = shift if @_;
    return $self->{'motif_tag'};

    my $self = shift;

    return $self->{'source_tag'} = shift if @_;
    return $self->{'source_tag'};

    my $self = shift;

    return $self->{'desc_tag'} = shift if @_;
    return $self->{'desc_tag'};

    my $self = shift;

    return $self->{'_cmodel'} = shift if @_;
    return $self->{'_cmodel'};

    my $self = shift;

    return $self->{'_rfam'} = shift if @_;
    return $self->{'_rfam'};

    my $self = shift;

    return $self->{'_minscore'} = shift if @_;
    return $self->{'_minscore'};

    my $self = shift;

    return $self->{'_program_version'} = shift if @_;
    return $self->{'_program_version'};

     my ($self, $method) = @_;  
    if($method && ($method !~ /Infernal/i)) {
    $self->throw("method $method not supported in " . ref($self));
    }
    return $self->SUPER::analysis_method($method);

    my ($self,@args) = @_;
    # even though next_prediction doesn't expect any args (and this method
    # does neither), we pass on args in order to be prepared if this changes
    # ever
    return $self->next_prediction(@args);

    my ($self) = @_;
    
    my ($start, $end, $strand, $score);
    
    my %hsp_key = ('0' => 'structure',
                   '1' => 'model',
                   '2' => 'midline',
                   '3' => 'hit');
    my $line;
    PARSER:
    while($line = $self->_readline) {
        next if $line =~ m{^\s+$};
        if ($line =~ m{^sequence:\s+(\S+)} ){
            $self->_current_hit($1);
            next PARSER;
        } elsif ($line =~ m{^hit\s+\d+\s+:\s+(\d+)\s+(\d+)\s+(\d+\.\d+)\s+bits}xms) {
            $strand = 1;
            ($start, $end, $score) = ($1, $2, $3);
            if ($start > $end) {
                ($start, $end) = ($end, $start);
                $strand = -1;
            }
            #$self->debug(sprintf("Hit: %-30s\n\tStrand:%-4d Start:%-6d End:%-6d Score:%-10s\n",
            #       $self->_current_hit, $strand, $start, $end, $score));
        } elsif ($line =~ m{^(\s+)[<>\{\}\(\)\[\]:_,-\.]+}xms) { # start of HSP
            $self->_pushback($line); # set up for loop
            # what is length of the gap to the structure data?
            my $offset = length($1);
            my ($ct, $strln) = 0;
            my $hsp;
            HSP:
            while ($line = $self->_readline) {
                next if $line =~ m{^\s*$}; # toss empty lines
                chomp $line;
                # exit loop if at end of file or upon next hit/HSP
                if (!defined($line) || $line =~ m{^(sequence|hit)}) {
                    $self->_pushback($line);
                    last HSP;
                }
                # iterate to keep track of each line (4 lines per hsp block)
                my $iterator = $ct%4;
                # strlen set only with structure lines (proper length)
                $strln = length($line) if $iterator == 0;
                # only grab the data needed (hit start and stop in hit line above;
                # query start, end are from the actual query length (entire hit is
                # mapped to CM data, so all CM data is represented
                
                # yes this is kinda clumsy, but I'll probably morph this into
                # a proper SearchIO module soon.  For now this works...
                my $data = substr($line, $offset, $strln-$offset);
                $hsp->{ $hsp_key{$iterator} } .= $data;
                $ct++;
            }
            if ($self->minscore < $score) {
                my ($name, $program, $rfam, $cm, $dt, $st, $mt) =
                  ($self->_current_hit, $self->analysis_method, $self->rfam,
                   $self->covariance_model, $self->desc_tag, $self->source_tag,
                   $self->motif_tag);
                my $ver = $self->program_version || '';
                my $qid = $name;
                if ($name =~ m{(?:gb|gi|emb|dbj|sp|pdb|bbs|ref|lcl)\|(\d+)((?:\:|\|)\w+\|(\S*.\d+)\|)?}xms) {
                    $qid = $1; 
                }
                my $fp = Bio::SeqFeature::FeaturePair->new();
                my $strlen = $hsp->{'model'} =~ tr{A-Za-z}{A-Za-z}; # gaps don't count
                my $qf = Bio::SeqFeature::Generic->new( -primary_tag => $mt,
                              -source_tag  => "$st $ver",
                              -display_name => $cm || '',
                              -score       => $score,
                              -start       => 1,
                              -end         => $strlen,
                              -seq_id      => $rfam || '',
                              -strand      => 0, # covariance model does not have a strand
                            );
                my $hf = Bio::SeqFeature::Generic->new( -primary_tag => $mt,
                              -source_tag  => "$st $ver",
                              -display_name => $dt || '',
                              -score       => $score,
                              -start       => $start,
                              -end         => $end,
                              -seq_id      => $qid,
                              -strand      => $strand
                            );
                $fp->feature1($qf);
                $fp->feature2($hf); # should emphasis be on the hit?
                $fp->add_tag_value('secstructure', $hsp->{'structure'});
                $fp->add_tag_value('model', $hsp->{'model'});
                $fp->add_tag_value('midline', $hsp->{'midline'});
                $fp->add_tag_value('hit', $hsp->{'hit'});
                $fp->add_tag_value('seq_name', $name);
                $fp->display_name($dt);
                return $fp;
            } else {
                next PARSER;
            }
        }
    }
    return (defined($line)) ? 1 : 0;

    my $self = shift;
    return $self->{'_currhit'} = shift if @_;
    return $self->{'_currhit'};
}

1;

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

  https://redmine.open-bio.org/projects/bioperl/

 Title   : new
 Usage   : my $obj = Bio::Tools::Infernal->new();
 Function: Builds a new Bio::Tools::Infernal object 
 Returns : an instance of Bio::Tools::Infernal
 Args    : -fh/-file  - for input filehandle/filename
           -motiftag  - primary tag used in gene features (default 'misc_binding')
           -desctag   - tag used for display_name name (default 'infernal')
           -srctag    - source tag used in all features (default 'Infernal')
           -rfam      - Rfam id number
           -cm        - covariance model used in analysis (may be same as rfam #)
           -minscore  - minimum score (simple screener, since Infernal generates
                        a ton of spurious hits)
           -version   - Infernal program version