jscript_object_navigator.cpp

Go to the documentation of this file.

// See ../license.txt for license information.
//
// jscript_object_navigator.cpp
//
// 8-Jul-2003  phamilton  Created
//

#define REFLECT_IN_LIBRARY_SOURCE

#include "jscript_object_navigator.hpp"
#include <iostream>
#include "../common/object.hpp"
#include "../common/composition_object.hpp"
#include "../common/outerable_object.hpp"
#include "../common/comparable_object.hpp"
#include "../common/nameable_object.hpp"
#include "jscript_object_nav_errors.h"
#include "object_visitor.hpp"
#include "member_visitor.hpp"
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>

using namespace ph::reflect;

object_navigator *jscript_object_navigator_factory::create(const ph::common::object_base *root)
{
        // use jscript style navigation.
        return new jscript_object_navigator(root, _console, _debug);
}

ph::common::object_base *jscript_object_navigator::navigate(const ph::common::object_base *obj, const std::string &path)
/*
        Given the name of a sub-object, this function walks the 
        object tree and retrieves the named object.

        names are always relative to this object.

        root() - means the root of the object tree.
        parent(n) - means the nth (where the n can be left out) parent of this object.

        You can subscript a property if you know that the property is 
        a vector property,
*/
{
        // start off with the path passed in.
        std::string descr = path;

        // start off with the object passed in.
        const ph::common::object_base *o = obj;
        
        // walk the dots in the string.
        int dot = find_span_quotes(descr, '.');
        std::string part = "";
        long parsed = dot;
        while (dot >= 0)
        {
                part = descr.substr(0, dot);
                descr = descr.substr(dot+1);

                if (part.empty())
                {
                        error(e_empty_part, path.substr(parsed));
                        return 0;
                }

                // get this piece.
                const ph::common::object_base *found_o = get_sub_object(o, part);

                // if the obj is NULL, then just successfully return a NULL object.
                if (!found_o)
                        return 0;

                // next dot.
                o = found_o;
                parsed += dot;
                dot = find_span_quotes(descr, '.');
        }
        
        const ph::common::object_base *found_o = get_sub_object(o, descr);
        if (found_o)
        {       
                // although we don't modify any of the objects we visit, we do
                // need to return the actual object at the end, so
                // we cast out const.
                return const_cast<ph::common::object_base *>(found_o);
        }
        return 0;
}

static bool is_match_toggle_quotes(char i, char c, bool *inquotes)
{
        if (i == '\'' || i == '"')
                *inquotes = !*inquotes;
        else if (!*inquotes && i == c)
                return true;
        return false;
}

int jscript_object_navigator::find_span_quotes(const std::string &s, char c)
/*
        A simple find that can span quotes. This allows "." and "(" to appear in quotes.
*/
{
        // a proper std::find_if would be nice here, but this will only
        // work efficiently if this function returns an iterator.
        bool inquotes = false;
        for (int i = 0; i < (int)s.size(); i++)
                if (is_match_toggle_quotes(s[i], c, &inquotes))
                        return i;

        return -1;
}

void jscript_object_navigator::error(const std::string &msg, const std::string &name)
{
        if (!_silent)
                *_console << "Syntax Error. " + msg + " [" << name << "]" << std::endl;
}

static std::string get_name(const ph::common::object_base *obj)
{
        if (!obj->nameable())
                return "object has no nameable interface.";
        return obj->nameable()->name();
}

const ph::common::object_base *jscript_object_navigator::skip_composite(const ph::common::object_base *obj)
{
        // skip over composite
        if (obj->composition() && obj->composition()->composite())
                return go_parent(obj);
        else
                return obj;
}

const ph::common::object_base *jscript_object_navigator::go_parent(const ph::common::object_base *obj)
{
        if (obj->outerable())
                return obj->outerable()->outer();
        error(e_internal_no_outer_interface, get_name(obj));
        return 0;
}

const ph::common::object_base *jscript_object_navigator::get_composite(const ph::common::object_base *obj, const std::string &name)
{
        if (!obj->visitable())
        {
                error(e_internal_no_reflect_interface, get_name(obj));
                return 0;
        }
        
        // the property may be a composite object reference (they don't subscript).
        get_composite_object_visitor v(name);
        obj->visitable()->accept(&v);
        return v.obj();
}

const ph::common::object_base *jscript_object_navigator::get_obj(const ph::common::object_base *obj, const std::string &name)
{
        if (!obj->visitable())
        {
                error(e_internal_no_reflect_interface, get_name(obj));
                return 0;
        }
        
        get_object_visitor v(name);
        obj->visitable()->accept(&v);
        return v.obj();
}

const ph::common::object_base *jscript_object_navigator::get_nth_obj(const ph::common::object_base *obj, int n)
{
        if (!obj->visitable())
        {
                error(e_internal_no_reflect_interface, get_name(obj));
                return 0;
        }
        
        if (_debug)
                *_console << ">> getting [" << n << "]." << std::endl;

        get_nth_object_visitor v(n);
        obj->visitable()->accept(&v);
        return v.obj();
}

