gen_cpp.py

Go to the documentation of this file.

#!/usr/bin/env python
# Software License Agreement (BSD License)
#
# Copyright (c) 2010, Willow Garage, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above
#    copyright notice, this list of conditions and the following
#    disclaimer in the documentation and/or other materials provided
#    with the distribution.
#  * Neither the name of Willow Garage, Inc. nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#

import roslib; roslib.load_manifest('rve_interface_gen')
import roslib.packages
import rve_interface_gen.msgs as gen
import roslib.msgs as msgs
import roscpp.msg_gen as genmsg_cpp

from cStringIO import StringIO

import sys
import os

def write_header_begin(hs, i, pkg):
    print >> hs, '#ifndef INTERFACE_%s_%s_H'%(pkg.upper(), i.name.upper())
    print >> hs, '#define INTERFACE_%s_%s_H\n'%(pkg.upper(), i.name.upper())
    
def write_header_end(hs, i, pkg):
    print >> hs, '#endif // INTERFACE_%s_%s_H'%(pkg.upper(), i.name.upper())
    
def write_header_includes(hs, i, pkg):
    print >> hs, '#include <rve_interface_gen/interface.h>'
    print >> hs, '#include <ros/time.h>'
    print >> hs, '#include <ros/message_forward.h>'
    print >> hs, '#include <boost/function.hpp>'
    print >> hs, '#include <string>'
    
    headers = []
    for m in i.methods:
        for f in m.fields + m.return_fields:
            (base_type, is_array, array_len) = msgs.parse_type(f[0])
            if (is_array):
                raise RuntimeError("Arrays are not supported as parameter or return-values")
            
            if (not msgs.is_builtin(base_type)):
                resolved = msgs.resolve_type(base_type, pkg)
                headers.append(resolved)
                
    headers = set(headers)
    for h in headers:
        print >> hs, '#include <%s.h>'%(h)
    print >> hs

def msg_to_cpp(type):
    if (type == "string"):
        return 'std::string'
    elif (msgs.is_builtin(type)):
        return genmsg_cpp.msg_type_to_cpp(type)
    else:
        components = type.split('/')
        if (len(components) == 1):
            return '%s'%(components[0])
        else:
            ns = components[0]
            c = components[1]
            return '%s::%s'%(ns, c)
    
def write_header_forward_declarations(hs):
    print >> hs, 'namespace ros { class NodeHandle; }'
    print >> hs, 'namespace ros { template<typename M> class MessageEvent; }'
    print >> hs
    
def write_header_message_forward_declarations(hs, i):
    for m in i.methods:
        print >> hs, 'ROS_DECLARE_MESSAGE(%s_%sRequest);'%(i.name, m.name)
        print >> hs, 'ROS_DECLARE_MESSAGE(%s_%sResponse);'%(i.name, m.name)
        
    print >> hs
    
def normal_method_args(i, m, include_return_args = True):
    cpp_fields = []
    for f in m.fields:
        (type, _, _) = msgs.parse_type(f[0])
        name = f[1]
        
        cpp_type = msg_to_cpp(type)
        if (msgs.is_valid_constant_type(type) and type != "string"):
            cpp_fields.append('%s %s'%(cpp_type, name))
        else:
            cpp_fields.append('const %s& %s'%(cpp_type, name))
            
    if (include_return_args):
        for f in m.return_fields:
            (type, _, _) = msgs.parse_type(f[0])
            name = f[1]
            cpp_type = msg_to_cpp(type)
            cpp_fields.append('%s& out_%s'%(cpp_type, name))
        
    return cpp_fields
    
def normal_method_args_string(i, m, include_return_args = True):
    return ', '.join(normal_method_args(i, m, include_return_args))

