UAPNode.hpp

/*
 * UAP Node
 * Universal Accelerator Parser
 * Copyright (C) 2005, 2006 David Sagan, Daniel Bates, or Andy Wolski
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version. 
 * 
 * This library 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 Lesser General Public License
 * for more details. 
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc., 
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * 
 * Direct questions, comments, etc to:
 *   David Sagan (dcs16@cornell.edu)
 *   Andy Wolski (a.wolski@dl.ac.uk)
 */

#ifndef UAPNode_hpp
#define UAPNode_hpp 1

#include <iostream>
#include <string>
#include <map>
#include <list>
#include <cassert>

#include "UAP/UAPAttribute.hpp"
#include "UAP/UAPException.hpp"

class UAPNode;

typedef std::vector<UAPAttribute>                 AttributeVec;
typedef std::vector<UAPAttribute>::iterator       AttributeVecIter;
typedef std::vector<UAPAttribute>::const_iterator AttributeVecCIter;

typedef std::vector<UAPNode*>                     NodeVec;
typedef std::vector<UAPNode*>::iterator           NodeVecIter;
typedef std::vector<UAPNode*>::reverse_iterator   NodeVecRevIter;
typedef std::vector<UAPNode*>::const_iterator     NodeVecCIter;

typedef std::map<Str, UAPNode*>                 NodeMap;
typedef std::map<Str, UAPNode*>::iterator       NodeMapIter;
typedef std::map<Str, UAPNode*>::const_iterator NodeMapCIter;

enum UAPNode_type {ELEMENT_NODE, TEXT_NODE};

enum UAPNode_list {SLAVE, MASTER, CONTROLLER};

class UAPNode{
public:
  
  UAPNode();
  
  UAPNode(enum UAPNode_type _type, const Str& _name);
  
  UAPNode(const Str& _name);
  
  UAPNode(const UAPNode& node);
  
  Str getName() const;
  
  void setName(const Str& _name);
  
  void getPath(IntArray& path) const;
  
  enum UAPNode_type getType() const;
  
  void setType(enum UAPNode_type _type);
  
  UAPNode* getParent() const;
  
  void setParent(UAPNode* _parent);
  
  UAPNode* getTwin() const;
  
  void setTwin(UAPNode* _twin);
  
  UAPNode* getConnect() const;
  
  void setConnect(UAPNode* _connect);
  
  UAPNode* detachNode();
  
  void deleteNode();

  NodeVec& getChildren();

  NodeVecIter getChildIter (const UAPNode* child);
  
  UAPNode* addChild(const Str& _name, enum UAPNode_type _type, UAPNode* old_child = NULL);
  UAPNode* addChild(const Str& _name, UAPNode* old_child = NULL, 
                                                       enum UAPNode_type _type = ELEMENT_NODE);


  UAPNode* addChild(UAPNode* node, const UAPNode* old_child = NULL);

  UAPNode* addChildCopy(const UAPNode* node, const UAPNode* old_child = NULL);
  
  AttributeVec& getAttributes();
  
  UAPAttribute* getAttribute(const Str& _name);
  
  UAPNode* addAttribute(const Str& _name, const Str& _value, bool allow_repeats=false);
  
  Str getAttributeString(const Str& _name);
  
  bool removeAttribute(const Str& _name);

  NodeVec getChildrenByName(const Str& _name);
  
  UAPNode* getChildByName (const Str& _name, bool create = false);

  NodeVec getSubNodesByName(const Str& _name); 

  void getSubNodesByName(const Str& _name, NodeVec& nodeList);
  
  int getChildIndexNumber () const;

  UAPNode* add (UAPNode_list list_name, UAPNode* new_ele, UAPNode* old_ele = NULL);
    
  UAPNode* add (UAPNode_list list_name, UAPNode* new_ele, NodeVecIter insert_pt);

  NodeVec& getList(UAPNode_list list_name);
  
  Str toString(int indent = 0, bool encode_all = true, const Str& prefix = "") const;
  
  Str toStringTree(int indent = 0) const;

  Str toXMLTree (int indent = 0) const;

  void checkTree ();

  Str getXMLURI() const;
  
  void setXMLURI(const Str& uri);
  
  Str getXMLPrefix() const;
  
  void setXMLPrefix(const Str& prefix);

  Str getQName () const;

  Str getUniversalName () const;

  void addXMLNSAttributes (bool close_to_root = true);

  friend std::ostream& operator << (std::ostream& os, const UAPNode& node);
  friend std::ostream& operator << (std::ostream& os, const UAPNode* node);
  
private:
    
  // The name of this node.
  // Set to the XML localname if read from an XML file.
  Str name;

  // The local XML namespace prefix.
  // Rule: If xml_uri is blank (""), xml_prefix must also be blank.
  Str xml_prefix;

  // XML Universal Resource Identifier
  Str xml_uri;

  // The type of this node. 
  enum UAPNode_type type;
  
  // The parent of this node. 
  UAPNode* parent;
  
  // The twin of this node. 
  UAPNode* twin;

  // Used by branch and merger 
  UAPNode* connect;
  
  // The list of children of this node. 
  NodeVec children;
  
  // The list of attributes of this node. 
  AttributeVec attributes;
  
  // Used for controllers and girders. 
  // Used for superpositions and multipass control 
  NodeVec slaves;
  NodeVec masters;
  NodeVec controllers;

  // Index of this node in the parent's children array.
  // The index of the first child is 0.
  // Set to -1 if this node has no parent.
  // This is useful when copying trees.
  int ix_child;

  //----------------------------------------------------------------------------------

  // Used by deleteTree 
  void deleteTree2();

  // Used by toStringTree for indending the text.
  Str toStringTree2(int indent, int depth) const;

  // set method for ix_child
  void setChildIndexNumber (const int ix_c);

  // Work horse method for getPath2
  void getPath2(IntArray& path, int n) const;

  // Used by addXMLNSAttributes
  void add_xmlns_close_to_root(bool at_top_level, StrMap existing_xmlns, StrMap& needed_xmlns);
  void add_xmlns_far_from_root(StrMap existing_xmlns);

};

#endif

---