Login | Register

Info | Home

BioPHP - Sequence Database Class

Original code submitted by joseba
Code bellow is covered by GNU GPL v2 license.

Description

Last change: 2010/10/18 17:01 | Recent Changes | Original description
(short for \"Sequence Database\") Contains code for the SeqDB Class.

Code

Last change: 2010/10/18 17:01 | Recent Changes | Download | Original code
<?php
require_once(\"etc.inc\");
require_once(\"seq.inc\");
 
// ================== FUNCTIONS ========================

/*
We begin by describing parse_swissprot() first.

parse_swissprot() parses the Feature Table lines (those that begin with FT) in a Swissprot
data file, extracts the feature key name, from endpoint, to endpoint, and description, and
stores them in a (simple) array.  

process_ft() then pushes this array into a larger associative array, called $swiss, which is 
also an attribute of the Seq object. It is assigned a key of the form: FT_<feature_key_name>.
Examples are: FT_PEPTIDE, FT_DISULFID.
*/
function process_ft(&$swiss, $ft_r)
        {
        foreach($ft_r as $element)
                {
                $index = \"FT_\" . $element[0];
                array_shift($element);                                        
                if (count($swiss[$index]) == 0) 
                        {
                        $swiss[$index] = array();
                        array_push($swiss[$index], $element);
                        }
                else array_push($swiss[$index], $element); 
                }
        }

// at_entrystart() tests if the file pointer is at the start of a new sequence entry. 
function at_entrystart($linestr, $dbformat)
        {
        if ($dbformat == \"GENBANK\")
                return (substr($linestr,0,5) == \"LOCUS\");
        elseif ($dbformat == \"SWISSPROT\")
                return (substr($linestr,0,2) == \"ID\");
        }

// get_entryid() gets the primary accession number of the sequence entry which we are 
// currently processing.  This uniquely identifies a sequence entry.
function get_entryid(&$flines, $linestr, $dbformat)
        {
        if ($dbformat == \"GENBANK\")
                return trim(substr($linestr, 12, 16));
        elseif ($dbformat == \"SWISSPROT\")
                {
                list($lineno, $linestr) = each($flines);
                if (substr($linestr,0,2) == \"AC\")
                        {
                        $words = preg_split(\"/;/\", intrim(substr($linestr,5)));
                        prev($flines);
                        return $words[0];
                        }
                }
        }

// line2r() copies the lines belonging to a single sequence entry into an array.
function line2r($fpseq)
        {
        $flines = array();
        while(1)
                {
                $linestr = fgets($fpseq, 101);
                $flines[] = $linestr;
                if (left($linestr,2) == \'//\') return $flines;
                }
        return FALSE;
        }

// isa_qualifier() tests if the file pointer is at a line containing a feature qualifier.
// This applies only to GenBank sequence files.  
function isa_qualifier($str)
        {
        if (firstchar($str) == \'/\') return true;
        else return false;
        }

// fseekline() gets the byte offset (from beginning of file) of a particular line.  The file is
// identified by $fp file pointer, while the line is identified by $lineno, which is zero-based.
function fseekline($fp, $lineno)
        {
        $linectr = 0;
        fseek($fp, 0);
        while(!feof($fp))
                {
                $linestr = fgets($fp,101);
                if ($linectr == $lineno)
                        {
                        fseek($fp, $byteoff);
                        return $byteoff;
                        }
                $linectr++;
                $byteoff = ftell($fp);
                }
        }

// bsrch_tabfile() searches for a particular sequence id ($seqid) within an *.IDX file
// (identified by $fp file pointer), and returns data located in its $col-th column.
function bsrch_tabfile($fp, $col, $seqid)
        {
        $linectr = 0;
        fseek($fp, 0);
        while(!feof($fp))
                {
                fgets($fp, 41);
                $linectr++;
                }
        $lastline = $linectr;
        rewind($fp);

        if ($fp == FALSE) die(\"CANT OPEN FILE\");
        $searchspace = $lastline;
        $floor = 0;
        $ceiling = $lastline - 1;

        while(1)
                {
                $offset = ((int) ($searchspace/2));
                $lineno = $floor + $offset;

                fseekline($fp, $lineno);
                $word = preg_split(\"/\\s+/\", trim(fgets($fp,81)));
                if ($word[$col] == $seqid)
                        {
                        $word[] = $lineno;
                        return $word;
                        }
                elseif ($seqid > $word[$col])
                        {
                        $floor = $lineno + 1;
                        $searchspace = $ceiling - $floor + 1;
                        if ($searchspace <= 0) return FALSE;
                        }
                else
                        {
                        $ceiling = $lineno - 1;
                        $searchspace = $ceiling - $floor + 1;
                        if ($searchspace <= 0) return FALSE;
                        }
                }
        // fclose($fpidx);
        }

// ================== CLASSES ========================

class SeqDB
{ // OPENS definition of SEQDB CLASS.
var $dbname;
var $data_fn;
var $data_fp;
var $dir_fn;
var $dir_fp;
var $seqptr;
var $seqcount;
var $dbformat;
var $bof;
var $eof;

// We need the functions bof() and eof() to determine if we\'ve reached the end of
// file or not.
// Two ways of doing this: 1) examine value of seqptr, or 2) maintain boolean variables eof and bof

// first() positions the sequence pointer (i.e. the seqptr property of a Seq object) to 
// the first sequence in a database (SeqDB object).
function first()
        {
        $this->seqptr = 0;
        }

// last() positions the sequence pointer (i.e. the seqptr property of a Seq object) to 
// the last sequence in a database (SeqDB object).
function last()
        {
        $this->seqptr = $this->seqcount-1;
        }

// prev() (short for previous) positions the sequence pointer (i.e. the seqptr property of
// a Seq object) to the sequence that comes before the current sequence.  
function prev()
        {
        if ($this->seqptr > 0) $this->seqptr--;
        else $this->bof = TRUE;
        }

// next() positions the sequence pointer (i.e. the seqptr property of a Seq object) to the 
// sequence that comes after the current sequence.  
function next()
        {
        if ($this->seqptr < $this->seqcount-1) $this->seqptr++;
        else $this->eof = TRUE;
        }
        
// fetch() retrieves all data from the specified sequence record and returns them in the 
// form of a Seq object.  This method invokes one of several parser methods.
function fetch()
        {
        if ($this->data_fn == \"\") die(\"Cannot invoke fetch() method from a closed object.\");
        @$seqid = func_get_arg(0);

        // IDX and DIR files remain open for the duration of the FETCH() method.
        $fp = fopen($this->data_fn, \"r\");
        $fpdir = fopen($this->dir_fn, \"r\");

        if ($seqid != FALSE)
                {
                $idx_r = bsrch_tabfile($fp, 0, $seqid);
                if ($idx_r == FALSE) return FALSE;
                else $this->seqptr = $idx_r[3];
                }
        else
                 {
                 // For now, SEQPTR determines CURRENT SEQUENCE ID.  Alternative is to track curr line.
                 fseekline($fp, $this->seqptr);
                 $idx_r = preg_split(\"/\\s+/\", trim(fgets($fp, 81)));
                 }
        $dir_r = bsrch_tabfile($fpdir, 0, $idx_r[1]);

        $fpseq = fopen($dir_r[1], \"r\");
        fseekline($fpseq, $idx_r[2]);

        $flines = line2r($fpseq);

        $myseq = new seq();
        if ($this->dbformat == \"GENBANK\")
                $myseq = $this->parse_id($flines);
        elseif ($this->dbformat == \"SWISSPROT\")
                $myseq = $this->parse_swissprot($flines);

        fclose($fp);
        fclose($fpdir);
        fclose($fpseq);

        return $myseq;
        }

// parse_swissprot() parses a Swissprot data file and returns a Seq object containing parsed data.
function parse_swissprot($flines)
        { // OPENS parse_swissprot() function
        $accession = array();
        $date_r = array();
        $desc = \"\";
        $desc_lnctr = 0;
        $gename_r = array();
        $os_r = array();
        $os_linectr = 0;
        $os_str = \"\";
        $oc_linectr = 0;
        $oc_str = \"\";
        $ref_r = array();
        $ra_r = array();
        $ra_ctr = 0;
        $ra_str = \"\";
        $rl_ctr = 0;
        $rl_str = \"\";
        $db_r = array();
        $ft_r = array();
        $kw_str = \"\";
        $kw_r = array();
        
        while ( list($no, $linestr) = each($flines) )
                { // OPENS 1st (outermost) while ( list($no, $linestr) = each($flines) ) 
                  $linelabel = left($linestr, 2);
                  $linedata = trim(substr($linestr, 5));
                  $lineend = right($linedata, 1);
                  if (left($linestr, 2) == \"ID\")
                        { // OPENS if (left($linestr, 2) == \"ID\") 
                        $words = preg_split(\"/;/\", substr($linestr, 5));    
                        $endc = preg_split(\"/\\s/\", $words[0]);
                        $entry_name = $endc[0];
                        $namesrc = preg_split(\"/_/\", $entry_name);  
                        $protein_name = $namesrc[0];
                        $protein_source = $namesrc[1]; 
                        $data_class = $endc[1]; 
                        $moltype = $words[1];
                        $length = (int) substr($words[2], 0, strlen($words[2])-4);         
                        } // CLOSES if (left($linestr, 2) == \"ID\")
                if (left($linestr, 2) == \"AC\")
                        { // OPENS if (left($linestr, 2) == \"AC\") 
                        $accstr = $linedata;
                        $accstr = substr($accstr, 0, strlen($accstr)-1);
                        $accline = preg_split(\"/;/\", intrim($accstr));                    
                        $accession = array_merge($accession, $accline);
                        } // CLOSES if (left($linestr, 2) == \"AC\") 
                if (left($linestr, 2) == \"DT\")
                        { // OPENS if (left($linestr, 2) == \"DT\") 
                        // DT DD-MMM-YEAR (REL. XX, COMMENT)
                        $datestr = $linedata;
                        $datestr = substr($datestr, 0, strlen($datestr)-1); 
                        $words = preg_split(\"/\\(/\", $datestr);        
                        // ( \"DD-MMM-YEAR \", \"REL. XX, COMMENT\")
                        $firstcomma = strpos($words[1], \",\");
                        $comment = trim(substr($words[1], $firstcomma+1));
                  
                        // ( \"CREATED\" => (date, rel), \"LAST SEQUENCE UPDATE\" => (date, rel),
                        //   \"LAST ANNOTATION UPDATE\" => (date, rel), COMMENT1 => (date, rel),
                        //   \"COMMENT2\" => (date, rel), ... )
                  
                        if ($comment == \"CREATED\")
                                { // OPENS if ($comment == \"CREATED\") 
                                // this DT line is a DATE CREATED line.
                                $create_date = substr($words[0], 0, 11); 
                                $create_rel = substr($words[1], 5, ($firstcomma-5));
                                $date_r[$comment] = array($create_date, $create_rel);  
                                } // CLOSES if ($comment == \"CREATED\")
                        elseif ($comment == \"LAST SEQUENCE UPDATE\")
                                { // OPENS elseif ($comment == \"LAST SEQUENCE UPDATE\")
                                $sequpd_date = substr($words[0], 0, 11);
                                $sequpd_rel = substr($words[1], 5, ($firstcomma-5));
                                $date_r[$comment] = array($sequpd_date, $sequpd_rel);  
                                } // CLOSES elseif ($comment == \"LAST SEQUENCE UPDATE\")
                        elseif ($comment == \"LAST ANNOTATION UPDATE\")
                                { // OPENS elseif ($comment == \"LAST ANNOTATION UPDATE\")
                                $notupd_date = substr($words[0], 0, 11);
                                $notupd_rel = substr($words[1], 5, ($firstcomma-5));
                                $date_r[$comment] = array($notupd_date, $notupd_rel);  
                                } // CLOSES elseif ($comment == \"LAST ANNOTATION UPDATE\")
                        else
                                { // OPENS else part of if ($comment == \"CREATED\")  
                                // For now, we do not check vs. duplicate comments.
                                // We just overwrite the older comment with new one.
                                $other_comment = $comment; 
                                $other_date = substr($words[0], 0, 11);
                                $other_rel = substr($words[1], 5, ($firstcomma-5));
                                $date_r[$comment] = array($other_date, $other_rel);
                                } // CLOSES else part of if ($comment == \"CREATED\")
                        } // CLOSES if (left($linestr, 2) == \"DT\")    

                        if (left($linestr, 2) == \"DE\")
                                { // OPENS if (left($linestr, 2) == \"DE\") 
                                $desc_lnctr++;
                                $linestr = $linedata;
                                if ($desc_lnctr == 1) $desc .= $linestr;
                                else $desc .= \" \" . $linestr;
                                
                                // Checks if (FRAGMENT) or (FRAGMENTS) is found at the end
                                // of the DE line to determine if sequence is complete.                                  
                                if (right($linestr, 1) == \".\")
                                        { // OPENS if (right($linestr, 1) == \".\")
                                        if (         (strtoupper(right($linestr, 11)) == \"(FRAGMENT).\") or 
                                                (strtoupper(right($linestr, 12)) == \"(FRAGMENTS).\") )
                                                $is_fragment = TRUE;
                                        else $is_fragment = FALSE;
                                        } // CLOSE if (right($linestr, 1) == \".\")
                                } // CLOSES if (left($linestr, 2) == \"DE\")
                          
                        if ($linelabel == \"KW\")
                                {
                                $kw_str .= $linedata;                                  
                                if ($lineend == \".\")
                                        {                                             
                                        $kw_str = rem_right($kw_str);
                                        $kw_r = preg_split(\"/;/\", $kw_str);
                                        array_walk($kw_r, \"trim_element\");                                          
                                        $kw_str = \"\";
                                        }                                  
                                }          
                          
                        if ($linelabel == \"OS\")                          
                                { // OPENS if ($linelabel == \"OS\") 
                                $os_linectr++;
                                if ($lineend != \".\")
                                        { // we are not yet at the last OS line.
                                        if ($os_linectr == 1) $os_str .= $linedata;
                                        else $os_str .= \" $linedata\";
                                        }
                                else 
                                        { // we are at the last OS line.
                                        $os_str .= \" $linedata\";
                                        $os_str = rem_right($os_str);
                                        $os_line = preg_split(\"/\\, AND /\", $os_str);
                                        }
                                } // CLOSES if ($linelabel == \"OS\")

                        if ($linelabel == \"OG\")
                                $organelle = rem_right($linedata);
                                
                        if ($linelabel == \"OC\")
                                {
                                $oc_linectr++;
                                if ($lineend != \".\")
                                        { // we are not yet at the last OS line.
                                        if ($oc_linectr == 1) $oc_str .= $linedata;
                                        else $oc_str .= \" $linedata\";
                                        }
                                else 
                                        { // we are at the last OS line.
                                        $oc_str .= \" $linedata\";
                                        $oc_str = rem_right($oc_str);
                                        $oc_line = preg_split(\"/;/\", $oc_str);
                                        array_walk($oc_line, \"trim_element\");
                                        }
                                }                  
                                
                        if ($linelabel == \"FT\")
                                {
                                $ft_key = trim(substr($linestr, 5, 8));                                  
                                $ft_from = (int) trim(substr($linestr, 14, 6));
                                $ft_to = (int) trim(substr($linestr, 21, 6));
                                $ft_desc = rem_right(trim(substr($linestr, 34)));
                                $ft_r[] = array($ft_key, $ft_from, $ft_to, $ft_desc);
                                }  
                          
                  // ( rn => ( \"rp\" => \"my rp\", \"rc\" => (\"tok1\" => \"value\", ...) ) )
                  // ( 10 => ( \"RP\" => \"my rp\", \"RC\" => (\"PLASMID\" => \"PLA_VAL\", ... ) ) )
                  // Example: DR AARHUS/GHENT-2DPAGE; 8006; IEF.
                  
                        if ($linelabel == \"DR\")
                                {
                                // DR DATA_BANK_IDENTIFIER; PRIMARY_IDENTIFIER; SECONDARY_IDENTIFIER
                                // We assume that all three data items are mandatory/present in all DR entries.
                                // ( refno => ( (dbname1, pid1, sid1), (dbname2, pid2, sid2), ... ), 1 => ( ... ) )
                                // ( 0 => ( (REBASE, pid1, sid1), (WORPEP, pid2, sid2), ... ), 1 => ( ... ) )
                                $linedata = rem_right($linedata);
                                $dr_line = preg_split(\"/;/\", $linedata); 
                                array_walk($dr_line, \"trim_element\");
                                $db_name = $dr_line[0];
                                $db_pid = $dr_line[1];
                                $db_sid = $dr_line[2];
                                $db_r[] = array($db_name, $db_pid, $db_sid);                   
                                }                          
                  
                        if ($linelabel == \"RN\")
                                { // OPENS \"RN\"
                                // Remove the [ and ] between the reference number.
                                $refno = substr(rem_right($linedata), 1);
                                
                                $rc_ctr = 0;
                                $rc_str = \"\";
                                $rc_flag = FALSE;
                                $inner_r = array();
                                while ( list($no, $linestr) = each($flines) )
                                        { // OPENS 2nd WHILE
                                        $linelabel = left($linestr, 2);
                                        $linedata = trim(substr($linestr, 5));
                                        $lineend = right($linedata, 1);
                                        if ($linelabel == \"RP\") $inner_r[\"RP\"] = $linedata;
                                        elseif ($linelabel == \"RC\")
                                                { // OPENS elseif ($linelabel == \"RC\")
                                                $rc_str .= $linedata;
                                                while ( list($no, $linestr) = each($flines) )
                                                        { // OPENS 3rd WHILE
                                                        $linelabel = left($linestr, 2);
                                                        $linedata = trim(substr($linestr, 5));
                                                        $lineend = right($linedata, 1);
                                                        if ($linelabel == \"RC\")
                                                                $rc_str .= \" $linedata\";                       
                                                        else
                                                                { // opens else
                                                                prev($flines);
                                                                break;
                                                                } // closes else
                                                        } // CLOSES 3rd WHILE

                                                // we remove the last character if it is \";\"
                                                $rc_str = trim($rc_str);
                                                if (right($rc_str,1) == \";\") $rc_str = rem_right($rc_str);
                                                $rc_line = preg_split(\"/;/\", trim($rc_str));
                                                array_walk($rc_line, \"trim_element\");
                                                $innermost = array();
                                                
                                                foreach($rc_line as $tokval_str)
                                                        {
                                                        // here we assume that there is no whitespace
                                                        // before or after (left or right of) the \"=\".
                                                        $tokval_r = preg_split(\"/=/\", $tokval_str);
                                                        $token = $tokval_r[0];
                                                        $value = $tokval_r[1];
                                                        $innermost[$token] = $value;
                                                        }
                                                $inner_r[\"RC\"] = $innermost; 
                                                } // CLOSES elseif ($linelabel == \"RC\")
                                        elseif ($linelabel == \"RM\")
                                                { // We have no idea what RM is about, so we assume it\'s a single-line entry.
                                                // which may occur 0 to 1 times inside a SWISSPROT SEQUENCE RECORD.
                                                $inner_r[\"RM\"] = $linedata;
                                                }
                                        elseif ($linelabel == \"RX\")
                                                {
                                                $linedata = rem_right($linedata);
                                                $rx_line = preg_split(\"/;/\", intrim($linedata));
                                                $inner_r[\"RX_BDN\"] = $rx_line[0];
                                                $inner_r[\"RX_ID\"] = $rx_line[1];
                                                }
                                        elseif ($linelabel == \"RA\")
                                                {
                                                $ra_ctr++;
                                                if ($ra_ctr == 1) $ra_str = $linedata;
                                                else $ra_str .= \" $linedata\";
                                                if ($lineend == \";\")
                                                        {
                                                        $ra_str = rem_right($ra_str);
                                                        $ra_r = preg_split(\"/\\,/\", $ra_str);
                                                        array_walk($ra_r, \"trim_element\");
                                                        $inner_r[\"RA\"] = $ra_r;                   
                                                        }
                                                }
                                        elseif ($linelabel == \"RL\")
                                                {
                                                $rl_ctr++;
                                                if ($rl_ctr == 1) $rl_str = $linedata;
                                                else $rl_str .= \" $linedata\";
                                                }
                                        else
                                                {
                                                $inner_r[\"RL\"] = $rl_str;
                                                prev($flines);
                                                break;
                                                }
                                        } // CLOSES 2nd WHILE

                                $ref_r[$refno-1] = $inner_r;
                                $ra_str = \"\";
                                $ra_ctr = 0;
                                $rl_str = \"\";
                                $rl_ctr = 0;
                                } // CLOSES \"RN\"

                        if (left($linestr, 2) == \"GN\")
                                { // OPENS if (left($linestr, 2) == \"GN\") 
                                // GN is always exactly one line.
                                // GNAME1 OR GNAME2               ( (GNAME1, GNAME2) )
                                // GNAME1 AND GNAME2              ( (GNAME1), (GNAME2) )
                                // GNAME1 AND (GNAME2 OR GNAME3)  ( (GNAME1), (GNAME2, GNAME3) )
                                // GNAME1 OR (GNAME2 AND GNAME3)  NOT POSSIBLE!!!
                                
                                /* ALGORITHM:
                                  1) Split expressions by \" AND \".
                                  2) Test each \"token\" if in between parentheses or not.
                                  3) If not, then token is a singleton, else it\'s a multiple-ton.
                                  4) Singletons are translated into (GNAME1).
                                          Multiple-tons are translated into (GNAME1, GNAME 2).
                                  5) Push gene name array into larger array. Go to next token.
                                */

                                // Remove \"GN \" at the beginning of our line.
                                $linestr = trim(substr($linestr, 5));
                                // Remove the last character which is always a period.
                                $linestr = substr($linestr, 0, strlen($linestr)-1); 

                                // Go here if you detect at least one ( or ). 
                                if ( is_false(strpos($linestr, \"(\")) )
                                        { // GN Line does not contain any parentheses.
                 // Ergo, it is made up of all OR\'s or AND\'s but not both.
                                        if (strpos($linestr, \" OR \") != FALSE)
                                                {
                                                // Case 1: GNAME1 OR GNAME2.
                                                $temp = preg_split(\"/ OR /\", $linestr);
                                                $gename_r[] = $temp;
                                                }
                                        elseif (strpos($linestr, \" AND \") != FALSE)
                                                {
                                                // Case 2: GNAME1 AND GNAME2 AND GNAME3.
                                                $temp = preg_split(\"/ AND /\", $linestr);
                                                foreach($temp as $gene)
                                                        $gename_r[] = array($gene);
                                                }
                                        else $gename_r[] = array($linestr);
                                        // Case 0: GN GENENAME1. One gene name (no OR, AND).
                                        }
                                else
                                        { // OPENS else part of if ( is_false(strpos($linestr, \"(\")) )  
                 // GN Line contains at least one pair of parentheses.
                 // Case 3: GNAME1 AND (GNAME2 OR GNAME3) => ( (GNAME1), (GNAME2, GNAME3) )
                 // COMMENTS # 1 below.
                                        $temp = preg_split(\"/ AND /\", $linestr);
                                        foreach($temp as $gene)
                                                { // OPENS foreach($temp as $gene) 
                                                if (substr($gene, 0, 1) == \"(\")
                                                        { // a list of 2 or more gene names OR\'ed together
                                                        // remove the \"(\" and \")\" at both ends of the string.
                                                        $gene = substr($gene, 1);
                                                        $gene = substr($gene, 0, strlen($gene)-1);
                                                        $genelist = preg_split(\"/ OR /\", $gene);
                                                        $gename_r[] = $genelist;
                                                        }
                                                else
                                                        { // singleton
                                                        $gename_r[] = array($gene);
                                                        }
                                                } // CLOSES foreach($temp as $gene)
                                        } // CLOSES else part of if ( is_false(strpos($linestr, \"(\")) )  
                                } // CLOSES if (left($linestr, 2) == \"GN\") 
                          
                                // 0123456789012345678901234567890123456789
                                // SQ   SEQUENCE XXXX AA; XXXXX MW; XXXXX CN;
                                if ($linelabel == \"SQ\")
                                        { // OPENS if ($linelabel == \"SQ\")
                                        $linedata = rem_right($linedata);
                                        // XXXX AA, XXXX MW, XXXX CN                                                                    
                                        $words = preg_split(\"/;/\", substr($linedata, 8));                                  
                                        $aa = preg_split(\"/\\s+/\", trim($words[0]));
                                        $aa_count = (int) trim($aa[0]);
                                        $mw = preg_split(\"/\\s+/\", trim($words[1]));
                                        $mol_wt = (int) trim($mw[0]);                                                                    
                                        $cn = preg_split(\"/\\s+/\", trim($words[2]));
                                        $chk_no = trim($cn[0]);
                                        $chk_method = trim($cn[1]); 
                                        $sequence = \"\";
                                        while ( list($no, $linestr) = each($flines) )
                                                { 
                                                $linelabel = left($linestr, 2);
                                                if ($linelabel == \"//\") break;
                                                $linedata = intrim(trim($linestr));
                                                $sequence .= $linedata;                                                                                             
                                                } 
                                        } // CLOSES if ($linelabel == \"SQ\")                          

        } // CLOSES 1st (outermost) while ( list($no, $linestr) = each($flines) )                            
                
        $seqobj = new seq();                        
        $seqobj->id = $protein_name; 
        $seqobj->seqlength = $length;                                
        $seqobj->moltype = $moltype;
        $seqobj->date = $create_date;
        $seqobj->accession = $accession[0];
        array_shift($accession);
        $seqobj->sec_accession = $accession; 
        $seqobj->source = $os_line;
        $seqobj->organism = $oc_line;
        $seqobj->sequence = $sequence;                          
        $seqobj->definition = $desc;
        $seqobj->keywords = $kw_r;

        $genbank_ref_r = array();
        $inner_r = array();
        foreach($ref_r as $key => $value)
                {
                $inner_r[\"REFNO\"] = $key;                                                                
                $db_id = $value[\"RX_BDN\"];
                $inner_r[$db_id] = $value[\"RX_ID\"];                                                                
                $inner_r[\"REMARKS\"] = $value[\"RP\"];
                $inner_r[\"COMMENT\"] = $value[\"RC\"];                                                        
                $inner_r[\"TITLE\"] = $value[\"RL\"];
                $inner_r[\"JOURNAL\"] = $value[\"RL\"];          
                $inner_r[\"AUTHORS\"] = $value[\"RA\"];
                $genbank_ref_r[] = $inner_r;
                }
        $seqobj->reference = $genbank_ref_r;                                                        

        $swiss = array();
        $swiss[\"ID\"] = $protein_name;
        $swiss[\"PROT_NAME\"] = $protein_name;
        $swiss[\"MOL_TYPE\"] = $moltype;
        $swiss[\"PROT_SOURCE\"] = $protein_source;
        $swiss[\"DATA_CLASS\"] = $data_class;
        $swiss[\"LENGTH\"] = $length;                        
        $swiss[\"CREATE_DATE\"] = $create_date;  
        $swiss[\"CREATE_REL\"] = $create_rel; 
        $swiss[\"SEQUPD_DATE\"] = $sequpd_date;
        $swiss[\"SEQUPD_REL\"] = $sequpd_rel;
        $swiss[\"NOTUPD_DATE\"] = $notupd_date;
        $swiss[\"NOTUPD_REL\"] = $notupd_rel;
        // ACCESSION is an ARRAY.
        $swiss[\"ACCESSION\"] = $accession;
        $swiss[\"PRIM_AC\"] = $accession[0]; 
        $swiss[\"DESC\"] = $desc;
        $swiss[\"IS_FRAGMENT\"] = $is_fragment;
        // KEYWORDS is an ARRAY.
        $swiss[\"KEYWORDS\"] = $kw_r;
        // ORGANISM is an ARRAY.
        $swiss[\"ORGANISM\"] = $os_line;
        $swiss[\"ORGANELLE\"] = $organelle;
        // FT_<keyword> is an ARRAY.
        process_ft($swiss, $ft_r);                
        
        $swiss[\"AMINO_COUNT\"] = $aa_count;
        $swiss[\"MOLWT\"] = $mol_wt;
        $swiss[\"CHK_NO\"] = $chk_no;
        $swiss[\"CHK_METHOD\"] = $chk_method; 
        $swiss[\"SEQUENCE\"] = $sequence;        
        // GENE_NAME is an ARRAY.
        $swiss[\"GENE_NAME\"] = $gename_r;
        // ORG_CLASS is an ARRAY.                        
        $swiss[\"ORG_CLASS\"] = $oc_line;                        
        // REFERENCE is an ARRAY.
        $swiss[\"REFERENCE\"] = $ref_r;
        
        $seqobj->swissprot = $swiss;                // ARRAY          
        return $seqobj;                                                
        } // CLOSES parse_swissprot()

// parse_id() parses a GenBank data file and returns a Seq object containing parsed data.
function parse_id($flines)
        {
        $seqarr = array();
        $inseq_flag = false;
        $seqdata_flag = false;
        $accession_flag = false;
        $ref_array = array();
        $feature_array = array();
        $entry_ctr = 0;
        $ref_ctr = 0;
        $maxlength = 0;
        $minlength = 999999;
        $tot_seqlength = 0;
                
        while( list($lineno, $linestr) = each($flines) )
                { // OPENS outermost while( list($lineno, $linestr) = each($flines) )
      if (substr($linestr,0,5) == \"LOCUS\")
         {
         $entry_ctr++;
         $ref_ctr = 0;
         $ref_array = array();

         // This is the beginning of a SEQUENCE ENTRY.
         $seqdata = \"\";

         $seqobj = new seq();
         $seqobj->id = trim(substr($linestr, 12, 16));
         $seqobj->seqlength = trim(substr($linestr, 29, 11)) * 1;
         $tot_seqlength += $seqobj->seqlength;

         if ($seqobj->seqlength > $maxlength) $maxlength = $seqobj->seqlength;
         if ($seqobj->seqlength < $minlength) $minlength = $seqobj->seqlength;

         $seqobj->moltype = substr($linestr, 47, 6);
         if (substr($linestr, 44, 3) == \"ss-\") $seqobj->strands = \"SINGLE\";
         elseif (substr($linestr, 44, 3) == \"ds-\") $seqobj->strands = \"DOUBLE\";
         elseif (substr($linestr, 44, 3) == \"ms-\") $seqobj->strands = \"MIXED\";

         $seqobj->topology = strtoupper(substr($linestr, 55, 8));
         $seqobj->division = strtoupper(substr($linestr, 64, 3));
         $seqobj->date = strtoupper(substr($linestr, 68, 11));

         $inseq_flag = true;
         }

                if (trim(substr($linestr,0,10)) == \"BASE COUNT\")
         {
         if (count($feat_r) > 0)
            $seqobj->features = $feat_r;
         }
                        
      if (trim(substr($linestr,0,12)) == \"FEATURES\")
         { // OPENS if (trim(substr($linestr,0,12)) == \"FEATURES\") 
         // The REFERENCE section was present for this SEQUENCE ENTRY so we set REFERENCE attribute.
         if (count($ref_array) > 0) $seqobj->reference = $ref_array;
         $lastsubkey = \"\";

         $feat_r = array();
         $qual_r = array();

         // Go to the next line.
         list($lineno, $linestr) = each($flines);

         // This loops through each line in the entire FEATURES SECTION.
         while( substr($linestr,0,10) != \"BASE COUNT\" )
            { // FEATURES WHILE LOOP
            $label = trim(substr($linestr,0,21));
            $data = trim(substr($linestr,21));

            if (strlen($label) != 0)
               {
               // At the beginning of a new SUBKEY.
               $subkey = $label;
               // Add/save the qualifier array (qual_r) of the previous SUBKEY to our big feat_r array.
               if (count($qual_r) > 0)
                  {
                  $feat_r[$lastsubkey] = $qual_r;
                  $qual_r = array();
                  }

               $qual = $subkey;
               $qual_r[$qual] = \"\";
               $qual_ctr = 0;

               do
                  { // QUALIFIER WHILE LOOP
                  $qual_ctr++;
                  $qual_r[$qual] .= \" \" . $data;

                  list($lineno, $linestr) = each($flines);
                  $label = trim(substr($linestr,0,21));
                  $data = trim(substr($linestr,21));
                  } while( is_blank($label) and !(isa_qualifier($data)) );

               if (!(is_blank($label)))
                  {
                  $lastsubkey = $subkey;
                  $subkey = $label;
                  }
               }
            else
               { // we are inside a subkey section but on the 2nd, 3rd, nth line which have blank LABELS.
               if (isa_qualifier($data))
                  {
                  $wordarray = preg_split(\"/=/\", $data);
                  $qual = $wordarray[0];
                  $data = $wordarray[1];
                  $qual_r[$qual] = \"\";
                  $qual_ctr = 0;

                  do
                     { // QUALIFIER WHILE LOOP
                     $qual_ctr++;
                     $qual_r[$qual] .= \" \" . $data;
                     list($lineno, $linestr) = each($flines);
                     $label = trim(substr($linestr,0,21));
                     $data = trim(substr($linestr,21));
                     } while( is_blank($label) and !(isa_qualifier($data)) );

                  if (!(is_blank($label)))
                     {
                     $lastsubkey = $subkey;
                     $subkey = $label;
                     }
                  }
               } // ELSE PART of if (strlen($subkey) != 0)
            } // FEATURES WHILE LOOP

            if (count($qual_r) > 0)
               {
               $feat_r[$lastsubkey] = $qual_r;
               $qual_r = array();
               }

            prev($flines);
         } // CLOSES if (trim(substr($linestr,0,12)) == \"FEATURES\") 
                        
      if (substr($linestr,0,10) == \"DEFINITION\")
         {
         $wordarray = explode(\" \", $linestr);
         array_shift($wordarray);
         $seqobj->definition = implode(\" \", $wordarray);
         }
                                        
      if ($inseq_flag == TRUE)
         { // OPENS if ($inseq_flag == TRUE) 
         if (trim(substr($linestr, 0, 12)) == \"REFERENCE\")
            {
            // at this point, we are at the line with REFERENCE x (base y of z) in it.
            $wordarray = preg_split(\"/\\s+/\", trim(substr($linestr,12)));

            $ref_rec = array();
            $ref_rec[\"REFNO\"] = $wordarray[0];
            array_shift($wordarray);
            $ref_rec[\"BASERANGE\"] = implode(\" \", $wordarray);
            $lastsubkey = \"\";
            $subkey_lnctr = 0;

            while( list($lineno, $linestr) = each($flines) )
               {
               $subkey = trim(substr($linestr,0,12));

               // If current subkey is blank string, then this is a continuation of the last subsection.
               if (strlen($subkey) == 0) $subkey = $lastsubkey;

               // If we are at the next subkey section (e.g. lastsubkey was AUTHORS, and current is TITLE).
               if ($subkey != $lastsubkey) $subkey_lnctr = 0;

               switch ($subkey)
                  {
                  case \"AUTHORS\":
                     $subkey_lnctr++;
                     $wordarray = preg_split(\"/\\s+/\", trim(substr($linestr,12)));
                     // we remove comma at the end of a name, and the element \"and\".
                     $newarray = array();
                     foreach($wordarray as $authname)
                        {
                        if (strtoupper($authname) != \"AND\")
                           {
                           if (substr($authname, strlen($authname)-1, 1) == \",\")
                              $authname = substr($authname, 0, strlen($authname)-1);
                           $newarray[] = $authname;
                           }
                        }
                     if ($subkey_lnctr == 1) $ref_rec[\"AUTHORS\"] = $newarray;
                     else $ref_rec[\"AUTHORS\"] = array_merge($ref_rec[\"AUTHORS\"], $newarray);
                     break;
                  case \"TITLE\":
                     $subkey_lnctr++;
                     if ($subkey_lnctr == 1) $ref_rec[\"TITLE\"] = trim(substr($linestr,12));
                     else $ref_rec[\"TITLE\"] .= \" \" . trim(substr($linestr,12));
                     break;
                  case \"JOURNAL\":
                     $subkey_lnctr++;
                     if ($subkey_lnctr == 1) $ref_rec[\"JOURNAL\"] = trim(substr($linestr,12));
                     else $ref_rec[\"JOURNAL\"] .= \" \" . trim(substr($linestr,12));
                     break;
                  case \"MEDLINE\":
                     $ref_rec[\"MEDLINE\"] = substr($linestr, 12, 8);
                     break;
                  case \"PUBMED\":
                     $ref_rec[\"PUBMED\"] = substr($linestr, 12, 8);
                     break;
                  case \"REMARK\":
                     $subkey_lnctr++;
                     if ($subkey_lnctr == 1) $ref_rec[\"REMARK\"] = trim(substr($linestr,12));
                     else $ref_rec[\"REMARK\"] .= \" \" . trim(substr($linestr,12));
                     break;
                  case \"COMMENT\":
                     $subkey_lnctr++;
                     if ($subkey_lnctr == 1) $ref_rec[\"COMMENT\"] = trim(substr($linestr,12));
                     else $ref_rec[\"COMMENT\"] .= \" \" . trim(substr($linestr,12));
                     break;
                  }
               if ($subkey == \"FEATURES\")
                  {
                  prev($flines);
                  break;
                  }
               if ($subkey == \"REFERENCE\")
                  {
                  $ref_ctr++;
                  prev($flines);
                  break;
                  }
               $lastsubkey = $subkey;
               }
            array_push($ref_array, $ref_rec);
            }
         if (trim(substr($linestr, 0, 12)) == \"SOURCE\")
            {
            // For now, assume a single-line SOURCE field.
            $seqobj->source = substr($linestr, 12);
            }
         if (trim(substr($linestr, 0, 12)) == \"SEGMENT\")
            {
            $seqobj->segment = substr($linestr, 12);
            $wordarray = preg_split(\"/\\s+/\", trim(substr($linestr,12)));
            $seqobj->segment_no = $wordarray[0];
            $seqobj->segment_count = $wordarray[2];
            }

         // For now, assume that KEYWORDS field consists of exactly one line.
         if (trim(substr($linestr, 0, 12)) == \"KEYWORDS\")
            {
            $wordarray = preg_split(\"/\\s+/\", trim($linestr));
            array_shift($wordarray);
            $wordarray = preg_split(\"/;+/\", implode(\" \", $wordarray));
            if ($wordarray[0] != \".\") $seqobj->keywords = $wordarray;
            }
         if (substr($linestr, 0, 7) == \"VERSION\")
            {
            // Assume that VERSION line is made up of exactly 2 or 3 tokens.
            $wordarray = preg_split(\"/\\s+/\", trim($linestr));
            $seqobj->version = $wordarray[1];
            if (count($wordarray) == 3) $seqobj->ncbi_gi_id = $wordarray[2];
            $accession_flag = false;
            }
         if ($accession_flag == TRUE)
            {
            // 2nd, 3rd, etc. line of ACCESSION field.
            $wordarray = preg_split(\"/\\s+/\", trim($linestr));
            $this->sec_accession = array_merge($this->sec_accession, $wordarray);
            }
         if (substr($linestr,0,9) == \"ACCESSION\")
            {
            $wordarray = preg_split(\"/\\s+/\", trim($linestr));
            $seqobj->accession = $wordarray[1];
            array_shift($wordarray);
            array_shift($wordarray);
            $seqobj->sec_accession = $wordarray;
            $accession_flag = true;
            }
         if (substr($linestr,0,10) == \"  ORGANISM\")
            {
            $seqobj->organism = substr($linestr,12);
            }
         if (($seqdata_flag == true) && (substr($linestr,0,2) != \"//\"))
            {
            $wordarray = explode(\" \", trim($linestr));
            array_shift($wordarray);
            $seqline = implode(\"\", $wordarray);
            $seqdata .= $seqline;
            }
         if (substr($linestr,0,6) == \"ORIGIN\") $seqdata_flag = true;
         if (substr($linestr,0,2) == \"//\")
            {
            $seqobj->sequence = $seqdata;
            $seqarr[$this->id] = $this;
            $seqdata_flag = false;
            $inseq_flag = false;
            break;
            }
         } // CLOSES if ($inseq_flag == TRUE) 
      } // CLOSES outermost while( list($lineno, $linestr) = each($flines) )
        $seqobj->seqarray = $seqarr;
        return $seqobj;
        } // Closes parse_id() constructor function definition

// open() opens or prepares the SeqDB for processing.  Opposite of close().
function open($dbname)
        {
        if (file_exists($dbname . \".idx\") == FALSE) die(\"ERROR: Index file $dbname.IDX does not exist!\");
        if (file_exists($dbname . \".dir\") == FALSE) die(\"ERROR: Index file $dbname.DIR does not exist!\");

        $this->dbname = $dbname;
        $this->data_fn = $dbname . \".idx\";
        $this->dir_fn = $dbname . \".dir\";
        $this->seqptr = 0;
        }

// close() closes the SeqDB database after we\'re through using it.  Opposite of open() method.  
function close()
        { //
        // Close simply assigns null values to attributes of the seqdb() object.
        // Methods like fetch would not function properly if these values are null.
        $this->dbname = \"\";
        $this->data_fn = \"\";
        $this->dir_fn = \"\";
        $this->seqptr = -1;
        }

/*
SeqDB() is the constructor method for the SeqDB class.  It does many things like create
and/or read a database\'s index files, initialize certain SeqDB properties, etc.
Syntax: $seqdb = new seqdb($dbname, $dbformat, $file1, $file2, ...);
Behavior: if $dbname exists and user gave no specific values for $file1, $file2, ...
             then seqdb() object USES/OPENS existing database (index files).
          if $dbname exists and user gave specific values for $file1, $file2, ...
             then seqdb() object OVERWRITES existing database (index files).
          if $dbname does not exist, then seqdb() object CREATES new database.
             even if $file1, $file2, ... are not specified.
We provide the create() method to explicitly create a new database.
We provide the use() or open() method to explicitly use an existing database.
*/
function SeqDB()
        {
        // Get all the arguments passed to this function.
        $args = func_get_args();                
        $dbname = $args[0];
        $dbformat = strtoupper($args[1]);                
        if (strlen($dbformat) == 0) $dbformat = \"GENBANK\";                
        $this->dbformat = $dbformat;

        $datafile = array();
        for($i = 2; $i < count($args); $i++)
                $datafile[] = $args[$i];

        /* db exists   fileX args   ACTION   TESTED
                        Y            Y        create   okay
                        Y            N        use
                        N            Y        create    okay
                        N            N        create    okay
        */
        // if user provided specific values for $file1, $file2, ... parameters.
        if ((file_exists($dbname)) and (count($datafile) > 0))
                {
                // For now, assume USING/OPENING a database is to be done in READ ONLY MODE.
                $this->open($dbname);
                }
        else
                {
                // March 26, 2003: I switched the 2 lines below with
                // the line: $this->open($dbname); to avoid die-ing with
                // the error message: \"ERROR: Index file does not exist!\"
                $fp = fopen($dbname . \".idx\", \"w+\");
                $fpdir = fopen($dbname . \".dir\", \"w+\");

                // Creates blank data and directory index files, and sets seqptr to 0, etc.
                $this->open($dbname);

                // if user did not provide any datafile name.
                if (count($datafile) == 0) return;

                $temp_r = array();
                // Build our *.DIR file
                foreach($datafile as $fileno=>$filename)
                        {
                        $outline = \"$fileno $filename\\n\";
                        fputs($fpdir, $outline);

                        // Automatically create an index file containing info across all data files.
                        $flines = file($filename);
                        $totlines = count($flines);

                        while( list($lineno, $linestr) = each($flines) )
                          {
                          // if (substr($linestr,0,5) == \"LOCUS\")
                          if (at_entrystart($linestr, $dbformat))
                                  {
                                  // $current_id = trim(substr($linestr, 12, 16));
                                  $current_id =  get_entryid($flines, $linestr, $dbformat);
                                  $outline = \"$current_id $fileno $lineno\\n\";
                                  // Put entries in an array first, sort them, then write to *.IDX file.
                                  // temp_r = (\"AB1234\" => (\"AB1234\", 1, 12), \"BC4321\" => ... );
                                  $temp_r[$current_id] = array($current_id, $fileno, $lineno);
                                  }
                                }
                        // Sort our array by its keys.
                        ksort($temp_r);
                        }
                // Build our *.IDX array.
                $this->seqcount = count($temp_r);
                foreach($temp_r as $seqid=>$line_r)
                        {
                        $outline = $line_r[0] . \" \" . $line_r[1] . \" \" . $line_r[2] . \"\\n\";
                        $fio = fputs($fp, $outline);
                        }
                }
        fclose($fp);
        fclose($fpdir);
        } // CLOSES definition of SeqDB constructor function.
        
} // CLOSES definition of SEQDB CLASS.
?>