vref.h

Go to the documentation of this file.

#ifndef REFERENCE_H
#define REFERENCE_H

/* file: vref.h
 * This file will replace the old ref.h gradually*/

#include <string>
#include <vector>
#include <iostream>
#include "gberr.h"
#include <map>

using namespace std;

class Ref {
        public:
                Ref(const Ref& ref) { authors=ref.authors; remark=ref.remark; }
                Ref(const string &austr);
                Ref& operator=(const Ref& ref);
                virtual void writeAce(ostream &ous, ostream &pap) const;
                virtual string makeKey() const {}
                void addRemark(const string &rm) { remark = rm; }
                virtual void toAce(ostream &ou) const;

                static void setCounter(int k) { counter = k; }
                static int nextCounter() { return counter++; }
                static void loadKey(const string &inf);
                static void dumpKey(const string &ouf);

        protected:
                vector<string> authors; // common to nearly all Ref
                string remark;          // an optional field

                static int counter;  
                static map<string, int> paperkey;
};

class Refwithty : public Ref { 
        public:
                Refwithty(const Refwithty &ref) : Ref(ref) { title=ref.title; year=ref.year; }
                Refwithty& operator=(const Refwithty &ref);
                Refwithty(const string &austr, const string &tit, int yr) : Ref(austr), title(tit), year(yr) { }
                Refwithty(const string &austr, const string &tit) : Ref(austr), year(0), title(tit) { }
                void toAce(ostream &ou) const;
                string makeKey() const;

        protected:
                string title;
                int year;   // some may not have year
};

class Inpress : public Refwithty {
        public:
                Inpress(const string &austr, const string &tit, const string &jn) : Refwithty(austr, tit), name(jn) { }
                Inpress(const string &austr, const string &tit, const string &jn, int yr)  : Refwithty(austr, tit, yr), name(jn) { }
                void toAce(ostream &ou) const;
                string makeKey() const { return Refwithty::makeKey() + name; }
                void setPubmed(int pm) { pubmed = pm; }
                int getPubmed() const { return pubmed; }

        private:
                string name;
                int pubmed;   // some In Press has this one
};

/* standard journal 
 * The constructor of this class will do some of the parsing job.
 * It will take the JOURNAL string as an additional parameter.
 * */
class Journal : public Refwithty {
        public:
                // the remaining member must be intialized with a parser function
                // call
                Journal(const string &austr, const string &tit) : Refwithty(austr, tit) {}
                Journal(const string &austr, const string &tit, int yr) : Refwithty(austr, tit, yr) {}

                Journal(const string &austr, const string &tit, const string &jl); 
                void setMedline(int med) { medline = med; }
                void setPubmed(int pub) { pubmed = pub; }
                Journal(const Journal &ref);
                Journal& operator=(const Journal &ref);
                string makeKey() const;  // expensive operation cache the result
                /* writes the paper object only */
                void toAce(ostream &pap) const;

        protected:
                // parse normal journal
                //virtual void parse(const string &jl);
                int pubmed;  // long enough, avoid conversion
                int medline; // storage v.s. conversion
                //string remark;

                // journal specific information
                string name;  // journal name
                string volume;  // holds Date if jname == Submitted
                string issue;   
                string page_begin;
                string page_end;
};

class Online : public Journal
{
        public:
                Online(const string &austr, const string &tit) : Journal(austr, tit) {}
                Online(const string &austr, const string &tit, const string &jn,
                                const string &vol, const string &pb, const string &pe, int yr) 
                                : Journal(austr, tit, yr) { name=jn; volume=vol; page_begin=pb; page_end=pe; }
                //void toAce(ostream &ou) const;
                //string makeKey() const;
                //void clear();

        //private:
                //void parse(const string &jl);
                //string name, volume, pageBegin, pageEnd;
};

class Book : public Refwithty {
        public:
                Book(const string &austr, const string &tit, const string &jl);
                void toAce(ostream &ou) const;
                string makeKey() const;

        private:
                string volume;
                string page_begin, page_end;
                string name;
                string publisher;        // some don't have publisher info
                vector<string> editors;
};

class Thesis : public Refwithty
{
        public:
                Thesis(const string &austr, const string &tit, const string &univ, int yr) : Refwithty(austr, tit, yr), university(univ) { }
                void toAce(ostream &ou) const;
                string makeKey() const;
                //void clear() { Refwithty::clear(); university.clear(); }

        private: 
                string university;
};

class Unpublished : public Refwithty
{
        public:
                Unpublished(const string &austr, const string &tit, int yr=0) : Refwithty(austr, tit, yr) {}
                string makekey() const { return "unpub" + Refwithty::makeKey(); }
};


class Submission : public Ref
{
        public:
                Submission(string austr, string dd) : Ref(austr), date(dd) { }
                Submission(string austr, string dd, string ad);
                void setConsrtm(const string &cs) { consrtm = cs; }
                void toAce(ostream &ou) const;  // write an ace object
                string makeKey() const;
                //void clear();

        private:
                string consrtm;
                string addr;   // some don't have address
                string date;   // date in string format
};

// some Patents do not have title
class Patent : public Ref
{
        public:
                Patent(const string &austr, const string &num, const string &d, const string &ow) : Ref(austr), date(d), number(num), owner(ow) { }
                Patent(const string &austr, const string &tit, const string &jl) 
                        : Ref(austr), title(tit) { parsejl(jl); }

                Patent(const string &austr, const string &jl)
                        : Ref(austr) { parsejl(jl); }

                void toAce(ostream &ou) const;
                string makeKey() const { return "Pat_" + number; }
                //void clear();

        private:
                void parsejl(const string &jl);
                string date;  // date string
                string number;  // patent unique number
                string owner;   // company or institute or university
                string addr;    // address of owner, some patent don't have this one
                string title;   // optional 
};

#endif