const ph::common::object_base *jscript_object_navigator::get_sub_object(
                        const ph::common::object_base *parent, const std::string &path)
{
        if (_debug)
                *_console << ">> searching [" << get_name(parent) << "] for [" << path << "]" << std::endl;
        int br = path.find('(');
        if (br >= 0 && path[path.length()-1] == ')')
        {
                // syntax was object(something)

                std::string prop = path.substr(0, br);
                std::string subs = path.substr(br+1, path.length() - br - 2);

                if (_debug)
                        *_console << ">> " << prop << "(" << subs << ")" << std::endl;
        
                // look at the special object references.
                if (subs.length() == 0)
                {
                        // syntax was object()
                        
                        if (prop == "root")
                        {
                                // root()
                                if (_debug)
                                        *_console << ">> returning root" << std::endl;
                                return _root;
                        }
                        else if (prop == "parent")
                        {
                                // parent()
                                const ph::common::object_base *obj = go_parent(parent);
                                if (!obj)
                                {
                                        error(e_internal_no_outer, prop);
                                        return 0;
                                }
                                
                                // skip over composite
                                obj = skip_composite(obj);

                                if (_debug)
                                        *_console << ">> returning [" << (obj ? get_name(obj) : "null") << "]" << std::endl;
                                        
                                return obj;
                        }
                        else
                        {
                                // see if the object to be found is a composite object, and if so return that.
                                if (_debug)
                                        *_console << ">> " << prop << std::endl;
                                        
                                const ph::common::object_base *c = get_composite(parent, prop);
                                if (!c)
                                {
                                        error(e_nobuiltin_or_composite, prop);
                                        return 0;
                                }

                                if (_debug)
                                        *_console << ">> returning [" << get_name(c) << "]" << std::endl;
                                return c;
                        }
                }
                else
                {
                        // syntax was object(subscript)
                        
                        if (prop == "parent")
                        {
                                // syntax was parent(subscript)
                                if (_debug)
                                        *_console << ">> parent(subscript)." << std::endl;
                        
                                // if the subscript has quotes around it, then use it as a string,
                                // otherwise it's a number.
                                if (subs[0] == '\'' && subs[subs.length()-1] == '\'')
                                {
                                        std::string parentname = subs.substr(1, subs.length()-2);
                                        bool found = false;
                                        const ph::common::object_base *pn = go_parent(parent);
                                        while (pn && !found)
                                        {
                                                if (get_name(pn) == parentname)
                                                        found = true;
                                                else
                                                        pn = go_parent(pn);
                                        }
                                        if (!found)
                                        {
                                                error(e_no_parent, parentname);
                                                return 0;
                                        }
                                        
                                        return pn;
                                }
                                else
                                {
                                        int count = boost::lexical_cast<long>(subs);
                                        const ph::common::object_base *pn = go_parent(parent);
                                        if (!pn)
                                        {
                                                error(e_internal_no_outer, subs);
                                                return 0;
                                        }
                                        
                                        // skip over composite
                                        pn = skip_composite(pn);
                                        while (pn && --count > 0)
                                        {
                                                pn = go_parent(pn);
                                                if (pn)
                                                        pn = skip_composite(pn);
                                        }
                                        
                                        if (!pn)
                                        {
                                                error(e_no_nth_parent, subs);
                                                return 0;
                                        }
                                        
                                        return pn;
                                }
                        }
                        else
                        {
                                // syntax was object(subscript)
                                if (_debug)
                                        *_console << ">> object(subscript)." << std::endl;

                                const ph::common::object_base *c = get_composite(parent, prop);
                                if (!c)
                                {
                                        error(e_no_composite, prop);
                                        return 0;
                                }
                                
                                // if the subscript has quotes around it, then use it as a string,
                                // otherwise it's a number.
                                if (subs[0] == '\'' && subs[subs.length()-1] == '\'')
                                {
                                        if (_debug)
                                                *_console << ">> object string subscript." << std::endl;

                                        const ph::common::object_base *obj = get_obj(c, subs.substr(1, subs.length()-2));
                                        if (!obj)
                                        {
                                                error(e_no_named_object, subs);
                                                return 0;
                                        }
                                        
                                        if (_debug)
                                                *_console << ">> returning [" << get_name(obj) << "]" << std::endl;
                                                
                                        return obj;
                                }
                                else
                                {
                                        if (_debug)
                                                *_console << ">> object nth subscript." << std::endl;
                                                
                                        // for the end user, we use 1 based subscripts.
                                        const ph::common::object_base *obj = get_nth_obj(c, boost::lexical_cast<long>(subs)-1);
                                        if (!obj)
                                        {
                                                error(e_no_nth_object, subs);
                                                return 0;
                                        }
                                        
                                        if (_debug)
                                                *_console << ">> returning [" << get_name(obj) << "]" << std::endl;
                                                
                                        if (obj->comparable() && obj->comparable()->equal(c))
                                                *_console << ">> object returned was same as composite?." << std::endl;
                                        
                                        return obj;
                                }
                        }
                }
        }
        else
        {
                // syntax was object.object. This will only work for singleton composites.
                if (_debug)
                        *_console << ">> " << path << std::endl;
                        
                // the property may be a composite object reference (they don't subscript).
                const ph::common::object_base *c = get_composite(parent, path);
                if (!c)
                {
                        error(e_no_composite, path);
                        return 0;
                }
                
                // if we have no composite interface, then it can't be a singleton composite.
                if (c->composition() && c->composition()->composite() && !c->composition()->composite()->singleton())
                {
                        error(e_not_singleton_composite, path);
                        return 0;
                }
                
                const ph::common::object_base *obj = get_nth_obj(c, 0);
                if (!obj)
                {
                        error(e_empty_singleton_composite, path);
                        return 0;
                }
                
                if (_debug)
                        *_console << ">> returning [" << get_name(obj) << "]" << std::endl;
                                        
                return  obj;
        }
        
        error(e_internal_get_sub_object_reached_end, path);
        return 0;
}

---