fix examples and tests

Author: lia-viam

src/viam/examples/mlmodel/example_audio_classification_client.cpp

@@ -27,6 +27,7 @@
 #include <boost/format.hpp>
 #include <boost/optional.hpp>
 #include <boost/program_options.hpp>
+#include <boost/variant/get.hpp>
 
 #include <viam/sdk/robot/client.hpp>
 #include <viam/sdk/services/mlmodel.hpp>

src/viam/examples/modules/tflite/main.cpp

@@ -26,6 +26,7 @@
 #include <grpcpp/security/credentials.h>
 #include <tensorflow/lite/c/c_api.h>
 
+#include <viam/sdk/common/proto_value.hpp>
 #include <viam/sdk/components/component.hpp>
 #include <viam/sdk/config/resource.hpp>
 #include <viam/sdk/module/service.hpp>
@@ -290,64 +291,67 @@ class MLModelServiceTFLite : public vsdk::MLModelService,
         // Now we can begin parsing and validating the provided `configuration`.
         // Pull the model path out of the configuration.
         const auto& attributes = state->configuration.attributes();
-        auto model_path = attributes->find("model_path");
-        if (model_path == attributes->end()) {
+        auto model_path = attributes.find("model_path");
+        if (model_path == attributes.end()) {
             std::ostringstream buffer;
             buffer << service_name
                    << ": Required parameter `model_path` not found in configuration";
             throw std::invalid_argument(buffer.str());
         }
-        const auto* const model_path_string = model_path->second->get<std::string>();
-        if (!model_path_string || model_path_string->empty()) {
+
+        const vsdk::ProtoValue& model_path_val = model_path->second;
+        if (!model_path_val.is_a<std::string>() ||
+            model_path_val.get_unchecked<std::string>().empty()) {
             std::ostringstream buffer;
             buffer << service_name
                    << ": Required non-empty string parameter `model_path` is either not a string "
                       "or is an empty string";
             throw std::invalid_argument(buffer.str());
         }
+        const std::string& model_path_string = model_path_val.get_unchecked<std::string>();
 
         // Process any tensor name remappings provided in the config.
-        auto remappings = attributes->find("tensor_name_remappings");
-        if (remappings != attributes->end()) {
-            const auto remappings_attributes = remappings->second->get<vsdk::ProtoStruct>();
-            if (!remappings_attributes) {
+        auto remappings = attributes.find("tensor_name_remappings");
+        if (remappings != attributes.end()) {
+            if (!remappings->second.is_a<vsdk::ProtoStruct>()) {
                 std::ostringstream buffer;
                 buffer << service_name
                        << ": Optional parameter `tensor_name_remappings` must be a dictionary";
                 throw std::invalid_argument(buffer.str());
             }
+            const auto remappings_attributes =
+                remappings->second.get_unchecked<vsdk::ProtoStruct>();
 
-            const auto populate_remappings = [](const vsdk::ProtoType& source, auto& target) {
-                const auto source_attributes = source.get<vsdk::ProtoStruct>();
-                if (!source_attributes) {
+            const auto populate_remappings = [](const vsdk::ProtoValue& source, auto& target) {
+                if (!source.is_a<vsdk::ProtoStruct>()) {
                     std::ostringstream buffer;
                     buffer << service_name
-                           << ": Fields `inputs` and `outputs` of `tensor_name_remappings` must be "
+                           << ": Fields `inputs` and `outputs` of `tensor_name_remappings` "
+                              "must be "
                               "dictionaries";
                     throw std::invalid_argument(buffer.str());
                 }
-                for (const auto& kv : *source_attributes) {
+                for (const auto& kv : source.get_unchecked<vsdk::ProtoStruct>()) {
                     const auto& k = kv.first;
-                    const auto* const kv_string = kv.second->get<std::string>();
-                    if (!kv_string) {
+                    if (!kv.second.is_a<std::string>()) {
                         std::ostringstream buffer;
-                        buffer
-                            << service_name
-                            << ": Fields `inputs` and `outputs` of `tensor_name_remappings` must "
-                               "be dictionaries with string values";
+                        buffer << service_name
+                               << ": Fields `inputs` and `outputs` of `tensor_name_remappings` "
+                                  "must "
+                                  "be dictionaries with string values";
                         throw std::invalid_argument(buffer.str());
                     }
-                    target[kv.first] = *kv_string;
+                    target[kv.first] = kv.second.get_unchecked<std::string>();
                 }
             };
 
-            const auto inputs_where = remappings_attributes->find("inputs");
-            if (inputs_where != remappings_attributes->end()) {
-                populate_remappings(*inputs_where->second, state->input_name_remappings);
+            const auto inputs_where = remappings_attributes.find("inputs");
+            if (inputs_where != remappings_attributes.end()) {
+                populate_remappings(inputs_where->second, state->input_name_remappings);
             }
-            const auto outputs_where = remappings_attributes->find("outputs");
-            if (outputs_where != remappings_attributes->end()) {
-                populate_remappings(*outputs_where->second, state->output_name_remappings);
+            const auto outputs_where = remappings_attributes.find("outputs");
+            if (outputs_where != remappings_attributes.end()) {
+                populate_remappings(outputs_where->second, state->output_name_remappings);
             }
         }
 
@@ -362,11 +366,11 @@ class MLModelServiceTFLite : public vsdk::MLModelService,
         // buffer which we can use with `TfLiteModelCreate`. That
         // still requires that the buffer be kept valid, but that's
         // more easily done.
-        const std::ifstream in(*model_path_string, std::ios::in | std::ios::binary);
+        const std::ifstream in(model_path_string, std::ios::in | std::ios::binary);
         if (!in) {
             std::ostringstream buffer;
             buffer << service_name << ": Failed to open file for `model_path` "
-                   << *model_path_string;
+                   << model_path_string;
             throw std::invalid_argument(buffer.str());
         }
         std::ostringstream model_path_contents_stream;
@@ -399,23 +403,29 @@ class MLModelServiceTFLite : public vsdk::MLModelService,
         // If present, extract and validate the number of threads to
         // use in the interpreter and create an interpreter options
         // object to carry that information.
-        auto num_threads = attributes->find("num_threads");
-        if (num_threads != attributes->end()) {
-            const auto* num_threads_double = num_threads->second->get<double>();
-            if (!num_threads_double || !std::isnormal(*num_threads_double) ||
-                (*num_threads_double < 0) ||
-                (*num_threads_double >= std::numeric_limits<std::int32_t>::max()) ||
-                (std::trunc(*num_threads_double) != *num_threads_double)) {
+        auto num_threads = attributes.find("num_threads");
+        if (num_threads != attributes.end()) {
+            auto throwError = [&] {
                 std::ostringstream buffer;
                 buffer << service_name
-                       << ": Value for field `num_threads` is not a positive integer: "
-                       << *num_threads_double;
+                       << ": Value for field `num_threads` is not a positive integer";
                 throw std::invalid_argument(buffer.str());
+            };
+
+            if (!num_threads->second.is_a<double>()) {
+                throwError();
+            }
+
+            double num_threads_double = num_threads->second.get_unchecked<double>();
+            if (!std::isnormal(num_threads_double) || (num_threads_double < 0) ||
+                (num_threads_double >= std::numeric_limits<std::int32_t>::max()) ||
+                (std::trunc(num_threads_double) != num_threads_double)) {
+                throwError();
             }
 
             state->interpreter_options.reset(TfLiteInterpreterOptionsCreate());
             TfLiteInterpreterOptionsSetNumThreads(state->interpreter_options.get(),
-                                                  static_cast<int32_t>(*num_threads_double));
+                                                  static_cast<int32_t>(num_threads_double));
         }
 
         // Build the single interpreter.

src/viam/sdk/tests/test_mlmodel.cpp

@@ -18,6 +18,8 @@
 #include <tuple>
 #include <unordered_map>
 
+#include <boost/variant/get.hpp>
+
 #include <viam/sdk/tests/mocks/mlmodel_mocks.hpp>
 #include <viam/sdk/tests/test_utils.hpp>