XMLTree.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2007 Stéphane Del Pino

//  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.  

//  $Id: XMLTree.hpp,v 1.1 2007/06/10 15:28:38 delpinux Exp $

#ifndef XML_TREE_HPP
#define XML_TREE_HPP

#include <ReferenceCounting.hpp>
#include <XMLTag.hpp>

#include <Assert.hpp>

#include <vector>
#include <string>
#include <map>

class XMLTree
{
public:
  typedef std::multimap<std::string,
                        ReferenceCounting<XMLTag> > TagList;

  typedef std::pair<TagList::iterator,TagList::iterator> range;
  typedef std::pair<TagList::const_iterator,TagList::const_iterator> const_range;

private:
  TagList __tagList;            
  std::vector<ReferenceCounting<XMLTag> >
  __openTags;                   
  XMLTree(const XMLTree&);

  std::string
  __getFullTagName() const
  {
    std::string path;
    for (std::vector<ReferenceCounting<XMLTag> >::const_iterator i=__openTags.begin();
         i != __openTags.end(); ++i) {
      path += '>'+(*i)->name();
    }
    return path;
  }

  std::string
  __tagFromPath(const std::string& pathName) const;

public:
  void setHead(const std::string& xml,
               const std::string& version,
               const std::string& versionNumber)
  {
    if ((xml != "xml")or(version != "version")or(versionNumber != "1.0"))
      {
      throw ErrorHandler(__FILE__,__LINE__,
                         "cannot read file format: <?"+xml+" "+version+"=\""+versionNumber+"\"?>",
                         ErrorHandler::normal);
    }
  }

  void check() const;

  void checkRange(const std::string& pathName,
                  const_range r) const;

  void addTag(ReferenceCounting<XMLTag> tag);

  void closeTag(const std::string& tagName);

  TagList::const_iterator end() const
  {
    return __tagList.end();
  }

  bool hasOpenTag() const
  {
    return (__openTags.rbegin() != __openTags.rend());
  }

  ReferenceCounting<XMLTag>
  getCurrentTag()
  {
    return *__openTags.rbegin();
  }

  ConstReferenceCounting<XMLTag>
  getCurrentTag() const
  {
    return *__openTags.rbegin();
  }

  bool hasTag(const std::string& pathName) const
  {
    ASSERT(pathName[0] == '>');
    return (__tagList.find(pathName) != __tagList.end());
  }

  ReferenceCounting<XMLTag>
  findTag(const std::string& pathName)
  {
    ASSERT(pathName[0] == '>');
    range r = __tagList.equal_range(pathName);
    this->checkRange(pathName,r);
    if (distance(r.first, r.second) != 1) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "tag "+this->__tagFromPath(pathName)+" is not unique!",
                         ErrorHandler::normal);
    }
    
    return r.first->second;
  }

  ReferenceCounting<XMLTag>
  findTag(const std::string& pathName) const
  {
    ASSERT(pathName[0] == '>');
    const_range r = __tagList.equal_range(pathName);
    this->checkRange(pathName,r);
    if (distance(r.first, r.second) != 1) {
      throw ErrorHandler(__FILE__,__LINE__,
                         "tag "+this->__tagFromPath(pathName)+" is not unique!",
                         ErrorHandler::normal);
    }
    return r.first->second;
  }

  range
  findTagRange(const std::string& pathName)
  {
    ASSERT(pathName[0] == '>');
    range r = __tagList.equal_range(pathName);
    this->checkRange(pathName,r);
    return r;
  }

  const_range
  findTagRange(const std::string& pathName) const
  {
    ASSERT(pathName[0] == '>');
    const_range r = __tagList.equal_range(pathName);
    this->checkRange(pathName,r);
    return r;
  }

  XMLTree()
  {
    ;
  }

  ~XMLTree()
  {
    ;
  }
};

#endif // XML_TREE_HPP

---