Switch String to AbstractString

Author: jdlangs

src/gentypes.jl

@@ -11,7 +11,7 @@ type ROSPackage
     name::ASCIIString
     msg::ROSModule
     srv::ROSModule
-    function ROSPackage(pkgname::String)
+    function ROSPackage(pkgname::ASCIIString)
         pkg = new(pkgname)
         pkg.msg = ROSMsgModule(pkg)
         pkg.srv = ROSSrvModule(pkg)
@@ -110,7 +110,7 @@ function _pkgtype_import(input::Expr)
     return ps,msb,ts
 end
 #Import a set of types from a single package
-function _usepkg(package::String, ismsg::Bool, names::String...)
+function _usepkg(package::ASCIIString, ismsg::Bool, names::ASCIIString...)
     global _rospy_imports
     if ! haskey(_rospy_imports, package)
         @debug("Creating new package: ",package,".", ismsg ? "msg" : "srv") 
@@ -148,7 +148,7 @@ cleartypes() = error("cleartypes() renamed to rostypereset()")
 
 #Populate the module with a new message type. Import and add dependencies first
 #so they will appear first in the generated code.
-function addtype!(mod::ROSMsgModule, typ::String)
+function addtype!(mod::ROSMsgModule, typ::ASCIIString)
     global _rospy_objects
     if !(typ in mod.members)
         @debug("Message type import: ", _fullname(mod), ".", typ)
@@ -164,7 +164,7 @@ end
 
 #Populate the module with a new service type. Import and add dependencies
 #first.
-function addtype!(mod::ROSSrvModule, typ::String)
+function addtype!(mod::ROSSrvModule, typ::ASCIIString)
     global _rospy_objects
     if !(typ in mod.members)
         @debug("Service type import: ", _fullname(mod), ".", typ)
@@ -190,7 +190,7 @@ function addtype!(mod::ROSSrvModule, typ::String)
 end
 
 #Return the python module and python object for a particular type
-function _pyvars(modname::String, typ::String)
+function _pyvars(modname::ASCIIString, typ::ASCIIString)
     pymod = _import_rospy_pkg(modname)
     pyobj =
         try pymod[typ]
@@ -234,7 +234,7 @@ function _importdeps!(mod::ROSModule, deps::Vector)
 end
 
 #Bring in the python modules as needed
-function _import_rospy_pkg(package::String)
+function _import_rospy_pkg(package::ASCIIString)
     global _rospy_modules
     if ! haskey(_rospy_modules, package)
         @debug("Importing python package: ", package)
@@ -352,7 +352,7 @@ function _exportexpr(mod::ROSSrvModule)
 end
 
 #All the generated code for a generated message type
-function buildtype(mod::ROSMsgModule, typename::String)
+function buildtype(mod::ROSMsgModule, typename::ASCIIString)
     global _rospy_objects
     fulltypestr = _rostypestr(mod, typename)
     pyobj = _rospy_objects[fulltypestr]
@@ -370,7 +370,7 @@ end
 
 #All the generated code for a generated service type
 #Will create 3 different composite types.
-function buildtype(mod::ROSSrvModule, typename::String)
+function buildtype(mod::ROSSrvModule, typename::ASCIIString)
     global _rospy_objects
 
     req_typestr = _rostypestr(mod, string(typename,"Request"))
@@ -407,7 +407,7 @@ end
 # (2) Default outer constructer with no arguments
 # (3) convert(PyObject, ...)
 # (4) convert(..., o::PyObject)
-function typecode(rosname::String, super::Symbol, members::Vector)
+function typecode(rosname::ASCIIString, super::Symbol, members::Vector)
     tname = _splittypestr(rosname)[2]
     @debug("Type: ", tname)
     tsym = symbol(tname)
@@ -522,11 +522,11 @@ end
 
 #Build a String => Iterable{String} object from the individual package
 #dependencies.
-function _collectdeps{S<:String}(pkgs::Dict{S, ROSPackage})
-    deps = Dict{ASCIIString, Set{ASCIIString}}()
+function _collectdeps{S<:AbstractString}(pkgs::Dict{S, ROSPackage})
+    deps = Dict{S, Set{S}}()
     for pname in keys(pkgs)
         if ! haskey(deps, pname)
-            deps[pname] = Set{ASCIIString}()
+            deps[pname] = Set{S}()
         end
         union!(deps[pname], pkgs[pname].msg.deps)
         union!(deps[pname], pkgs[pname].srv.deps)
@@ -557,36 +557,36 @@ function _order(d::Dict)
     tlist
 end
 
