added After and AfterTime decorator to commands

wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Command.java

@@ -218,6 +218,56 @@ public ParallelRaceGroup onlyWhile(BooleanSupplier condition) {
     return until(() -> !condition.getAsBoolean());
   }
 
+  /**
+   * Decorates this command to run once a condition becomes true.
+   * 
+   * <p>Note: This decorator works by adding this command to a composition. The command the
+   * decorator was called on cannot be scheduled independently or be added to a different
+   * composition (namely, decorators), unless it is manually cleared from the list of composed
+   * commands with {@link CommandScheduler#removeComposedCommand(Command)}. The command composition
+   * returned from this method can be further decorated without issue.
+   * 
+   * @param condition the condition to wait for
+   * @return the decorated command
+   */
+  public SequentialCommandGroup after(BooleanSupplier condition) {
+    // if we want this to bypass the `WaitUntilCommand` if the condition is already true,
+    // we can use a conditional command but it proposes some compositional issues
+    return new SequentialCommandGroup(new WaitUntilCommand(condition), this);
+  }
+
+  /**
+   * Decorates this command to run after a time delay.
+   * 
+   * <p>Note: This decorator works by adding this command to a composition. The command the
+   * decorator was called on cannot be scheduled independently or be added to a different
+   * composition (namely, decorators), unless it is manually cleared from the list of composed
+   * commands with {@link CommandScheduler#removeComposedCommand(Command)}. The command composition
+   * returned from this method can be further decorated without issue.
+   * 
+   * @param seconds the seconds to wait
+   * @return the decorated command
+   */
+  public SequentialCommandGroup afterSeconds(double seconds) {
+    return new SequentialCommandGroup(new WaitCommand(seconds), this);
+  }
+
+  /**
+   * Decorates this command to run after a time delay.
+   * 
+   * <p>Note: This decorator works by adding this command to a composition. The command the
+   * decorator was called on cannot be scheduled independently or be added to a different
+   * composition (namely, decorators), unless it is manually cleared from the list of composed
+   * commands with {@link CommandScheduler#removeComposedCommand(Command)}. The command composition
+   * returned from this method can be further decorated without issue.
+   * 
+   * @param time the time to wait
+   * @return the decorated command
+   */
+  public SequentialCommandGroup afterTime(Time time) {
+    return afterSeconds(time.in(Seconds));
+  }
+
   /**
    * Decorates this command with a runnable to run before this command starts.
    *

wpilibNewCommands/src/main/native/cpp/frc2/command/Command.cpp

@@ -84,6 +84,14 @@ CommandPtr Command::OnlyWhile(std::function<bool()> condition) && {
   return std::move(*this).ToPtr().OnlyWhile(std::move(condition));
 }
 
+CommandPtr After(std::function<bool()> condition) && {
+  return std::move(*this).ToPtr().After(std::move(condition));
+}
+
+CommandPtr AfterTime(units::second_t duration) && {
+  return std::move(*this).ToPtr().AfterTime(duration);
+}
+
 CommandPtr Command::IgnoringDisable(bool doesRunWhenDisabled) && {
   return std::move(*this).ToPtr().IgnoringDisable(doesRunWhenDisabled);
 }

wpilibNewCommands/src/main/native/cpp/frc2/command/CommandPtr.cpp

@@ -165,6 +165,24 @@ CommandPtr CommandPtr::OnlyIf(std::function<bool()> condition) && {
   return std::move(*this).Unless(std::not_fn(std::move(condition)));
 }
 
+CommandPtr CommandPtr::After(std::function<bool()> condition) && {
+  AssertValid();
+  std::vector<std::unique_ptr<Command>> temp;
+  temp.emplace_back(std::make_unique<WaitUntilCommand>(std::move(condition)));
+  temp.emplace_back(std::move(m_ptr));
+  m_ptr = std::make_unique<SequentialCommandGroup>(std::move(temp));
+  return std::move(*this);
+}
+
+CommandPtr CommandPtr::AfterTime(units::second_t duration) && {
+  AssertValid();
+  std::vector<std::unique_ptr<Command>> temp;
+  temp.emplace_back(std::make_unique<WaitCommand>(duration));
+  temp.emplace_back(std::move(m_ptr));
+  m_ptr = std::make_unique<SequentialCommandGroup>(std::move(temp));
+  return std::move(*this);
+}
+
 CommandPtr CommandPtr::DeadlineWith(CommandPtr&& parallel) && {
   AssertValid();
   std::vector<std::unique_ptr<Command>> vec;

wpilibNewCommands/src/main/native/include/frc2/command/Command.h

@@ -217,6 +217,24 @@ class Command : public wpi::Sendable, public wpi::SendableHelper<Command> {
   [[nodiscard]]
   CommandPtr OnlyWhile(std::function<bool()> condition) &&;
 
+  /**
+   * Decorates this command to run after a condition becomes true.
+   *
+   * @param condition the condition to run after
+   * @return the decorated command
+   */
+  [[nodiscard]]
+  CommandPtr After(std::function<bool()> condition) &&;
+
+  /**
+   * Decorates this command to run after a specified amount of time.
+   *
+   * @param duration the time to wait before running
+   * @return the decorated command
+   */
+  [[nodiscard]]
+  CommandPtr AfterTime(units::second_t duration) &&;
+
   /**
    * Decorates this command with a runnable to run before this command starts.
    *

wpilibNewCommands/src/main/native/include/frc2/command/CommandPtr.h

@@ -182,6 +182,24 @@ class CommandPtr final {
   [[nodiscard]]
   CommandPtr OnlyIf(std::function<bool()> condition) &&;
 
+  /**
+   * Decorates this command to run after a condition becomes true.
+   *
+   * @param condition the condition to run after
+   * @return the decorated command
+   */
+  [[nodiscard]]
+  CommandPtr After(std::function<bool()> condition) &&;
+
+  /**
+   * Decorates this command to run after a specified amount of time.
+   *
+   * @param duration the time to wait before running
+   * @return the decorated command
+   */
+  [[nodiscard]]
+  CommandPtr AfterTime(units::second_t duration) &&;
+
   /**
    * Decorates this command with a set of commands to run parallel to it, ending
    * when the calling command ends and interrupting all the others. Often more