---

MapDataDocument_convert.cpp

//$Header: /home/ben/Mapper/c++/RCS/MapDataDocument_convert.cpp,v 6.25 2002/07/09 22:50:52 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 <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
#include <memory>

#include <dom/DOM_Attr.hpp>
#include <dom/DOM_DOMException.hpp>
#include <dom/DOM_Element.hpp>
#include <dom/DOM_Document.hpp>
#include <dom/DOM_Node.hpp>

#include <string>

#include "MapDataDocument.h"
#include "MapperErrorHandler.h"
#include "curve.h"
#include "curve_segment.h"
#include "vector2.h"



void MapDataDocument::convert_Curve(
   DOM_Element &elem, //input
   MapperErrorHandler &err_handler
   )
   throw(
      error::attribute_error
      )
{
   string id;
   vector2 *from;
   vector2 *to;
   {//retrieve attribute values
      get_attribute( id, elem, "id" );
      this->get_attribute( from, elem, "from" );
      this->get_attribute( to, elem, "to" );
   };
   curve *c = new curve;
   c->param.push_back( from );
   c->param.push_back( to );
   this->curves_[id] = c;
   elem.setUserData( c );
   {//set the parameters, from Coord children
      DOM_NodeList children(
         elem.getElementsByTagName( DOMString("Coord" ) )
         );
      const unsigned n = children.getLength();
      assert( c->param.size() == 2 );
      c->param.reserve( n ); //optimisation
      for( unsigned i = 0; i < n; i++ ){
         DOM_Node node( children.item(i) );
         assert( node.getNodeType() == DOM_Node::ELEMENT_NODE );
         DOM_Element &child( static_cast< DOM_Element & >( node ) );
         try{
            vector2 position( this->random_position() );
            if( has_attribute( child, "x" ) )
               get_attribute( position.x, child, "x" );
            ;
            if( has_attribute( child, "y" ) )
               get_attribute( position.y, child, "y" );
            ;
            vector2 *p = new vector2( position );
            child.setUserData( p );
            c->param.push_back( p );
         }catch( error::attribute_error &e ){
            err_handler.error( e );
         };
      };
   };
}



void MapDataDocument::convert_Fixed_point(
   DOM_Element &elem //input
   )
   throw(
      error::attribute_error
      )
{
   string point_name;
   double x;
   double y;
   {//retrieve attribute values
      get_attribute( point_name, elem, "point" );
      get_attribute( x, elem, "x" );
      get_attribute( y, elem, "y" );
   };
   map< string, vector2 * >::iterator i =
      this->named_points_.find( point_name );
   if( i == this->named_points_.end() )
      throw error::attribute_error( elem, "point not found", "point" );
   ;
   vector2 *p = (*i).second;
   assert( p );
   this->fixed_points_.insert( p );
   p->x = x;
   p->y = y;
   elem.setUserData( p );
}


void MapDataDocument::convert_Point(
   DOM_Element &elem //input
   )
   throw(
      error::attribute_error
      )
{
   string id;
   vector2 position( this->random_position() );
   {//retrieve attribute values
      get_attribute( id, elem, "id" );
      if( has_attribute( elem, "x" ) )
         get_attribute( position.x, elem, "x" );
      ;
      if( has_attribute( elem, "y" ) )
         get_attribute( position.y, elem, "y" );
      ;
   };
   vector2 *p = new vector2( position );
   this->named_points_[id] = p;
   elem.setUserData( p );
}



void MapDataDocument::convert_Point_alias(
   DOM_Element &elem //input
   )
   throw(
      error::attribute_error
      )
{
   string id;
   vector2 *p;
   {//retrieve attribute values
      get_attribute( id, elem, "id" );
      if( this->named_points_.count( id ) ){
         throw error::attribute_error( elem, "already the id of a point", "id" );
      };
      this->get_attribute( p, elem, "point" );
      assert( p );
   };
   this->named_points_[id] = p;
}
   


void MapDataDocument::convert_pointrefs(
   DOM_Element &elem, //input
   const char *tag,
   MapperErrorHandler &err_handler
   )
{
   DOM_NodeList children(
      elem.getElementsByTagName( DOMString(tag) )
      );
   for( unsigned i = 0; i < children.getLength(); i++ ){
      DOM_Node node( children.item(i) );
      if( node.getNodeType() != DOM_Node::ELEMENT_NODE ) continue;
      DOM_Element &child( static_cast< DOM_Element & >( node ) );
      try{
         vector2 *p;
         this->get_attribute( p, child, "point" );
         child.setUserData( p );
      }catch( error::attribute_error &e ){
         err_handler.error( e );
      };
   };
}



