Aceobj.h

Go to the documentation of this file.

#ifndef ACEOBJ_H
#define ACEOBJ_H

// an Ace object to represent Aceobject in a generic Tree
//#include "gentree.h"
#include <string>
#include <sstream>
#include <vector>
#include <iostream>

using namespace std;
// count the leading tabs, split the rest into vector vec
int digestLine(vector<string> &vec, const string &str);

struct Acenode {
        Acenode(const string &t, const string &v) : type(t), value(v), parent(0), child(0), sibling(0) {}
        Acenode(const string &t, const string&v, Acenode* p) : type(t), value(v), parent(p), child(0), sibling(0) {}

        // make a node from a ?type?value? string
        Acenode(const string &dump) : parent(0), child(0), sibling(0) { parse(dump); }
        Acenode(const string &dump, Acenode* p) : parent(p), child(0), sibling(0) { parse(dump); }

        //helper function, should be private
        void parse(const string &dump);

        void addChild(const string &t, const string &v) {
                child = new Acenode(t,v, this); }
        void addChild(const string &dump) {
                child = new Acenode(dump, this); }
        void addSibling(const string &t, const string&v) {
                sibling = new Acenode(t,v,this->parent); }
        void addSibling(const string &dump) {
                sibling = new Acenode(dump, this->parent); }

        Acenode* right() { return sibling; }
        Acenode* down() { return child; }
        // get everything to the right of this 
        // pointer as a vector of strings
        vector<string> row() const;
        vector<string> col() const;

        void del();

        int asInt() { return atoi(value.c_str()); }
        double asFloat() { return atof(value.c_str()); }
        string asString() { return value; }

        string type;
        string value;
        Acenode *parent;
        Acenode *child;
        Acenode *sibling;
};
Acenode* find(Acenode *n, const string &tag);
void del(Acenode* p);

class Aceobj {
        public:
                Aceobj() : root(0) { }

                Aceobj(const string &str) { parse(str); }
                //Aceobj(const Aceobj &obj);
                //
                //Destructor, needs to clean all nodes of the tree
                ~Aceobj() { del(root); }
                void clear() { del(root); root=0; }

                void parse(const string &str);
                bool empty() { return root == 0; }
                string getName() const { return root->asString(); }

                //node_pointer at(const string &tag_path);
                //node<pair<string, string> >* at(const string &tag_path, int pos=0);
                Acenode* at(const string &tag_path, int pos=0);

                //node<pair<string, string> >* get(const string &tag, int pos=0);
                Acenode* get(const string &tag, int pos=0);

        private:
                //node<pair<string, string> > *root;
                Acenode *root;
                //string objtype;  // object type: Sequence, Protein, Paper ....
                //string objname;  // string identifier for the object
};

#endif