Actions API

use horus::prelude::*;

action! {
    /// Navigate to a target pose.
    NavigateToPose {
        goal {
            x: f64,
            y: f64,
            theta: f64,
        }
        feedback {
            distance_remaining: f64,
            estimated_time_sec: f64,
        }
        result {
            success: bool,
            final_x: f64,
            final_y: f64,
        }
    }
}

pub fn publish_feedback(&self, feedback: A::Feedback)

handle.publish_feedback(NavFeedback {
    distance_remaining: 3.2,
    progress: 0.65,
});

pub fn succeed(self, result: A::Result) -> GoalOutcome<A>

return handle.succeed(MoveArmResult { final_position: current_pos });

pub fn should_abort(&self) -> bool

loop {
    if handle.should_abort() {
        return handle.canceled(partial_result);
    }
    // ... do work ...
    handle.publish_feedback(progress);
}

use horus::prelude::*;

action! {
    MoveArm {
        goal { target_x: f64, target_y: f64, target_z: f64 }
        feedback { progress: f64, current_x: f64, current_y: f64, current_z: f64 }
        result { success: bool, final_x: f64, final_y: f64, final_z: f64 }
    }
}

let server = ActionServerNode::<MoveArm>::builder()
    .on_goal(|goal| {
        // Validate the goal
        if goal.target_z < 0.0 {
            GoalResponse::Reject("Z must be non-negative".into())
        } else {
            GoalResponse::Accept
        }
    })
    .on_cancel(|_goal_id| CancelResponse::Accept)
    .on_execute(|handle| {
        let goal = handle.goal();
        let mut progress = 0.0;

        while progress < 1.0 {
            // Check for cancellation
            if handle.should_abort() {
                return handle.canceled(MoveArmResult {
                    success: false,
                    final_x: 0.0, final_y: 0.0, final_z: 0.0,
                });
            }

            progress += 0.01;
            handle.publish_feedback(MoveArmFeedback {
                progress,
                current_x: goal.target_x * progress,
                current_y: goal.target_y * progress,
                current_z: goal.target_z * progress,
            });

            std::thread::sleep(10_u64.ms());
        }

        handle.succeed(MoveArmResult {
            success: true,
            final_x: goal.target_x,
            final_y: goal.target_y,
            final_z: goal.target_z,
        })
    })
    .preemption_policy(PreemptionPolicy::Priority)
    .goal_timeout(30_u64.secs())
    .build();

let mut scheduler = Scheduler::new();
scheduler.add(server).order(0).build();

pub fn send_goal(&self, goal: A::Goal) -> Result<ClientGoalHandle<A>, ActionError>

use horus::prelude::*;

let handle = client.send_goal(NavigateToPoseGoal { x: 1.0, y: 2.0, theta: 0.0 })?;
// Monitor with handle.status(), handle.result(), handle.last_feedback()

pub fn send_goal_with_priority(&self, goal: A::Goal, priority: GoalPriority) -> Result<ClientGoalHandle<A>, ActionError>

pub fn send_goal_and_wait(&self, goal: A::Goal, timeout: Duration) -> Result<A::Result, ActionError>

let result = client.send_goal_and_wait(
    MoveArmGoal { target: [0.5, 0.3, 0.1], speed: 0.5 },
    10_u64.secs(),
)?;
println!("Arm reached: {:?}", result.final_position);

pub fn send_goal_and_wait_with_feedback(
    &self, goal: A::Goal, timeout: Duration,
    feedback_cb: impl Fn(GoalId, &A::Feedback),
) -> Result<A::Result, ActionError>

let result = client.send_goal_and_wait_with_feedback(
    nav_goal,
    30_u64.secs(),
    |_id, feedback| {
        println!("Progress: {:.0}%, distance: {:.1}m",
            feedback.progress * 100.0, feedback.distance_remaining);
    },
)?;

use horus::prelude::*;

// Simple blocking usage (no scheduler needed)
let client = SyncActionClient::<MoveArm>::new()?;

let result = client.send_goal_and_wait_with_feedback(
    MoveArmGoal { target_x: 1.0, target_y: 2.0, target_z: 0.5 },
    30_u64.secs(),
    |feedback| {
        println!("Progress: {:.0}%", feedback.progress * 100.0);
    },
)?;

if result.success {
    println!("Arm reached ({:.1}, {:.1}, {:.1})",
        result.final_x, result.final_y, result.final_z);
}

ActionResult::succeeded(goal_id, result)
ActionResult::aborted(goal_id, result)
ActionResult::canceled(goal_id, result)
ActionResult::preempted(goal_id, result)

// Server callbacks (passed to ActionServerBuilder)
type GoalCallback<A>    = Box<dyn Fn(&<A as Action>::Goal) -> GoalResponse + Send + Sync>;
type CancelCallback     = Box<dyn Fn(GoalId) -> CancelResponse + Send + Sync>;
type ExecuteCallback<A> = Box<dyn Fn(ServerGoalHandle<A>) -> GoalOutcome<A> + Send + Sync>;

// Client callbacks (passed to ActionClientBuilder)
type FeedbackCallback<A> = Box<dyn Fn(GoalId, &<A as Action>::Feedback) + Send + Sync>;
type ResultCallback<A>   = Box<dyn Fn(GoalId, GoalStatus, &<A as Action>::Result) + Send + Sync>;
type StatusCallback      = Box<dyn Fn(GoalId, GoalStatus) + Send + Sync>;