vpp-api/java/jvpp/gen/jvpp_callback_facade_gen.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2016 Cisco and/or its affiliates.
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 import os, util
  17 from string import Template
  18
  19 import callback_gen
  20 import dto_gen
  21
  22 jvpp_ifc_template = Template("""
  23 package $base_package.$callback_facade_package;
  24
  25 /**
  26  * <p>Callback Java API representation of vpe.api.
  27  * <br>It was generated by jvpp_callback_facade_gen.py based on $inputfile
  28  * <br>(python representation of vpe.api generated by vppapigen).
  29  */
  30 public interface CallbackJVpp extends java.lang.AutoCloseable {
  31
  32     @Override
  33     void close();
  34
  35     // TODO add send
  36
  37 $methods
  38 }
  39 """)
  40
  41 jvpp_impl_template = Template("""
  42 package $base_package.$callback_facade_package;
  43
  44 /**
  45  * <p>Default implementation of CallbackJVpp interface.
  46  * <br>It was generated by jvpp_callback_facade_gen.py based on $inputfile
  47  * <br>(python representation of vpe.api generated by vppapigen).
  48  */
  49 public final class CallbackJVppFacade implements $base_package.$callback_facade_package.CallbackJVpp {
  50
  51     private final $base_package.JVpp jvpp;
  52     private final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> callbacks;
  53
  54     public CallbackJVppFacade(final $base_package.JVpp jvpp,
  55                               java.util.Map<Integer, $base_package.$callback_package.JVppCallback> callbacks) {
  56         if(jvpp == null) {
  57             throw new java.lang.NullPointerException("jvpp is null");
  58         }
  59         this.jvpp = jvpp;
  60         this.callbacks = callbacks;
  61     }
  62
  63     @Override
  64     public void close() {
  65     }
  66
  67     // TODO add send()
  68
  69 $methods
  70 }
  71 """)
  72
  73 method_template = Template(
  74     """    void $name($base_package.$dto_package.$request request, $base_package.$callback_package.$callback callback);""")
  75 method_impl_template = Template("""    public final void $name($base_package.$dto_package.$request request, $base_package.$callback_package.$callback callback) {
  76         synchronized (callbacks) {
  77             callbacks.put(jvpp.$name(request), callback);
  78         }
  79     }
  80 """)
  81
  82 no_arg_method_template = Template("""    void $name($base_package.$callback_package.$callback callback);""")
  83 no_arg_method_impl_template = Template("""    public final void $name($base_package.$callback_package.$callback callback) {
  84         synchronized (callbacks) {
  85             callbacks.put(jvpp.$name(), callback);
  86         }
  87     }
  88 """)
  89
  90
  91 def generate_jvpp(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile):
  92     """ Generates callback facade """
  93     print "Generating JVpp callback facade"
  94
  95     if os.path.exists(callback_facade_package):
  96         util.remove_folder(callback_facade_package)
  97
  98     os.mkdir(callback_facade_package)
  99
 100     methods = []
 101     methods_impl = []
 102     for func in func_list:
 103
 104         if util.is_notification(func['name']) or util.is_ignored(func['name']):
 105             # TODO handle notifications
 106             continue
 107
 108         camel_case_name = util.underscore_to_camelcase(func['name'])
 109         camel_case_name_upper = util.underscore_to_camelcase_upper(func['name'])
 110         if util.is_reply(camel_case_name):
 111             continue
 112
 113         # Strip suffix for dump calls
 114         callback_type = get_request_name(camel_case_name_upper, func['name']) + callback_gen.callback_suffix
 115
 116         if len(func['args']) == 0:
 117             methods.append(no_arg_method_template.substitute(name=camel_case_name,
 118                                                              base_package=base_package,
 119                                                              dto_package=dto_package,
 120                                                              callback_package=callback_package,
 121                                                              callback=callback_type))
 122             methods_impl.append(no_arg_method_impl_template.substitute(name=camel_case_name,
 123                                                                        base_package=base_package,
 124                                                                        dto_package=dto_package,
 125                                                                        callback_package=callback_package,
 126                                                                        callback=callback_type))
 127         else:
 128             methods.append(method_template.substitute(name=camel_case_name,
 129                                                       request=camel_case_name_upper,
 130                                                       base_package=base_package,
 131                                                       dto_package=dto_package,
 132                                                       callback_package=callback_package,
 133                                                       callback=callback_type))
 134             methods_impl.append(method_impl_template.substitute(name=camel_case_name,
 135                                                                 request=camel_case_name_upper,
 136                                                                 base_package=base_package,
 137                                                                 dto_package=dto_package,
 138                                                                 callback_package=callback_package,
 139                                                                 callback=callback_type))
 140
 141     join = os.path.join(callback_facade_package, "CallbackJVpp.java")
 142     jvpp_file = open(join, 'w')
 143     jvpp_file.write(
 144         jvpp_ifc_template.substitute(inputfile=inputfile,
 145                                      methods="\n".join(methods),
 146                                      base_package=base_package,
 147                                      dto_package=dto_package,
 148                                      callback_facade_package=callback_facade_package))
 149     jvpp_file.flush()
 150     jvpp_file.close()
 151
 152     jvpp_file = open(os.path.join(callback_facade_package, "CallbackJVppFacade.java"), 'w')
 153     jvpp_file.write(jvpp_impl_template.substitute(inputfile=inputfile,
 154                                                   methods="\n".join(methods_impl),
 155                                                   base_package=base_package,
 156                                                   dto_package=dto_package,
 157                                                   callback_package=callback_package,
 158                                                   callback_facade_package=callback_facade_package))
 159     jvpp_file.flush()
 160     jvpp_file.close()
 161
 162     generate_callback(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile)
 163
 164
 165 jvpp_facade_callback_template = Template("""
 166 package $base_package.$callback_facade_package;
 167
 168 /**
 169  * <p>JVppGlobalCallback implementation for Java Callback API.
 170  * <br>It was generated by jvpp_callback_facade_gen.py based on $inputfile
 171  * <br>(python representation of vpe.api generated by vppapigen).
 172  */
 173 public final class CallbackJVppFacadeCallback implements $base_package.$callback_package.JVppGlobalCallback {
 174
 175     private final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> requests;
 176
 177     public CallbackJVppFacadeCallback(final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> requestMap) {
 178         this.requests = requestMap;
 179     }
 180
 181 $methods
 182 }
 183 """)
 184
 185 jvpp_facade_callback_method_template = Template("""
 186     @Override
 187     @SuppressWarnings("unchecked")
 188     public void on$callback_dto($base_package.$dto_package.$callback_dto reply) {
 189
 190         $base_package.$callback_package.$callback callback;
 191         synchronized(requests) {
 192             callback = ($base_package.$callback_package.$callback) requests.remove(reply.context);
 193         }
 194
 195         if(callback != null) {
 196             callback.on$callback_dto(reply);
 197         }
 198     }
 199 """)
 200
 201
 202 def generate_callback(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile):
 203     callbacks = []
 204     for func in func_list:
 205
 206         if util.is_notification(func['name']) or util.is_ignored(func['name']):
 207             # TODO handle notifications
 208             continue
 209
 210         camel_case_name_with_suffix = util.underscore_to_camelcase_upper(func['name'])
 211         if not util.is_reply(camel_case_name_with_suffix):
 212             continue
 213
 214         callbacks.append(jvpp_facade_callback_method_template.substitute(base_package=base_package,
 215                                                                          dto_package=dto_package,
 216                                                                          callback_package=callback_package,
 217                                                                          callback=util.remove_reply_suffix(camel_case_name_with_suffix) + callback_gen.callback_suffix,
 218                                                                          callback_dto=camel_case_name_with_suffix))
 219
 220     jvpp_file = open(os.path.join(callback_facade_package, "CallbackJVppFacadeCallback.java"), 'w')
 221     jvpp_file.write(jvpp_facade_callback_template.substitute(inputfile=inputfile,
 222                                                              base_package=base_package,
 223                                                              dto_package=dto_package,
 224                                                              callback_package=callback_package,
 225                                                              methods="".join(callbacks),
 226                                                              callback_facade_package=callback_facade_package))
 227     jvpp_file.flush()
 228     jvpp_file.close()
 229
 230
 231 # Returns request name or special one from unconventional_naming_rep_req map
 232 def get_request_name(camel_case_dto_name, func_name):
 233     if func_name in reverse_dict(util.unconventional_naming_rep_req):
 234         request_name = util.underscore_to_camelcase_upper(reverse_dict(util.unconventional_naming_rep_req)[func_name])
 235     else:
 236         request_name = camel_case_dto_name
 237     return remove_suffix(request_name)
 238
 239
 240 def reverse_dict(map):
 241     return dict((v, k) for k, v in map.iteritems())
 242
 243
 244 def remove_suffix(name):
 245     if util.is_reply(name):
 246         return util.remove_reply_suffix(name)
 247     else:
 248         if util.is_dump(name):
 249             return util.remove_suffix(name, util.dump_suffix)
 250         else:
 251             return name