persist/test/foo.cpp

Go to the documentation of this file.

// See ../../license.txt for license information.
//
// foo.cpp
//
// 4-Jul-2003  phamilton  Created
//

#include "foo.hpp"
#include "boost/lexical_cast.hpp"

using namespace persist_test;

ph::common::object_base *foo::get_composite_object(const std::string &name)
{
        if (name == "templates")
                return &templates;
        else if (name == "bars")
                return &bars;
        else
                return 0;
}

bool foo::has(const std::string &name) const
{
        return name == "name" || name == "type" || 
                name == "x" || name == "y" || name == "z" || 
                name == "bars" || name == "templates";
}

void foo::set(const std::string &name, const std::string &value)
{
        if (name == "name")
                _name = value;
        else if (name == "type")
                _type = value;
        else if (name == "x")
                x = boost::lexical_cast<int>(value);
        else if (name == "y")
                y = boost::lexical_cast<double>(value);
        else if (name == "z")
                z = (value != "false");
}

std::string foo::get(const std::string &name) const
{
        if (name == "name")
                return _name;
        else if (name == "type")
                return _type;
        else if (name == "x")
                return boost::lexical_cast<std::string>(x);
        else if (name == "y")
                return boost::lexical_cast<std::string>(y);
        else if (name == "z")
                return z ? "true" : "false";
        else
                return "unknown: " + name;
}

bool foo::write(ph::common::object_writer *writer) const
{
        ph::common::object_writer_context obj(writer, _type);
        obj.attr("name", _name);
        {
                ph::common::object_writer_context _x(writer, "x");
                _x.data(boost::lexical_cast<std::string>(x));
        }       
        {
                ph::common::object_writer_context _x(writer, "y");
                _x.data(boost::lexical_cast<std::string>(y));
        }       
        {
                ph::common::object_writer_context _x(writer, "z");
                _x.data(z ? "true" : "false");
        }
        if (bars.vector()->size() > 0)
        {
                ph::common::object_writer_context c2(writer, "bars");
                for (std::vector<ph::common::object_base *>::const_iterator i = bars.vector()->begin(); 
                                i != bars.vector()->end(); i++)
                        if ((*i)->persistable())
                                (*i)->persistable()->write(writer);
        }
        if (templates.vector()->size() > 0)
        {
                ph::common::object_writer_context c2(writer, "templates");
                for (std::vector<ph::common::object_base *>::const_iterator i = templates.vector()->begin(); 
                                i != templates.vector()->end(); i++)
                        if ((*i)->persistable())
                                (*i)->persistable()->write(writer);
        }
        return true;
}

---