Beispiel #1
0
 def __init__(self, ns, filename, parent=None, params=None, env_args=None, \
                  resolve_dict=None, include_resolve_dict=None, arg_names=None):
     """
     @param ns: namespace
     @type  ns: str
     @param filename: name of file this is being loaded from
     @type  filename: str
     @param resolve_dict: (optional) resolution dictionary for substitution args
     @type  resolve_dict: dict
     @param include_resolve_dict: special resolution dictionary for
     <include> tags. Must be None if this is not an <include>
     context.
     @type include_resolve_dict: dict
     @param arg_names: name of args that have been declared in this context
     @type  arg_names: [str]
     """
     self.parent = parent
     self.ns = make_global_ns(ns or '/')
     self._remap_args = []
     self.params = params or []
     self.env_args = env_args or []
     self.filename = filename
     # for substitution args
     self.resolve_dict = resolve_dict or {}
     # arg names. Args that have been declared in this context
     self.arg_names = arg_names or []
     # special scoped resolve dict for processing in <include> tag
     self.include_resolve_dict = include_resolve_dict or None
Beispiel #2
0
 def __init__(self, ns, filename, parent=None, params=None, env_args=None, \
                  resolve_dict=None, include_resolve_dict=None, arg_names=None):
     """
     @param ns: namespace
     @type  ns: str
     @param filename: name of file this is being loaded from
     @type  filename: str
     @param resolve_dict: (optional) resolution dictionary for substitution args
     @type  resolve_dict: dict
     @param include_resolve_dict: special resolution dictionary for
     <include> tags. Must be None if this is not an <include>
     context.
     @type include_resolve_dict: dict
     @param arg_names: name of args that have been declared in this context
     @type  arg_names: [str]
     """
     self.parent = parent
     self.ns = make_global_ns(ns or '/')
     self._remap_args = []
     self.params = params or []
     self.env_args = env_args or []
     self.filename = filename
     # for substitution args
     self.resolve_dict = resolve_dict or {}
     # arg names. Args that have been declared in this context
     self.arg_names = arg_names or []
     # special scoped resolve dict for processing in <include> tag
     self.include_resolve_dict = include_resolve_dict or None
     # when this context was created via include, was pass_all_args set?
     self.pass_all_args = False
Beispiel #3
0
 def _ns_clear_params_attr(self,
                           tag_name,
                           tag,
                           context,
                           ros_config,
                           node_name=None,
                           include_filename=None):
     """
     Common processing routine for xml tags with NS and CLEAR_PARAMS attributes
     
     @param tag: DOM Node
     @type  tag: Node
     @param context: current namespace context 
     @type  context: LoaderContext
     @param clear_params: list of params to clear
     @type  clear_params: [str]
     @param node_name: name of node (for use when tag_name == 'node')
     @type  node_name: str
     @param include_filename: <include> filename if this is an <include> tag. If specified, context will use include rules.
     @type  include_filename: str
     @return: loader context 
     @rtype:  L{LoaderContext}
     """
     if tag.hasAttribute(NS):
         ns = self.resolve_args(tag.getAttribute(NS), context)
         if not ns:
             raise XmlParseException(
                 "<%s> tag has an empty '%s' attribute" % (tag_name, NS))
     else:
         ns = None
     if include_filename is not None:
         child_ns = context.include_child(ns, include_filename)
     else:
         child_ns = context.child(ns)
     clear_p = self.resolve_args(tag.getAttribute(CLEAR_PARAMS), context)
     if clear_p:
         clear_p = _bool_attr(clear_p, False, 'clear_params')
         if clear_p:
             if tag_name == 'node':
                 if not node_name:
                     raise XmlParseException(
                         "<%s> tag must have a 'name' attribute to use '%s' attribute"
                         % (tag_name, CLEAR_PARAMS))
                 # use make_global_ns to give trailing slash in order to be consistent with XmlContext.ns
                 ros_config.add_clear_param(
                     make_global_ns(ns_join(child_ns.ns, node_name)))
             else:
                 if not ns:
                     raise XmlParseException(
                         "'ns' attribute must be set in order to use 'clear_params'"
                     )
                 ros_config.add_clear_param(child_ns.ns)
     return child_ns
