[WORKFLOW] AI update based on proto changes from commit 90357e0

Author: viambot

src/viam/sdk/common/kinematics.cpp

@@ -0,0 +1,42 @@
+#include <viam/sdk/common/kinematics.hpp>
+
+#include <ostream>
+
+namespace viam {
+namespace sdk {
+
+bool KinematicsFileConfig::operator==(const KinematicsFileConfig& other) const {
+    return kinematics_type == other.kinematics_type && extra == other.extra;
+}
+
+namespace proto_convert_details {
+
+template <>
+struct to_proto_impl<KinematicsFileConfig> {
+    void operator()(const KinematicsFileConfig& kinematics, viam::common::v1::KinematicsFileConfig* proto) const {
+        proto->set_kinematics_type(static_cast<viam::common::v1::KinematicsType>(kinematics.kinematics_type));
+        *proto->mutable_extra() = to_proto(kinematics.extra);
+    }
+};
+
+template <>
+struct from_proto_impl<viam::common::v1::KinematicsFileConfig> {
+    KinematicsFileConfig operator()(const viam::common::v1::KinematicsFileConfig* proto) const {
+        KinematicsFileConfig kinematics;
+        kinematics.kinematics_type = static_cast<KinematicsType>(proto->kinematics_type());
+        kinematics.extra = from_proto(proto->extra());
+        return kinematics;
+    }
+};
+
+}  // namespace proto_convert_details
+
+// For Boost test logging
+std::ostream& operator<<(std::ostream& os, const KinematicsFileConfig& kinematics) {
+    os << "{kinematics_type: " << static_cast<int>(kinematics.kinematics_type)
+       << ", extra: " << kinematics.extra.ShortDebugString() << "}";
+    return os;
+}
+
+}  // namespace sdk
+}  // namespace viam

src/viam/sdk/common/kinematics.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <string>
+
+#include <viam/api/common/v1/common.pb.h>
+#include <viam/sdk/common/proto_convert.hpp>
+#include <viam/sdk/common/proto_value.hpp>
+
+namespace viam {
+namespace sdk {
+
+/// @defgroup Kinematics Classes related to Kinematics configuration
+
+/// @enum KinematicsType
+/// @brief Defines the type of kinematics configuration.
+/// @ingroup Kinematics
+enum class KinematicsType {
+    KINEMATICS_TYPE_UNSPECIFIED = 0,
+    KINEMATICS_TYPE_SIX_AXIS_ARM = 1,
+    KINEMATICS_TYPE_GANTRY = 2,
+    KINEMATICS_TYPE_CARTESIAN = 3,
+    KINEMATICS_TYPE_CUSTOM = 4
+};
+
+/// @struct KinematicsFileConfig
+/// @brief Defines the kinematics configuration of a component.
+/// @ingroup Kinematics
+struct KinematicsFileConfig {
+    /// @brief The type of kinematics configuration.
+    KinematicsType kinematics_type;
+    /// @brief Additional arguments to the method.
+    ProtoStruct extra;
+
+    /// @brief Equality operator for `KinematicsFileConfig`.
+    bool operator==(const KinematicsFileConfig& other) const;
+};
+
+/// @brief Convert an SDK `KinematicsFileConfig` to its corresponding API proto type.
+/// @param kinematics The SDK `KinematicsFileConfig` to convert.
+/// @return The API proto `viam::common::v1::KinematicsFileConfig`.
+viam::common::v1::KinematicsFileConfig to_proto(const KinematicsFileConfig& kinematics);
+
+/// @brief Convert an API proto `viam::common::v1::KinematicsFileConfig` to its corresponding SDK type.
+/// @param proto The API proto `viam::common::v1::KinematicsFileConfig` to convert.
+/// @return The SDK `KinematicsFileConfig`.
+KinematicsFileConfig from_proto(const viam::common::v1::KinematicsFileConfig& proto);
+
+}  // namespace sdk
+}  // namespace viam

