object.cpp

Go to the documentation of this file.

/* libobby - Network text editing library
 * Copyright (C) 2005 0x539 dev group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "common.hpp"
#include "format_string.hpp"
#include "serialise/error.hpp"
#include "serialise/object.hpp"

obby::serialise::object::attribute_iterator::attribute_iterator(
        const base_iterator& base
) :
        base_iterator(base)
{
}
/*
obby::serialise::object::attribute_iterator::value_type&
obby::serialise::object::attribute_iterator::operator*()
{
        return base_iterator::operator->()->second;
}
*/
const obby::serialise::object::attribute_iterator::value_type&
obby::serialise::object::attribute_iterator::operator*() const
{
        return base_iterator::operator->()->second;
}
/*
obby::serialise::object::attribute_iterator::value_type*
obby::serialise::object::attribute_iterator::operator->()
{
        return &base_iterator::operator->()->second;
}
*/
const obby::serialise::object::attribute_iterator::value_type*
obby::serialise::object::attribute_iterator::operator->() const
{
        return &base_iterator::operator->()->second;
}

obby::serialise::object::object(
        const object* parent
) :
        m_parent(parent), m_name(), m_line(0)
{
}

void obby::serialise::object::serialise(
        token_list& tokens
) const
{
        // Find indentation level
        unsigned int indentation_deep = get_indentation();

        // Add object name
        tokens.add(token::TYPE_IDENTIFIER, m_name, 0);

        // Add attributes
        for(attribute_iterator iter = attributes_begin();
            iter != attributes_end();
            ++ iter)
        {
                iter->serialise(tokens);
        }

        // Add children
        for(child_iterator iter = children_begin();
            iter != children_end();
            ++ iter)
        {
                // Indent child to our indentation + 1
                tokens.add(
                        token::TYPE_INDENTATION,
                        std::string(indentation_deep + 1, ' '),
                        0
                );

                // Serialise it
                iter->serialise(tokens);
        }
}

void obby::serialise::object::deserialise(
        const token_list& tokens,
        token_list::iterator& iter
)
{
        unsigned int indentation_deep = get_indentation();

        // Object name
        m_name = iter->get_text();

        // Line of object declaration
        m_line = iter->get_line();
        ++ iter;

        // Expect any number of attributes
        while(iter != tokens.end() &&
              iter->get_type() == token::TYPE_IDENTIFIER)
                m_attributes[iter->get_text()].deserialise(tokens, iter);

        // Indentation (for child objects)
        while(iter != tokens.end() &&
              iter->get_type() == token::TYPE_INDENTATION)
        {
                // Get indentation of this child
                unsigned int child_indentation = iter->get_text().length();
                // Belongs to some super-object
                if(child_indentation <= indentation_deep) break;

                // Is a child
                tokens.next_token(iter);

                // Next token must be identifier (object name)
                if(iter->get_type() == token::TYPE_IDENTIFIER)
                {
                        if(indentation_deep != child_indentation - 1)
                        {
                                throw error(
                                        _(
                                                "Child object's indentation "
                                                "must be parent's plus one"
                                        ),
                                        iter->get_line()
                                );
                        }

                        object& child = add_child();
                        child.deserialise(tokens, iter);
                }
                else
                {
                        throw error(
                                _("Expected child object after indentation"),
                                iter->get_line()
                        );
                }
        }

        // An object _must_ follow even if it is not a child of us but one of
        // our parent (or grandparent...).
        if(iter != tokens.end() && iter->get_type() != token::TYPE_INDENTATION)
        {
                obby::format_string str(
                        _("Expected child object instead of '%0%'")
                );
                str << iter->get_text();
                throw error(str.str(), iter->get_line() );
        }
}

const obby::serialise::object* obby::serialise::object::get_parent() const
{
        return m_parent;
}

obby::serialise::object& obby::serialise::object::add_child()
{
        m_children.push_back(object(this) );
        return m_children.back();
}

const std::string& obby::serialise::object::get_name() const
{
        return m_name;
}

void obby::serialise::object::set_name(
        const std::string& name
)
{
        m_name = name;
}

obby::serialise::attribute& obby::serialise::object::add_attribute(
        const std::string& name
)
{
        return m_attributes.insert(
                std::make_pair(name, attribute(name))
        ).first->second;
}

obby::serialise::attribute*
obby::serialise::object::get_attribute(const std::string& name)
{
        attribute_map::iterator iter = m_attributes.find(name);
        if(iter == m_attributes.end() ) return NULL;
        return &iter->second;
}

const obby::serialise::attribute*
obby::serialise::object::get_attribute(const std::string& name) const
{
        attribute_map::const_iterator iter = m_attributes.find(name);
        if(iter == m_attributes.end() ) return NULL;
        return &iter->second;
}

obby::serialise::attribute&
obby::serialise::object::get_required_attribute(const std::string& name)
{
        attribute_map::iterator iter = m_attributes.find(name);
        if(iter == m_attributes.end() )
        {
                format_string str(_("Object '%0%' requires attribute '%1%'") );
                str << m_name << name;
                throw error(str.str(), m_line);
        }

        return iter->second;
}

const obby::serialise::attribute&
obby::serialise::object::get_required_attribute(const std::string& name) const
{
        attribute_map::const_iterator iter = m_attributes.find(name);
        if(iter == m_attributes.end() )
        {
                format_string str(_("Object '%0%' requires attribute '%1%'") );
                str << m_name << name;
                throw error(str.str(), m_line);
        }

        return iter->second;
}

obby::serialise::object::attribute_iterator
obby::serialise::object::attributes_begin() const
{
        return attribute_iterator(m_attributes.begin() );
}

obby::serialise::object::attribute_iterator
obby::serialise::object::attributes_end() const
{
        return attribute_iterator(m_attributes.end() );
}

obby::serialise::object::child_iterator
obby::serialise::object::children_begin() const
{
        return m_children.begin();
}

obby::serialise::object::child_iterator
obby::serialise::object::children_end() const
{
        return m_children.end();
}

unsigned int obby::serialise::object::get_line() const
{
        return m_line;
}

unsigned int obby::serialise::object::get_indentation() const
{
        unsigned int indentation_deep = 0;
        const object* parent = m_parent;

        // Find indentation level
        while(parent != NULL)
        {
                ++ indentation_deep;
                parent = parent->get_parent();
        }

        return indentation_deep;
}

---