src/core/parseactor.cpp

   1 // Copyright 2008 Brian Caine
   2
   3 // This file is part of Potpourri.
   4
   5 // Potpourri is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9
  10 // Potpourri is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTIBILITY of FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with Potpourri. If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 // Poorly implemented xml parsing
  20
  21 #include "../../include/core/parseactor.h"
  22 #include "../../include/core/XmlExtra.h"
  23
  24 #include <stdexcept>
  25 #include <iostream>
  26
  27 namespace XMLParser{
  28 namespace parseactor{
  29
  30 std::string parsename(xmlpp::Node* node)
  31 {
  32   std::string results;
  33
  34   results = getContents(node);
  35
  36   return results;
  37 }
  38 }}
  39
  40 std::string XMLParser::parseactor::parsesource(xmlpp::Node* node)
  41 {
  42   std::string results;
  43
  44   results = getContents(node);
  45
  46   return results;
  47 }
  48
  49 std::string XMLParser::parseactor::parsepair(xmlpp::Node* node)
  50 {
  51   std::string results;
  52
  53   results = getContents(node);
  54
  55   return results;
  56 }
  57
  58 XMLParser::parseactor::pos XMLParser::parseactor::parsepos(xmlpp::Node* node)
  59 {
  60   XMLParser::parseactor::pos results;
  61
  62   xmlpp::Node::NodeList list = node->get_children();
  63
  64   xmlpp::Node::NodeList::iterator iter;
  65   for (iter = list.begin(); iter != list.end(); iter++)
  66     {
  67
  68       if ((*iter)->get_name() == "pair")
  69         {
  70           std::string temp = parsepair(*iter);
  71           results.m_pair = temp;
  72         }
  73
  74     }
  75
  76   return results;
  77 }
  78
  79 float XMLParser::parseactor::parseangle(xmlpp::Node* node)
  80 {
  81   float results;
  82
  83   results = fromString<float>(getContents(node));
  84
  85   return results;
  86 }
  87
  88 XMLParser::parseactor::graphics
  89 XMLParser::parseactor::parsegraphics(xmlpp::Node* node)
  90 {
  91   XMLParser::parseactor::graphics results;
  92
  93   xmlpp::Node::NodeList list = node->get_children();
  94
  95   xmlpp::Node::NodeList::iterator iter;
  96   for (iter = list.begin(); iter != list.end(); iter++)
  97     {
  98
  99       if ((*iter)->get_name() == "source")
 100         {
 101           std::string temp = parsesource(*iter);
 102           results.m_source = temp;
 103         }
 104
 105       if ((*iter)->get_name() == "pos")
 106         {
 107           XMLParser::parseactor::pos temp = parsepos(*iter);
 108           results.m_pos = temp;
 109         }
 110
 111       if ((*iter)->get_name() == "angle")
 112         {
 113           float temp = parseangle(*iter);
 114           results.m_angle = temp;
 115         }
 116
 117     }
 118
 119   return results;
 120 }
 121
 122 float XMLParser::parseactor::parsemass(xmlpp::Node* node)
 123 {
 124   float results;
 125
 126   results = fromString<float>(getContents(node));
 127
 128   return results;
 129 }
 130
 131 float XMLParser::parseactor::parseinertia(xmlpp::Node* node)
 132 {
 133   float results;
 134
 135   results = fromString<float>(getContents(node));
 136
 137   return results;
 138 }
 139
 140 bool XMLParser::parseactor::parsefixed(xmlpp::Node*){ return true; }
 141
 142 XMLParser::parseactor::body
 143 XMLParser::parseactor::parsebody(xmlpp::Node* node)
 144 {
 145   XMLParser::parseactor::body results;
 146
 147   xmlpp::Node::NodeList list = node->get_children();
 148
 149   xmlpp::Node::NodeList::iterator iter;
 150   for (iter = list.begin(); iter != list.end(); iter++)
 151     {
 152
 153       if ((*iter)->get_name() == "mass")
 154         {
 155           float temp = parsemass(*iter);
 156           results.m_mass = temp;
 157         }
 158
 159       if ((*iter)->get_name() == "inertia")
 160         {
 161           float temp = parseinertia(*iter);
 162           results.m_inertia = temp;
 163         }
 164
 165       if ((*iter)->get_name() == "fixed")
 166         {
 167           bool temp = parsefixed(*iter);
 168           results.m_fixed = temp;
 169         }
 170
 171     }
 172
 173   return results;
 174 }
 175
 176 XMLParser::parseactor::data
 177 XMLParser::parseactor::parsedata(xmlpp::Node* node)
 178 {
 179   XMLParser::parseactor::data results;
 180
 181   xmlpp::Node::NodeList list = node->get_children();
 182
 183   xmlpp::Node::NodeList::iterator iter;
 184   for (iter = list.begin(); iter != list.end(); iter++)
 185     {
 186
 187       if ((*iter)->get_name() == "pair")
 188         {
 189           std::string temp = parsepair(*iter);
 190           results.m_pair.push_back(temp);
 191         }
 192
 193     }
 194
 195   return results;
 196 }
 197
 198 XMLParser::parseactor::poly
 199 XMLParser::parseactor::parsepoly(xmlpp::Node* node)
 200 {
 201   XMLParser::parseactor::poly results;
 202
 203   xmlpp::Node::NodeList list = node->get_children();
 204
 205   xmlpp::Node::NodeList::iterator iter;
 206   for (iter = list.begin(); iter != list.end(); iter++)
 207     {
 208
 209       if ((*iter)->get_name() == "data")
 210         {
 211           XMLParser::parseactor::data temp = parsedata(*iter);
 212           results.m_data = temp;
 213         }
 214
 215       if ((*iter)->get_name() == "offset")
 216         {
 217           XMLParser::parseactor::offset temp = parseoffset(*iter);
 218           results.m_offset = temp;
 219         }
 220
 221       if ((*iter)->get_name() == "elasticity")
 222         {
 223           float temp = parseelasticity(*iter);
 224           results.m_elasticity = temp;
 225         }
 226
 227       if ((*iter)->get_name() == "friction")
 228         {
 229           float temp = parsefriction(*iter);
 230           results.m_friction = temp;
 231         }
 232
 233     }
 234
 235   return results;
 236 }
 237
 238 XMLParser::parseactor::offset
 239 XMLParser::parseactor::parseoffset(xmlpp::Node* node)
 240 {
 241   XMLParser::parseactor::offset results;
 242
 243   xmlpp::Node::NodeList list = node->get_children();
 244
 245   xmlpp::Node::NodeList::iterator iter;
 246   for (iter = list.begin(); iter != list.end(); iter++)
 247     {
 248
 249       if ((*iter)->get_name() == "pair")
 250         {
 251           std::string temp = parsepair(*iter);
 252           results.m_pair = temp;
 253         }
 254
 255     }
 256
 257   return results;
 258 }
 259
 260 XMLParser::parseactor::circle
 261 XMLParser::parseactor::parsecircle(xmlpp::Node* node)
 262 {
 263   XMLParser::parseactor::circle results;
 264
 265   xmlpp::Node::NodeList list = node->get_children();
 266
 267   xmlpp::Node::NodeList::iterator iter;
 268   for (iter = list.begin(); iter != list.end(); iter++)
 269     {
 270
 271       if ((*iter)->get_name() == "offset")
 272         {
 273           offset temp = parseoffset(*iter);
 274           results.m_offset = temp;
 275         }
 276
 277       if ((*iter)->get_name() == "radius")
 278         {
 279           float temp = parseradius(*iter);
 280           results.m_radius = temp;
 281         }
 282
 283       if ((*iter)->get_name() == "elasticity")
 284         {
 285           float temp = parseelasticity(*iter);
 286           results.m_elasticity = temp;
 287         }
 288
 289       if ((*iter)->get_name() == "friction")
 290         {
 291           float temp = parsefriction(*iter);
 292           results.m_friction = temp;
 293         }
 294     }
 295
 296   return results;
 297 }
 298
 299 float XMLParser::parseactor::parseradius(xmlpp::Node* node)
 300 {
 301   float results;
 302
 303   results = fromString<float>(getContents(node));
 304
 305   return results;
 306 }
 307
 308 XMLParser::parseactor::line
 309 XMLParser::parseactor::parseline(xmlpp::Node* node)
 310 {
 311   XMLParser::parseactor::line results;
 312
 313   xmlpp::Node::NodeList list = node->get_children();
 314
 315   xmlpp::Node::NodeList::iterator iter;
 316   for (iter = list.begin(); iter != list.end(); iter++)
 317     {
 318
 319       if ((*iter)->get_name() == "pair")
 320         {
 321           std::string temp = parsepair(*iter);
 322           results.m_a = temp;
 323         }
 324
 325       if ((*iter)->get_name() == "pair")
 326         {
 327           std::string temp = parsepair(*iter);
 328           results.m_b = temp;
 329         }
 330
 331       if ((*iter)->get_name() == "radius")
 332         {
 333           float temp = parseradius(*iter);
 334           results.m_radius = temp;
 335         }
 336
 337       if ((*iter)->get_name() == "elasticity")
 338         {
 339           float temp = parseelasticity(*iter);
 340           results.m_elasticity = temp;
 341         }
 342
 343       if ((*iter)->get_name() == "friction")
 344         {
 345           float temp = parsefriction(*iter);
 346           results.m_friction = temp;
 347         }
 348     }
 349
 350   return results;
 351 }
 352
 353 XMLParser::parseactor::physics
 354 XMLParser::parseactor::parsephysics(xmlpp::Node* node)
 355 {
 356   XMLParser::parseactor::physics results;
 357
 358   xmlpp::Node::NodeList list = node->get_children();
 359
 360   xmlpp::Node::NodeList::iterator iter;
 361   for (iter = list.begin(); iter != list.end(); iter++)
 362     {
 363
 364       if ((*iter)->get_name() == "body")
 365         {
 366           body temp = parsebody(*iter);
 367           results.m_body = temp;
 368         }
 369
 370       if ((*iter)->get_name() == "poly")
 371         {
 372           poly temp = parsepoly(*iter);
 373           results.m_poly.push_back(temp);
 374         }
 375
 376       if ((*iter)->get_name() == "circle")
 377         {
 378           circle temp = parsecircle(*iter);
 379           results.m_circle.push_back(temp);
 380         }
 381
 382       if ((*iter)->get_name() == "line")
 383         {
 384           line temp = parseline(*iter);
 385           results.m_line.push_back(temp);
 386         }
 387
 388     }
 389
 390   return results;
 391 }
 392 std::string XMLParser::parseactor::parseevent(xmlpp::Node* node)
 393 {
 394   std::string results;
 395
 396   results = getContents(node);
 397
 398   return results;
 399 }
 400
 401 std::string XMLParser::parseactor::parsescript(xmlpp::Node* node)
 402 {
 403   std::string results;
 404
 405   results = getContents(node);
 406
 407   return results;
 408 }
 409
 410 namespace XMLParser{
 411 namespace parseactor{
 412 reaction parsereaction(xmlpp::Node* node)
 413 {
 414   reaction results;
 415
 416   xmlpp::Node::NodeList list = node->get_children();
 417
 418   xmlpp::Node::NodeList::iterator iter;
 419   for (iter = list.begin(); iter != list.end(); iter++)
 420     {
 421
 422       if ((*iter)->get_name() == "event")
 423         {
 424           std::string temp = parseevent(*iter);
 425           results.m_event = temp;
 426         }
 427
 428       if ((*iter)->get_name() == "script")
 429         {
 430           std::string temp = parsescript(*iter);
 431           results.m_script = temp;
 432         }
 433
 434     }
 435
 436   return results;
 437 }
 438 }}
 439
 440 XMLParser::parseactor::actor
 441 XMLParser::parseactor::parseactor(xmlpp::Node* node)
 442 {
 443   XMLParser::parseactor::actor results;
 444
 445   xmlpp::Node::NodeList list = node->get_children();
 446
 447   xmlpp::Node::NodeList::iterator iter;
 448   for (iter = list.begin(); iter != list.end(); iter++)
 449     {
 450
 451       if ((*iter)->get_name() == "name")
 452         {
 453           std::string temp = parsename(*iter);
 454           results.m_name = temp;
 455         }
 456
 457       if ((*iter)->get_name() == "graphics")
 458         {
 459           graphics temp = parsegraphics(*iter);
 460           results.m_graphics.push_back(temp);
 461         }
 462
 463       if ((*iter)->get_name() == "physics")
 464         {
 465           physics temp = parsephysics(*iter);
 466           results.m_physics = temp;
 467         }
 468
 469       if ((*iter)->get_name() == "reaction")
 470         {
 471           reaction temp = parsereaction(*iter);
 472           results.m_reaction.push_back(temp);
 473         }
 474
 475     }
 476
 477   return results;
 478 }
 479
 480 namespace XMLParser{
 481 namespace parseactor{
 482 actor parseactorFromBuffer(std::string buffer)
 483 {
 484   actor results;
 485
 486   xmlpp::Node* base = 0;
 487
 488   try
 489     {
 490       xmlpp::DomParser parser;
 491       parser.set_substitute_entities();
 492       parser.set_validate();
 493
 494       parser.parse_memory(buffer);
 495
 496       if (parser)
 497         base = parser.get_document()->get_root_node();
 498       else
 499         throw std::runtime_error("some weird error");
 500
 501       results = XMLParser::parseactor::parseactor(base);
 502     }
 503
 504   catch (const std::exception& e)
 505     {
 506       throw std::runtime_error(std::string(
 507         "XMLParser::parseactor::parseactorFromBuffer(): xmlpp error: ") +
 508         e.what());
 509     }
 510
 511   return results;
 512 }
 513 }}
 514
 515 float XMLParser::parseactor::parseelasticity(xmlpp::Node* node)
 516 {
 517   float results;
 518
 519   results = fromString<float>(getContents(node));
 520
 521   return results;
 522 }
 523
 524 float XMLParser::parseactor::parsefriction(xmlpp::Node* node)
 525 {
 526   float results;
 527
 528   results = fromString<float>(getContents(node));
 529
 530   return results;
 531 }