comparison vamp-capnp/VampnProto.h @ 80:d9e85a65d45b

Inching toward a client

 #include <capnp/serialize-packed.h>
 
 #include <vamp-hostsdk/Plugin.h>
 #include <vamp-hostsdk/PluginLoader.h>
 #include <vamp-hostsdk/PluginStaticData.h>
+#include <vamp-hostsdk/PluginConfiguration.h>
+#include <vamp-hostsdk/RequestResponse.h>
 
 #include "vamp-support/PluginHandleMapper.h"
 #include "vamp-support/PluginOutputIdMapper.h"
 #include "vamp-support/RequestResponseType.h"
 

                      const PluginHandleMapper &pmapper) {
 
         resp.plugin = pmapper.handleToPlugin(r.getHandle());
         readExtractorStaticData(resp.staticData, r.getStaticData());
         readConfiguration(resp.defaultConfiguration,
-                                r.getDefaultConfiguration());
+                          r.getDefaultConfiguration());
     }
 
     static void
     buildConfigurationRequest(ConfigurationRequest::Builder &b,
                               const Vamp::HostExt::ConfigurationRequest &cr,

         b.getRequest().initList();
     }
 
     static void
     buildRpcResponse_List(RpcResponse::Builder &b,
-                           const Vamp::HostExt::ListResponse &resp) {
+                          const Vamp::HostExt::ListResponse &resp) {
 
         auto r = b.getResponse().initList();
         auto p = r.initAvailable(resp.available.size());
         for (size_t i = 0; i < resp.available.size(); ++i) {
             auto pd = p[i];

         }
     }
     
     static void
     buildRpcRequest_Load(RpcRequest::Builder &b,
-                          const Vamp::HostExt::LoadRequest &req) {
+                         const Vamp::HostExt::LoadRequest &req) {
         auto u = b.getRequest().initLoad();
         buildLoadRequest(u, req);
     }
 
     static void
     buildRpcResponse_Load(RpcResponse::Builder &b,
-                           const Vamp::HostExt::LoadResponse &resp,
-                           const PluginHandleMapper &pmapper) {
+                          const Vamp::HostExt::LoadResponse &resp,
+                          const PluginHandleMapper &pmapper) {
 
         if (resp.plugin) {
             auto u = b.getResponse().initLoad();
             buildLoadResponse(u, resp, pmapper);
         } else {

         }
     }
 
     static void
     buildRpcRequest_Configure(RpcRequest::Builder &b,
-                               const Vamp::HostExt::ConfigurationRequest &cr,
-                               const PluginHandleMapper &pmapper) {
+                              const Vamp::HostExt::ConfigurationRequest &cr,
+                              const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initConfigure();
         buildConfigurationRequest(u, cr, pmapper);
     }
 
     static void
     buildRpcResponse_Configure(RpcResponse::Builder &b,
-                                const Vamp::HostExt::ConfigurationResponse &cr,
-                                const PluginHandleMapper &pmapper) {
+                               const Vamp::HostExt::ConfigurationResponse &cr,
+                               const PluginHandleMapper &pmapper) {
 
         if (!cr.outputs.empty()) {
             auto u = b.getResponse().initConfigure();
             buildConfigurationResponse(u, cr, pmapper);
         } else {

         }
     }
     
     static void
     buildRpcRequest_Process(RpcRequest::Builder &b,
-                             const Vamp::HostExt::ProcessRequest &pr,
-                             const PluginHandleMapper &pmapper) {
+                            const Vamp::HostExt::ProcessRequest &pr,
+                            const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initProcess();
         buildProcessRequest(u, pr, pmapper);
     }
     
     static void
     buildRpcResponse_Process(RpcResponse::Builder &b,
-                              const Vamp::HostExt::ProcessResponse &pr,
-                              const PluginHandleMapper &pmapper) {
+                             const Vamp::HostExt::ProcessResponse &pr,
+                             const PluginHandleMapper &pmapper) {
 
         auto u = b.getResponse().initProcess();
         buildProcessResponse(u, pr, pmapper);
     }
     
     static void
     buildRpcRequest_Finish(RpcRequest::Builder &b,
-                            const Vamp::HostExt::FinishRequest &req,
-                            const PluginHandleMapper &pmapper) {
+                           const Vamp::HostExt::FinishRequest &req,
+                           const PluginHandleMapper &pmapper) {
 
         auto u = b.getRequest().initFinish();
         u.setHandle(pmapper.pluginToHandle(req.plugin));
     }
     
     static void
     buildRpcResponse_Finish(RpcResponse::Builder &b,
-                             const Vamp::HostExt::ProcessResponse &pr,
-                             const PluginHandleMapper &pmapper) {
+                            const Vamp::HostExt::ProcessResponse &pr,
+                            const PluginHandleMapper &pmapper) {
 
         auto u = b.getResponse().initFinish();
         buildFinishResponse(u, pr, pmapper);
     }
 
     static void
     buildRpcResponse_Error(RpcResponse::Builder &b,
-                            const std::string &errorText,
-                            RRType responseType)
+                           const std::string &errorText,
+                           RRType responseType)
     {
         std::string type;
 
         auto e = b.getResponse().initError();
 

         e.setMessage(std::string("error in ") + type + " request: " + errorText);
     }
 
     static void
     buildRpcResponse_Exception(RpcResponse::Builder &b,
-                                const std::exception &e,
-                                RRType responseType)
+                               const std::exception &e,
+                               RRType responseType)
     {
         return buildRpcResponse_Error(b, e.what(), responseType);
     }
     
     static RRType

         }
     }
 
     static void
     readRpcResponse_List(Vamp::HostExt::ListResponse &resp,
-                          const RpcResponse::Reader &r) {
+                         const RpcResponse::Reader &r) {
         if (getRequestResponseType(r) != RRType::List) {
             throw std::logic_error("not a list response");
         }
         resp.available.clear();
         auto pp = r.getResponse().getList().getAvailable();

         }
     }
     
     static void
     readRpcRequest_Load(Vamp::HostExt::LoadRequest &req,
-                         const RpcRequest::Reader &r) {
+                        const RpcRequest::Reader &r) {
         if (getRequestResponseType(r) != RRType::Load) {
             throw std::logic_error("not a load request");
         }
         readLoadRequest(req, r.getRequest().getLoad());
     }

         readLoadResponse(resp, r.getResponse().getLoad(), pmapper);
     }
     
     static void
     readRpcRequest_Configure(Vamp::HostExt::ConfigurationRequest &req,
-                              const RpcRequest::Reader &r,
-                              const PluginHandleMapper &pmapper) {
+                             const RpcRequest::Reader &r,
+                             const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration request");
         }
         readConfigurationRequest(req, r.getRequest().getConfigure(), pmapper);
     }
 
     static void
     readRpcResponse_Configure(Vamp::HostExt::ConfigurationResponse &resp,
-                               const RpcResponse::Reader &r,
-                               const PluginHandleMapper &pmapper) {
+                              const RpcResponse::Reader &r,
+                              const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration response");
         }
         resp = {};
         readConfigurationResponse(resp,

                                   pmapper);
     }
     
     static void
     readRpcRequest_Process(Vamp::HostExt::ProcessRequest &req,
-                            const RpcRequest::Reader &r,
+                           const RpcRequest::Reader &r,
+                           const PluginHandleMapper &pmapper) {
+        if (getRequestResponseType(r) != RRType::Process) {
+            throw std::logic_error("not a process request");
+        }
+        readProcessRequest(req, r.getRequest().getProcess(), pmapper);
+    }
+
+    static void
+    readRpcResponse_Process(Vamp::HostExt::ProcessResponse &resp,
+                            const RpcResponse::Reader &r,
                             const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Process) {
-            throw std::logic_error("not a process request");
-        }
-        readProcessRequest(req, r.getRequest().getProcess(), pmapper);
-    }
-
-    static void
-    readRpcResponse_Process(Vamp::HostExt::ProcessResponse &resp,
-                             const RpcResponse::Reader &r,
-                             const PluginHandleMapper &pmapper) {
-        if (getRequestResponseType(r) != RRType::Process) {
             throw std::logic_error("not a process response");
         }
         resp = {};
         readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
     }
     
     static void
     readRpcRequest_Finish(Vamp::HostExt::FinishRequest &req,
-                           const RpcRequest::Reader &r,
+                          const RpcRequest::Reader &r,
+                          const PluginHandleMapper &pmapper) {
+        if (getRequestResponseType(r) != RRType::Finish) {
+            throw std::logic_error("not a finish request");
+        }
+        req.plugin = pmapper.handleToPlugin
+            (r.getRequest().getFinish().getHandle());
+    }
+
+    static void
+    readRpcResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
+                           const RpcResponse::Reader &r,
                            const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Finish) {
-            throw std::logic_error("not a finish request");
-        }
-        req.plugin = pmapper.handleToPlugin
-            (r.getRequest().getFinish().getHandle());
-    }
-
-    static void
-    readRpcResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
-                            const RpcResponse::Reader &r,
-                            const PluginHandleMapper &pmapper) {
-        if (getRequestResponseType(r) != RRType::Finish) {
             throw std::logic_error("not a finish response");
         }
         resp = {};
         readFinishResponse(resp, r.getResponse().getFinish(), pmapper);
     }