make to_proto and from_proto normal functions and remove v2 namespace

Author: lia-viam

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

@@ -10,42 +10,29 @@ 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());
+template <typename T, typename = EquivalentApiType<T>>
+auto to_repeated_field(const std::vector<T>& v) {
+    ::google::protobuf::RepeatedPtrField<EquivalentApiType<T>> result;
+    result.Reserve(v.size());
 
-        for (const auto& elem : v) {
-            *(result.Add()) = v2::to_proto(elem);
-        }
-
-        return result;
+    for (const auto& elem : v) {
+        *(result.Add()) = to_proto(elem);
     }
-};
 
-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());
+    return result;
+}
 
-        for (const auto& elem : v) {
-            result.push_back(v2::from_proto(elem));
-        }
+template <typename T, typename = EquivalentSdkType<T>>
+auto from_repeated_field(const ::google::protobuf::RepeatedPtrField<T>& v) {
+    std::vector<EquivalentSdkType<T>> result;
+    result.reserve(v.size());
 
-        return result;
+    for (const auto& elem : v) {
+        result.push_back(from_proto(elem));
     }
-};
-
-namespace {
-
-constexpr auto& to_repeated_field = proto_convert_details::static_const<to_repeated_field_>::value;
-
-constexpr auto& from_repeated_field =
-    proto_convert_details::static_const<from_repeated_field_>::value;
 
-}  // namespace
+    return result;
+}
 
 }  // namespace impl
 }  // namespace sdk

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

@@ -51,7 +51,7 @@ class ServiceHelper : public ServiceHelperBase {
     }
 
     auto getExtra() const {
-        return request_->has_extra() ? v2::from_proto(request_->extra()) : ProtoStruct{};
+        return request_->has_extra() ? from_proto(request_->extra()) : ProtoStruct{};
     }
 
    private:

src/viam/sdk/common/proto_convert.hpp

