align consecutive assignments

Author: JJJYmmm

.clang-format

@@ -10,6 +10,12 @@ BreakBeforeBraces: Attach
 AllowShortFunctionsOnASingleLine: Inline
 AllowShortIfStatementsOnASingleLine: Never
 AllowShortLoopsOnASingleLine: false
+AlignConsecutiveAssignments:
+  Enabled: true
+  AcrossEmptyLines: false
+  AcrossComments: false
+  AlignCompound: false
+  PadOperators: true
 PointerAlignment: Middle
 ReferenceAlignment: Middle
 SortIncludes: false

robot_client/cpp/model_client.cpp

@@ -5,7 +5,7 @@
 #include <cstring>
 #include <utility>
 
-namespace proto = robot_server::protocol;
+namespace proto   = robot_server::protocol;
 namespace sockets = robot_server::sockets;
 
 namespace robot_server {
@@ -15,8 +15,8 @@ namespace {
 bool send_message(sockets::socket_handle fd, uint16_t op, uint32_t request_id, const std::vector<uint8_t> & payload,
                   std::string & error) {
     proto::header h;
-    h.op = op;
-    h.request_id = request_id;
+    h.op          = op;
+    h.request_id  = request_id;
     h.payload_len = payload.size();
 
     std::vector<uint8_t> header;
@@ -55,7 +55,7 @@ bool make_predict_request(const ModelObservation & obs, proto::predict_request &
         return false;
     }
 
-    req.task = obs.prompt;
+    req.task  = obs.prompt;
     req.state = obs.state;
     req.images.clear();
     req.images.reserve(obs.images.size());
@@ -75,11 +75,11 @@ bool make_predict_request(const ModelObservation & obs, proto::predict_request &
 
         const size_t image_size = (size_t)stride * (size_t)src.height;
         proto::image_payload image;
-        image.name = src.name.empty() ? "image" + std::to_string(i) : src.name;
+        image.name         = src.name.empty() ? "image" + std::to_string(i) : src.name;
         image.image_format = proto::image_raw_rgb_u8;
-        image.width = src.width;
-        image.height = src.height;
-        image.channels = 3;
+        image.width        = src.width;
+        image.height       = src.height;
+        image.channels     = 3;
         image.stride_bytes = stride;
         image.data.resize(image_size);
         std::memcpy(image.data.data(), src.rgb_hwc_u8, image_size);
@@ -157,10 +157,10 @@ bool ModelClient::predict(const ModelObservation & obs, ModelResponse & response
         return false;
     }
 
-    response.chunk_size = resp.chunk_size;
-    response.action_dim = resp.action_dim;
+    response.chunk_size   = resp.chunk_size;
+    response.action_dim   = resp.action_dim;
     response.actions_flat = std::move(resp.actions);
-    response.metrics = std::move(resp.metrics);
+    response.metrics      = std::move(resp.metrics);
     return true;
 }
 
@@ -177,7 +177,7 @@ bool ModelClient::call(uint16_t op, const std::vector<uint8_t> & request_payload
     }
 
     const uint32_t request_id = next_request_id_++;
-    bool ok = send_message(fd, op, request_id, request_payload, error);
+    bool ok                   = send_message(fd, op, request_id, request_payload, error);
     proto::header response_header;
     if (ok) {
         ok = recv_message(fd, response_header, response_payload, error);

robot_client/cpp/model_client.h

@@ -12,10 +12,10 @@ namespace client {
 
 struct ModelImage {
     const uint8_t * rgb_hwc_u8 = nullptr;
-    uint32_t width = 0;
-    uint32_t height = 0;
-    uint32_t stride_bytes = 0;
-    std::string name = "image";
+    uint32_t width             = 0;
+    uint32_t height            = 0;
+    uint32_t stride_bytes      = 0;
+    std::string name           = "image";
 };
 
 struct ModelObservation {
@@ -48,7 +48,7 @@ class ModelClient {
               std::string & error);
 
     std::string host_;
-    uint16_t port_ = 5555;
+    uint16_t port_            = 5555;
     uint32_t next_request_id_ = 1;
 };
 

robot_client/examples/cpp/minimal_example.cpp

@@ -37,28 +37,28 @@ std::vector<float> make_random_state(uint32_t dim) {
 
 int main(int argc, char ** argv) {
     std::string host = "127.0.0.1";
-    uint16_t port = 5555;
+    uint16_t port    = 5555;
     if (argc > 1) {
         host = argv[1];
     }
     if (argc > 2) {
         port = (uint16_t)std::stoi(argv[2]);
     }
 
-    const uint32_t width = 224;
-    const uint32_t height = 224;
+    const uint32_t width       = 224;
+    const uint32_t height      = 224;
     std::vector<uint8_t> image = make_random_rgb_image(width, height);
-    std::vector<float> state = make_random_state(6);
+    std::vector<float> state   = make_random_state(6);
 
     client::ModelObservation obs;
     client::ModelImage camera;
-    camera.name = "image";
-    camera.rgb_hwc_u8 = image.data();
-    camera.width = width;
-    camera.height = height;
+    camera.name         = "image";
+    camera.rgb_hwc_u8   = image.data();
+    camera.width        = width;
+    camera.height       = height;
     camera.stride_bytes = width * 3;
     obs.images.push_back(camera);
-    obs.state = state;
+    obs.state  = state;
     obs.prompt = "grab the block.";
 
     client::ModelClient model(host, port);

robot_server/model-server.cpp

@@ -26,15 +26,15 @@ struct server_args {
     std::string action_decoder_path;
     std::string state_proj_path;
     std::string action_expert_path;
-    std::string task = "grab the block.";
-    std::string host = "127.0.0.1";
-    int port = 5555;
-    int threads = 0;
-    int n_batch = 512;
-    int n_ctx = 2048;
-    int noise_mode = SMOLVLA_NOISE_MODE_GAUSSIAN;
+    std::string task   = "grab the block.";
+    std::string host   = "127.0.0.1";
+    int port           = 5555;
+    int threads        = 0;
+    int n_batch        = 512;
+    int n_ctx          = 2048;
+    int noise_mode     = SMOLVLA_NOISE_MODE_GAUSSIAN;
     int64_t noise_seed = -1;
-    int verbosity = 0;
+    int verbosity      = 0;
 };
 
 static bool parse_model_type(const std::string & value, robotcpp::model_type & out) {
@@ -184,21 +184,21 @@ static bool parse_args(int argc, char ** argv, server_args & args) {
 
 static robotcpp::model_args make_model_args(const server_args & args) {
     robotcpp::model_args model_args;
-    model_args.type = args.model_type;
-    model_args.threads = args.threads;
-    model_args.verbosity = args.verbosity;
-    model_args.llm_path = args.llm_path;
-    model_args.mmproj_path = args.mmproj_path;
-    model_args.vit_path = args.vit_path;
-    model_args.tokenizer_path = args.tokenizer_path;
-    model_args.state_path = args.state_path;
+    model_args.type                = args.model_type;
+    model_args.threads             = args.threads;
+    model_args.verbosity           = args.verbosity;
+    model_args.llm_path            = args.llm_path;
+    model_args.mmproj_path         = args.mmproj_path;
+    model_args.vit_path            = args.vit_path;
+    model_args.tokenizer_path      = args.tokenizer_path;
+    model_args.state_path          = args.state_path;
     model_args.action_decoder_path = args.action_decoder_path;
-    model_args.state_proj_path = args.state_proj_path;
-    model_args.action_expert_path = args.action_expert_path;
-    model_args.n_batch = args.n_batch;
-    model_args.n_ctx = args.n_ctx;
-    model_args.noise_mode = args.noise_mode;
-    model_args.noise_seed = args.noise_seed;
+    model_args.state_proj_path     = args.state_proj_path;
+    model_args.action_expert_path  = args.action_expert_path;
+    model_args.n_batch             = args.n_batch;
+    model_args.n_ctx               = args.n_ctx;
+    model_args.noise_mode          = args.noise_mode;
+    model_args.noise_seed          = args.noise_seed;
     return model_args;
 }
 

robot_server/model_adapter.cpp

@@ -22,16 +22,16 @@ bool model_adapter::predict(const proto::predict_request & req, proto::predict_r
     obs.images.reserve(req.images.size());
     for (const proto::image_payload & src : req.images) {
         robotcpp::model_image image;
-        image.name = src.name.empty() ? "image" : src.name;
-        image.data = src.data.empty() ? nullptr : src.data.data();
-        image.width = static_cast<int>(src.width);
-        image.height = static_cast<int>(src.height);
-        image.channels = static_cast<int>(src.channels);
+        image.name         = src.name.empty() ? "image" : src.name;
+        image.data         = src.data.empty() ? nullptr : src.data.data();
+        image.width        = static_cast<int>(src.width);
+        image.height       = static_cast<int>(src.height);
+        image.channels     = static_cast<int>(src.channels);
         image.stride_bytes = static_cast<int>(src.stride_bytes);
         obs.images.push_back(image);
     }
     obs.state = req.state;
-    obs.task = req.task;
+    obs.task  = req.task;
 
     robotcpp::model_result result;
     if (!model_->predict(obs, result, error)) {
@@ -40,11 +40,11 @@ bool model_adapter::predict(const proto::predict_request & req, proto::predict_r
 
     resp.chunk_size = static_cast<uint32_t>(result.chunk_size);
     resp.action_dim = static_cast<uint32_t>(result.action_dim);
-    resp.actions = std::move(result.actions);
+    resp.actions    = std::move(result.actions);
     resp.metrics.reserve(result.metrics.size());
     for (const robotcpp::model_metric & src : result.metrics) {
         proto::metric dst;
-        dst.name = src.name;
+        dst.name  = src.name;
         dst.value = src.value;
         resp.metrics.push_back(std::move(dst));
     }

robot_server/model_adapter.h

@@ -17,7 +17,7 @@ class model_adapter {
     explicit model_adapter(std::unique_ptr<robotcpp::Model> model);
     ~model_adapter();
 
-    model_adapter(const model_adapter &) = delete;
+    model_adapter(const model_adapter &)             = delete;
     model_adapter & operator=(const model_adapter &) = delete;
 
     bool predict(const robot_server::protocol::predict_request & req, robot_server::protocol::predict_response & resp,

robot_server/protocol.cpp

@@ -254,8 +254,8 @@ bool decode_predict_request(const std::vector<uint8_t> & payload, predict_reques
     req = predict_request{};
     reader r(payload.data(), payload.size());
     uint32_t image_count = 0;
-    uint32_t state_dim = 0;
-    uint32_t task_len = 0;
+    uint32_t state_dim   = 0;
+    uint32_t task_len    = 0;
 
     if (!r.u32(image_count) || !r.u32(state_dim) || !r.u32(task_len)) {
         error = "short predict request";

robot_server/protocol.h

@@ -8,25 +8,25 @@
 namespace robot_server {
 namespace protocol {
 
-static constexpr uint32_t k_magic = 0x414c5653u; // "SVLA" in little-endian bytes.
-static constexpr uint16_t k_version = 3;
-static constexpr uint16_t k_header_size = 32;
+static constexpr uint32_t k_magic               = 0x414c5653u; // "SVLA" in little-endian bytes.
+static constexpr uint16_t k_version             = 3;
+static constexpr uint16_t k_header_size         = 32;
 static constexpr uint64_t k_default_max_payload = 256ull * 1024ull * 1024ull;
 
 enum op : uint16_t {
-    op_health = 1,
-    op_reset = 2,
-    op_predict = 3,
+    op_health   = 1,
+    op_reset    = 2,
+    op_predict  = 3,
     op_shutdown = 4,
 };
 
 enum status : uint32_t {
-    status_ok = 0,
-    status_bad_request = 1,
-    status_bad_magic = 2,
-    status_bad_version = 3,
+    status_ok              = 0,
+    status_bad_request     = 1,
+    status_bad_magic       = 2,
+    status_bad_version     = 3,
     status_payload_too_big = 4,
-    status_internal_error = 5,
+    status_internal_error  = 5,
 };
 
 enum image_format : uint32_t {
@@ -35,24 +35,24 @@ enum image_format : uint32_t {
 
 struct image_payload {
     uint32_t image_format = image_raw_rgb_u8;
-    uint32_t width = 0;
-    uint32_t height = 0;
-    uint32_t channels = 0;
+    uint32_t width        = 0;
+    uint32_t height       = 0;
+    uint32_t channels     = 0;
     uint32_t stride_bytes = 0;
     std::string name;
     std::vector<uint8_t> data;
 };
 
 struct header {
-    uint32_t magic = k_magic;
-    uint16_t version = k_version;
+    uint32_t magic       = k_magic;
+    uint16_t version     = k_version;
     uint16_t header_size = k_header_size;
-    uint16_t op = 0;
-    uint16_t flags = 0;
-    uint32_t request_id = 0;
-    uint32_t status = status_ok;
+    uint16_t op          = 0;
+    uint16_t flags       = 0;
+    uint32_t request_id  = 0;
+    uint32_t status      = status_ok;
     uint64_t payload_len = 0;
-    uint32_t reserved = 0;
+    uint32_t reserved    = 0;
 };
 
 struct metric {

robot_server/session.cpp

@@ -20,7 +20,7 @@
 #include <utility>
 #include <vector>
 
-namespace proto = robot_server::protocol;
+namespace proto  = robot_server::protocol;
 using clock_type = std::chrono::steady_clock;
 
 namespace robot_server {
@@ -32,17 +32,17 @@ static double elapsed_ms(const clock_type::time_point & a, const clock_type::tim
 
 static void add_metric(proto::predict_response & resp, const char * name, double value) {
     proto::metric metric;
-    metric.name = name;
+    metric.name  = name;
     metric.value = value;
     resp.metrics.push_back(std::move(metric));
 }
 
 static bool send_message(sockets::socket_handle fd, uint16_t op, uint32_t request_id, uint32_t status,
                          const std::vector<uint8_t> & payload, std::string & error) {
     proto::header h;
-    h.op = op;
-    h.request_id = request_id;
-    h.status = status;
+    h.op          = op;
+    h.request_id  = request_id;
+    h.status      = status;
     h.payload_len = payload.size();
 
     std::vector<uint8_t> hdr;
@@ -124,8 +124,8 @@ bool handle_client(sockets::socket_handle fd, model_adapter & policy, std::mutex
             std::unique_lock<std::mutex> lock(predict_mutex);
             const double server_queue_ms = elapsed_ms(t_queue0, clock_type::now());
 
-            const auto t_predict0 = clock_type::now();
-            const bool ok = policy.predict(req, resp, error);
+            const auto t_predict0          = clock_type::now();
+            const bool ok                  = policy.predict(req, resp, error);
             const double server_predict_ms = elapsed_ms(t_predict0, clock_type::now());
             lock.unlock();