src/viam/sdk/components/gantry.hpp

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <viam/sdk/resource/stoppable.hpp>
+#include <viam/sdk/common/kinematics.hpp>
 
 namespace viam {
 namespace sdk {
@@ -86,6 +87,15 @@ class Gantry : public Component, public Stoppable {
     /// @return The result of the executed command.
     virtual ProtoStruct do_command(const ProtoStruct& command) = 0;
 
+    /// @brief Get the Kinematics configuration of the component.
+    inline KinematicsFileConfig get_kinematics() {
+        return get_kinematics({});
+    }
+
+    /// @brief Get the Kinematics configuration of the component.
+    /// @param extra Any additional arguments to the method
+    virtual KinematicsFileConfig get_kinematics(const ProtoStruct& extra) = 0;
+
     /// @brief Returns `GeometryConfig`s associated with the calling gantry
     inline std::vector<GeometryConfig> get_geometries() {
         return get_geometries({});
@@ -107,4 +117,4 @@ struct API::traits<Gantry> {
 };
 
 }  // namespace sdk
-}  // namespace viam
+}  // namespace viam

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

@@ -2,6 +2,7 @@
 
 #include <viam/api/component/gantry/v1/gantry.grpc.pb.h>
 #include <viam/api/component/gantry/v1/gantry.pb.h>
+#include <viam/sdk/common/kinematics.hpp>
 
 #include <viam/sdk/common/client_helper.hpp>
 
@@ -69,6 +70,12 @@ ProtoStruct GantryClient::do_command(const ProtoStruct& command) {
         .invoke([](auto& response) { return from_proto(response.result()); });
 }
 
+KinematicsFileConfig GantryClient::get_kinematics(const ProtoStruct& extra) {
+    return make_client_helper(this, *stub_, &StubType::GetKinematics)
+        .with(extra)
+        .invoke([](auto& response) { return from_proto(response.kinematics()); });
+}
+
 std::vector<GeometryConfig> GantryClient::get_geometries(const ProtoStruct& extra) {
     return make_client_helper(this, *stub_, &StubType::GetGeometries)
         .with(extra)
@@ -77,4 +84,4 @@ std::vector<GeometryConfig> GantryClient::get_geometries(const ProtoStruct& extr
 
 }  // namespace impl
 }  // namespace sdk
-}  // namespace viam
+}  // namespace viam

src/viam/sdk/components/private/gantry_client.hpp

@@ -8,6 +8,7 @@
 #include <viam/api/component/gantry/v1/gantry.grpc.pb.h>
 
 #include <viam/sdk/components/gantry.hpp>
+#include <viam/sdk/common/kinematics.hpp>
 
 namespace viam {
 namespace sdk {
@@ -29,13 +30,15 @@ class GantryClient : public Gantry {
     bool is_moving() override;
     void stop(const ProtoStruct& extra) override;
     ProtoStruct do_command(const ProtoStruct& command) override;
+    KinematicsFileConfig get_kinematics(const ProtoStruct& extra) override;
     std::vector<GeometryConfig> get_geometries(const ProtoStruct& extra) override;
 
     using Gantry::get_geometries;
     using Gantry::get_lengths;
     using Gantry::get_position;
     using Gantry::home;
     using Gantry::move_to_position;
+    using Gantry::get_kinematics;
     using Gantry::stop;
 
    private:
@@ -46,4 +49,4 @@ class GantryClient : public Gantry {
 
 }  // namespace impl
 }  // namespace sdk
-}  // namespace viam
+}  // namespace viam

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

@@ -1,6 +1,8 @@
 #include <viam/sdk/components/private/gantry_server.hpp>
 
 #include <viam/sdk/common/private/service_helper.hpp>
+#include <viam/api/common/v1/common.pb.h>
+#include <viam/sdk/common/kinematics.hpp>
 
 namespace viam {
 namespace sdk {
@@ -80,6 +82,17 @@ ::grpc::Status GantryServer::DoCommand(::grpc::ServerContext*,
     });
 }
 
+::grpc::Status GantryServer::GetKinematics(
+    ::grpc::ServerContext*,
+    const ::viam::common::v1::GetKinematicsRequest* request,
+    ::viam::common::v1::GetKinematicsResponse* response) noexcept {
+    return make_service_helper<Gantry>(
+        "GantryServer::GetKinematics", this, request)([&](auto& helper, auto& gantry) {
+        const KinematicsFileConfig kinematics = gantry->get_kinematics(helper.getExtra());
+        *response->mutable_kinematics() = to_proto(kinematics);
+    });
+}
+
 ::grpc::Status GantryServer::GetGeometries(
     ::grpc::ServerContext*,
     const ::viam::common::v1::GetGeometriesRequest* request,
@@ -95,4 +108,4 @@ ::grpc::Status GantryServer::GetGeometries(
 
 }  // namespace impl
 }  // namespace sdk
-}  // namespace viam
+}  // namespace viam

src/viam/sdk/components/private/gantry_server.hpp

@@ -5,6 +5,7 @@
 
 #include <viam/api/component/gantry/v1/gantry.grpc.pb.h>
 #include <viam/api/component/gantry/v1/gantry.pb.h>
+#include <viam/api/common/v1/common.pb.h>
 
 #include <viam/sdk/components/gantry.hpp>
 #include <viam/sdk/resource/resource_manager.hpp>