-_rostypestr(mod::ROSModule, name::String) = string(_name(mod),"/",name)
-function _splittypestr(typestr::String)
+_rostypestr(mod::ROSModule, name::ASCIIString) = string(_name(mod),"/",name)
+function _splittypestr(typestr::ASCIIString)
     if ! _isrostype(typestr)
         error(string("Invalid message type '$typestr', ",
                      "use 'package_name/type_name'"))
     end
-    rospkg, typ = split(typestr, '/')
+    rospkg, typ = map(ascii, split(typestr, '/'))
     rospkg, typ
 end
 #Valid ROS type string is all word chars split by a single forward slash, with
 #optional square brackets for array types
-_isrostype(s::String) = ismatch(r"^\w+/\w+(?:\[\d*\])?$", s)
+_isrostype(s::ASCIIString) = ismatch(r"^\w+/\w+(?:\[\d*\])?$", s)
 
 #Sanitize a string by checking for and removing brackets if they are present
 #Return the sanitized type and the number inside the brackets if it is a fixed
 #size type. Returns 0 if variable size (no number), -1 if no brackets
-function _check_array_type(typ::String)
+function _check_array_type(typ::ASCIIString)
     arraylen = -1
     m = match(r"^([\w/]+)\[(\d*)\]$", typ)
     if m != nothing
         btype = m.captures[1]
         if isempty(m.captures[2])
             arraylen = 0
         else
-            arraylen = int(m.captures[2])
+            arraylen = parse(Int, m.captures[2])
         end
     else
         btype = typ
     end
-    btype, arraylen
+    ascii(btype), arraylen
 end
 
 #Get the rospy PyObject corresponding to a generated type
@@ -607,7 +607,7 @@ end
 
 #Check if the type name conflicts with a Julia builtin. Currently this is only
 #some of the messages from the std_msgs.msg package
-_nameconflicts(typename::String) = isdefined(Base, symbol(typename))
+_nameconflicts(typename::ASCIIString) = isdefined(Base, symbol(typename))
 
 #Get a default value for any builtin ROS type
 _typedefault{T<:Real}(::Type{T}) = zero(T)

src/pubsub.jl

@@ -4,14 +4,14 @@ export Publisher, Subscriber, publish
 type Publisher{MsgType<:MsgT}
     o::PyObject
 
-    function Publisher(topic::String; kwargs...)
+    function Publisher(topic::AbstractString; kwargs...)
         @debug("Creating <$(string(MsgType))> publisher on topic: '$topic'")
         rospycls = _get_rospy_class(MsgType)
-        return new(__rospy__[:Publisher](topic, rospycls; kwargs...))
+        return new(__rospy__[:Publisher](ascii(topic), rospycls; kwargs...))
     end
 end
-Publisher{MsgType<:MsgT}(topic::String, ::Type{MsgType}; kwargs...) =
-    Publisher{MsgType}(topic; kwargs...)
+Publisher{MsgType<:MsgT}(topic::AbstractString, ::Type{MsgType}; kwargs...) =
+    Publisher{MsgType}(ascii(topic); kwargs...)
 
 function publish{MsgType<:MsgT}(p::Publisher{MsgType}, msg::MsgType)
     pycall(p.o["publish"], PyAny, convert(PyObject, msg))
@@ -22,21 +22,21 @@ type Subscriber{MsgType<:MsgT}
     callback
 
     function Subscriber(
-        topic::String, cb, cb_args::Tuple=(); kwargs...
+        topic::AbstractString, cb, cb_args::Tuple=(); kwargs...
     )
         @debug("Creating <$(string(MsgType))> subscriber on topic: '$topic'")
         rospycls = _get_rospy_class(MsgType)
-        jl_callback(msg::PyObject) = cb(convert(MsgType, msg), cb_args...)
+        jl_cb(msg::PyObject) = cb(convert(MsgType, msg), cb_args...)
         return new(
-            __rospy__[:Subscriber](topic, rospycls, jl_callback; kwargs...),
-            jl_callback
+            __rospy__[:Subscriber](ascii(topic), rospycls, jl_cb; kwargs...),
+            jl_cb
         )
     end
 end
 Subscriber{MsgType<:MsgT}(
-    topic::String,
+    topic::AbstractString,
     ::Type{MsgType},
     cb,
     cb_args::Tuple=();
     kwargs...
-) = Subscriber{MsgType}(topic, cb, cb_args; kwargs...)
+) = Subscriber{MsgType}(ascii(topic), cb, cb_args; kwargs...)

src/rospy.jl

@@ -4,35 +4,39 @@ export init_node, is_shutdown, spin,
        logdebug, loginfo, logwarn, logerr, logfatal
 
 #General rospy functions
