pfeature.h

Go to the documentation of this file.

//file: pfeature.h

/* a new feature class that is going to replace the old feature
 * initially used for the GenBank protein feature.
 * needs to define all the operators for it to be used as
 * elements of containers.
 * */

#ifndef PFEATURE_H
#define PFEATURE_H

#include <string>
#include <vector>
#include <iostream>
#include <map>
#include <set>
#include "strformat.h"
#include "gbfn.h"
#include "featureError.h"
#include "gbseq.h"

#define NO_CLONE
//#define NO_GENE   // no gene object made for genomic DNA
// also remove Gene, STS from sequence objects

using namespace std;

class gbdnaseq;
class gbprtseq;

/* an integer representation, better than string
 * but could not represent segmented sequences such as 
 *      gene            order(AF019954.1:<279..586,AF019955.1:1..1103,
 *                      AF019956.1:1..640,AF019957.1:1..1111,AF019958.1:1..707,
 *                      AF019959.1:1..918,AF019960.1:1..974,AF019961.1:1..749,
 *                      1..>423)
 *
 * */
class locseg {
        public:
        friend class feature;
        locseg() : begin(0), end(0), rangeType('-'), fuzzy_begin(0), fuzzy_end(0), complement(false) { }
        locseg(int bb, int ee) : begin(bb), end(ee), rangeType('-'), fuzzy_begin(0), fuzzy_end(0), complement(false) { }
        locseg(int bb, int ee, char rt) : begin(bb), end(ee), rangeType(rt), fuzzy_begin(0), fuzzy_end(0), complement(false) { }
        locseg(const locseg &ls);

        locseg(const string &lstr) throw(featLocErr);

        virtual locseg& operator=(const locseg &ls);

        /* for 99.99% of the locations the returned value would
         * be an empty string
         * returns operation as to how to mark fuzzy ends
         * */
        string getOperation() const;

        bool isAbnormal() const { 
                return rangeType != '-' || fuzzy_begin != 0 || fuzzy_end != 0 || complement; }

        virtual ostream& writeRange(ostream &ous) const { 
                ous << begin << "\t" << end; return ous; }

        virtual ostream& outRange(ostream &ous) const;

        bool isFuzzy() const { 
                return fuzzy_begin != 0 || fuzzy_end != 0 || rangeType != '-'; }

        int getFuzzyBegin() const { return complement ? fuzzy_end : fuzzy_begin; }
        int getFuzzyEnd() const { return complement ? fuzzy_begin : fuzzy_end; }
        int getBegin() const { return complement ? end : begin; }
        int getEnd() const { return complement ? begin : end; }
        char getRangeType() const { return rangeType; }

        protected:
                void parse(string &str) throw(featLocErr);
                int begin, end;

                char rangeType;

                /* end operation information
                 *default set to 0, nothing or normal
                 * -1 for < beyond first; len one_of
                 * positive meand begin is between begin and fuzzy_begin
                 * Needs to look at methods using this field
                 * meaning redefined
                */
                int fuzzy_begin;  
                // should be all one_of in the range

                int fuzzy_end;    

                bool complement;   // default is false
                //string name;       // optional name for the segment, 
                                   // usually for order()
};
class namedlocseg : public locseg {
        public:
        friend class feature;
        namedlocseg() : locseg(), name() {}
        namedlocseg(const string &nn, int bb, int ee) : locseg(bb,ee), name(nn) {}
        namedlocseg(const namedlocseg& loc) : locseg(loc) { name=loc.name; }
        namedlocseg(const locseg& loc) : locseg(loc) { }
        namedlocseg(const string &lstr) throw(featLocErr);
        namedlocseg& operator=(const namedlocseg& loc);
        const string& getName() const { return name; }  // for reading only

        ostream& writeRange(ostream &ous) const {
                ous << name << "\t"; return locseg::writeRange(ous); }

        protected:
                string name;
};

/* feature needs to know some information about the master
 * object sequence
 * We can include the main sequence as a member or passed 
 * the main sequence as an arguments in all the functions.
 * */
class feature {
        public:
                enum Segrelation {none=0, join, order};  // none is default

                feature() : complement(false), segop(none), onone(true) { }
                ~feature() { clear(); }