def list_params(ns):
    """
    Get list of parameters in ns

    :param ns: namespace to match, ``str``
    """
    try:
        ns = make_global_ns(ns)
        names = get_param_server().getParamNames()
        names.sort()
        return [n for n in names if n.startswith(ns)]
    except socket.error:
        raise RosParamIOException("Unable to communicate with master!")
Beispiel #5
0
def list_params(ns):
    """
    Get list of parameters in ns

    :param ns: namespace to match, ``str``
    """
    try:
        ns = make_global_ns(ns)
        names = get_param_server().getParamNames()
        names.sort()
        return [n for n in names if n.startswith(ns)]
    except socket.error:
        raise RosParamIOException("Unable to communicate with master!")
Beispiel #6
0
def test_make_global_ns():
    from rosgraph.names import make_global_ns

    for n in ['~foo']:
        try:
            make_global_ns(n)
            assert False, "make_global_ns should fail on %s"%n
        except ValueError: pass

    assert '/foo/' == make_global_ns('foo')
    assert '/' == make_global_ns('')
    assert '/foo/' == make_global_ns('/foo')
    assert '/foo/' == make_global_ns('/foo/')
    assert '/foo/bar/' == make_global_ns('/foo/bar')
    assert '/foo/bar/' == make_global_ns('/foo/bar/')
Beispiel #7
0
def test_make_global_ns():
    from rosgraph.names import make_global_ns

    for n in ['~foo']:
        try:
            make_global_ns(n)
            assert False, "make_global_ns should fail on %s" % n
        except ValueError:
            pass

    assert '/foo/' == make_global_ns('foo')
    assert '/' == make_global_ns('')
    assert '/foo/' == make_global_ns('/foo')
    assert '/foo/' == make_global_ns('/foo/')
    assert '/foo/bar/' == make_global_ns('/foo/bar')
    assert '/foo/bar/' == make_global_ns('/foo/bar/')
Beispiel #8
0
 def _set_param(self, ctx, my_state, test_vals, param_server):
     ctx = make_global_ns(ctx)
     for type, vals in test_vals:
         try:
             caller_id = ns_join(ctx, "node")
             count = 0
             for val in vals:
                 key = ns_join(caller_id, "%s-%s"%(type,count))
                 param_server.set_param(key, val)
                 self.assert_(param_server.has_param(key))
                 true_key = ns_join(ctx, key)
                 my_state[true_key] = val
                 count += 1
         except Exception:
             assert "getParam failed on type[%s], val[%s]"%(type,val)
 def _ns_clear_params_attr(self, tag_name, tag, context, ros_config, node_name=None, include_filename=None):
     """
     Common processing routine for xml tags with NS and CLEAR_PARAMS attributes
     
     @param tag: DOM Node
     @type  tag: Node
     @param context: current namespace context 
     @type  context: LoaderContext
     @param clear_params: list of params to clear
     @type  clear_params: [str]
     @param node_name: name of node (for use when tag_name == 'node')
     @type  node_name: str
     @param include_filename: <include> filename if this is an <include> tag. If specified, context will use include rules.
     @type  include_filename: str
     @return: loader context 
     @rtype:  L{LoaderContext}
     """
     if tag.hasAttribute(NS):
         ns = self.resolve_args(tag.getAttribute(NS), context)
         if not ns:
             raise XmlParseException("<%s> tag has an empty '%s' attribute"%(tag_name, NS))
     else:
         ns = None
     if include_filename is not None:
         child_ns = context.include_child(ns, include_filename)
     else:
         child_ns = context.child(ns)
     clear_p = self.resolve_args(tag.getAttribute(CLEAR_PARAMS), context)
     if clear_p:
         clear_p = _bool_attr(clear_p, False, 'clear_params')
         if clear_p:
             if tag_name == 'node':
                 if not node_name:
                     raise XmlParseException("<%s> tag must have a 'name' attribute to use '%s' attribute"%(tag_name, CLEAR_PARAMS))
                 # use make_global_ns to give trailing slash in order to be consistent with XmlContext.ns
                 ros_config.add_clear_param(make_global_ns(ns_join(child_ns.ns, node_name)))
             else:
                 if not ns:
                     raise XmlParseException("'ns' attribute must be set in order to use 'clear_params'")                
                 ros_config.add_clear_param(child_ns.ns)
     return child_ns