-init_node(name::String; args...) = __rospy__[:init_node](name; args...)
+init_node(name::AbstractString; args...) =
+    __rospy__[:init_node](ascii(name); args...)
 spin()                 = __rospy__[:spin]()
 is_shutdown()          = __rospy__[:is_shutdown]()
 get_published_topics() = __rospy__[:get_published_topics]()
 get_ros_root()         = __rospy__[:get_ros_root]()
 
 #Parameter server API
-get_param(param_name::String, def=nothing) = begin
+function get_param(param_name::AbstractString, def=nothing)
     try
         if def == nothing
-            __rospy__[:get_param](param_name)
+            __rospy__[:get_param](ascii(param_name))
         else
-            __rospy__[:get_param](param_name, def)
+            __rospy__[:get_param](ascii(param_name), def)
         end
     catch ex
         throw(KeyError(pycall(pybuiltin("str"), PyAny, ex.val)[2:end-1]))
     end
 end
-set_param(param_name::String, val) = __rospy__[:set_param](param_name, val)
-has_param(param_name::String) = __rospy__[:has_param](param_name)
-delete_param(param_name::String) = begin
+set_param(param_name::AbstractString, val) =
+    __rospy__[:set_param](ascii(param_name), val)
+has_param(param_name::AbstractString) =
+    __rospy__[:has_param](ascii(param_name))
+function delete_param(param_name::AbstractString)
     try
-        __rospy__[:delete_param](param_name)
+        __rospy__[:delete_param](ascii(param_name))
     catch ex
         throw(KeyError(pycall(pybuiltin("str"), PyAny, ex.val)[2:end-1]))
     end
 end
 #Doesn't work for some reason
-#rospy_search_param(param_name::String) = __rospy__[:rospy_search_param](param_name)
+#rospy_search_param(param_name::AbstractString) =
+#    __rospy__[:rospy_search_param](ascii(param_name))
 get_param_names() = __rospy__[:get_param_names]()
 
 #Logging API

src/services.jl

@@ -9,23 +9,23 @@ end
 
 type ServiceProxy{SrvType <: ServiceDefinition}
     o::PyObject
-    
-    function ServiceProxy(name::String; kwargs...)
+
+    function ServiceProxy(name::AbstractString; kwargs...)
         @debug("Creating <$SrvType> service proxy for '$name'")
         rospycls = _get_rospy_class(SrvType)
-        new(__rospy__[:ServiceProxy](name, rospycls; kwargs...))
+        new(__rospy__[:ServiceProxy](ascii(name), rospycls; kwargs...))
     end
 end
 function ServiceProxy{SrvType<:ServiceDefinition}(
-    name::String, 
-    srv::Type{SrvType}; 
+    name::AbstractString,
+    srv::Type{SrvType};
     kwargs...
 )
-    ServiceProxy{SrvType}(name; kwargs...)
+    ServiceProxy{SrvType}(ascii(name); kwargs...)
 end
 
 function call{SrvType <: ServiceDefinition}(
-    srv::ServiceProxy{SrvType}, 
+    srv::ServiceProxy{SrvType},
     req::SrvT
 )
     if ! isa(req, _srv_reqtype(SrvType))
@@ -41,15 +41,15 @@ type Service{SrvType <: ServiceDefinition}
     o::PyObject
     jl_handler
 
-    function Service(name::String, handler; kwargs...)
+    function Service(name::AbstractString, handler; kwargs...)
         @debug("Providing <$SrvType> service at '$name'")
         rospycls = _get_rospy_class(SrvType)
         ReqType = _srv_reqtype(SrvType)
-        jl_handler(req::PyObject) =
+        jl_hndl(req::PyObject) =
             convert(PyObject, handler(convert(ReqType,req)))
         try
-            new(__rospy__[:Service](name, rospycls, jl_handler; kwargs...),
-                jl_handler
+            new(__rospy__[:Service](ascii(name), rospycls, jl_hndl; kwargs...),
+                jl_hndl
             )
         catch err
             if isa(err, PyCall.PyError)
@@ -61,17 +61,17 @@ type Service{SrvType <: ServiceDefinition}
     end
 end
 function Service{SrvType<:ServiceDefinition}(
-    name::String,
+    name::AbstractString,
     srv::Type{SrvType},
     handler;
     kwargs...
 )
-    Service{SrvType}(name, handler; kwargs...)
+    Service{SrvType}(ascii(name), handler; kwargs...)
 end
 
-function wait_for_service(service::String; kwargs...)
+function wait_for_service(service::AbstractString; kwargs...)
     try
-        __rospy__[:wait_for_service](service; kwargs...)
+        __rospy__[:wait_for_service](ascii(service); kwargs...)
     catch ex
         error("Timeout exceeded waiting for service '$service'")
     end