comparison capnproto/VampnProto.h @ 13:1d13354ddc44

Build & read config request/response etc

         od.hasDuration = r.getHasDuration();
 
         od.hasFixedBinCount = r.getHasFixedBinCount();
         if (od.hasFixedBinCount) {
             od.binCount = r.getBinCount();
+            od.binNames.clear();
             for (const auto &n: r.getBinNames()) {
                 od.binNames.push_back(n);
             }
         }
 

         pd.isQuantized = r.getIsQuantized();
         if (pd.isQuantized) {
             pd.quantizeStep = r.getQuantizeStep();
         }
 
+        pd.valueNames.clear();
         for (const auto &n: r.getValueNames()) {
             pd.valueNames.push_back(n);
         }
     }
     

             readRealTime(f.duration, r.getDuration());
         }
 
         f.label = r.getLabel();
 
+        f.values.clear();
         for (auto v: r.getValues()) {
             f.values.push_back(v);
         }
     }
     

 
     static void
     readFeatureSet(Vamp::Plugin::FeatureSet &fs,
                    const FeatureSet::Reader &r) {
 
+        fs.clear();
         for (const auto &p: r.getFeaturePairs()) {
             Vamp::Plugin::FeatureList vfl;
             for (const auto &f: p.getFeatures()) {
                 Vamp::Plugin::Feature vf;
                 readFeature(vf, f);

 
         d.maker = r.getMaker();
         d.copyright = r.getCopyright();
         d.pluginVersion = r.getPluginVersion();
 
+        d.category.clear();
         for (auto c: r.getCategory()) {
             d.category.push_back(c);
         }
 
         d.minChannelCount = r.getMinChannelCount();
         d.maxChannelCount = r.getMaxChannelCount();
 
+        d.parameters.clear();
         for (auto p: r.getParameters()) {
             Vamp::Plugin::ParameterDescriptor pd;
             readParameterDescriptor(pd, p);
             d.parameters.push_back(pd);
         }
 
+        d.programs.clear();
         for (auto p: r.getPrograms()) {
             d.programs.push_back(p);
         }
 
         d.inputDomain = toInputDomain(r.getInputDomain());
 
+        d.basicOutputInfo.clear();
         for (auto o: r.getBasicOutputInfo()) {
             Vamp::HostExt::PluginStaticData::Basic b;
             readBasicDescriptor(b, o);
             d.basicOutputInfo.push_back(b);
         }

         resp.plugin = mapper.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 &mapper) {
+
+        b.setPluginHandle(mapper.pluginToHandle(cr.plugin));
+        auto c = b.initConfiguration();
+        buildPluginConfiguration(c, cr.configuration);
+    }
+
+    static void
+    readConfigurationRequest(Vamp::HostExt::ConfigurationRequest &cr,
+                             const ConfigurationRequest::Reader &r,
+                             PluginHandleMapper &mapper) {
+
+        auto h = r.getPluginHandle();
+        cr.plugin = mapper.handleToPlugin(h);
+        auto c = r.getConfiguration();
+        readPluginConfiguration(cr.configuration, c);
+    }
+
+    static void
+    buildConfigurationResponse(ConfigurationResponse::Builder &b,
+                               const Vamp::HostExt::ConfigurationResponse &cr) {
+
+        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) {
+
+        cr.outputs.clear();
+        for (const auto &o: r.getOutputs()) {
+            Vamp::Plugin::OutputDescriptor desc;
+            readOutputDescriptor(desc, o);
+            cr.outputs.push_back(desc);
+        }
+    }
 };
 
 }