generic.cpp

Go to the documentation of this file.

// See license.txt for license information.
//
// generic.cpp
//
// 2-Nov-2005  phamilton  Created
//

#include "generic.hpp"
#include "../xmlobj_clone.hpp"
#include "../reflect/member.hpp"

using namespace ph::xmlobj::generic;

ph::common::object_base *generic::get_composite_object(const std::string &name)
/**
        We create any composite object that is asked for. This is the only way to
        ensure that all objects are correctly created when parseing.
*/
{
        for (std::vector<boost::shared_ptr<xmlobj_vector> >::iterator i=_composites.begin();
                i != _composites.end(); i++)
        {
                if (i->get()->name() == name)
                        return i->get();
        }
        xmlobj_vector *v = new xmlobj_vector(this, name);
        _composites.push_back(boost::shared_ptr<xmlobj_vector>(v));
        return v;
}

bool generic::has(const std::string &name) const
/**
        We have all members asked for. This is the way that it must work, 
        otherwise the parser bails on us.
*/
{ 
        return true; 
}

void generic::set(const std::string &name, const std::string &value)
/**
        Remove any composites with this name. They are really members if they
        are being set. This is because we will tell the parser that everything
        is a composite (cos we aren't sure), but later on the parser is nice
        enough to set the member anyway when it get's data through.
*/
{
        for (std::vector<boost::shared_ptr<xmlobj_vector> >::iterator i=_composites.begin();
                i != _composites.end(); i++)
                if (i->get()->name() == name)
                {
                        _composites.erase(i);
                        break;
                }
                
        _members[name] = value;
}

bool generic::accept(ph::common::object_name_visitor *v) const
{
        return v->visit(this, nameable());
}

bool generic::accept(ph::common::member_visitor *v)
{       
        if (!xmlobj::accept(v)) return false;
        for (std::map<std::string, std::string>::iterator i=_members.begin(); 
                i != _members.end(); i++)
        {
                ph::reflect::string_member m(&i->second); 
                if (!v->visit(this, i->first, &m)) 
                        return false;
        }
        return true;
}

bool generic::accept(ph::common::const_member_visitor *v) const
{       
        if (!xmlobj::accept(v)) return false;
        for (std::map<std::string, std::string>::const_iterator i=_members.begin(); 
                i != _members.end(); i++)
        {
                ph::reflect::const_string_member m(&i->second); 
                if (!v->visit(this, i->first, &m)) 
                        return false;
        }
        return true;
}

bool generic::accept(ph::common::object_visitor *v)
{ 
        if (!xmlobj::accept(v)) return false;
        for (std::vector<boost::shared_ptr<xmlobj_vector> >::iterator 
                        i=_composites.begin();
                        i != _composites.end(); i++)
                if (!i->get()->accept(v))
                        return false;
        return true;
}

bool generic::accept(ph::common::const_object_visitor *v) const
{ 
        if (!xmlobj::accept(v)) return false;
        for (std::vector<boost::shared_ptr<xmlobj_vector> >::const_iterator 
                        i=_composites.begin();
                        i != _composites.end(); i++)
                if (!i->get()->accept(v))
                        return false;
        return true;
}

ph::common::object_base *generic::clone(const std::string &name, 
        ph::common::cloneable_object_context *context) const
{ 
        return xmlobj_clone(this, name, context); 
}

---