package Boulder::Unigene;
use Boulder::Stream;
require Exporter;
@ISA = qw(Exporter Boulder::Stream);
@EXPORT = ();
@EXPORT_OK = ();
use Carp;
use constant DEFAULT_UNIGENE_PATH => '/data/unigene/Hs.dat';

=head1 NAME

Boulder::Unigene - Fetch Unigene data records as parsed Boulder Stones


  # parse a file of Unigene records
  $ug = new Boulder::Unigene(-accessor=>'File',
                             -param => '/data/unigene/Hs.dat');
  while (my $s = $ug->get) {
    print $s->Identifier;
    print $s->Gene;

  # parse flatfile records yourself
  open (UG,"/data/unigene/Hs.dat");
  local $/ = "*RECORD*";
  while (<UG>) {
     my $s = Boulder::Unigene->parse($_);
     # etc.


Boulder::Unigene provides retrieval and parsing services for UNIGENE records

Boulder::Unigene provides retrieval and parsing services for NCBI
Unigene records.  It returns Unigene entries in L<Stone>
format, allowing easy access to the various fields and values.
Boulder::Unigene is a descendent of Boulder::Stream, and provides a
stream-like interface to a series of Stone objects.

Access to Unigene is provided by one I<accessors>, which
give access to  local Unigene database.  When you
create a new Boulder::Unigene stream, you provide the
accessors, along with accessor-specific parameters that control what
entries to fetch.  The accessors is:

=over 2

=item File

This provides access to local Unigene entries by reading from a flat file
(typically Hs.dat file downloadable from NCBI's Ftp site).
The stream will return a Stone corresponding to each of the entries in 
the file, starting from the top of the file and working downward.  The 
parameter is the path to the local file.


It is also possible to parse a single Unigene entry from a text string 
stored in a scalar variable, returning a Stone object.

=head2 Boulder::Unigene methods

This section lists the public methods that the I<Boulder::Unigene>
class makes available.

=over 4

=item new()

   # Local fetch via File
   $ug=new Boulder::Unigene(-accessor  =>  'File',
                            -param     =>  '/data/unigene/Hs.dat');

The new() method creates a new I<Boulder::Unigene> stream on the
accessor provided.  The only possible accessors is B<File>.  
If successful, the method returns the stream
object.  Otherwise it returns undef.

new() takes the following arguments:

	-accessor	Name of the accessor to use
	-param		Parameters to pass to the accessor

Specify the accessor to use with the B<-accessor> argument.  If not
specified, it defaults to B<File>.  

B<-param> is an accessor-specific argument.  The possibilities is:

For B<File>, the B<-param> argument must point to a string-valued
scalar, which will be interpreted as the path to the file to read
Unigene entries from.

=item get()

The get() method is inherited from I<Boulder::Stream>, and simply
returns the next parsed Unigene Stone, or undef if there is nothing
more to fetch.  It has the same semantics as the parent class,
including the ability to restrict access to certain top-level tags.

=item put()

The put() method is inherited from the parent Boulder::Stream class,
and will write the passed Stone to standard output in Boulder format.
This means that it is currently not possible to write a
Boulder::Unigene object back into Unigene flatfile form.



The tags returned by the parsing operation are taken from the names shown in the Flat file
Hs.dat since no better description of them is provided yet by the database source producer.

=head2 Top-Level Tags

These are tags that appear at the top level of the parsed Unigene

=over 4

=item Identifier

The Unigene identifier of this entry.  Identifier is a single-value tag.

      my $identifierNo = $s->Identifier;

=item Title

The Unigene title for this entry.

      my $titledef=$s->Title;

=item Gene
The Gene associated with   this Unigene entry

      my $thegene=$s->Gene;

=item Cytoband
The cytological band position of this entry

      my $thecytoband=$s->Cytoband;

=item Counts
The number of EST in this record

      my $thecounts=$s->Counts;

=item LocusLink
The id of the LocusLink entry associated with this record

      my $thelocuslink=$s->LocusLink;

=item Chromosome
This field contains a list, of the chromosomes numbers in which this entry has been linked

      my @theChromosome=$s->Chromosome;


=head2 STS     
Multiple records in the form ^STS     ACC=XXXXXX NAME=YYYYYY

=over 4

=item ACC

=item NAME


=head2 TXMAP
Multiple records in the form  ^TXMAP  XXXXXXX; MARKER=YYYYY; RHPANEL=ZZZZ

The TXMAP tag points to a Stone record that contains multiple
subtags.  Each subtag is the name of a feature which points, in turn,
to a Stone that describes the feature's location and other attributes.

Each feature will contain one or more of the following subtags:

=over 4

=item MARKER



=head2 PROTSIM
Multiple records in the form ^PROTSIM ORG=XXX; PROTID=DBID:YYY; PCT=ZZZ; ALN=QQQQ
Where DBID is 
	PID for indicate presence of GenPept identifier, 
	SP to indicate SWISSPROT identifier,
	PIR to indicate PIR identifier,
	PRF to indicate ???

=over 4

=item ORG

=item PROTID

=item PCT

=item ALN


Multiple records in the form ^SEQUENCE ACC=XXX; NID=YYYY; PID = CLONE= END= LID=


=item ACC

=item NID

=item PID

=item CLONE

=item END

=item LID


=head1 SEE ALSO

L<Boulder>, L<Boulder::Blast>, L<Boulder::Genbank>

=head1 AUTHOR

Lincoln Stein <>.
Luca I.G. Toldo <>

Copyright (c) 1997 Lincoln D. Stein
Copyright (c) 1999 Luca I.G. Toldo

This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.  See DISCLAIMER.txt for
disclaimers of warranty.


# Following did not require any changes compared to
sub new  {
    my($package,@parameters) = @_;
    # superclass constructor
    my($self) = new Boulder::Stream;
    # figure out whether parameters are named.  Look for
    # an initial '-'
    if ($parameters[0]=~/^-/) {
	my(%parameters) = @parameters;
	$self->{'accessor'}=$parameters{'-accessor'} || 'File';
	$self->{'OUT'}=$parameters{'-out'} || 'main::STDOUT';
    } else {
    croak "Require parameters" unless defined($self->{'param'});
    $self->{'accessor'} = new {$self->{'accessor'}}($self->{'param'});
    return bless $self,$package;

# Following required no changes compared to
sub read_record {
    my($self,@tags) = @_;

    if (wantarray) {
	while (!$self->{'done'}) {
	    $s = $self->read_one_record(@tags);
	    next unless $s;
	    next if $query && !(&$query);
	return @result;

    # we get here if in a scalar context
    while (!$self->{'done'}) {
	$s = $self->read_one_record(@tags);
	next unless $s;
	return $s unless $query;
	return $s if &$query;
    return undef;

# Here is everything new
sub parse {
  my $self = shift;
  my $record = shift;
  return unless $record;
  my $tags = shift;
  my %ok;
  %ok = map {$_ => 1} @$tags if ref($tags) eq 'ARRAY';
    my($s,@lines,$line,$accumulated,$key,$keyword,$value,$feature,@features, $label);
  $s = new Stone;
#<LIGT> following this line the parsing of the record must be done
#              each key-value pair is stored by the following command:
#	$self->_addToStone($key,$value,$stone,\%ok);
# Process new record lines
 undef $unigeneid, $title, $gene,$cytoband, $locuslink, $chromosome, $scount;
 undef $sts, $txmap,$protsim,$sequence;
 undef @sts,@txmaps,@protsims,@sequences;
  foreach $line  (@recordlines) {
    if      ($line=~/^ID/) {
    } elsif ($line=~/^TITLE/) {
     shift @titles;
     $title=join(' ',@titles);
    } elsif ($line=~/^GENE/) {
    } elsif ($line=~/^CYTOBAND/) {
    } elsif ($line=~/^LOCUSLINK/) {
    } elsif ($line=~/^CHROMOSOME/) {
    } elsif ($line=~/^SCOUNT/) {
    } elsif ($line=~/^STS/) {
     (@sts)=split(/\s+/,$line); shift @sts;  $sts=join(' ',@sts);

     undef @features;    
     $featurelabel="Accession"; $featurevalue=$name;
     $feature = {'label'=>$featurelabel,'value'=>$featurevalue};
     $feature = {'label'=>$featurelabel,'value'=>$featurevalue};

    } elsif ($line=~/^TXMAP/) {
     (@txmaps)=split(/\s+/,$line); shift @txmaps;  $txmap=join(' ',@txmaps);
#     $self->_addToStone('TXMAP',$txmap,$s,\%ok);
    undef @features;
    } elsif ($line=~/^PROTSIM/) {
     (@protsims)=split(/\s+/,$line); shift @protsims;  $protsim=join(' ',@protsims);
#     $self->_addToStone('PROTSIM',$protsim,$s,\%ok);
    undef @features;
    } elsif ($line=~/^SEQUENCE/) {
     (@sequences)=split(/\s+/,$line); shift @sequences;  $sequence=join(' ',@sequences);
#     $self->_addToStone('SEQUENCE',$sequence,$s,\%ok);
    undef @features;
  return $s;

# Following is unchanged from
sub read_one_record {
  my($self,@tags) = @_;
  my $accessor = $self->{'accessor'};
  my $record   = $accessor->fetch_next();
  unless ($record) {
    return undef;

  return $self->parse($record,\@tags);

# Following is unchanged from
sub _trim {
    my($v) = @_;
    return $v;

# Following is unchanged from
sub _canonicalize {
  my $h = shift;

# Following is unchanged from
sub _addToStone {
    my($self,$xlabel,$value,$stone,$ok) = @_;
    return unless !%{$ok} || $ok->{$xlabel};

# Following is entirely rewritten
sub _addFeaturesToStone {
	my($self,$features,$basecount,$stone,$ok) = @_;
	my($f) = new Stone;
	foreach (@$features) {
		my($q) = $_->{'value'};
		my($label) = _canonicalize($_->{'label'});
		my($position) = $q=~m!^([^/]+)!;
		my @qualifiers = $q=~m!/(\w+)=([^/]+)!g;
		my %qualifiers;
		while (my($key,$value) = splice(@qualifiers,0,2)) {
			$value =~ s/^\s*\"//;
			$value =~s/\"\s*$//;
			$value=~s/\s+//g if uc($key) eq 'TRANSLATION';  
			$qualifiers{_canonicalize($key)} = $value;
		$f->insert($label=>new Stone('Position'=>$position,%qualifiers));

# -------------------------- DEFINITION OF ACCESSOR OBJECTS ------------------------------
#only name changes for avoid namespace collisions
package UnigeneAccessor;
use Carp;

sub new {
    my($class,@parameters) = @_;
    croak "UnigeneAccessor::new:  Abstract class\n";

sub fetch_next {
    my($self) = @_;
    croak "UnigeneAccessor::fetch_next: Abstract class\n";


# Following, only the File package since the only one supported.
# If other access methods must be supported, then here appropriate
# packages and methods must be implemented
package File;
use Carp;

# Following, removed the search for the string locus in the file
#   as validation that the input be compliant with parser
sub new {
    my($package,$path) = @_;
    $path = $DEFAULT_PATH unless $path;
    open (UG,$path) or croak "File::new(): couldn't open $path: $!";
    # read the junk at the beginning
    my $found; $found++;
    croak "File::new(): $path doesn't look like a Unigene flat file"
	unless $found;
    $_ = <UG>;
    return bless {'fh'=>UG},$package;

# Following, changed the record separator
sub fetch_next {
    my $self = shift;
    return undef unless $self->{'fh'};
    my($fh) = $self->{'fh'};
    chomp($line = <$fh>);
    return $line;