rename to _impl

Author: lia-viam

src/viam/sdk/common/client_helper.hpp

@@ -85,7 +85,7 @@ class ClientHelper {
             debug_key_ = *value.get<std::string>();
         }
 
-        proto_convert_details::to_proto<ProtoStruct>{}(extra, request_.mutable_extra());
+        proto_convert_details::to_proto_impl<ProtoStruct>{}(extra, request_.mutable_extra());
         return with(std::forward<RequestSetupCallable>(rsc));
     }
 

src/viam/sdk/common/linear_algebra.cpp

@@ -36,13 +36,13 @@ Vector3& Vector3::set_z(double z) {
 
 namespace proto_convert_details {
 
-void to_proto<Vector3>::operator()(const Vector3& self, common::v1::Vector3* proto) const {
+void to_proto_impl<Vector3>::operator()(const Vector3& self, common::v1::Vector3* proto) const {
     proto->set_x(self.x());
     proto->set_y(self.y());
     proto->set_z(self.z());
 }
 
-Vector3 from_proto<common::v1::Vector3>::operator()(const common::v1::Vector3* proto) const {
+Vector3 from_proto_impl<common::v1::Vector3>::operator()(const common::v1::Vector3* proto) const {
     return {proto->x(), proto->y(), proto->z()};
 }
 

src/viam/sdk/common/linear_algebra.hpp

@@ -41,12 +41,12 @@ struct Vector3 {
 namespace proto_convert_details {
 
 template <>
-struct to_proto<Vector3> {
+struct to_proto_impl<Vector3> {
     void operator()(const Vector3&, common::v1::Vector3*) const;
 };
 
 template <>
-struct from_proto<common::v1::Vector3> {
+struct from_proto_impl<common::v1::Vector3> {
     Vector3 operator()(const common::v1::Vector3*) const;
 };
 

src/viam/sdk/common/pose.cpp

@@ -16,7 +16,7 @@ std::ostream& operator<<(std::ostream& os, const pose_in_frame& v) {
 
 namespace proto_convert_details {
 
-void to_proto<pose>::operator()(const pose& self, common::v1::Pose* proto) const {
+void to_proto_impl<pose>::operator()(const pose& self, common::v1::Pose* proto) const {
     proto->set_x(self.coordinates.x);
     proto->set_y(self.coordinates.y);
     proto->set_z(self.coordinates.z);
@@ -26,7 +26,7 @@ void to_proto<pose>::operator()(const pose& self, common::v1::Pose* proto) const
     proto->set_theta(self.theta);
 }
 
-pose from_proto<common::v1::Pose>::operator()(const common::v1::Pose* proto) const {
+pose from_proto_impl<common::v1::Pose>::operator()(const common::v1::Pose* proto) const {
     pose pose;
     pose.coordinates.x = proto->x();
     pose.coordinates.y = proto->y();
@@ -39,19 +39,19 @@ pose from_proto<common::v1::Pose>::operator()(const common::v1::Pose* proto) con
     return pose;
 }
 
-void to_proto<pose_in_frame>::operator()(const pose_in_frame& self,
-                                         common::v1::PoseInFrame* pif) const {
+void to_proto_impl<pose_in_frame>::operator()(const pose_in_frame& self,
+                                              common::v1::PoseInFrame* pif) const {
     *(pif->mutable_reference_frame()) = self.reference_frame;
     common::v1::Pose proto_pose;
-    to_proto<pose>{}(self.pose, &proto_pose);
+    to_proto_impl<pose>{}(self.pose, &proto_pose);
     *(pif->mutable_pose()) = std::move(proto_pose);
 };
 
-pose_in_frame from_proto<common::v1::PoseInFrame>::operator()(
+pose_in_frame from_proto_impl<common::v1::PoseInFrame>::operator()(
     const common::v1::PoseInFrame* proto) const {
     pose_in_frame pif;
     pif.reference_frame = proto->reference_frame();
-    pif.pose = from_proto<common::v1::Pose>{}(&(proto->pose()));
+    pif.pose = from_proto_impl<common::v1::Pose>{}(&(proto->pose()));
 
     return pif;
 }

src/viam/sdk/common/pose.hpp

@@ -50,22 +50,22 @@ struct pose_in_frame {
 namespace proto_convert_details {
 
 template <>
-struct to_proto<pose> {
+struct to_proto_impl<pose> {
     void operator()(const pose&, common::v1::Pose*) const;
 };
 
 template <>
-struct from_proto<common::v1::Pose> {
+struct from_proto_impl<common::v1::Pose> {
     pose operator()(const common::v1::Pose*) const;
 };
 
 template <>
-struct to_proto<pose_in_frame> {
+struct to_proto_impl<pose_in_frame> {
     void operator()(const pose_in_frame&, common::v1::PoseInFrame*) const;
 };
 
 template <>
-struct from_proto<common::v1::PoseInFrame> {
+struct from_proto_impl<common::v1::PoseInFrame> {
     pose_in_frame operator()(const common::v1::PoseInFrame*) const;
 };
 

src/viam/sdk/common/proto_convert.hpp

@@ -25,13 +25,13 @@ constexpr const T static_const<T>::value;
 //      void operator()(const SdkType&, common::v1::ApiType*) const
 // to provide API/ABI insulated proto conversion
 template <typename SdkType>
-struct to_proto;
+struct to_proto_impl;
 
 // This struct should be explicitly specialized with a
 //      SdkType operator()(const ProtoType*) const
 // to provided API/ABI insulated construction from proto
 template <typename ProtoType>
-struct from_proto;
+struct from_proto_impl;
 
 // This is a helper type trait for deducing corresponding API types from a to_proto specialization.
 // We use boost::callable_traits to generate a tuple of the arguments to the to_proto call operator,
@@ -41,23 +41,23 @@ 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_impl {
+struct to_proto_fn {
     template <typename SdkType>
     auto operator()(const SdkType& t) const {
-        using ProtoReturnType = ProtoArgType<to_proto<SdkType>>;
+        using ProtoReturnType = ProtoArgType<to_proto_impl<SdkType>>;
 
         ProtoReturnType ret;
-        to_proto<SdkType>{}(t, &ret);
+        to_proto_impl<SdkType>{}(t, &ret);
 
         return ret;
     }
 };
 
 // Implementation struct for the omni-from_proto callable defined below.
-struct from_proto_impl {
+struct from_proto_fn {
     template <typename ProtoType>
     auto operator()(const ProtoType& proto) const {  // NOLINT(misc-no-recursion)
-        return from_proto<ProtoType>{}(&proto);
+        return from_proto_impl<ProtoType>{}(&proto);
     }
 };
 
@@ -71,13 +71,13 @@ namespace {
 /// 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_impl>::value;
+    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_impl>::value;
+    proto_convert_details::static_const<proto_convert_details::from_proto_fn>::value;
 
 }  // namespace
 
@@ -87,13 +87,13 @@ constexpr auto& from_proto =
 /// This is the return type of calling to_proto on an instance of SdkType.
 template <typename SdkType>
 using EquivalentApiType =
-    proto_convert_details::ProtoArgType<proto_convert_details::to_proto<SdkType>>;
+    proto_convert_details::ProtoArgType<proto_convert_details::to_proto_impl<SdkType>>;
 
 /// @brief Type alias for the SDK type corresponding to a given API type.
 /// This is the return type of calling from_proto on an instance of ApiType.
 template <typename ApiType>
 using EquivalentSdkType =
-    boost::callable_traits::return_type_t<proto_convert_details::from_proto<ApiType>>;
+    boost::callable_traits::return_type_t<proto_convert_details::from_proto_impl<ApiType>>;
 
 }  // namespace sdk
 }  // namespace viam

src/viam/sdk/common/proto_value.cpp

@@ -250,11 +250,12 @@ void to_value(const ProtoStruct& m, Value* v) {
 
 namespace proto_convert_details {
 
-void to_proto<ProtoValue>::operator()(const ProtoValue& self, google::protobuf::Value* v) const {
+void to_proto_impl<ProtoValue>::operator()(const ProtoValue& self,
+                                           google::protobuf::Value* v) const {
     self.vtable_.to_value(self.self_.get(), v);
 }
 
-ProtoValue from_proto<google::protobuf::Value>::operator()(  // NOLINT(misc-no-recursion)
+ProtoValue from_proto_impl<google::protobuf::Value>::operator()(  // NOLINT(misc-no-recursion)
     const google::protobuf::Value* v) const {
     switch (v->kind_case()) {
         case Value::KindCase::kBoolValue: {
@@ -285,14 +286,15 @@ ProtoValue from_proto<google::protobuf::Value>::operator()(  // NOLINT(misc-no-r
     }
 }
 
-void to_proto<ProtoStruct>::operator()(const ProtoStruct& self, google::protobuf::Struct* s) const {
+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)));
     }
 }
 
-ProtoStruct from_proto<google::protobuf::Struct>::operator()(  // NOLINT(misc-no-recursion)
+ProtoStruct from_proto_impl<google::protobuf::Struct>::operator()(  // NOLINT(misc-no-recursion)
     const google::protobuf::Struct* s) const {
     ProtoStruct result;
 

src/viam/sdk/common/proto_value.hpp

@@ -54,7 +54,7 @@ struct all_moves_noexcept
 /// definition.
 class ProtoValue {
    public:
-    friend proto_convert_details::to_proto<ProtoValue>;
+    friend proto_convert_details::to_proto_impl<ProtoValue>;
 
     /// @brief Type discriminator constants for possible values stored in a ProtoValue.
     enum Kind { k_null = 0, k_bool = 1, k_double = 2, k_string = 3, k_list = 4, k_struct = 5 };
@@ -318,22 +318,22 @@ extern template ProtoStruct&& ProtoValue::get_unchecked<ProtoStruct>() &&;
 namespace proto_convert_details {
 
 template <>
-struct to_proto<ProtoValue> {
+struct to_proto_impl<ProtoValue> {
     void operator()(const ProtoValue&, google::protobuf::Value*) const;
 };
 
 template <>
-struct to_proto<ProtoStruct> {
+struct to_proto_impl<ProtoStruct> {
     void operator()(const ProtoStruct&, google::protobuf::Struct*) const;
 };
 
 template <>
-struct from_proto<google::protobuf::Value> {
+struct from_proto_impl<google::protobuf::Value> {
     ProtoValue operator()(const google::protobuf::Value*) const;
 };
 
 template <>
-struct from_proto<google::protobuf::Struct> {
+struct from_proto_impl<google::protobuf::Struct> {
     ProtoStruct operator()(const google::protobuf::Struct*) const;
 };
 

src/viam/sdk/common/utils.cpp

@@ -30,7 +30,7 @@ bool operator==(const response_metadata& lhs, const response_metadata& rhs) {
 
 namespace proto_convert_details {
 
-void to_proto<time_pt>::operator()(time_pt tp, google::protobuf::Timestamp* result) const {
+void to_proto_impl<time_pt>::operator()(time_pt tp, google::protobuf::Timestamp* result) const {
     const std::chrono::nanoseconds since_epoch = tp.time_since_epoch();
 
     const auto sec_floor = std::chrono::duration_cast<std::chrono::seconds>(since_epoch);
@@ -40,14 +40,14 @@ void to_proto<time_pt>::operator()(time_pt tp, google::protobuf::Timestamp* resu
     result->set_nanos(static_cast<int32_t>(nano_part.count()));
 }
 
-time_pt from_proto<google::protobuf::Timestamp>::operator()(
+time_pt from_proto_impl<google::protobuf::Timestamp>::operator()(
     const google::protobuf::Timestamp* timestamp) const {
     return time_pt{std::chrono::seconds{timestamp->seconds()} +
                    std::chrono::nanoseconds{timestamp->nanos()}};
 }
 
-void to_proto<std::chrono::microseconds>::operator()(std::chrono::microseconds duration,
-                                                     google::protobuf::Duration* proto) const {
+void to_proto_impl<std::chrono::microseconds>::operator()(std::chrono::microseconds duration,
+                                                          google::protobuf::Duration* proto) const {
     namespace sc = std::chrono;
 
     const sc::seconds seconds = sc::duration_cast<sc::seconds>(duration);
@@ -57,7 +57,7 @@ void to_proto<std::chrono::microseconds>::operator()(std::chrono::microseconds d
     proto->set_seconds(seconds.count());
 }
 
-std::chrono::microseconds from_proto<google::protobuf::Duration>::operator()(
+std::chrono::microseconds from_proto_impl<google::protobuf::Duration>::operator()(
     const google::protobuf::Duration* proto) const {
     namespace sc = std::chrono;
     const sc::seconds seconds_part{proto->seconds()};
@@ -74,12 +74,12 @@ std::chrono::microseconds from_proto<google::protobuf::Duration>::operator()(
     return from_seconds + from_nanos;
 }
 
-void to_proto<response_metadata>::operator()(const response_metadata& self,
-                                             common::v1::ResponseMetadata* proto) const {
+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);
 }
 
-response_metadata from_proto<common::v1::ResponseMetadata>::operator()(
+response_metadata from_proto_impl<common::v1::ResponseMetadata>::operator()(
     const common::v1::ResponseMetadata* proto) const {
     return {v2::from_proto(proto->captured_at())};
 }

src/viam/sdk/common/utils.hpp

@@ -48,32 +48,32 @@ bool operator==(const response_metadata& lhs, const response_metadata& rhs);
 namespace proto_convert_details {
 
 template <>
-struct to_proto<time_pt> {
+struct to_proto_impl<time_pt> {
     void operator()(time_pt, google::protobuf::Timestamp*) const;
 };
 
 template <>
-struct from_proto<google::protobuf::Timestamp> {
+struct from_proto_impl<google::protobuf::Timestamp> {
     time_pt operator()(const google::protobuf::Timestamp*) const;
 };
 
 template <>
-struct to_proto<std::chrono::microseconds> {
+struct to_proto_impl<std::chrono::microseconds> {
     void operator()(std::chrono::microseconds, google::protobuf::Duration*) const;
 };
 
 template <>
-struct from_proto<google::protobuf::Duration> {
+struct from_proto_impl<google::protobuf::Duration> {
     std::chrono::microseconds operator()(const google::protobuf::Duration*) const;
 };
 
 template <>
-struct to_proto<response_metadata> {
+struct to_proto_impl<response_metadata> {
     void operator()(const response_metadata&, common::v1::ResponseMetadata*) const;
 };
 
 template <>
-struct from_proto<common::v1::ResponseMetadata> {
+struct from_proto_impl<common::v1::ResponseMetadata> {
     response_metadata operator()(const common::v1::ResponseMetadata*) const;
 };