                /* return true if it has read a feature successfully
                 * return false if could read any more
                 * Repeated qualifiers will be concatenated with ' | '
                 * */
                bool next(string &ln, istream &ins); // construct the next object
                feature(const feature &feat);
                feature& operator=(const feature &feat);
                void writeAceProtein(ostream &ous, gbprtseq &prt);  // protein features
                void writeAceDNA(ostream &ous, ostream &sub, ostream &snp, gbdnaseq& seq) throw(featErr);  // for nucleic acids features
                string getName() const { return name; }
                //ostream& dumpRange(ostream &ous) { ous << loc.getBeginStr() << " " << loc.getEndStr(); return ous; }

                /* string dump for debuging purposes */
                friend ostream& operator<<(ostream &ous, const feature &feat);

                /* concatenate all dbxref into one string */
                string getDbxrefString() const;

                /* concatenate all qualifiers into one single string */
                //string getQualifierString() const;
                string getAllQualifiers() const;
                //ostream& writeRange(ostream &ous) const { loc.writeRange(ous); return ous; }

                void clear();

                int getBegin() const { return locs[0]->begin; }
                int getEnd() const { return locs[locs.size()-1]->end; }

                int getNumSeg() const { return locs.size(); }
                //bool isJoin() const { return locs.size() > 1; }
                //should look at the operation string: oder, join 
                //friend ostream& operator<<(ostream &ous, const location &loc);
                const string& getOperation() const { return locop; }
                Segrelation getSegop() const { return segop; }  // replaces getOperation

                /* this function uses integer begin and end, 
                 * has no sense of orientation.  It is safe to use this function for
                 * protein features which is always from small to large.
                 * */
                ostream& writeRange(ostream &ous) const { 
                        ous << getBegin() << " " << getEnd(); return ous; }
                /* this one know the direction of the gene, always from 5' to 3' */
                ostream& outRange(ostream &ous) const;
                //void clear();

                int outSeg(ostream &ous) const;
                void outSegMultiple(ostream &ous, const gbdnaseq &seq) const;

                string getLocationString() const { return locstr; }

                string getTaxid() const;
                bool hasDbxref() const { return !dbxref.empty(); }

                bool isComplement() const { return complement; }

                int getBeginEndinfo() const;
                int getEndEndinfo() const;

                ostream& endInfo(ostream &ous) const;
                // complement translated into large begin small end
                bool nostart() const;
                bool noend() const;
                bool hasQualifier(const string &key) const { 
                        return qualifiers.find(key) != qualifiers.end(); }
                // returns "" if qualifiers not found
                string getQualifierValue(const string &qkey) const;

                // this has not been fully used yet.
                static void readValidQualifier(const string &file);

                static void loadSubseq(const string &file);
                static void dumpSubseq(const string &file);
                // the default is 0
                static void addSubseq(const string &seq) { subseq.insert(make_pair(seq,0)); }
                static bool existSubseq(const string &seq) { return subseq.find(seq) != subseq.end(); }

                static void loadGeneName(const string &file);
                static void dumpGeneName(const string &file);

                static string getGeneSymbol(const string &gene, string &allele);
                // new version.  Given the gene, returns a <symbol,allele>pair
                static pair<string,string> getGeneSymbol(const string &gene);

                static const int QUAL = 5;
                static const int QUAL_VAL = 21;
                static const string QUAL_SPACE;
                static bool PRTOUT;   // specify policy
                // for genome annotation PRTOUT=false, for regular GB = true

        private:
                static string addGene(const string &gene, string &allele);
                //static bool isGeneSymbol(const string &gene);
                // breaks up gene by char "*" gene*allele
                static pair<string,string> separateAllele(const string &gene);
                // make a pair of symbol,allele from gene
                static pair<string,string> makeGeneSymbol(const string &gene);
                // insertion only
                static pair<string,string> insertGeneSymbol(const string& gene, const string &symbol);
                // will check the presence of allele, do the actuall insertion
                // return <symbol,allele> pair
                static pair<string,string> insertGeneAsSymbol(const string& gene);