@@ -11,16 +11,6 @@ namespace sdk {
 
 namespace proto_convert_details {
 
-// This is copied from range-v3 to allow the definition of callable object instances without
-// ODR/linkage issues. It is obviated in C++17 and onwards by constexpr inline.
-template <typename T>
-struct static_const {
-    static constexpr const T value{};
-};
-
-template <typename T>
-constexpr const T static_const<T>::value;
-
 // This struct should be explicitly specialized with a
 //      void operator()(const SdkType&, common::v1::ApiType*) const
 // to provide API/ABI insulated proto conversion
@@ -40,48 +30,30 @@ template <typename Callable>
 using ProtoArgType = std::remove_pointer_t<
     boost::mp11::mp_back<boost::callable_traits::args_t<Callable, boost::mp11::mp_list>>>;
 
-// Implementation struct for the omni-to_proto callable defined below.
-struct to_proto_fn {
-    template <typename SdkType>
-    auto operator()(const SdkType& t) const {
-        using ProtoReturnType = ProtoArgType<to_proto_impl<SdkType>>;
-
-        ProtoReturnType ret;
-        to_proto_impl<SdkType>{}(t, &ret);
-
-        return ret;
-    }
-};
-
-// Implementation struct for the omni-from_proto callable defined below.
-struct from_proto_fn {
-    template <typename ProtoType>
-    auto operator()(const ProtoType& proto) const {  // NOLINT(misc-no-recursion)
-        return from_proto_impl<ProtoType>{}(&proto);
-    }
-};
-
 }  // namespace proto_convert_details
 
-namespace v2 {
-
-namespace {
-
-/// @brief Function object implementing conversion from an SDK type to an API type.
-/// This callable works for any type with a proto_convert_details::to_proto specialization as
-/// described above.
-constexpr auto& to_proto =
-    proto_convert_details::static_const<proto_convert_details::to_proto_fn>::value;
-
-/// @brief Function object implementing conversion from an API type to an SDK type.
-/// This callable works for any type with a proto_convert_details::from_proto specialization as
-/// described above.
-constexpr auto& from_proto =
-    proto_convert_details::static_const<proto_convert_details::from_proto_fn>::value;
-
-}  // namespace
-
-}  // namespace v2
+/// @brief Convert an SDK type to its corresponding API type.
+/// @remark Only participates in overload resolution if to_proto_impl<SdkType> has been specialized.
+template <typename SdkType,
+          typename = decltype(sizeof(proto_convert_details::to_proto_impl<SdkType>))>
+auto to_proto(const SdkType& t) {
+    namespace pcd = proto_convert_details;
+    using ProtoReturnType = pcd::ProtoArgType<pcd::to_proto_impl<SdkType>>;
+
+    ProtoReturnType ret;
+    pcd::to_proto_impl<SdkType>{}(t, &ret);
+
+    return ret;
+}
+
+/// @brief Convert an API type to its corresponding SDK type.
+/// @remark Only participates in overload resolution if from_proto_impl<ApiType> has been
+/// specialized.
+template <typename ApiType,
+          typename = decltype(sizeof(proto_convert_details::from_proto_impl<ApiType>))>
+auto from_proto(const ApiType& proto) {
+    return proto_convert_details::from_proto_impl<ApiType>{}(&proto);
+}
 
 /// @brief Type alias for the API type corresponding to a given SDK type.
 /// This is the return type of calling to_proto on an instance of SdkType.

src/viam/sdk/common/proto_value.cpp

@@ -237,13 +237,13 @@ void to_value(std::string s, Value* v) {
 void to_value(const ProtoList& vec, Value* v) {
     ::google::protobuf::ListValue l;
     for (const auto& val : vec) {
-        *l.add_values() = v2::to_proto(val);
+        *l.add_values() = to_proto(val);
     }
     *(v->mutable_list_value()) = std::move(l);
 }
 
 void to_value(const ProtoStruct& m, Value* v) {
-    *(v->mutable_struct_value()) = v2::to_proto(m);
+    *(v->mutable_struct_value()) = to_proto(m);
 }
 
 }  // namespace proto_value_details
@@ -271,13 +271,13 @@ ProtoValue from_proto_impl<google::protobuf::Value>::operator()(  // NOLINT(misc
             ProtoList vec;
             vec.reserve(v->list_value().values_size());
             for (const Value& list_val : v->list_value().values()) {
-                vec.push_back(v2::from_proto(list_val));
+                vec.push_back(from_proto(list_val));
             }
 
             return ProtoValue(std::move(vec));
         }
         case Value::KindCase::kStructValue: {
-            return ProtoValue(v2::from_proto(v->struct_value()));
+            return ProtoValue(from_proto(v->struct_value()));
         }
         case Value::KindCase::KIND_NOT_SET:
         case Value::KindCase::kNullValue:
@@ -290,7 +290,7 @@ void to_proto_impl<ProtoStruct>::operator()(const ProtoStruct& self,
                                             google::protobuf::Struct* s) const {
     for (const auto& kv : self) {
         s->mutable_fields()->insert(
-            google::protobuf::MapPair<std::string, Value>(kv.first, v2::to_proto(kv.second)));
+            google::protobuf::MapPair<std::string, Value>(kv.first, to_proto(kv.second)));
     }
 }
 
