00001 // See license.txt for license information. 00002 // 00003 // generic.cpp 00004 // 00005 // 2-Nov-2005 phamilton Created 00006 // 00007 00008 #include "generic.hpp" 00009 #include "../xmlobj_clone.hpp" 00010 #include "../reflect/member.hpp" 00011 00012 using namespace ph::xmlobj::generic; 00013 00014 ph::common::object_base *generic::get_composite_object(const std::string &name) 00015 /** 00016 We create any composite object that is asked for. This is the only way to 00017 ensure that all objects are correctly created when parseing. 00018 */ 00019 { 00020 for (std::vector<boost::shared_ptr<xmlobj_vector> >::iterator i=_composites.begin(); 00021 i != _composites.end(); i++) 00022 { 00023 if (i->get()->name() == name) 00024 return i->get(); 00025 } 00026 xmlobj_vector *v = new xmlobj_vector(this, name); 00027 _composites.push_back(boost::shared_ptr<xmlobj_vector>(v)); 00028 return v; 00029 } 00030 00031 bool generic::has(const std::string &name) const 00032 /** 00033 We have all members asked for. This is the way that it must work, 00034 otherwise the parser bails on us. 00035 */ 00036 { 00037 return true; 00038 } 00039 00040 void generic::set(const std::string &name, const std::string &value) 00041 /** 00042 Remove any composites with this name. They are really members if they 00043 are being set. This is because we will tell the parser that everything 00044 is a composite (cos we aren't sure), but later on the parser is nice 00045 enough to set the member anyway when it get's data through. 00046 */ 00047 { 00048 for (std::vector<boost::shared_ptr<xmlobj_vector> >::iterator i=_composites.begin(); 00049 i != _composites.end(); i++) 00050 if (i->get()->name() == name) 00051 { 00052 _composites.erase(i); 00053 break; 00054 } 00055 00056 _members[name] = value; 00057 } 00058 00059 bool generic::accept(ph::common::object_name_visitor *v) const 00060 { 00061 return v->visit(this, nameable()); 00062 } 00063 00064 bool generic::accept(ph::common::member_visitor *v) 00065 { 00066 if (!xmlobj::accept(v)) return false; 00067 for (std::map<std::string, std::string>::iterator i=_members.begin(); 00068 i != _members.end(); i++) 00069 { 00070 ph::reflect::string_member m(&i->second); 00071 if (!v->visit(this, i->first, &m)) 00072 return false; 00073 } 00074 return true; 00075 } 00076 00077 bool generic::accept(ph::common::const_member_visitor *v) const 00078 { 00079 if (!xmlobj::accept(v)) return false; 00080 for (std::map<std::string, std::string>::const_iterator i=_members.begin(); 00081 i != _members.end(); i++) 00082 { 00083 ph::reflect::const_string_member m(&i->second); 00084 if (!v->visit(this, i->first, &m)) 00085 return false; 00086 } 00087 return true; 00088 } 00089 00090 bool generic::accept(ph::common::object_visitor *v) 00091 { 00092 if (!xmlobj::accept(v)) return false; 00093 for (std::vector<boost::shared_ptr<xmlobj_vector> >::iterator 00094 i=_composites.begin(); 00095 i != _composites.end(); i++) 00096 if (!i->get()->accept(v)) 00097 return false; 00098 return true; 00099 } 00100 00101 bool generic::accept(ph::common::const_object_visitor *v) const 00102 { 00103 if (!xmlobj::accept(v)) return false; 00104 for (std::vector<boost::shared_ptr<xmlobj_vector> >::const_iterator 00105 i=_composites.begin(); 00106 i != _composites.end(); i++) 00107 if (!i->get()->accept(v)) 00108 return false; 00109 return true; 00110 } 00111 00112 ph::common::object_base *generic::clone(const std::string &name, 00113 ph::common::cloneable_object_context *context) const 00114 { 00115 return xmlobj_clone(this, name, context); 00116 } 00117