def write_header_interface_declaration(hs, i, pkg):
    print >> hs, 'struct %s : public rve_interface_gen::Interface\n{'%(i.name)
    
    # Write virtual destructor
    print >> hs, '  virtual ~%s() {}'%(i.name)
    print >> hs
    
    for m in i.methods:
        print >> hs, '  typedef %s::%s_%sRequest %sRequest;'%(pkg, i.name, m.name, m.name)
        print >> hs, '  typedef boost::shared_ptr<%sRequest> %sRequestPtr;'%(m.name, m.name)
        print >> hs, '  typedef boost::shared_ptr<%sRequest const> %sRequestConstPtr;'%(m.name, m.name)
        print >> hs, '  typedef %s::%s_%sResponse %sResponse;'%(pkg, i.name, m.name, m.name)
        print >> hs, '  typedef boost::shared_ptr<%sResponse> %sResponsePtr;'%(m.name, m.name)
        print >> hs, '  typedef boost::shared_ptr<%sResponse const> %sResponseConstPtr;'%(m.name, m.name)
        print >> hs, '  typedef rve_rpc::CallHandle<%sRequest, %sResponse> %sHandle;'%(m.name, m.name, m.name)
        print >> hs, '  typedef rve_rpc::MethodResponse<%sResponse> %sMethodResponse;'%(m.name, m.name)
        print >> hs, '  typedef boost::function<void(const %sMethodResponse&)> %sResponseCallback;'%(m.name, m.name)
        print >> hs
    
    print >> hs, '};\n'
    
def write_header_proxy_declaration(hs, i, pkg):
    print >> hs, 'struct %sProxy : public %s\n{'%(i.name, i.name)
    
    print >> hs, '  %sProxy(rve_rpc::Client& client);'%(i.name)
    
    for m in i.methods:
        # first way to call, of the form:
        # void <name>(arg0, arg1, ..., return_arg0&, return_arg1&, ...)
        print >> hs, '  void %s(%s);'%(m.name, normal_method_args_string(i, m))
        # second way to call, with asynchronous return of the form:
        # void <name>Async(arg0, arg1, ..., <name>ResponseCallback)
        print >> hs, '  void %sAsync(%s);'%(m.name, ', '.join(normal_method_args(i, m, False) + ['const %sResponseCallback& cb'%m.name]))
        # third way to call, with "fast" call/response, of the form:
        # <name>ResponseConstPtr <name>(<name>RequestConstPtr)
        print >> hs, '  %sResponseConstPtr %s(const %sRequestConstPtr& in);'%(m.name, m.name, m.name)
        # fourth way to call, with "fast" call and asynchronous response, of the form:
        # void <name>Async(<name>RequestConstPtr, <name>ResponseCallback)
        print >> hs, '  void %sAsync(const %sRequestConstPtr& in, const %sResponseCallback& cb);'%(m.name, m.name, m.name)
        
        # if there are no return args, provide a fifth and sixth ways to call:
        # void <name>Async(arg0, arg1, ...)
        # void <name>Async(<name>RequestConstPtr)    
        if (len(m.return_fields) == 0):
            print >> hs, '  void %sAsync(%s);'%(m.name, normal_method_args_string(i, m))
            print >> hs, '  void %sAsync(const %sRequestConstPtr& req);'%(m.name, m.name)
        
    print >> hs, 'private:'
    print >> hs, '  struct Impl;'
    print >> hs, '  typedef boost::shared_ptr<Impl> ImplPtr;'
    print >> hs, '  ImplPtr impl_;'
    
    print >> hs, '};\n'
    
def write_header_server_declaration(hs, i, pkg):
    print >> hs, 'struct %sServer : public %s\n{'%(i.name, i.name)
    
    print >> hs, '  %sServer(rve_rpc::Server& server);'%(i.name)
    
    for m in i.methods:
        print >> hs, '  virtual void %s(%s) {ROS_BREAK();}'%(m.name, normal_method_args_string(i, m))
        print >> hs, '  virtual void %s(%sHandle& handle);'%(m.name, m.name)
        
    print >> hs, 'private:'
    print >> hs, '  struct Impl;'
    print >> hs, '  typedef boost::shared_ptr<Impl> ImplPtr;'
    print >> hs, '  ImplPtr impl_;'
    
    print >> hs, '};\n'
    
    
def write_cpp_includes(cpps, i, pkg):
    print >> cpps, '#include <%s/%s.h>'%(pkg, i.name)
    print >> cpps, '#include <rve_rpc/client.h>'
    print >> cpps, '#include <rve_rpc/server.h>'
    
    for m in i.methods:
        print >> cpps, '#include <%s/%s_%sRequest.h>'%(pkg, i.name, m.name)
        print >> cpps, '#include <%s/%s_%sResponse.h>'%(pkg, i.name, m.name)
        
    print >> cpps
    print >> cpps, 'using namespace %s;\n'%(pkg)