void MapDataDocument::convert_Curve_segments(
   DOM_Element &elem, //input
   MapperErrorHandler &err_handler
   )
{
   DOM_NodeList children(
      elem.getElementsByTagName( DOMString("Curve-segment") )
      );
   for( unsigned i = 0; i < children.getLength(); i++ ){
      DOM_Node node( children.item(i) );
      DOM_Element &child( static_cast< DOM_Element & >( node ) );
      try{
         curve *c;
         vector2 *from;
         vector2 *to;
         this->get_attribute( c, child, "curve" );
         this->get_attribute( to, child, "point" );
         {//determine the from point
            from = 0;
            DOM_Node f = child.getPreviousSibling();
            while( !from && !f.isNull() ){
               if( f.getNodeType() == DOM_Node::ELEMENT_NODE ){
                  DOM_Element &sib( static_cast< DOM_Element & >( f ) );
                  DOMString tag( sib.getTagName() );
                  if( DOMString("Node").equals( tag ) ||
                      DOMString("Line-segment").equals( tag ) ||
                      DOMString("Curve-segment").equals( tag ) )
                     this->get_attribute( from, sib, "point" );
                  ;
               };
               if( !from )
                  f = f.getPreviousSibling(); //next
               ;
            };
         };
         if( c && from && to ){
            curve_segment *s = new curve_segment(  c, from, to );
            child.setUserData( s );
         };
      }catch( error::attribute_error &e ){
         err_handler.error( e );
      };
   };
}



void MapDataDocument::convert(
   MapperErrorHandler &err_handler //input
   )
{
   DOM_Element root( this->doc.getDocumentElement() );
   {//set default values for the attributes of the root tag
      this->precision = 6U;
      this->origin_ = vector2(0,1);
      this->width_ = 1.0;
      this->height_ = 1.0;
   };
   try{//process the attributes of the root tag
      {//get attributes
         if( has_attribute( root, "precision" ) ){
            get_attribute( this->precision, root, "precision" );
         };
         if( has_attribute( root, "width" ) ){
            get_attribute( this->width_, root, "width" );
         };
         if( has_attribute( root, "height" ) ){
            get_attribute( this->height_, root, "height" );
         };
         if( has_attribute( root, "x" ) ){
            get_attribute( this->origin_.x, root, "x" );
         };
         if( has_attribute( root, "y" ) ){
            get_attribute( this->origin_.y, root, "y" );
         };
      };
      {//check attribute values
         if( this->width_ <= 0 )
            throw error::attribute_error( root, "negative value", "width" );
         ;
         if( this->height_ <= 0 )
            throw error::attribute_error( root, "negative value", "height" );
         ;
      };
   }catch( error::attribute_error &e ){
      err_handler.error( e );
   };
   
   DOM_NodeList children( root.getChildNodes() );
   for( unsigned i = 0; i < children.getLength(); i++ ){
      DOM_Node node( children.item(i) );
      if( node.getNodeType() != DOM_Node::ELEMENT_NODE ) continue;
      DOM_Element &elem( static_cast< DOM_Element & >( node ) );
      DOMString tag( elem.getTagName() );
      try{
         if(       DOMString("Area-feature").equals( tag ) ){
            this->convert_pointrefs( elem, "Node", err_handler  );
            this->convert_pointrefs( elem, "Line-segment", err_handler );
            this->convert_Curve_segments( elem, err_handler );
         }else if( DOMString("Constraint-group").equals( tag ) )
            this->convert_Constraint_group( elem, err_handler );
         else if(  DOMString("Curve").equals( tag ) )
            this->convert_Curve( elem, err_handler );
         else if(  DOMString("Fixed-point").equals( tag ) )
            this->convert_Fixed_point( elem );
         else if(  DOMString("Linear-feature").equals( tag ) ){
            this->convert_pointrefs( elem, "Node", err_handler );
            this->convert_pointrefs( elem, "Line-segment", err_handler );
            this->convert_Curve_segments( elem, err_handler );
         }else if( DOMString("Tracing").equals( tag ) )
            this->convert_Tracing( elem, err_handler );
         else if(  DOMString("Point").equals( tag ) )
            this->convert_Point( elem );
         else if(  DOMString("Point-alias").equals( tag ) )
            this->convert_Point_alias( elem );
         else if(  DOMString("Point-feature").equals( tag ) )
            this->convert_pointrefs( elem, "Node", err_handler );
         else if(  DOMString("Units").equals( tag ) ){
            DOMString angle_attr( elem.getAttribute( DOMString( "angle" ) ) );
            if( !DOMString("degrees").equals( angle_attr ) )
               throw error::attribute_error( elem, "unrecognised units", "angle" );
            //In a future version, could amend to parse different values.
            ;
         }else{
            throw error::element_error( elem, "unexpected element" );
         };
      }catch( error::element_error &e ){
         err_handler.error( e );
      };
   };
}



vector2 MapDataDocument::random_position(void) const
{
   static const double f = 1.0/(double)RAND_MAX;
   return vector2(
      this->origin_.x + this->width_ * ((double)rand()) * f,
      this->origin_.y - this->height_ * ((double)rand()) * f
      );
}

---