comparison capnproto/VampnProto.h @ 28:b5005ebc5116

Be sure not to get any unnecessary lookups -- I think this is probably redundant but at least it's explicit

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

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

         }
 
         f.label = r.getLabel();
 
         f.values.clear();
-        for (auto v: r.getValues()) {
+        auto vv = r.getValues();
+        for (auto v: vv) {
             f.values.push_back(v);
         }
     }
     
     static void

     static void
     readFeatureSet(Vamp::Plugin::FeatureSet &fs,
                    const FeatureSet::Reader &r) {
 
         fs.clear();
-        for (const auto &p: r.getFeaturePairs()) {
+        auto pp = r.getFeaturePairs();
+        for (const auto &p: pp) {
             Vamp::Plugin::FeatureList vfl;
-            for (const auto &f: p.getFeatures()) {
+            auto ff = p.getFeatures();
+            for (const auto &f: ff) {
                 Vamp::Plugin::Feature vf;
                 readFeature(vf, f);
                 vfl.push_back(vf);
             }
             fs[p.getOutput()] = vfl;

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

 
     static void
     readPluginConfiguration(Vamp::HostExt::PluginConfiguration &c,
                             const PluginConfiguration::Reader &r) {
 
-        for (const auto &pp: r.getParameterValues()) {
-            c.parameterValues[pp.getParameter()] = pp.getValue();
+        auto pp = r.getParameterValues();
+        for (const auto &p: pp) {
+            c.parameterValues[p.getParameter()] = p.getValue();
         }
 
         c.currentProgram = r.getCurrentProgram();
         c.channelCount = r.getChannelCount();
         c.stepSize = r.getStepSize();

 
         req.pluginKey = r.getPluginKey();
         req.inputSampleRate = r.getInputSampleRate();
 
         int flags = 0;
-        for (const auto &a: r.getAdapterFlags()) {
+        auto aa = r.getAdapterFlags();
+        for (auto a: aa) {
             if (a == AdapterFlag::ADAPT_INPUT_DOMAIN) {
                 flags |= Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN;
             }
             if (a == AdapterFlag::ADAPT_CHANNEL_COUNT) {
                 flags |= Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT;

     static void
     readConfigurationResponse(Vamp::HostExt::ConfigurationResponse &cr,
                               const ConfigurationResponse::Reader &r) {
 
         cr.outputs.clear();
-        for (const auto &o: r.getOutputs()) {
+        auto oo = r.getOutputs();
+        for (const auto &o: oo) {
             Vamp::Plugin::OutputDescriptor desc;
             readOutputDescriptor(desc, o);
             cr.outputs.push_back(desc);
         }
     }

                      std::vector<std::vector<float> > &buffers,
                      const ProcessInput::Reader &b) {
 
         readRealTime(timestamp, b.getTimestamp());
         buffers.clear();
-        for (const auto &v: b.getInputBuffers()) {
+        auto vv = b.getInputBuffers();
+        for (const auto &v: vv) {
             std::vector<float> buf;
             for (auto x: v) {
                 buf.push_back(x);
             }
             buffers.push_back(buf);

         if (getRequestResponseType(r) != RRType::List) {
             throw std::logic_error("not a list response");
         }
         v.clear();
         if (r.getSuccess()) {
-            for (const auto &p: r.getResponse().getList().getPlugins()) {
+            auto pp = r.getResponse().getList().getPlugins();
+            for (const auto &p: pp) {
                 Vamp::HostExt::PluginStaticData psd;
                 readPluginStaticData(psd, p);
                 v.push_back(psd);
             }
         }