comparison capnproto/VampnProto.h @ 51:f4244a2d55ac

Introduce and use output id mappers

     }
 
     static void
     buildLoadResponse(LoadResponse::Builder &b,
                       const Vamp::HostExt::LoadResponse &resp,
-                      PluginHandleMapper &pmapper) {
+                      const PluginHandleMapper &pmapper) {
 
         b.setPluginHandle(pmapper.pluginToHandle(resp.plugin));
         auto sd = b.initStaticData();
         buildPluginStaticData(sd, resp.staticData);
         auto conf = b.initDefaultConfiguration();

     }
 
     static void
     readLoadResponse(Vamp::HostExt::LoadResponse &resp,
                      const LoadResponse::Reader &r,
-                     PluginHandleMapper &pmapper) {
+                     const PluginHandleMapper &pmapper) {
 
         resp.plugin = pmapper.handleToPlugin(r.getPluginHandle());
         readPluginStaticData(resp.staticData, r.getStaticData());
         readPluginConfiguration(resp.defaultConfiguration,
                                 r.getDefaultConfiguration());
     }
 
     static void
     buildConfigurationRequest(ConfigurationRequest::Builder &b,
                               const Vamp::HostExt::ConfigurationRequest &cr,
-                              PluginHandleMapper &pmapper) {
+                              const PluginHandleMapper &pmapper) {
 
         b.setPluginHandle(pmapper.pluginToHandle(cr.plugin));
         auto c = b.initConfiguration();
         buildPluginConfiguration(c, cr.configuration);
     }
 
     static void
     readConfigurationRequest(Vamp::HostExt::ConfigurationRequest &cr,
                              const ConfigurationRequest::Reader &r,
-                             PluginHandleMapper &pmapper) {
+                             const PluginHandleMapper &pmapper) {
 
         auto h = r.getPluginHandle();
         cr.plugin = pmapper.handleToPlugin(h);
         auto c = r.getConfiguration();
         readPluginConfiguration(cr.configuration, c);

     }
     
     static void
     buildProcessRequest(ProcessRequest::Builder &b,
                         const Vamp::HostExt::ProcessRequest &pr,
-                        PluginHandleMapper &pmapper) {
+                        const PluginHandleMapper &pmapper) {
 
         b.setPluginHandle(pmapper.pluginToHandle(pr.plugin));
         auto input = b.initInput();
         buildProcessInput(input, pr.timestamp, pr.inputBuffers);
     }
 
     static void
     readProcessRequest(Vamp::HostExt::ProcessRequest &pr,
                        const ProcessRequest::Reader &r,
-                       PluginHandleMapper &pmapper) {
+                       const PluginHandleMapper &pmapper) {
 
         auto h = r.getPluginHandle();
         pr.plugin = pmapper.handleToPlugin(h);
         readProcessInput(pr.timestamp, pr.inputBuffers, r.getInput());
     }
 
     static void
     buildProcessResponse(ProcessResponse::Builder &b,
                          const Vamp::HostExt::ProcessResponse &pr,
-                         const PluginOutputIdMapper &omapper) {
+                         const PluginHandleMapper &pmapper) {
 
         auto f = b.initFeatures();
-        buildFeatureSet(f, pr.features, omapper);
+        buildFeatureSet(f, pr.features,
+                        pmapper.pluginToOutputIdMapper(pr.plugin));
     }
     
     static void
     readProcessResponse(Vamp::HostExt::ProcessResponse &pr,
                         const ProcessResponse::Reader &r,
-                        const PluginOutputIdMapper &omapper) {
-
-        readFeatureSet(pr.features, r.getFeatures(), omapper);
+                        const PluginHandleMapper &pmapper) {
+
+        readFeatureSet(pr.features, r.getFeatures(),
+                       pmapper.handleToOutputIdMapper(r.getPluginHandle()));
     }
 
     static void
     buildVampRequest_List(VampRequest::Builder &b) {
         b.getRequest().setList();

     }
 
     static void
     buildVampResponse_Load(VampResponse::Builder &b,
                            const Vamp::HostExt::LoadResponse &resp,
-                           PluginHandleMapper &pmapper) {
+                           const PluginHandleMapper &pmapper) {
         b.setSuccess(resp.plugin != 0);
         b.setErrorText("");
         auto u = b.getResponse().initLoad();
         buildLoadResponse(u, resp, pmapper);
     }
 
     static void
     buildVampRequest_Configure(VampRequest::Builder &b,
                                const Vamp::HostExt::ConfigurationRequest &cr,
-                               PluginHandleMapper &pmapper) {
+                               const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initConfigure();
         buildConfigurationRequest(u, cr, pmapper);
     }
 
     static void

     }
     
     static void
     buildVampRequest_Process(VampRequest::Builder &b,
                              const Vamp::HostExt::ProcessRequest &pr,
-                             PluginHandleMapper &pmapper) {
+                             const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initProcess();
         buildProcessRequest(u, pr, pmapper);
     }
     
     static void
     buildVampResponse_Process(VampResponse::Builder &b,
                               const Vamp::HostExt::ProcessResponse &pr,
-                              const PluginOutputIdMapper &omapper) {
+                              const PluginHandleMapper &pmapper) {
         b.setSuccess(true);
         b.setErrorText("");
         auto u = b.getResponse().initProcess();
-        buildProcessResponse(u, pr, omapper);
+        buildProcessResponse(u, pr, pmapper);
     }
     
     static void
     buildVampRequest_Finish(VampRequest::Builder &b,
                             Vamp::Plugin *p,
-                            PluginHandleMapper &pmapper) {
+                            const PluginHandleMapper &pmapper) {
 
         auto u = b.getRequest().initFinish();
         u.setPluginHandle(pmapper.pluginToHandle(p));
     }
     
     static void
     buildVampResponse_Finish(VampResponse::Builder &b,
                              const Vamp::HostExt::ProcessResponse &pr,
-                             const PluginOutputIdMapper &omapper) {
-
-        buildVampResponse_Process(b, pr, omapper);
+                             const PluginHandleMapper &pmapper) {
+
+        buildVampResponse_Process(b, pr, pmapper);
     }
 
     static RRType
     getRequestResponseType(const VampRequest::Reader &r) {
         switch (r.getRequest().which()) {

     }
 
     static void
     readVampResponse_Load(Vamp::HostExt::LoadResponse &resp,
                           const VampResponse::Reader &r,
-                          PluginHandleMapper &pmapper) {
+                          const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Load) {
             throw std::logic_error("not a load response");
         }
         resp = {};
         if (r.getSuccess()) {

     }
     
     static void
     readVampRequest_Configure(Vamp::HostExt::ConfigurationRequest &req,
                               const VampRequest::Reader &r,
-                              PluginHandleMapper &pmapper) {
+                              const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration request");
         }
         readConfigurationRequest(req, r.getRequest().getConfigure(), pmapper);
     }

     }
     
     static void
     readVampRequest_Process(Vamp::HostExt::ProcessRequest &req,
                             const VampRequest::Reader &r,
-                            PluginHandleMapper &pmapper) {
+                            const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Process) {
             throw std::logic_error("not a process request");
         }
         readProcessRequest(req, r.getRequest().getProcess(), pmapper);
     }
 
     static void
     readVampResponse_Process(Vamp::HostExt::ProcessResponse &resp,
                              const VampResponse::Reader &r,
-                             const PluginOutputIdMapper &omapper) {
+                             const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Process) {
             throw std::logic_error("not a process response");
         }
         resp = {};
         if (r.getSuccess()) {
-            readProcessResponse(resp, r.getResponse().getProcess(), omapper);
+            readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
         }
     }
     
     static void
     readVampRequest_Finish(Vamp::Plugin *&finishPlugin,
                            const VampRequest::Reader &r,
-                           PluginHandleMapper &pmapper) {
+                           const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Finish) {
             throw std::logic_error("not a finish request");
         }
         finishPlugin = pmapper.handleToPlugin
             (r.getRequest().getFinish().getPluginHandle());
     }
 
     static void
     readVampResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
                             const VampResponse::Reader &r,
-                            const PluginOutputIdMapper &omapper) {
+                            const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Finish) {
             throw std::logic_error("not a finish response");
         }
         resp = {};
         if (r.getSuccess()) {
-            readProcessResponse(resp, r.getResponse().getFinish(), omapper);
+            readProcessResponse(resp, r.getResponse().getFinish(), pmapper);
         }
     }
 };
 
 }