---

DOM_output.cpp

//$Header: /home/ben/Mapper/c++/RCS/DOM_output.cpp,v 6.6 2002/07/06 17:41:49 ben Exp $
// Copyright Benedict Adamson 2002.
// This file is part of Mapper.

// Mapper 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 of the License, or
// (at your option) any later version.

// Mapper 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 Mapper; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include <cassert>
#include <cstdio>
#include <iostream>

#include <dom/DOM_Element.hpp>
#include <dom/DOM_CDATASection.hpp>
#include <dom/DOM_Comment.hpp>
#include <dom/DOM_Document.hpp>
#include <dom/DOM_DocumentType.hpp>
#include <dom/DOM_EntityReference.hpp>
#include <dom/DOM_NamedNodeMap.hpp>
#include <dom/DOM_NodeList.hpp>
#include <dom/DOM_ProcessingInstruction.hpp>
#include <dom/DOM_Text.hpp>

#include "DOM_output.h"



void DOM_output::write(
   ostream &out,
   const DOMString &s
   )
{
   const char *c = s.transcode();
   out << c;
   delete c;
}



void DOM_output::write(
   ostream &out,
   const DOM_Element &elem
   )
{
   write_tag( out, elem );
   write_children( out, elem );
   if( elem.hasChildNodes() ){
      //output end tag
      DOMString tag( elem.getTagName() );
      out << "</";
      write( out, tag );
      out << '>';
   };
}



void DOM_output::write(
   ostream &out,
   const DOM_CDATASection &node
   )
{
   DOMString text( node.getData() );
   out << "<![CDATA[";
   write( out, text );
   out << "]]>";
}



void DOM_output::write(
   ostream &out,
   const DOM_EntityReference &node
   )
{
   DOMString name( node.getNodeName() );
   write( out, name );
}



void DOM_output::write(
   ostream &out,
   const DOM_ProcessingInstruction &node
   )
{
   out << "<?";
   write( out, node.getTarget() );
   out << ' ';
   write( out, node.getData() );
   out << "?>\n";
}



void DOM_output::write(
   ostream &out,
   const DOM_Comment &node
   )
{
   out << "<!--";
   write( out, node.getData() );
   out << "-->";
}



void DOM_output::write(
   ostream &out,
   const DOM_DocumentType &node
   )
{
   out << "<!DOCTYPE ";
   write( out, node.getName() );
   out << " SYSTEM \"";
   write( out, node.getSystemId() );
   out << "\">\n";
}



void DOM_output::write(
   ostream &out,
   const DOM_Text &node
   )
{
   write( out, node.getData() );
}



void DOM_output::write(
   ostream &out,
   const DOM_Node &node
   )
{
   switch( node.getNodeType() ){
      case DOM_Node::ELEMENT_NODE:
         write(
            out, static_cast< const DOM_Element & >( node )
            );
         break;
      case DOM_Node::CDATA_SECTION_NODE:
         write(
            out, static_cast< const DOM_CDATASection & >( node )
            );
         break;
      case DOM_Node::ENTITY_REFERENCE_NODE:
         write(
            out, static_cast< const DOM_EntityReference & >( node )
            );
         break;
      case DOM_Node::PROCESSING_INSTRUCTION_NODE:
         write(
            out, static_cast< const DOM_ProcessingInstruction & >( node )
            );
         break;
      case DOM_Node::COMMENT_NODE:
         write(
            out, static_cast< const DOM_Comment & >( node )
            );
         break;
      case DOM_Node::DOCUMENT_TYPE_NODE:
         write(
            out, static_cast< const DOM_DocumentType & >( node )
            );
         break;
      case DOM_Node::XML_DECL_NODE:
         //Do nothing, already output
         break;
      case DOM_Node::TEXT_NODE:
         write(
            out, static_cast< const DOM_Text & >( node )
            );
         break;
      case DOM_Node::DOCUMENT_NODE:
         write(
            out, static_cast< const DOM_Document & >( node )
            );
         break;
      case DOM_Node::ATTRIBUTE_NODE:
      case DOM_Node::ENTITY_NODE:
      case DOM_Node::DOCUMENT_FRAGMENT_NODE:
      case DOM_Node::NOTATION_NODE:
      default:
#ifndef NDEBUG
         abort(); //not implemented
#endif
         break;
   };
}


   
void DOM_output::write_tag(
   ostream &out,
   const DOM_Element &elem
   )
{
   out << '<';
   DOMString tag( elem.getTagName() );
   write( out, tag );
   {//output the attributes
      DOM_NamedNodeMap nodes( elem.getAttributes() );
      for( unsigned i=0; i < nodes.getLength(); i++ ){
         DOM_Node node( nodes.item(i) );
         assert( !node.isNull() );
         DOM_Attr &attr(
            static_cast< DOM_Attr & >( node )
            );
         out << ' ';
         write( out, attr.getName() );
         out << "=\"";
         write( out, attr.getValue() );
         out << '"';
      };
   };
   if( !elem.hasChildNodes() )
      out << '/';
   ;
   out << '>';
}



void DOM_output::write_children(
   ostream &out,
   const DOM_Node &node
   )
{
  DOM_Node child( node.getFirstChild() );
  while( !child.isNull() ){
    write( out, child );
    child = child.getNextSibling();
  };
}



void DOM_output::write(
   ostream &out,
   const DOM_Document &doc
   )
{
   out << "<?xml version=\"1.0\" standalone=\"no\"?>\n";
   write_children( out, doc );
}



void DOM_output::traceback(
   ostream &out,
   const DOM_Element &elem
   )
{
   out << "in ";
   write_tag( out, elem );
   out << '\n';
   DOM_Node parent( elem.getParentNode() );
   if( parent.getNodeType() == DOM_Node::ELEMENT_NODE )
      traceback( out, static_cast< const DOM_Element & >( parent ) );
   ;
}

---