def write_cpp_proxy_methods(cpps, i, m, pkg):
    # first way to call, of the form:
    # void <name>(arg0, arg1, ..., return_arg0&, return_arg1&, ...)
    print >> cpps, 'void %sProxy::%s(%s)\n{'%(i.name, m.name, normal_method_args_string(i, m))
    print >> cpps, '  %sRequestPtr req(new %sRequest);'%(m.name, m.name)
    for field in m.fields:
        print >> cpps, '  req->%s = %s;'%(field[1], field[1])
    print >> cpps, '  %sResponseConstPtr res = impl_->%s_method_.call(req);'%(m.name, m.name)
    for field in m.return_fields:
        print >> cpps, '  out_%s = res->%s;'%(field[1], field[1])
    print >> cpps, '}\n'
    
    # second way to call, with asynchronous return of the form:
    # void <name>Async(arg0, arg1, ..., <name>ResponseCallback)
    print >> cpps, 'void %sProxy::%sAsync(%s)\n{'%(i.name, m.name, ', '.join(normal_method_args(i, m, False) + ['const %sResponseCallback& cb'%m.name]))
    print >> cpps, '  %sRequestPtr req(new %sRequest);'%(m.name, m.name)
    for field in m.fields:
        print >> cpps, '  req->%s = %s;'%(field[1], field[1])
    print >> cpps, '  impl_->%s_method_.callAsync(req, cb);'%(m.name)
    print >> cpps, '}\n'
    
    # third way to call, with "fast" call/response, of the form:
    # <name>ResponseConstPtr <name>(<name>RequestConstPtr)
    print >> cpps, '%s::%sResponseConstPtr %sProxy::%s(const %sRequestConstPtr& in)\n{'%(i.name, m.name, i.name, m.name, m.name)
    print >> cpps, '  return impl_->%s_method_.call(in);'%(m.name)
    print >> cpps, '}\n'
    
    # fourth way to call, with "fast" call and asynchronous response, of the form:
    # void <name>Async(<name>RequestConstPtr, <name>ResponseCallback)
    print >> cpps, 'void %sProxy::%sAsync(const %sRequestConstPtr& in, const %sResponseCallback& cb)\n{'%(i.name, m.name, m.name, m.name)
    print >> cpps, '  impl_->%s_method_.callAsync(in, cb);'%(m.name)
    print >> cpps, '}\n'
    
    # if there are no return args, provide fifth and sixth ways to call:
    # void <name>Async(arg0, arg1, ...)
    # void <name>Async(<name>RequestConstPtr) 
    if (len(m.return_fields) == 0):
        print >> cpps, 'void %sProxy::%sAsync(%s)\n{'%(i.name, m.name, normal_method_args_string(i, m))
        print >> cpps, '  %sRequestPtr req(new %sRequest);'%(m.name, m.name)
        for field in m.fields:
            print >> cpps, '  req->%s = %s;'%(field[1], field[1])
        print >> cpps, '  impl_->%s_method_.callAsync(req, %sResponseCallback());'%(m.name, m.name)
        print >> cpps, '}\n'
        
        print >> cpps, 'void %sProxy::%sAsync(const %sRequestConstPtr& in)\n{'%(i.name, m.name, m.name)
        print >> cpps, '  impl_->%s_method_.callAsync(in, %sResponseCallback());'%(m.name, m.name)
        print >> cpps, '}\n'
        

def write_cpp_proxy_definition(cpps, i, pkg):    
    print >> cpps, 'struct %sProxy::Impl\n{'%(i.name)
    print >> cpps, """ 
  Impl(rve_rpc::Client& client)
  : client_(client)
  {
  }
"""

    print >> cpps, '  rve_rpc::Client client_;'
    for m in i.methods:
        print >> cpps, '  rve_rpc::Method<%sRequest, %sResponse> %s_method_;'%(m.name, m.name, m.name)
    print >> cpps, '};\n'
    
    print >> cpps, '%sProxy::%sProxy(rve_rpc::Client& client)'%(i.name, i.name)
    print >> cpps, ': impl_(new Impl(client))\n{'
    for m in i.methods:
        print >> cpps, '  impl_->%s_method_ = impl_->client_.addMethod<%sRequest, %sResponse>("%s_%s_%s");'%(m.name, m.name, m.name, pkg, i.name, m.name)

    print >> cpps, '}\n'
    
    for m in i.methods:
        write_cpp_proxy_methods(cpps, i, m, pkg)
        