@@ -57,6 +58,11 @@ class GantryServer : public ResourceServer,
                                      const ::viam::common::v1::DoCommandRequest* request,
                                      ::viam::common::v1::DoCommandResponse* response) noexcept;
 
+    virtual ::grpc::Status GetKinematics(
+        ::grpc::ServerContext* context,
+        const ::viam::common::v1::GetKinematicsRequest* request,
+        ::viam::common::v1::GetKinematicsResponse* response) noexcept;
+
     virtual ::grpc::Status GetGeometries(
         ::grpc::ServerContext* context,
         const ::viam::common::v1::GetGeometriesRequest* request,
@@ -65,4 +71,4 @@ class GantryServer : public ResourceServer,
 
 }  // namespace impl
 }  // namespace sdk
-}  // namespace viam
+}  // namespace viam

src/viam/sdk/tests/mocks/mock_gantry.cpp

@@ -1,6 +1,7 @@
 #include <viam/sdk/tests/mocks/mock_gantry.hpp>
 
 #include <viam/sdk/tests/test_utils.hpp>
+#include <viam/sdk/common/kinematics.hpp>
 
 namespace viam {
 namespace sdktests {
@@ -10,6 +11,13 @@ std::vector<double> fake_lengths() {
     return {1.0, 2.0, 3.0, 4.0};
 }
 
+sdk::KinematicsFileConfig fake_kinematics() {
+    sdk::KinematicsFileConfig k;
+    k.kinematics_type = sdk::KinematicsType::KINEMATICS_TYPE_GANTRY;
+    k.extra = fake_map();
+    return k;
+}
+
 std::shared_ptr<MockGantry> MockGantry::get_mock_gantry() {
     return std::make_shared<MockGantry>("mock_gantry");
 }
@@ -45,10 +53,14 @@ sdk::ProtoStruct MockGantry::do_command(const sdk::ProtoStruct& command) {
     return (peek_command = command);
 }
 
+sdk::KinematicsFileConfig MockGantry::get_kinematics(const sdk::ProtoStruct&) {
+    return peek_kinematics;
+}
+
 std::vector<sdk::GeometryConfig> MockGantry::get_geometries(const sdk::ProtoStruct&) {
     return fake_geometries();
 }
 
 }  // namespace gantry
 }  // namespace sdktests
-}  // namespace viam
+}  // namespace viam

src/viam/sdk/tests/mocks/mock_gantry.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <viam/sdk/components/gantry.hpp>
+#include <viam/sdk/common/kinematics.hpp>
 
 namespace viam {
 namespace sdktests {
@@ -22,13 +23,15 @@ class MockGantry : public sdk::Gantry {
     bool is_moving() override;
     void stop(const sdk::ProtoStruct& extra) override;
     sdk::ProtoStruct do_command(const sdk::ProtoStruct& command) override;
+    sdk::KinematicsFileConfig get_kinematics(const sdk::ProtoStruct& extra) override;
     std::vector<sdk::GeometryConfig> get_geometries(const sdk::ProtoStruct& extra) override;
 
     std::vector<double> peek_positions;
     bool peek_stop_called{false};
     bool peek_home_called{false};
     sdk::ProtoStruct peek_command;
+    sdk::KinematicsFileConfig peek_kinematics;
 };
 }  // namespace gantry
 }  // namespace sdktests
-}  // namespace viam
+}  // namespace viam

src/viam/sdk/tests/test_gantry.cpp

@@ -5,9 +5,11 @@
 #include <viam/sdk/components/gantry.hpp>
 #include <viam/sdk/tests/mocks/mock_gantry.hpp>
 #include <viam/sdk/tests/test_utils.hpp>
+#include <viam/sdk/common/kinematics.hpp>
 
 BOOST_TEST_DONT_PRINT_LOG_VALUE(std::vector<viam::sdk::GeometryConfig>)
 BOOST_TEST_DONT_PRINT_LOG_VALUE(std::vector<double>)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(viam::sdk::KinematicsFileConfig)
 
 namespace viam {
 namespace sdktests {
@@ -83,7 +85,16 @@ BOOST_AUTO_TEST_CASE(test_do_command) {
     });
 }
 
+BOOST_AUTO_TEST_CASE(test_get_kinematics) {
+    std::shared_ptr<MockGantry> mock = MockGantry::get_mock_gantry();
+    client_to_mock_pipeline<Gantry>(mock, [&](Gantry& client) {
+        mock->peek_kinematics = fake_kinematics();
+        const auto& kinematics = client.get_kinematics();
+        BOOST_CHECK_EQUAL(kinematics, fake_kinematics());
+    });
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }  // namespace sdktests
-}  // namespace viam
+}  // namespace viam