parseobj.cpp

00001 // See ../../license.txt for license information.
00002 //
00003 // parse.cpp
00004 //
00005 // NOTES
00006 // XML Parser for the persistence framework.
00007 //
00008 // 30-Jun-2003 phamilton Created
00009 //
00010 
00011 #define PERSIST_IN_LIBRARY_SOURCE
00012 
00013 #include <iostream>
00014 #include <fstream>
00015 #include <unistd.h> 
00016 #include <boost/lexical_cast.hpp>
00017 #include <boost/filesystem/path.hpp>
00018 #include <boost/filesystem/operations.hpp>
00019 #include <boost/bind.hpp>
00020 #include "parseobj.hpp"
00021 #include "../../common/object.hpp"
00022 #include "../../common/composition_object.hpp"
00023 #include "../../common/persistable_object.hpp"
00024 #include "../../common/outerable_object.hpp"
00025 #include "../../common/importable_object.hpp"
00026 
00027 using namespace ph::persist;
00028 
00029 // important strings
00030 const xmlstring s_objtype = S("type");
00031 const xmlstring s_objname = S("name");
00032 
00033 // possible errors.
00034 const std::string efmt_bad_stack = S("Expected an entry on the object stack.");
00035 const std::string efmt_bad_tag = S("Unknown tag [%s].");
00036 const std::string efmt_fail_create = S("Couldn't create object [%s (%s)].");
00037 const std::string efmt_fail_create_root = S("Couldn't create root object [%s (%s)].");
00038 const std::string efmt_fail_create_delayed = S("Couldn't create delayed object [%s (%s)].");
00039 const std::string efmt_fail_not_importable = S("Object created was not importable.");
00040 const std::string efmt_prop_not_comp = S("Member is not composite object [%s(%s)].");
00041 const std::string efmt_bad_aggr_obj = S("Composite did not accept object (wrong type?) [%s(%s)].");
00042 const std::string efmt_bad_import = S("Could not import [%s].");
00043 const std::string efmt_bad_stream = S("Could not create URL stream for [%s].");
00044 const std::string efmt_bad_urlstream = S("Could not open URL stream for [%s].");
00045 const std::string efmt_bad_endimport = S("Bad place for an end import tag [%s].");
00046 const std::string efmt_bad_fragment = S("Bad place for a fragment tag [%s].");
00047 const std::string efmt_bad_endfragment = S("Bad place for an end fragment tag [%s].");
00048 const std::string efmt_bad_location = S("Location not found for a fragment tag [%s].");
00049 const std::string efmt_no_interface = S("Object has no %s interface [%s].");
00050 const std::string efmt_not_composite = S("Object is not composite [%s].");
00051 const std::string efmt_bad_data = S("Tried to set a member [%s] with bad data [%s].");
00052 const std::string efmt_bad_path = S("Bad pathvar encountered [%s] with [%s].");
00053 const std::string efmt_bad_ref_location = S("Location not found for a reference [%s].");
00054 const std::string efmt_end_stack = S("At the end, the stack still had elements. top: [%s]. "
00055 "Check for unbalanced tags.");
00056 const std::string efmt_import_is_root = S("An import is at the root of the file.");
00057 
00058 xml::parseobj::parseobj(parseobj *outer, std::istream *stream, const boost::filesystem::path &streampath, 
00059 ph::common::persistable_object_context *context,
00060 std::ostream *console, const boost::filesystem::path &rootpath, bool silent, unsigned int debug) :
00061 parse(console, silent)
00062 {
00063 _outer = outer;
00064 _stream = stream;
00065 
00066 // make sure that the streampath passed in is complete.
00067 _streampath = boost::filesystem::system_complete(streampath);
00068 _context = context;
00069 _rootpath = rootpath;
00070 _debug = debug;
00071 
00072 _obj = 0;
00073 _root = 0;
00074 _rootouter = 0;
00075 _cdata = "";
00076 _comment = "";
00077 _abort = false;
00078 _inmember = false;
00079 _anonymousobjnum = 0;
00080 _import = 0;
00081 _rootname = "";
00082 _fragment = false;
00083 _delayed_obj = 0;
00084 }
00085 
00086 static std::string obj_name(ph::common::object_base *obj)
00087 {
00088 std::string name;
00089 if (get_persistable_obj_name(obj, &name))
00090 return name;
00091 else
00092 return "No name for object";
00093 }
00094 
00095 static std::string obj_type(ph::common::object_base *obj)
00096 {
00097 std::string type;
00098 if (get_persistable_obj_type(obj, &type))
00099 return type;
00100 else
00101 return "No type for object";
00102 }
00103 
00104 void xml::parseobj::finish_handler()
00105 {
00106 // we have finished. Make sure that the stack is empty and that we have successfully
00107 // stashed an object.
00108 if (!_abort && !_stack.empty())
00109 error(efmt_end_stack, obj_name(_stack.top()), true);
00110 }
00111 
00112 void xml::parseobj::startelement_handler(const xmlstring &element, const std::vector<xmlstring> &atts)
00113 {
00114 if (_abort)
00115 return;
00116 
00117 if (_debug & (PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00118 *_errorhandler << ">> startelement : [" << element << "]" << std::endl;
00119 
00120 xmlstring arg = attr(atts, 0);
00121 
00122 if (arg.empty())
00123 {
00124 if (_stack.empty())
00125 {
00126 error(efmt_bad_stack, true);
00127 _abort = true;
00128 return;
00129 }
00130 
00131 ph::common::object_base *top = _stack.top();
00132 if (!test_persistable(top))
00133 return;
00134 
00135 if (top->persistable()->has(element))
00136 {
00137 // the top has this as an element, so see if it's a composite element,
00138 // then push that, or we are starting a member,
00139 ph::common::object_base *c = top->persistable()->get_composite_object(element);
00140 if (c)
00141 {
00142 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00143 obj_out("pushing", c);
00144 _stack.push(c);
00145 }
00146 else
00147 {
00148 // a normal member
00149 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00150 element_out("in member", element);
00151 _inmember = true;
00152 }
00153 if (_debug & (PARSEOBJ_DATA_DEBUG | PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00154 *_errorhandler << ">> emptying cdata." << std::endl;
00155 _cdata = "";
00156 }
00157 else
00158 {
00159 // it's possible that we are trying to build an unnamed ph::common::object_base.
00160 ph::common::object_base *obj = create_object(_stack.top(), element, 
00161 S("_") + boost::lexical_cast<std::string>(_anonymousobjnum++));
00162 if (!obj)
00163 {
00164 error(efmt_bad_tag, element, true);
00165 _abort = true;
00166 return;
00167 }
00168 
00169 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00170 {
00171 obj_out("composite (1)", _stack.top());
00172 obj_out("adding to composite (1)", obj);
00173 }
00174 if (!test_composition(_stack.top()))
00175 return;
00176 if (!_stack.top()->composition()->composite()->add(obj, true))
00177 {
00178 error(efmt_bad_aggr_obj, obj_name(_stack.top()), obj_type(_stack.top()), true);
00179 _abort = true;
00180 return;
00181 }
00182 
00183 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00184 obj_out("pushing anonymous", obj);
00185 _stack.push(obj);
00186 }
00187 }
00188 else if (_import)
00189 {
00190 // in the middle of an import.
00191 // we can expect...
00192 // name value=
00193 // param name= value
00194 
00195 if (element == "name")
00196 _import->_rootname = expectedattr(atts, "value");
00197 else if (element == "param")
00198 {
00199 // add parameter, do subs on the name and the value.
00200 _import->add_param(
00201 dosubs(expectedattr(atts, "name")), 
00202 dosubs(expectedattr(atts, "value")));
00203 }
00204 else if (element == "pathparam")
00205 {
00206 // add parameter, do subs on the name and the value
00207 // and push them back. We convert relative paths
00208 // to absolute.
00209 std::string pathstr = dosubs(expectedattr(atts, "value"));
00210 
00211 try
00212 {
00213 boost::filesystem::path p = pathstr;
00214 if (!p.is_complete())
00215 p = _streampath.branch_path() / p;
00216 _import->add_param(dosubs(expectedattr(atts, "name")), p.string());
00217 }
00218 catch (...)
00219 {
00220 error(efmt_bad_path, element, pathstr, true);
00221 _abort = true;
00222 return;
00223 } 
00224 }
00225 }
00226 else if (_delayed_obj)
00227 {
00228 // in the middle of an delayed import.
00229 // we can expect...
00230 // name value=
00231 // param name= value
00232 
00233 if (element == "name")
00234 {
00235 // set the root name for the import object.
00236 _delayed_obj->setname(expectedattr(atts, "value"));
00237 }
00238 else if (element == "param")
00239 {
00240 // add parameter, do subs on the name and the value.
00241 _delayed_obj->addparam(
00242 dosubs(expectedattr(atts, "name")), 
00243 dosubs(expectedattr(atts, "value")));
00244 }
00245 else if (element == "pathparam")
00246 {
00247 // add parameter, do subs on the name and the value
00248 // and push them back. We convert relative paths
00249 // to absolute.
00250 std::string pathstr = dosubs(expectedattr(atts, "value"));
00251 
00252 try
00253 {
00254 boost::filesystem::path p = pathstr;
00255 if (!p.is_complete())
00256 p = _streampath.branch_path() / p;
00257 _delayed_obj->addparam(dosubs(expectedattr(atts, "name")), p.string());
00258 }
00259 catch (...)
00260 {
00261 error(efmt_bad_path, element, pathstr, true);
00262 _abort = true;
00263 return;
00264 }
00265 }
00266 }
00267 else
00268 {
00269 // an element with attributes
00270 // now check the tag.
00271 if (element == S("import") || element == S("xi:include"))
00272 {
00273 xmlstring url = attr(atts, "href");
00274 // allow for href or url.
00275 if (url.empty())
00276 url = expectedattr(atts, "url");
00277 xmlstring name = attr(atts, "name");
00278 
00279 // try any string substitutions on the value (for $() stuff).
00280 url = dosubs(url);
00281 name = dosubs(name);
00282 
00283 if (_context->delayed_import())
00284 {
00285 // we want to import the XML passed.
00286 // create a substream of the current stream for the import.
00287 boost::filesystem::path p(url, boost::filesystem::no_check);
00288 if (!p.is_complete())
00289 p = _streampath.branch_path() / p;
00290 
00291 // create a proxy object to handle parseing during import.
00292 ph::common::object_base *obj = _context->create_delayed(_errorhandler,
00293 p, name, _debug);
00294 if (obj)
00295 {
00296 // delayed objects need an importable interface, since 
00297 // our XML files can have names and parameters.
00298 _delayed_obj = obj->importable();
00299 if (!_delayed_obj)
00300 {
00301 error(efmt_fail_not_importable, true);
00302 _abort = true;
00303 return;
00304 }
00305 }
00306 else
00307 {
00308 error(efmt_fail_create_delayed, url, name, true);
00309 _abort = true;
00310 return;
00311 }
00312 
00313 if (_stack.empty())
00314 {
00315 error(efmt_import_is_root, true);
00316 _abort = true;
00317 return;
00318 }
00319 else
00320 {
00321 // if the object on the top of the stack is a composite, then add this object to that.
00322 if (!test_composition(_stack.top()))
00323 return;
00324 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00325 {
00326 obj_out("composite (2)", _stack.top());
00327 obj_out("adding to composite (2)", obj);
00328 }
00329 if (!_stack.top()->composition()->composite()->add(obj, true))
00330 {
00331 error(efmt_bad_aggr_obj, obj_name(_stack.top()), obj_type(_stack.top()), true);
00332 _abort = true;
00333 return;
00334 }
00335 }
00336 if (_debug & PARSEOBJ_DELAYED_DEBUG)
00337 *_errorhandler << ">> [" << p.string() << "] delaying." << std::endl;
00338 _stack.push(obj);
00339 }
00340 else
00341 {
00342 if (_import)
00343 {
00344 error(efmt_bad_import, url, true);
00345 _abort = true;
00346 return;
00347 }
00348 
00349 // we want to import the XML passed.
00350 // create a substream of the current stream for the import.
00351 boost::filesystem::path p(url, boost::filesystem::no_check);
00352 _importstreampath = p;
00353 if (!_importstreampath.is_complete())
00354 _importstreampath = _streampath.branch_path() / _importstreampath;
00355 _importstream = new std::ifstream(_importstreampath.native_file_string().c_str());
00356 
00357 // create a new importer.
00358 _import = new parseobj(this, _importstream, _importstreampath, _context, 
00359 _errorhandler, _rootpath, _silent, _debug);
00360 
00361 if (name != "")
00362 _import->_rootname = name;
00363 }
00364 }
00365 else if (element == S("fragment"))
00366 {
00367 xmlstring location = expectedattr(atts, "location");
00368 if (_fragment)
00369 {
00370 error(efmt_bad_fragment, location, true);
00371 _abort = true;
00372 return;
00373 }
00374 
00375 ph::common::object_base *c = _context->find_composite_object(_root, _root, location);
00376 if (!c)
00377 {
00378 error(efmt_bad_location, location, true);
00379 _abort = true;
00380 return;
00381 }
00382 
00383 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00384 obj_out("pushing composite", c);
00385 _stack.push(c);
00386 _fragment = true;
00387 }
00388 else if (element == S("var"))
00389 {
00390 // do subs on the name and the value.
00391 // and push them back.
00392 add_param(
00393 dosubs(expectedattr(atts, "name")), 
00394 dosubs(expectedattr(atts, "value")));
00395 }
00396 else if (element == S("pathvar"))
00397 {
00398 // do subs on the name and the value.
00399 // and push them back. We convert relative paths
00400 // to absolute.
00401 std::string pathstr = dosubs(expectedattr(atts, "value"));
00402 
00403 try
00404 {
00405 boost::filesystem::path p = pathstr;
00406 if (!p.is_complete())
00407 p = _streampath.branch_path() / p;
00408 add_param(dosubs(expectedattr(atts, "name")), p.string());
00409 }
00410 catch (...)
00411 {
00412 error(efmt_bad_path, element, pathstr, true);
00413 _abort = true;
00414 return;
00415 } 
00416 }
00417 else
00418 {
00419 if (arg == s_objname)
00420 {
00421 xmlstring val = attrval(atts, 0);
00422 
00423 // starting an object. name is given.
00424 ph::common::object_base *obj = 0;
00425 
00426 if (_stack.empty())
00427 {
00428 // create the new object.
00429 // it's possible that we arer in the middle of parseing
00430 // some NEW objects into the middle of another file.
00431 
00432 // If there is an outer stack, then ask THAT object to create a new one,
00433 // otherwise just use the context.
00434 if (_outer && !_outer->_stack.empty())
00435 obj = create_object(_outer->_stack.top(), element, val);
00436 
00437 if (!obj) 
00438 obj = _context->create(element, val);
00439 
00440 if (!obj)
00441 {
00442 error(efmt_fail_create_root, element, val, true);
00443 _abort = true;
00444 return;
00445 }
00446 
00447 // save away this object as the root object.
00448 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00449 obj_out("stashing as root", obj);
00450 
00451 _root = obj;
00452 
00453 // root objects can have an outer as well. This is especially
00454 // true in the case of delayed importing.
00455 if (_rootouter)
00456 if (_root->outerable())
00457 _root->outerable()->outer(_rootouter);
00458 
00459 // set the filepath for the root object.
00460 if (!test_persistable(_root))
00461 return;
00462 _root->persistable()->set_file_path(_streampath.string()); 
00463 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00464 obj_out("setting the path to [" + _streampath.string() + "]", obj);
00465 }
00466 else
00467 {
00468 // if the object on the top of the stack is a composite, then add this object to that.
00469 if (!test_composition(_stack.top()))
00470 return;
00471 
00472 // create the object.
00473 obj = create_object(_stack.top(), element, val);
00474 
00475 // object could not be created for some reason.
00476 if (!obj)
00477 {
00478 error(efmt_fail_create, element, val, true);
00479 _abort = true;
00480 return;
00481 }
00482 
00483 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00484 {
00485 obj_out("composite (3)", _stack.top());
00486 obj_out("adding to composite (3)", obj);
00487 }
00488 
00489 if (!_stack.top()->composition()->composite()->add(obj, true))
00490 {
00491 error(efmt_bad_aggr_obj, obj_name(_stack.top()), obj_type(_stack.top()), true);
00492 _abort = true;
00493 return;
00494 }
00495 }
00496 
00497 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00498 obj_out("pushing obj with name", obj);
00499 _stack.push(obj);
00500 }
00501 else if (_stack.empty())
00502 {
00503 error(efmt_bad_stack, true);
00504 _abort = true;
00505 }
00506 else
00507 {
00508 error(efmt_bad_tag, element, true);
00509 _abort = true;
00510 }
00511 }
00512 }
00513 }
00514 
00515 void xml::parseobj::cdata_handler(const xmlstring &s, int len)
00516 {
00517 if (_abort)
00518 return;
00519 
00520 if (_debug & (PARSEOBJ_DATA_DEBUG | PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00521 *_errorhandler << ">> cdata : [" << s << "]" << std::endl;
00522 
00523 _cdata += s;
00524 }
00525 
00526 void xml::parseobj::comment_handler(const xmlstring &s)
00527 {
00528 if (_abort)
00529 return;
00530 
00531 if (_debug & (PARSEOBJ_DATA_DEBUG | PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00532 *_errorhandler << ">> comment : [" << s << "]" << std::endl;
00533 
00534 _comment = s;
00535 }
00536 
00537 void xml::parseobj::endelement_handler(const xmlstring &element)
00538 {
00539 if (_abort)
00540 return;
00541 
00542 if (_debug & (PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00543 *_errorhandler << ">> endelement : [" << element << "]" << std::endl;
00544 
00545 if (_stack.empty())
00546 {
00547 error(efmt_bad_stack, true);
00548 _abort = true;
00549 return;
00550 }
00551 
00552 if (element == S("import") || element == S("xi:include"))
00553 {
00554 if (_context->delayed_import())
00555 {
00556 // add proxy object as the object.
00557 if (!_delayed_obj)
00558 {
00559 error(efmt_bad_endimport, element, true);
00560 _abort = true;
00561 return;
00562 }
00563 ph::common::object_base *obj = _stack.top();
00564 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00565 obj_out("popping because delayed", obj);
00566 // if we are closing off a delayed, just pop it off.
00567 _stack.pop();
00568 _delayed_obj = 0;
00569 }
00570 else
00571 {
00572 if (!_import)
00573 {
00574 error(efmt_bad_endimport, element, true);
00575 _abort = true;
00576 return;
00577 }
00578 
00579 if (!parse::parse_xml(_importstream, _importstreampath.string(), _import, 0))
00580 {
00581 error(efmt_bad_urlstream, element, true);
00582 _abort = true;
00583 return;
00584 }
00585 
00586 ph::common::object_base *obj = _import->obj();
00587 if (!obj)
00588 {
00589 error(efmt_bad_import, _importstreampath.string(), true);
00590 _abort = true;
00591 return;
00592 }
00593 
00594 // make sure that the object get's the correct name.
00595 if (!_import->_rootname.empty())
00596 set_persistable_obj_name(obj, _import->_rootname);
00597 
00598 // set the filepath for the object.
00599 if (!test_persistable(obj))
00600 return;
00601 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00602 obj_out("setting the path to [" + _importstreampath.string() + "]", obj);
00603 // TBD: the following should be a real path.
00604 obj->persistable()->set_file_path(_importstreampath.string());
00605 
00606 // if the object on the top of the stack is a composite, then add this object to that.
00607 if (!test_composition(_stack.top()))
00608 return;
00609 
00610 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00611 {
00612 obj_out("composite (4)", _stack.top());
00613 obj_out("adding to composite (4)", obj);
00614 }
00615 
00616 if (!_stack.top()->composition()->composite()->add(obj, true))
00617 {
00618 error(efmt_bad_aggr_obj, obj_name(_stack.top()), obj_type(_stack.top()), true);
00619 _abort = true;
00620 return;
00621 }
00622 
00623 // finish up.
00624 delete _importstream;
00625 _importstream = 0;
00626 delete _import;
00627 _import = 0;
00628 }
00629 }
00630 else if (element == "param")
00631 {
00632 // end of parameters.
00633 }
00634 else if (element == "pathparam")
00635 {
00636 // end of path parameters.
00637 }
00638 else if (element == "var")
00639 {
00640 // end of variable.
00641 }
00642 else if (element == "pathvar")
00643 {
00644 // end of path variable.
00645 }
00646 else if (element == S("fragment"))
00647 {
00648 if (!_fragment)
00649 {
00650 error(efmt_bad_endfragment, element, true);
00651 _abort = true;
00652 return;
00653 }
00654 
00655 // pop the stack.
00656 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00657 obj_out("popping", _stack.top());
00658 _stack.pop();
00659 _fragment = false;
00660 }
00661 else if (_inmember)
00662 {
00663 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00664 obj_out("setting member [" + element + "] of ", _stack.top());
00665 if (!test_persistable(_stack.top()))
00666 return;
00667 
00668 try {
00669 _stack.top()->persistable()->set(element, dosubs(_cdata));
00670 }
00671 catch (...)
00672 {
00673 error(efmt_bad_data, element, _cdata, true);
00674 _abort = true;
00675 return;
00676 }
00677 if (_debug & (PARSEOBJ_DATA_DEBUG | PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00678 *_errorhandler << ">> emptying cdata." << std::endl;
00679 _cdata = "";
00680 _inmember = false;
00681 }
00682 else
00683 {
00684 ph::common::object_base *obj = _stack.top();
00685 if (obj_type(obj) == element)
00686 {
00687 // see if _cdata is anything other than whitespace.
00688 if (_cdata.find_first_not_of(" \t\n") != std::string::npos)
00689 *_errorhandler << ">> Ignoring cdata. [" << _cdata << "]" << std::endl;
00690 
00691 // closing out the current object
00692 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00693 obj_out("closing out ", obj);
00694 _stack.pop();
00695 
00696 if (_stack.empty())
00697 { 
00698 // we are at the end. Pickup the object.
00699 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00700 obj_out("stashing as _obj", obj);
00701 _obj = obj;
00702 }
00703 }
00704 else if (obj->composition() && obj->composition()->composite())
00705 {
00706 if (obj_name(obj) != element)
00707 {
00708 error(efmt_bad_tag, element, true);
00709 _abort = true;
00710 return;
00711 }
00712 
00713 if (_cdata.find_first_not_of(" \t\n") != std::string::npos)
00714 {
00715 if (obj->composition()->composite()->singleton()
00716 && obj->composition()->composite()->count() == 0)
00717 {
00718 // find the object that the cdata refers to, and add that as a reference.
00719 ph::common::object_base *o = _context->find_object(_root, obj, _cdata);
00720 if (!o)
00721 {
00722 error(efmt_bad_ref_location, _cdata, true);
00723 _abort = true;
00724 return;
00725 }
00726 
00727 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00728 {
00729 obj_out("composite (5)", obj);
00730 obj_out("adding to composite (5)", o);
00731 }
00732 
00733 // add the object to the composite, but it's not owned.
00734 if (!obj->composition()->composite()->add(o, false))
00735 {
00736 error(efmt_bad_aggr_obj, obj_name(obj), obj_type(obj), true);
00737 _abort = true;
00738 return;
00739 }
00740 
00741 // we have used up cdata.
00742 if (_debug & (PARSEOBJ_DATA_DEBUG | PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00743 *_errorhandler << ">> emptying cdata." << std::endl;
00744 _cdata = "";
00745 
00746 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00747 obj_out("popping because composite", obj);
00748 // if we are closing off a composite, just pop it off.
00749 _stack.pop();
00750 }
00751 else
00752 {
00753 // we can help generic out at this point. The only way that it knows if
00754 // an element is a composite or if it's a member is if it get's some
00755 // type of non-whitespace CDATA through. We call set as if this
00756 // is a member. This might cause some concern for other parsers since they'll
00757 // see members AND composites, but they can be written the same.
00758 
00759 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00760 obj_out("popping because composite (possible member?)", obj);
00761 // if we are closing off a composite, just pop it off.
00762 _stack.pop();
00763 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00764 obj_out("setting member [" + element + "] of ", _stack.top());
00765 if (!test_persistable(_stack.top()))
00766 return;
00767 try 
00768 {
00769 _stack.top()->persistable()->set(element, dosubs(_cdata));
00770 }
00771 catch (...)
00772 {
00773 error(efmt_bad_data, element, _cdata, true);
00774 _abort = true;
00775 return;
00776 }
00777 if (_debug & (PARSEOBJ_DATA_DEBUG | PARSEOBJ_ELEMENT_DEBUG | PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00778 *_errorhandler << ">> emptying cdata." << std::endl;
00779 _cdata = "";
00780 }
00781 } 
00782 else
00783 {
00784 if (_debug & (PARSEOBJ_STACK_DEBUG | PARSEOBJ_OBJECT_DEBUG))
00785 obj_out("popping because composite", obj);
00786 // if we are closing off a composite, just pop it off.
00787 _stack.pop();
00788 }
00789 }
00790 else
00791 {
00792 error(efmt_bad_tag, element, true);
00793 _abort = true;
00794 }
00795 }
00796 }
00797 
00798 ph::common::object_base *xml::parseobj::create_object(ph::common::object_base *top, const xmlstring &type, const xmlstring &name)
00799 {
00800 // see if the tos is a composite.
00801 // if it's a composite, then we need to use it's parent
00802 // to clone actual objects off.
00803 ph::common::object_base *topsearch = top;
00804 if (top->composition() && top->composition()->composite())
00805 {
00806 if (!test_outerable(top))
00807 return 0;
00808 topsearch = top->outerable()->outer();
00809 }
00810 
00811 if (_debug & PARSEOBJ_OBJECT_DEBUG)
00812 *_errorhandler << ">> create_object type: [" << type 
00813 << "] name: [" << name 
00814 << "] top->name: [" << obj_name(top) << "]" << std::endl;
00815 
00816 // try to create the new object using the top object.
00817 if (!test_persistable(top))
00818 return 0;
00819 ph::common::object_base *obj = topsearch->persistable()->create(type, name, _context);
00820 
00821 // if the above fails, ask the object manager.
00822 if (!obj)
00823 obj = _context->create(type, name);
00824 
00825 if (obj)
00826 { 
00827 // make sure we set the parent straight away so that templates etc
00828 // are used correctly.
00829 if (obj->outerable())
00830 obj->outerable()->outer(top);
00831 }
00832 
00833 return obj;
00834 }
00835 
00836 xmlstring xml::parseobj::dosubs(const xmlstring &s)
00837 /*
00838  Substitute string values in the string.
00839 
00840  All $(arg) pairs are substitute.
00841 */
00842 {
00843 xmlstring remain = s;
00844 xmlstring news = S("");
00845 int loc = remain.find(S("$("));
00846 if (loc >= 0)
00847 {
00848 while (loc >= 0)
00849 {
00850 news += remain.substr(0, loc);
00851 remain = remain.substr(loc);
00852 loc = remain.find(L')');
00853 if (loc >= 0)
00854 {
00855 xmlstring token = remain.substr(2, loc-2);
00856 remain = remain.substr(loc+1);
00857 
00858 std::string value;
00859 if (find_param(token, &value))
00860 news += value;
00861 else
00862 news += S("$(") + token + S(")");
00863 }
00864 loc = remain.find(S("$("));
00865 }
00866 news += remain;
00867 }
00868 
00869 if (news.empty())
00870 return s;
00871 else
00872 return news;
00873 }
00874 
00875 void xml::parseobj::add_params(const std::map<std::string, std::string> &params)
00876 {
00877 // copy the map. This code could be much simpler I think...
00878 std::for_each(params.begin(), params.end(), 
00879 boost::bind(&add_param_1,
00880 &_params,
00881 boost::bind(&std::map<std::string, std::string>::value_type::first, _1),
00882 boost::bind(&std::map<std::string, std::string>::value_type::second, _1)));
00883 }
00884 
00885 void xml::parseobj::add_param_1(std::map<std::string, std::string> *params, 
00886 const std::string &name, const std::string &val)
00887 {
00888 (*params)[name] = val;
00889 }
00890 
00891 void xml::parseobj::add_param(const std::string &name, const std::string &val) 
00892 {
00893 add_param_1(&_params, name, val);
00894 }
00895 
00896 bool xml::parseobj::find_param(const std::string &name, std::string *value)
00897 {
00898 std::map<std::string, std::string>::iterator i = _params.find(name);
00899 if (i == _params.end())
00900 return false;
00901 *value = i->second;
00902 return true;
00903 }
00904 
00905 bool xml::parseobj::test_outerable(ph::common::object_base *obj)
00906 {
00907 if (!obj->outerable())
00908 {
00909 error(efmt_no_interface, "outerable", obj_name(obj), true);
00910 _abort = true;
00911 return false;
00912 }
00913 return true;
00914 }
00915 
00916 bool xml::parseobj::test_persistable(ph::common::object_base *obj)
00917 {
00918 if (!obj->persistable())
00919 {
00920 error(efmt_no_interface, "persistable", obj_name(obj), true);
00921 _abort = true;
00922 return false;
00923 }
00924 return true;
00925 }
00926 
00927 bool xml::parseobj::test_composition(ph::common::object_base *obj)
00928 {
00929 if (!obj->composition())
00930 {
00931 error(efmt_no_interface, "composition", obj_name(obj), true);
00932 _abort = true;
00933 return false;
00934 }
00935 if (!obj->composition()->composite())
00936 {
00937 error(efmt_not_composite, obj_name(obj), true);
00938 _abort = true;
00939 return false;
00940 }
00941 return true;
00942 }
00943 
00944 void xml::parseobj::obj_out(const std::string &msg, ph::common::object_base *obj)
00945 {
00946 *_errorhandler << ">> " << msg << " [" << obj_type(obj) << ", " << obj_name(obj) << "]" << std::endl;
00947 }
00948 
00949 void xml::parseobj::element_out(const std::string &msg, const xmlstring &element)
00950 {
00951 *_errorhandler << ">> " << msg << " [" << element << "]" << std::endl;
00952 }
00953 
00954 // TBD: These don't work.
00955 xmlstring xml::parseobj::getdecodedattrval(const std::vector<xmlstring> &atts, int index)
00956 {
00957 xmlstring val = attrval(atts, index);
00958 xmlstring news;
00959 if (decodexmldata(val, &news))
00960 return news;
00961 else
00962 return val;
00963 }
00964 
00965 xmlstring xml::parseobj::getdecodedexpectedattr(const std::vector<xmlstring> &atts, const xmlstring &token)
00966 {
00967 xmlstring val = expectedattr(atts, token);
00968 xmlstring news;
00969 if (decodexmldata(val, &news))
00970 return news;
00971 else
00972 return val;
00973 }
00974 
00975 xmlstring xml::parseobj::getdecodedattr(const std::vector<xmlstring> &atts, const xmlstring &token)
00976 {
00977 xmlstring val = attr(atts, token);
00978 xmlstring news;
00979 if (decodexmldata(val, &news))
00980 return news;
00981 else
00982 return val;
00983 }