---

tree.h

Go to the documentation of this file.

/* Tree -- Base class for tree structures 
   Copyright (C) 2002 Aaron Bentley

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/*template <typename Payload>
class Node
{
private:
   Node *parent;
   vector <Node *> children;

   Payload *loadptr;
   Payload &loadref;

public:
   Node (Payload *a_payload)
      :
   loadptr(a_payload), loadref;
   {
      child=NULL;
      parent=NULL;
      next=NULL;
      prev=NULL;
      first=NULL;
      last=NULL;
   }
   virtual ~Node()
   {
      for (vector<Node *>::iterator it=children.begin(); it!=children.end();
    ++it)
      {
    delete *it;
      }
      delete a_payload;
   }
   Payload &operator *()
   {
      return loadref;
   }
   
   void addChild(Node *ch)
   {
      children.push_back(ch);
   }
};

class XmlContents()
{
   virtual void getStream(ostream &stream, );
}*/
#include <string>
using std::string;

template <typename T>
class TreeNode
{
   private:
   T *parent;
   T *child;
   T *next;
   T *prev;
   T &othis;
   public:
   TreeNode(T &a_othis)
      :
   parent(NULL), child(NULL), next(NULL), prev(NULL), othis(a_othis)
   {}
   T* addChild(T *ch)
   {
      if (ch==NULL) return ch;
      if (child==NULL)
      {
    child=ch;
    ch->parent=&othis;
      }
      else child->getLastRecur().setNext(ch);
      return ch;
   }

   T& getLastRecur()
   {
      if (next!=NULL) return next->getLastRecur();
      else return othis;
   }

   void setNext(T *ch)
   {
      for (T *cur=ch; cur!=NULL; cur=cur->next)
      {
    cur->parent=parent;
      }
      next=ch;
      next->prev=&othis;
   }
   T const *getFirstChild() const
   {
      return child;
   }
   T *getFirstChild()
   {
      return child;
   }
   T const *getNext() const
   {
      return next;
   }
   T *getNext()
   {
      return next;
   }
};

class XmlNode : public TreeNode <XmlNode>
{
public:
   XmlNode()
      :
   TreeNode<XmlNode>(*this)
   {}
   virtual string getString(int indent=0) const
   {
      return "";
   }
};


class XmlText : public XmlNode
{
private:
   string text;
public:
   XmlText(string const &is);

   string getString(int indent=0) const;
};

XmlText::XmlText(string const &a_text)
   :
   text(a_text)
{
}
string XmlText::getString(int indent=0) const
{
   return text;
}

class XmlTag : public XmlNode
{
private:
   string tag;

public:
   XmlTag(string a_tag);
   string getString(int indent=0) const;
};

XmlTag::XmlTag(string a_tag)
   :
tag(a_tag)
{
}

string XmlTag::getString(int indent=0) const
{
   string output;
  
   if (indent>0) 
      output+='\n';

   for (int i=0; i<indent; ++i)
      output+=' ';

   output+=string("<")+tag;

   if (getFirstChild()==NULL) return output+" />";
   else
   {
      output+=">";
      for (XmlNode const *cur=getFirstChild(); cur!=NULL; cur=cur->getNext())
      {
    output+=cur->getString(indent+3);
      }
      output+=string("</")+tag+">";
   }
   
   return output;
}
class XmlTree public XmlNode;
{
   static string getString(XmlNode const &);
};
string XmlTree::getString(XmlNode const &top)
{
   string output
   int indent=0;
   for (XmlNode const *cur=top; cur!=NULL)
   {
      if (cur->getFirstChild()!==NULL)
      {
    output+=
      }
   }
}
#include <iostream>
int main()
{
   XmlTag top("xml");
   top.addChild(new XmlTag("contents"))->addChild(new XmlText("Foo"));
   std::cout<<top.getString()<<std::endl;
   return 0;
}

---