make to/from repeated field its own function object and a private detail

Author: lia-viam

src/viam/sdk/CMakeLists.txt

@@ -143,7 +143,6 @@ target_sources(viamsdk
       ../../viam/sdk/common/linear_algebra.hpp
       ../../viam/sdk/common/pose.hpp
       ../../viam/sdk/common/proto_convert.hpp
-      ../../viam/sdk/common/proto_convert_vector.hpp
       ../../viam/sdk/common/proto_value.hpp
       ../../viam/sdk/common/service_helper.hpp
       ../../viam/sdk/common/utils.hpp

src/viam/sdk/common/private/repeated_ptr_convert.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <vector>
+
+#include <google/protobuf/repeated_field.h>
+
+#include <viam/sdk/common/proto_convert.hpp>
+
+namespace viam {
+namespace sdk {
+namespace impl {
+
+struct to_repeated_field_ {
+    template <typename T, typename = EquivalentApiType<T>>
+    auto operator()(const std::vector<T>& v) const {
+        ::google::protobuf::RepeatedPtrField<EquivalentApiType<T>> result;
+        result.Reserve(v.size());
+
+        for (const auto& elem : v) {
+            *(result.Add()) = v2::to_proto(elem);
+        }
+
+        return result;
+    }
+};
+
+struct from_repeated_field_ {
+    template <typename T, typename = EquivalentSdkType<T>>
+    auto operator()(const ::google::protobuf::RepeatedPtrField<T>& v) const {
+        std::vector<EquivalentSdkType<T>> result;
+        result.reserve(v.size());
+
+        for (const auto& elem : v) {
+            result.push_back(v2::from_proto(elem));
+        }
+
+        return result;
+    }
+};
+
+constexpr to_repeated_field_ to_repeated_field;
+constexpr from_repeated_field_ from_repeated_field;
+
+}  // namespace impl
+}  // namespace sdk
+}  // namespace viam

src/viam/sdk/common/proto_convert_vector.hpp

@@ -3,7 +3,7 @@
 #include <common/v1/common.pb.h>
 
 #include <viam/sdk/common/pose.hpp>
-#include <viam/sdk/common/proto_convert_vector.hpp>
+#include <viam/sdk/common/private/repeated_ptr_convert.hpp>
 
 namespace viam {
 namespace sdk {
@@ -38,13 +38,13 @@ namespace proto_convert_details {
 
 void to_proto<WorldState::geometries_in_frame>::operator()(
     const WorldState::geometries_in_frame& self, common::v1::GeometriesInFrame* proto) const {
-    *(proto->mutable_geometries()) = v2::to_proto(self.geometries);
+    *(proto->mutable_geometries()) = impl::to_repeated_field(self.geometries);
     *(proto->mutable_reference_frame()) = self.reference_frame;
 }
 
 WorldState::geometries_in_frame from_proto<common::v1::GeometriesInFrame>::operator()(
     const common::v1::GeometriesInFrame* proto) const {
-    return {v2::from_proto(proto->geometries()), proto->reference_frame()};
+    return {impl::from_repeated_field(proto->geometries()), proto->reference_frame()};
 }
 
 void to_proto<WorldState::transform>::operator()(const WorldState::transform& self,
@@ -68,13 +68,14 @@ WorldState::transform from_proto<common::v1::Transform>::operator()(
 }
 
 void to_proto<WorldState>::operator()(const WorldState& self, common::v1::WorldState* proto) const {
-    *(proto->mutable_obstacles()) = v2::to_proto(self.obstacles());
-    *(proto->mutable_transforms()) = v2::to_proto(self.transforms());
+    *(proto->mutable_obstacles()) = impl::to_repeated_field(self.obstacles());
+    *(proto->mutable_transforms()) = impl::to_repeated_field(self.transforms());
 }
 
 WorldState from_proto<common::v1::WorldState>::operator()(
     const common::v1::WorldState* proto) const {
-    return WorldState(v2::from_proto(proto->obstacles()), v2::from_proto(proto->transforms()));
+    return WorldState(impl::from_repeated_field(proto->obstacles()),
+                      impl::from_repeated_field(proto->transforms()));
 }
 
 }  // namespace proto_convert_details

src/viam/sdk/common/world_state.cpp

@@ -368,7 +368,7 @@ std::vector<RobotClient::frame_system_config> RobotClient::get_frame_system_conf
     viam::robot::v1::FrameSystemConfigResponse resp;
     ClientContext ctx;
 
-    *(req.mutable_supplemental_transforms()) = v2::to_proto(additional_transforms);
+    *(req.mutable_supplemental_transforms()) = sdk::impl::to_repeated_field(additional_transforms);
 
     const grpc::Status response = impl_->stub_->FrameSystemConfig(ctx, req, &resp);
     if (is_error_response(response)) {
@@ -397,7 +397,7 @@ pose_in_frame RobotClient::transform_pose(
 
     *req.mutable_source() = v2::to_proto(query);
     *req.mutable_destination() = std::move(destination);
-    *req.mutable_supplemental_transforms() = v2::to_proto(additional_transforms);
+    *req.mutable_supplemental_transforms() = sdk::impl::to_repeated_field(additional_transforms);
 
     const grpc::Status response = impl_->stub_->TransformPose(ctx, req, &resp);
     if (is_error_response(response)) {

src/viam/sdk/robot/client.cpp

@@ -8,7 +8,7 @@
 #include <viam/api/service/motion/v1/motion.pb.h>
 
 #include <viam/sdk/common/client_helper.hpp>
-#include <viam/sdk/common/proto_convert_vector.hpp>
+#include <viam/sdk/common/private/repeated_ptr_convert.hpp>
 #include <viam/sdk/common/proto_value.hpp>
 #include <viam/sdk/common/utils.hpp>
 #include <viam/sdk/services/motion.hpp>
@@ -246,13 +246,13 @@ std::string MotionClient::move_on_globe(
                       request.set_heading(*heading);
                   }
 
-                  *request.mutable_obstacles() = v2::to_proto(obstacles);
+                  *request.mutable_obstacles() = impl::to_repeated_field(obstacles);
 
                   if (motion_configuration) {
                       *request.mutable_motion_configuration() = to_proto(*motion_configuration);
                   }
 
-                  *request.mutable_bounding_regions() = v2::to_proto(bounding_regions);
+                  *request.mutable_bounding_regions() = impl::to_repeated_field(bounding_regions);
               })
         .invoke([](auto& response) { return response.execution_id(); });
 }
@@ -268,7 +268,7 @@ pose_in_frame MotionClient::get_pose(
                   *request.mutable_component_name() = component_name.to_proto();
                   *request.mutable_destination_frame() = destination_frame;
                   *request.mutable_supplemental_transforms() =
-                      v2::to_proto(supplemental_transforms);
+                      impl::to_repeated_field(supplemental_transforms);
               })
         .invoke([](auto& response) { return v2::from_proto(response.pose()); });
 }

src/viam/sdk/services/private/motion_client.cpp

@@ -4,7 +4,7 @@
 
 #include <viam/sdk/common/exception.hpp>
 #include <viam/sdk/common/pose.hpp>
-#include <viam/sdk/common/proto_convert_vector.hpp>
+#include <viam/sdk/common/private/repeated_ptr_convert.hpp>
 #include <viam/sdk/common/proto_value.hpp>
 #include <viam/sdk/common/service_helper.hpp>
 #include <viam/sdk/common/utils.hpp>
@@ -232,9 +232,9 @@ ::grpc::Status MotionServer::MoveOnGlobe(
         const auto destination = v2::from_proto(request->destination());
         const auto component_name = Name::from_proto(request->component_name());
         const auto movement_sensor_name = Name::from_proto(request->movement_sensor_name());
-        const std::vector<geo_geometry> obstacles = v2::from_proto(request->obstacles());
+        const std::vector<geo_geometry> obstacles = impl::from_repeated_field(request->obstacles());
         const std::vector<geo_geometry> bounding_regions =
-            v2::from_proto(request->bounding_regions());
+            impl::from_repeated_field(request->bounding_regions());
 
         boost::optional<double> heading;
         if (request->has_heading()) {

src/viam/sdk/services/private/motion_server.cpp

@@ -8,7 +8,7 @@
 #include <viam/api/service/navigation/v1/navigation.pb.h>
 
 #include <viam/sdk/common/client_helper.hpp>
-#include <viam/sdk/common/proto_convert_vector.hpp>
+#include <viam/sdk/common/private/repeated_ptr_convert.hpp>
 #include <viam/sdk/common/proto_value.hpp>
 #include <viam/sdk/common/utils.hpp>
 #include <viam/sdk/services/navigation.hpp>
@@ -21,7 +21,7 @@ namespace proto_convert_details {
 template <>
 struct from_proto<service::navigation::v1::Path> {
     Navigation::Path operator()(const service::navigation::v1::Path* proto) const {
-        return {proto->destination_waypoint_id(), v2::from_proto(proto->geopoints())};
+        return {proto->destination_waypoint_id(), impl::from_repeated_field(proto->geopoints())};
     }
 };
 
@@ -72,7 +72,7 @@ Navigation::LocationResponse NavigationClient::get_location(const ProtoStruct& e
 std::vector<Navigation::Waypoint> NavigationClient::get_waypoints(const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetWaypoints)
         .with([&](auto& request) { *request.mutable_extra() = v2::to_proto(extra); })
-        .invoke([](auto& response) { return v2::from_proto(response.waypoints()); });
+        .invoke([](auto& response) { return impl::from_repeated_field(response.waypoints()); });
 }
 
 void NavigationClient::add_waypoint(const geo_point& location, const ProtoStruct& extra) {
@@ -96,13 +96,13 @@ void NavigationClient::remove_waypoint(const std::string id, const ProtoStruct&
 std::vector<geo_geometry> NavigationClient::get_obstacles(const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetObstacles)
         .with([&](auto& request) { *request.mutable_extra() = v2::to_proto(extra); })
-        .invoke([](auto& response) { return v2::from_proto(response.obstacles()); });
+        .invoke([](auto& response) { return impl::from_repeated_field(response.obstacles()); });
 }
 
 std::vector<NavigationClient::Path> NavigationClient::get_paths(const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetPaths)
         .with([&](auto& request) { *request.mutable_extra() = v2::to_proto(extra); })
-        .invoke([](auto& response) { return v2::from_proto(response.paths()); });
+        .invoke([](auto& response) { return impl::from_repeated_field(response.paths()); });
 }
 
 NavigationClient::Properties NavigationClient::get_properties() {

src/viam/sdk/services/private/navigation_client.cpp

@@ -19,7 +19,7 @@ template <>
 struct to_proto<Navigation::Path> {
     void operator()(const Navigation::Path& self, service::navigation::v1::Path* proto) const {
         *(proto->mutable_destination_waypoint_id()) = self.destination_waypoint_id;
-        *(proto->mutable_geopoints()) = v2::to_proto(self.geopoints);
+        *(proto->mutable_geopoints()) = impl::to_repeated_field(self.geopoints);
     }
 };
 
@@ -72,7 +72,8 @@ ::grpc::Status NavigationServer::GetWaypoints(::grpc::ServerContext*,
                                               GetWaypointsResponse* response) noexcept {
     return make_service_helper<Navigation>(
         "NavigationServer::GetWaypoints", this, request)([&](auto& helper, auto& nav) {
-        *(response->mutable_waypoints()) = v2::to_proto(nav->get_waypoints(helper.getExtra()));
+        *(response->mutable_waypoints()) =
+            impl::to_repeated_field(nav->get_waypoints(helper.getExtra()));
     });
 }
 
@@ -97,7 +98,8 @@ ::grpc::Status NavigationServer::GetObstacles(::grpc::ServerContext*,
                                               GetObstaclesResponse* response) noexcept {
     return make_service_helper<Navigation>(
         "NavigationServer::GetObstacles", this, request)([&](auto& helper, auto& nav) {
-        *(response->mutable_obstacles()) = v2::to_proto(nav->get_obstacles(helper.getExtra()));
+        *(response->mutable_obstacles()) =
+            impl::to_repeated_field(nav->get_obstacles(helper.getExtra()));
     });
 }
 
@@ -106,7 +108,7 @@ ::grpc::Status NavigationServer::GetPaths(::grpc::ServerContext*,
                                           GetPathsResponse* response) noexcept {
     return make_service_helper<Navigation>(
         "NavigationServer::GetPaths", this, request)([&](auto& helper, auto& nav) {
-        *response->mutable_paths() = v2::to_proto(nav->get_paths(helper.getExtra()));
+        *response->mutable_paths() = impl::to_repeated_field(nav->get_paths(helper.getExtra()));
     });
 }
 

src/viam/sdk/services/private/navigation_server.cpp

@@ -198,17 +198,17 @@ geo_point from_proto<common::v1::GeoPoint>::operator()(const common::v1::GeoPoin
 void to_proto<geo_geometry>::operator()(const geo_geometry& self,
                                         common::v1::GeoGeometry* proto) const {
     *(proto->mutable_location()) = v2::to_proto(self.location);
-    *(proto->mutable_geometries()) = v2::to_proto(self.geometries);
+    *(proto->mutable_geometries()) = impl::to_repeated_field(self.geometries);
 }
 
 geo_geometry from_proto<common::v1::GeoGeometry>::operator()(
     const common::v1::GeoGeometry* proto) const {
-    return {v2::from_proto(proto->location()), v2::from_proto(proto->geometries())};
+    return {v2::from_proto(proto->location()), impl::from_repeated_field(proto->geometries())};
 }
 
 std::vector<GeometryConfig> from_proto<common::v1::GetGeometriesResponse>::operator()(
     const common::v1::GetGeometriesResponse* proto) const {
-    return v2::from_proto(proto->geometries());
+    return impl::from_repeated_field(proto->geometries());
 }
 
 }  // namespace proto_convert_details