@@ -299,7 +299,7 @@ ProtoStruct from_proto_impl<google::protobuf::Struct>::operator()(  // NOLINT(mi
     ProtoStruct result;
 
     for (const auto& val : s->fields()) {
-        result.emplace(val.first, v2::from_proto(val.second));
+        result.emplace(val.first, from_proto(val.second));
     }
 
     return result;

src/viam/sdk/common/utils.cpp

@@ -76,12 +76,12 @@ std::chrono::microseconds from_proto_impl<google::protobuf::Duration>::operator(
 
 void to_proto_impl<response_metadata>::operator()(const response_metadata& self,
                                                   common::v1::ResponseMetadata* proto) const {
-    *(proto->mutable_captured_at()) = v2::to_proto(self.captured_at);
+    *(proto->mutable_captured_at()) = to_proto(self.captured_at);
 }
 
 response_metadata from_proto_impl<common::v1::ResponseMetadata>::operator()(
     const common::v1::ResponseMetadata* proto) const {
-    return {v2::from_proto(proto->captured_at())};
+    return {from_proto(proto->captured_at())};
 }
 
 }  // namespace proto_convert_details

src/viam/sdk/common/utils.hpp

@@ -5,6 +5,7 @@
 
 #include <boost/optional/optional.hpp>
 
+#include <viam/sdk/common/proto_convert.hpp>
 #include <viam/sdk/common/proto_value.hpp>
 #include <viam/sdk/components/component.hpp>
 #include <viam/sdk/resource/resource_api.hpp>

src/viam/sdk/common/world_state.cpp

@@ -50,18 +50,18 @@ WorldState::geometries_in_frame from_proto_impl<common::v1::GeometriesInFrame>::
 void to_proto_impl<WorldState::transform>::operator()(const WorldState::transform& self,
                                                       common::v1::Transform* proto) const {
     *(proto->mutable_reference_frame()) = self.reference_frame;
-    *(proto->mutable_pose_in_observer_frame()) = v2::to_proto(self.pose_in_observer_frame);
+    *(proto->mutable_pose_in_observer_frame()) = to_proto(self.pose_in_observer_frame);
     if (self.physical_object) {
-        *(proto->mutable_physical_object()) = v2::to_proto(*self.physical_object);
+        *(proto->mutable_physical_object()) = to_proto(*self.physical_object);
     }
 }
 
 WorldState::transform from_proto_impl<common::v1::Transform>::operator()(
     const common::v1::Transform* proto) const {
     WorldState::transform result{proto->reference_frame(),
-                                 v2::from_proto(proto->pose_in_observer_frame())};
+                                 from_proto(proto->pose_in_observer_frame())};
     if (proto->has_physical_object()) {
-        result.physical_object = v2::from_proto(proto->physical_object());
+        result.physical_object = from_proto(proto->physical_object());
     }
 
     return result;

src/viam/sdk/components/private/arm_client.cpp

@@ -17,12 +17,12 @@ ArmClient::ArmClient(std::string name, std::shared_ptr<grpc::Channel> channel)
 pose ArmClient::get_end_position(const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetEndPosition)
         .with(extra)
-        .invoke([&](auto& response) { return v2::from_proto(response.pose()); });
+        .invoke([&](auto& response) { return from_proto(response.pose()); });
 }
 
 void ArmClient::move_to_position(const pose& pose, const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::MoveToPosition)
-        .with(extra, [&](auto& request) { *request.mutable_to() = v2::to_proto(pose); })
+        .with(extra, [&](auto& request) { *request.mutable_to() = to_proto(pose); })
         .invoke();
 }
 