def write_cpp_server_definition(cpps, i, pkg):
    for m in i.methods:
        print >> cpps, '  void %sServer::%s(%sHandle& handle)\n  {'%(i.name, m.name, m.name)
        # prevent warning about unused variable 'req'
        if (len(m.fields) > 0):
            print >> cpps, '    const %sRequestConstPtr& req = handle.getRequest();'%(m.name)
        print >> cpps, '    %sResponsePtr res(new %sResponse);'%(m.name, m.name)
        print >> cpps, '    this->%s('%(m.name),
        print >> cpps, ', '.join([f for f in (', '.join(['req->%s'%(f[1]) for f in m.fields]), ', '.join(['res->%s'%(f[1]) for f in m.return_fields])) if len(f) > 0]),
        print >> cpps, ');\n'
        print >> cpps, '    handle.respond(res);'
        print >> cpps, '  }'
    
    print >> cpps, 'struct %sServer::Impl\n{'%(i.name)
    print >> cpps, """
  Impl(rve_rpc::Server& server, %sServer* parent)
  : server_(server)
  , parent_(parent)
  {
  }
"""%(i.name)

    for m in i.methods:
        print >> cpps, '  void %s_callback(%sHandle& handle)\n  {'%(m.name, m.name)
        print >> cpps, '    parent_->%s(handle);'%(m.name)
        print >> cpps, '  }'

    print >> cpps
    print >> cpps, '  rve_rpc::Server server_;'
    print >> cpps, '  %sServer* parent_;'%(i.name)
    print >> cpps, '};\n'
    
    print >> cpps, '%sServer::%sServer(rve_rpc::Server& server)'%(i.name, i.name)
    print >> cpps, ': impl_(new Impl(server, this))'
    print >> cpps, '{'
    for m in i.methods:
        print >> cpps, '  impl_->server_.addMethod<%sRequest, %sResponse>("%s_%s_%s", boost::bind(&Impl::%s_callback, impl_.get(), _1));'%(m.name, m.name, pkg, i.name, m.name, m.name)
    print >> cpps, '}'
    

def generate(output_dir, i, pkg, pkg_path):
    hs = StringIO()
    cpps = StringIO()
    
    write_header_begin(hs, i, pkg)
    write_header_includes(hs, i, pkg)
    
    write_header_forward_declarations(hs)
    
    print >> hs, 'namespace %s\n{\n'%(pkg)
    
    write_header_message_forward_declarations(hs, i)
    write_header_interface_declaration(hs, i, pkg)
    write_header_proxy_declaration(hs, i, pkg)
    write_header_server_declaration(hs, i, pkg)
    
    print >> hs, '}\n'
    
    write_header_end(hs, i, pkg)
    
    write_cpp_includes(cpps, i, pkg)
    write_cpp_proxy_definition(cpps, i, pkg)
    write_cpp_server_definition(cpps, i, pkg)
    
    header_dir = '%s/include/%s'%(output_dir, pkg)
    cpp_dir = '%s/src'%(output_dir)
    try:
        os.makedirs(header_dir)
    except OSError, e:
        pass
    try:
        os.makedirs(cpp_dir)
    except OSError, e:
        pass
         
    f = open('%s/%s.h'%(header_dir, i.name), 'w')
    print >> f, hs.getvalue()
    f.close()
    
    f = open('%s/%s.cpp'%(cpp_dir, i.name), 'w')
    print >> f, cpps.getvalue()
    f.close()

if __name__ == "__main__":
    input = sys.argv[1]
    output_dir = sys.argv[2]
        
    (package_dir, package) = roslib.packages.get_dir_pkg(input)
    p = gen.load_from_file(input)
    for i in p.interfaces:
        generate(output_dir, i, package, package_dir)