comparison capnproto/VampnProto.h @ 55:38780f15ac8d

Make RequestResponse types more consistent by adding plugin to ConfigurationResponse and introducing a FinishRequest

         readPluginConfiguration(cr.configuration, c);
     }
 
     static void
     buildConfigurationResponse(ConfigurationResponse::Builder &b,
-                               const Vamp::HostExt::ConfigurationResponse &cr) {
-
+                               const Vamp::HostExt::ConfigurationResponse &cr,
+                               const PluginHandleMapper &pmapper) {
+
+        b.setPluginHandle(pmapper.pluginToHandle(cr.plugin));
         auto olist = b.initOutputs(cr.outputs.size());
         for (size_t i = 0; i < cr.outputs.size(); ++i) {
             auto od = olist[i];
             buildOutputDescriptor(od, cr.outputs[i]);
         }
     }
 
     static void
     readConfigurationResponse(Vamp::HostExt::ConfigurationResponse &cr,
-                              const ConfigurationResponse::Reader &r) {
-
+                              const ConfigurationResponse::Reader &r,
+                              const PluginHandleMapper &pmapper) {
+
+        cr.plugin = pmapper.handleToPlugin(r.getPluginHandle());
         cr.outputs.clear();
         auto oo = r.getOutputs();
         for (const auto &o: oo) {
             Vamp::Plugin::OutputDescriptor desc;
             readOutputDescriptor(desc, o);

         buildConfigurationRequest(u, cr, pmapper);
     }
 
     static void
     buildVampResponse_Configure(VampResponse::Builder &b,
-                                const Vamp::HostExt::ConfigurationResponse &cr) {
+                                const Vamp::HostExt::ConfigurationResponse &cr,
+                                const PluginHandleMapper &pmapper) {
         b.setSuccess(!cr.outputs.empty());
         b.setErrorText("");
         auto u = b.getResponse().initConfigure();
-        buildConfigurationResponse(u, cr);
+        buildConfigurationResponse(u, cr, pmapper);
     }
     
     static void
     buildVampRequest_Process(VampRequest::Builder &b,
                              const Vamp::HostExt::ProcessRequest &pr,

         buildProcessResponse(u, pr, pmapper);
     }
     
     static void
     buildVampRequest_Finish(VampRequest::Builder &b,
-                            Vamp::Plugin *p,
+                            const Vamp::HostExt::FinishRequest &req,
                             const PluginHandleMapper &pmapper) {
 
         auto u = b.getRequest().initFinish();
-        u.setPluginHandle(pmapper.pluginToHandle(p));
+        u.setPluginHandle(pmapper.pluginToHandle(req.plugin));
     }
     
     static void
     buildVampResponse_Finish(VampResponse::Builder &b,
                              const Vamp::HostExt::ProcessResponse &pr,

         readConfigurationRequest(req, r.getRequest().getConfigure(), pmapper);
     }
 
     static void
     readVampResponse_Configure(Vamp::HostExt::ConfigurationResponse &resp,
-                               const VampResponse::Reader &r) {
+                               const VampResponse::Reader &r,
+                               const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration response");
         }
         resp = {};
         if (r.getSuccess()) {
-            readConfigurationResponse(resp, r.getResponse().getConfigure());
+            readConfigurationResponse(resp,
+                                      r.getResponse().getConfigure(),
+                                      pmapper);
         }
     }
     
     static void
     readVampRequest_Process(Vamp::HostExt::ProcessRequest &req,

             readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
         }
     }
     
     static void
-    readVampRequest_Finish(Vamp::Plugin *&finishPlugin,
+    readVampRequest_Finish(Vamp::HostExt::FinishRequest &req,
                            const VampRequest::Reader &r,
                            const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Finish) {
             throw std::logic_error("not a finish request");
         }
-        finishPlugin = pmapper.handleToPlugin
+        req.plugin = pmapper.handleToPlugin
             (r.getRequest().getFinish().getPluginHandle());
     }
 
     static void
     readVampResponse_Finish(Vamp::HostExt::ProcessResponse &resp,