                static string geneOfSymbol(const string& sym);
                static string cleanGene(const string& gene, const string wd);
                static string nojunkGene(const string &gene);
                // use a counter to make sure returned symbol is unique
                static string nextGeneSymbol();
                static void goodGeneSymbol(const string &gene, string &symbol);
                static bool isGoodGeneSymbol(const string &gene, const string &symbol);
                static string acronymWithAllDigits(const string& str, const int n=1);
                // extract hidden gene symbol, separated by sep
                // if found one the return it, if not returns an empty string
                static string xHiddenGeneSymbol(const string &str, const string &sep);
                // helper function fro xHiddenGeneSymbol
                static string shortIsGeneSymbol(const string &str, string::size_type idx, const int seplen);
                // only test up to 8, because this is the numbers
                // used for naming genes
                static bool isRomanNumber(const string &str);
                // only test the most commonly used by biologiest
                static bool isGreek(const string &str);

                // a helper function for next()
                // after this function call ln will contain the line
                // next to this qualifier.
                void nextQualifier(istream &ins, string &ln); 

                // extract the gene,allele pair from this feature
                pair<string, string> geneallele() const;

                void outgeneline(ostream &ous, const gbdnaseq &seq, const string &tag) const;
                // return the iterator pointing to the longest 
                // qualifier of five selected qualifiers: 
                // gene, stantard_name, function, product, phenotype
                map<string,string>::iterator composeTitle();

                // a helper function for nextQualifier
                void insertQualifier(const string& key, string& value);
                void writeSource(ostream &ous, ostream &sub, gbdnaseq &seq) throw(featErr);
                void writemRNA(ostream &ous, ostream &sub, const gbdnaseq &seq);
                void writeSegmRNA(ostream &sub, const gbdnaseq &seq);
                void writeCDS(ostream &ous, ostream &sub, const gbdnaseq &seq);
                void writeSegCDS(ostream &sub, const gbdnaseq &seq);
                void subCDS(ostream &ous, ostream &sub, const gbdnaseq &seq, const string &cdsKey, const string &prtKey, const string &title) const;
                void writeGene(ostream &ous, ostream &sub, gbdnaseq &seq) const;

                void writeProtein(ostream &sub, const gbdnaseq &seq, const string &key, const string &title) const;
                //tRNA, snRNA, rRNA, etc
                void writeRNA(ostream &sout, ostream &subout, gbdnaseq &seq);
                void RNAdump(ostream &ous, const gbdnaseq &seq) const;
                void writeFeature(ostream &ous, const gbdnaseq &seq) const throw(featErr);
                bool writeFeatureOfWholeSeq(ostream &ous, const gbdnaseq &seq) const;
                void writeImmuno(ostream &ous, ostream &sub, const gbdnaseq &seq) const;
                void writeSNP(ostream &snp, gbdnaseq &seq) const;
                // for Protein Objects
                // site feature of protein objects
                void writePrtSite(ostream &ous, gbprtseq &prt) const;
                void writePrtRegion(ostream &ous, gbprtseq &prt) const;

                string name;  // current feature name

                string locstr;  // the location string in GenBank format

                vector<locseg*> locs;  // location information
                bool onone;  // location on one sequence as to one multiple seq
                bool complement;
                Segrelation segop;    // how to construct the sequence from segments
                string locop;  // default is no operation, just a,b,
                // join, order (only two possibilities, now)
                void parseLoc() throw(featLocErr);

                map<string, string> qualifiers;
                vector<string> dbxref;

                static set<string> validqual;  // valid qualifiers

           /* store all subsequence key
                 * During parsing, this class knows all subsequences, so that when
                 * duplicated subsequence names occur it can detect them.
                 * Known subsequence names can be loaded before the parsing.
                 * To control multiple sequences with the same name, changed
                 * it to a map that keeps track of how many has been named after
                 * this identifier.
                 *
                 * For example, Genome G1 has a model mRNA pointing to mRNA m1
                 * Genomic G2 also has a model pointing to mRNA m1.  In most cases
                 * there is only onel-model-to-one-mRNA.  But there exceptions
                 * make it necessary to name model other than the m1_mod
                 * */
                //static set<string> subseq;    
                static map<string, int> subseq;

                static map<string,string> genen2s;  // name to symbol
                static set<string> genesbl;  // all second from geneName
                static int genecnt;  // for generating a gene symbol

};

#endif