@@ -83,8 +83,8 @@ void ArmClient::stop(const ProtoStruct& extra) {
 
 ProtoStruct ArmClient::do_command(const ProtoStruct& command) {
     return make_client_helper(this, *stub_, &StubType::DoCommand)
-        .with([&](auto& request) { *request.mutable_command() = v2::to_proto(command); })
-        .invoke([](auto& response) { return v2::from_proto(response.result()); });
+        .with([&](auto& request) { *request.mutable_command() = to_proto(command); })
+        .invoke([](auto& response) { return from_proto(response.result()); });
 }
 
 Arm::KinematicsData ArmClient::get_kinematics(const ProtoStruct& extra) {
@@ -109,7 +109,7 @@ Arm::KinematicsData ArmClient::get_kinematics(const ProtoStruct& extra) {
 std::vector<GeometryConfig> ArmClient::get_geometries(const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetGeometries)
         .with(extra)
-        .invoke([](auto& response) { return v2::from_proto(response); });
+        .invoke([](auto& response) { return from_proto(response); });
 }
 
 }  // namespace impl

src/viam/sdk/components/private/arm_server.cpp

@@ -16,7 +16,7 @@ ::grpc::Status ArmServer::GetEndPosition(
     return make_service_helper<Arm>(
         "ArmServer::GetEndPosition", this, request)([&](auto& helper, auto& arm) {
         const pose p = arm->get_end_position(helper.getExtra());
-        *response->mutable_pose() = v2::to_proto(p);
+        *response->mutable_pose() = to_proto(p);
     });
 }
 
@@ -26,7 +26,7 @@ ::grpc::Status ArmServer::MoveToPosition(
     ::viam::component::arm::v1::MoveToPositionResponse*) noexcept {
     return make_service_helper<Arm>(
         "ArmServer::MoveToPosition", this, request)([&](auto& helper, auto& arm) {
-        arm->move_to_position(v2::from_proto(request->to()), helper.getExtra());
+        arm->move_to_position(from_proto(request->to()), helper.getExtra());
     });
 }
 
@@ -98,8 +98,8 @@ ::grpc::Status ArmServer::DoCommand(::grpc::ServerContext*,
                                     const ::viam::common::v1::DoCommandRequest* request,
                                     ::viam::common::v1::DoCommandResponse* response) noexcept {
     return make_service_helper<Arm>("ArmServer::DoCommand", this, request)([&](auto&, auto& arm) {
-        const ProtoStruct result = arm->do_command(v2::from_proto(request->command()));
-        *response->mutable_result() = v2::to_proto(result);
+        const ProtoStruct result = arm->do_command(from_proto(request->command()));
+        *response->mutable_result() = to_proto(result);
     });
 }
 
@@ -143,7 +143,7 @@ ::grpc::Status ArmServer::GetGeometries(
         "ArmServer::GetGeometries", this, request)([&](auto& helper, auto& arm) {
         const std::vector<GeometryConfig> geometries = arm->get_geometries(helper.getExtra());
         for (const auto& geometry : geometries) {
-            *response->mutable_geometries()->Add() = v2::to_proto(geometry);
+            *response->mutable_geometries()->Add() = to_proto(geometry);
         }
     });
 }

src/viam/sdk/components/private/base_client.cpp

@@ -53,8 +53,8 @@ void BaseClient::set_power(const Vector3& linear,
     return make_client_helper(this, *stub_, &StubType::SetPower)
         .with(extra,
               [&](auto& request) {
-                  *request.mutable_linear() = v2::to_proto(linear);
-                  *request.mutable_angular() = v2::to_proto(angular);
+                  *request.mutable_linear() = to_proto(linear);
+                  *request.mutable_angular() = to_proto(angular);
               })
         .invoke();
 }
@@ -65,8 +65,8 @@ void BaseClient::set_velocity(const Vector3& linear,
     return make_client_helper(this, *stub_, &StubType::SetVelocity)
         .with(extra,
               [&](auto& request) {
-                  *request.mutable_linear() = v2::to_proto(linear);
-                  *request.mutable_angular() = v2::to_proto(angular);
+                  *request.mutable_linear() = to_proto(linear);
+                  *request.mutable_angular() = to_proto(angular);
               })
         .invoke();
 }
@@ -84,7 +84,7 @@ bool BaseClient::is_moving() {
 std::vector<GeometryConfig> BaseClient::get_geometries(const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetGeometries)
         .with(extra)
-        .invoke([](auto& response) { return v2::from_proto(response); });
+        .invoke([](auto& response) { return from_proto(response); });
 }
 
 Base::properties BaseClient::get_properties(const ProtoStruct& extra) {
@@ -99,8 +99,8 @@ Base::properties BaseClient::get_properties(const ProtoStruct& extra) {
 
 ProtoStruct BaseClient::do_command(const ProtoStruct& command) {
     return make_client_helper(this, *stub_, &StubType::DoCommand)
-        .with([&](auto& request) { *request.mutable_command() = v2::to_proto(command); })
-        .invoke([](auto& response) { return v2::from_proto(response.result()); });
+        .with([&](auto& request) { *request.mutable_command() = to_proto(command); })
+        .invoke([](auto& response) { return from_proto(response.result()); });
 }
 
 }  // namespace impl