Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
c6f54e963c415f572d6a5aef591b60c162c7a2f1
allwpilib/commandsv3/BUILD.bazel

97 lines
2.7 KiB
Python
Raw Normal View History

[commands] Add Commands v3 framework (#6518) The framework fundamentally relies on the continuation API added in Java 21 (which is currently internal to the JDK). Continuations allow for call stacks to be saved to the heap and resumed later. The async framework allows command bodies to be written in an imperative style. However, an async command will need to be actively cooperative and periodically call coroutine.yield() in loops to yield control back to the command scheduler to let it process other commands. There are also some other additions like priority levels (as opposed to a blanket yes/no for ignoring incoming commands), factories requiring names be provided for commands, and the scheduler tracking all running commands and not just the highest-level groups. However, those changes aren't unique to an async framework, and could just as easily be used in a traditional command framework.
2025-10-10 16:47:22 -04:00
load("@allwpilib_pip_deps//:requirements.bzl", "requirement")
load("@aspect_bazel_lib//lib:write_source_files.bzl", "write_source_files")
load("@rules_java//java:defs.bzl", "java_binary")
load("@rules_python//python:defs.bzl", "py_binary")
load("//commandsv3:generate.bzl", "generate_commandsv3")
load("//shared/bazel/rules:java_rules.bzl", "wpilib_java_junit5_test", "wpilib_java_library")
py_binary(
name = "generate_files",
srcs = ["generate_files.py"],
target_compatible_with = select({
"@rules_bzlmodrio_toolchains//constraints/is_systemcore:systemcore": ["@platforms//:incompatible"],
"//conditions:default": [],
}),
deps = [requirement("jinja2")],
)
filegroup(
name = "templates",
srcs = glob(["src/generate/main/**"]) + [
"//wpilibj:hid_schema",
],
)
generate_commandsv3(
name = "generate_commandsv3",
)
write_source_files(
name = "write_commandsv3",
files = {
"src/generated": ":generate_commandsv3",
},
suggested_update_target = "//:write_all",
tags = ["pregeneration"],
visibility = ["//visibility:public"],
)
filegroup(
name = "generated_java",
srcs = glob(["src/generated/main/java/**/*.java"]),
)
wpilib_java_library(
name = "commandsv3-java",
srcs = glob(["src/main/java/**/*.java"]) + [":generated_java"],
exported_plugins = ["//javacPlugin:plugin"],
maven_artifact_name = "commands3-java",
[build] Fixup maven publishing (#8753) This primarily fixes up the bazel publishing to match the gradle publishing again, as some new libraries were added but not hooked up to the maven publishing. During the process, I noticed that the 3rd party libraries (googletest, catch2, and imgui_suite) were still getting published on the old `edu.wpi` namespace. I tried to clean up all the other references to that that I could. Note: opencv and libssh are handled outside `allwpilib` so they need to be updated separately.
2026-04-11 16:52:43 -04:00
maven_group_id = "org.wpilib",
[commands] Add Commands v3 framework (#6518) The framework fundamentally relies on the continuation API added in Java 21 (which is currently internal to the JDK). Continuations allow for call stacks to be saved to the heap and resumed later. The async framework allows command bodies to be written in an imperative style. However, an async command will need to be actively cooperative and periodically call coroutine.yield() in loops to yield control back to the command scheduler to let it process other commands. There are also some other additions like priority levels (as opposed to a blanket yes/no for ignoring incoming commands), factories requiring names be provided for commands, and the scheduler tracking all running commands and not just the highest-level groups. However, those changes aren't unique to an async framework, and could just as easily be used in a traditional command framework.
2025-10-10 16:47:22 -04:00
plugins = ["//javacPlugin:plugin"],
visibility = ["//visibility:public"],
deps = [
"//cscore:cscore-java",
"//hal:hal-java",
"//ntcore:ntcore-java",
"//wpiannotations",
"//wpilibj:wpilibj-java",
"//wpimath:wpimath-java",
"//wpinet:wpinet-java",
"//wpiunits:wpiunits-java",
"//wpiutil:wpiutil-java",
"@maven//:us_hebi_quickbuf_quickbuf_runtime",
],
)
wpilib_java_junit5_test(
name = "commandsv3-java-test",
HAND FIX - Fixup bazel files
2025-11-07 19:56:21 -05:00
srcs = glob(["src/test/java/**/*.java"]),
[epilogue] Fix v3 scheduler incompatibility with epilogue (#8458) Was caused by checking assignability like`Protobuf<Scheduler, ProtoMessage>` instead of `Protobuf<Scheduler, ? extends ProtoMessage<?>>` This epilogue bug would have also applied to other protobuf-serializable types
2025-12-07 01:38:10 -05:00
plugins = [
"//epilogue-processor:plugin",
],
[commands] Add Commands v3 framework (#6518) The framework fundamentally relies on the continuation API added in Java 21 (which is currently internal to the JDK). Continuations allow for call stacks to be saved to the heap and resumed later. The async framework allows command bodies to be written in an imperative style. However, an async command will need to be actively cooperative and periodically call coroutine.yield() in loops to yield control back to the command scheduler to let it process other commands. There are also some other additions like priority levels (as opposed to a blanket yes/no for ignoring incoming commands), factories requiring names be provided for commands, and the scheduler tracking all running commands and not just the highest-level groups. However, those changes aren't unique to an async framework, and could just as easily be used in a traditional command framework.
2025-10-10 16:47:22 -04:00
deps = [
":commandsv3-java",
[epilogue] Fix v3 scheduler incompatibility with epilogue (#8458) Was caused by checking assignability like`Protobuf<Scheduler, ProtoMessage>` instead of `Protobuf<Scheduler, ? extends ProtoMessage<?>>` This epilogue bug would have also applied to other protobuf-serializable types
2025-12-07 01:38:10 -05:00
"//epilogue-runtime:epilogue-java",
[commands] Add Commands v3 framework (#6518) The framework fundamentally relies on the continuation API added in Java 21 (which is currently internal to the JDK). Continuations allow for call stacks to be saved to the heap and resumed later. The async framework allows command bodies to be written in an imperative style. However, an async command will need to be actively cooperative and periodically call coroutine.yield() in loops to yield control back to the command scheduler to let it process other commands. There are also some other additions like priority levels (as opposed to a blanket yes/no for ignoring incoming commands), factories requiring names be provided for commands, and the scheduler tracking all running commands and not just the highest-level groups. However, those changes aren't unique to an async framework, and could just as easily be used in a traditional command framework.
2025-10-10 16:47:22 -04:00
"//hal:hal-java",
"//ntcore:ntcore-java",
"//wpiannotations",
"//wpilibj:wpilibj-java",
"//wpimath:wpimath-java",
"//wpiunits:wpiunits-java",
"//wpiutil:wpiutil-java",
"@maven//:us_hebi_quickbuf_quickbuf_runtime",
],
)
java_binary(
name = "DevMain-Java",
HAND FIX - Fixup bazel files
2025-11-07 19:56:21 -05:00
srcs = ["src/dev/java/org/wpilib/command3/DevMain.java"],
main_class = "org.wpilib.command3.DevMain",
[commands] Add Commands v3 framework (#6518) The framework fundamentally relies on the continuation API added in Java 21 (which is currently internal to the JDK). Continuations allow for call stacks to be saved to the heap and resumed later. The async framework allows command bodies to be written in an imperative style. However, an async command will need to be actively cooperative and periodically call coroutine.yield() in loops to yield control back to the command scheduler to let it process other commands. There are also some other additions like priority levels (as opposed to a blanket yes/no for ignoring incoming commands), factories requiring names be provided for commands, and the scheduler tracking all running commands and not just the highest-level groups. However, those changes aren't unique to an async framework, and could just as easily be used in a traditional command framework.
2025-10-10 16:47:22 -04:00
deps = [
"//hal:hal-java",
"//ntcore:ntcore-java",
"//wpimath:wpimath-java",
"//wpiutil:wpiutil-java",
],
)
Reference in New Issue Copy Permalink