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         this.jvpp = java.util.Objects.requireNonNull(jvpp,"jvpp is null");
  57         this.callbacks = callbacks;
  58     }
  59
  60     @Override
  61     public void close() {
  62     }
  63
  64     // TODO add send()
  65
  66 $methods
  67 }
  68 """)
  69
  70 method_template = Template(
  71     """    void $name($base_package.$dto_package.$request request, $base_package.$callback_package.$callback callback);""")
  72 method_impl_template = Template("""    public final void $name($base_package.$dto_package.$request request, $base_package.$callback_package.$callback callback) {
  73         synchronized (callbacks) {
  74             callbacks.put(jvpp.$name(request), callback);
  75         }
  76     }
  77 """)
  78
  79 no_arg_method_template = Template("""    void $name($base_package.$callback_package.$callback callback);""")
  80 no_arg_method_impl_template = Template("""    public final void $name($base_package.$callback_package.$callback callback) {
  81         synchronized (callbacks) {
  82             callbacks.put(jvpp.$name(), callback);
  83         }
  84     }
  85 """)
  86
  87
  88 def generate_jvpp(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile):
  89     """ Generates callback facade """
  90     print "Generating JVpp callback facade"
  91
  92     if os.path.exists(callback_facade_package):
  93         util.remove_folder(callback_facade_package)
  94
  95     os.mkdir(callback_facade_package)
  96
  97     methods = []
  98     methods_impl = []
  99     for func in func_list:
 100
 101         if util.is_notification(func['name']) or util.is_ignored(func['name']):
 102             # TODO handle notifications
 103             continue
 104
 105         camel_case_name = util.underscore_to_camelcase(func['name'])
 106         camel_case_name_upper = util.underscore_to_camelcase_upper(func['name'])
 107         if util.is_reply(camel_case_name):
 108             continue
 109
 110         # Strip suffix for dump calls
 111         callback_type = get_request_name(camel_case_name_upper, func['name']) + callback_gen.callback_suffix
 112
 113         if len(func['args']) == 0:
 114             methods.append(no_arg_method_template.substitute(name=camel_case_name,
 115                                                              base_package=base_package,
 116                                                              dto_package=dto_package,
 117                                                              callback_package=callback_package,
 118                                                              callback=callback_type))
 119             methods_impl.append(no_arg_method_impl_template.substitute(name=camel_case_name,
 120                                                                        base_package=base_package,
 121                                                                        dto_package=dto_package,
 122                                                                        callback_package=callback_package,
 123                                                                        callback=callback_type))
 124         else:
 125             methods.append(method_template.substitute(name=camel_case_name,
 126                                                       request=camel_case_name_upper,
 127                                                       base_package=base_package,
 128                                                       dto_package=dto_package,
 129                                                       callback_package=callback_package,
 130                                                       callback=callback_type))
 131             methods_impl.append(method_impl_template.substitute(name=camel_case_name,
 132                                                                 request=camel_case_name_upper,
 133                                                                 base_package=base_package,
 134                                                                 dto_package=dto_package,
 135                                                                 callback_package=callback_package,
 136                                                                 callback=callback_type))
 137
 138     join = os.path.join(callback_facade_package, "CallbackJVpp.java")
 139     jvpp_file = open(join, 'w')
 140     jvpp_file.write(
 141         jvpp_ifc_template.substitute(inputfile=inputfile,
 142                                      methods="\n".join(methods),
 143                                      base_package=base_package,
 144                                      dto_package=dto_package,
 145                                      callback_facade_package=callback_facade_package))
 146     jvpp_file.flush()
 147     jvpp_file.close()
 148
 149     jvpp_file = open(os.path.join(callback_facade_package, "CallbackJVppFacade.java"), 'w')
 150     jvpp_file.write(jvpp_impl_template.substitute(inputfile=inputfile,
 151                                                   methods="\n".join(methods_impl),
 152                                                   base_package=base_package,
 153                                                   dto_package=dto_package,
 154                                                   callback_package=callback_package,
 155                                                   callback_facade_package=callback_facade_package))
 156     jvpp_file.flush()
 157     jvpp_file.close()
 158
 159     generate_callback(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile)
 160
 161
 162 jvpp_facade_callback_template = Template("""
 163 package $base_package.$callback_facade_package;
 164
 165 /**
 166  * <p>JVppGlobalCallback implementation for Java Callback API.
 167  * <br>It was generated by jvpp_callback_facade_gen.py based on $inputfile
 168  * <br>(python representation of vpe.api generated by vppapigen).
 169  */
 170 public final class CallbackJVppFacadeCallback implements $base_package.$callback_package.JVppGlobalCallback {
 171
 172     private final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> requests;
 173
 174     public CallbackJVppFacadeCallback(final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> requestMap) {
 175         this.requests = requestMap;
 176     }
 177
 178 $methods
 179 }
 180 """)
 181
 182 jvpp_facade_callback_method_template = Template("""
 183     @Override
 184     @SuppressWarnings("unchecked")
 185     public void on$callback_dto($base_package.$dto_package.$callback_dto reply) {
 186
 187         $base_package.$callback_package.$callback callback;
 188         synchronized(requests) {
 189             callback = ($base_package.$callback_package.$callback) requests.remove(reply.context);
 190         }
 191
 192         if(callback != null) {
 193             callback.on$callback_dto(reply);
 194         }
 195     }
 196 """)
 197
 198
 199 def generate_callback(func_list, base_package, dto_package, callback_package, callback_facade_package, inputfile):
 200     callbacks = []
 201     for func in func_list:
 202
 203         if util.is_notification(func['name']) or util.is_ignored(func['name']):
 204             # TODO handle notifications
 205             continue
 206
 207         camel_case_name_with_suffix = util.underscore_to_camelcase_upper(func['name'])
 208         if not util.is_reply(camel_case_name_with_suffix):
 209             continue
 210
 211         callbacks.append(jvpp_facade_callback_method_template.substitute(base_package=base_package,
 212                                                                          dto_package=dto_package,
 213                                                                          callback_package=callback_package,
 214                                                                          callback=util.remove_reply_suffix(camel_case_name_with_suffix) + callback_gen.callback_suffix,
 215                                                                          callback_dto=camel_case_name_with_suffix))
 216
 217     jvpp_file = open(os.path.join(callback_facade_package, "CallbackJVppFacadeCallback.java"), 'w')
 218     jvpp_file.write(jvpp_facade_callback_template.substitute(inputfile=inputfile,
 219                                                              base_package=base_package,
 220                                                              dto_package=dto_package,
 221                                                              callback_package=callback_package,
 222                                                              methods="".join(callbacks),
 223                                                              callback_facade_package=callback_facade_package))
 224     jvpp_file.flush()
 225     jvpp_file.close()
 226
 227
 228 # Returns request name or special one from unconventional_naming_rep_req map
 229 def get_request_name(camel_case_dto_name, func_name):
 230     if func_name in reverse_dict(util.unconventional_naming_rep_req):
 231         request_name = util.underscore_to_camelcase_upper(reverse_dict(util.unconventional_naming_rep_req)[func_name])
 232     else:
 233         request_name = camel_case_dto_name
 234     return remove_suffix(request_name)
 235
 236
 237 def reverse_dict(map):
 238     return dict((v, k) for k, v in map.iteritems())
 239
 240
 241 def remove_suffix(name):
 242     if util.is_reply(name):
 243         return util.remove_reply_suffix(name)
 244     else:
 245         if util.is_dump(name):
 246             return util.remove_suffix(name, util.dump_suffix)
 247         else:
 248             return name