mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-20 00:51:42 +00:00
076ed7770c
This is the C++ version of #1682. The old command framework is still available, but will be deprecated. Due to name conflicts, the new framework is in the frc2 namespace. Eventually (after the old command framework is removed in a future year) it will be moved into the main frc namespace.
101 lines
3.6 KiB
C++
101 lines
3.6 KiB
C++
/*----------------------------------------------------------------------------*/
|
|
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
|
|
/* Open Source Software - may be modified and shared by FRC teams. The code */
|
|
/* must be accompanied by the FIRST BSD license file in the root directory of */
|
|
/* the project. */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
#include "frc2/command/Command.h"
|
|
|
|
#include <iostream>
|
|
|
|
#include "frc2/command/CommandScheduler.h"
|
|
#include "frc2/command/InstantCommand.h"
|
|
#include "frc2/command/ParallelCommandGroup.h"
|
|
#include "frc2/command/ParallelDeadlineGroup.h"
|
|
#include "frc2/command/ParallelRaceGroup.h"
|
|
#include "frc2/command/PerpetualCommand.h"
|
|
#include "frc2/command/ProxyScheduleCommand.h"
|
|
#include "frc2/command/SequentialCommandGroup.h"
|
|
#include "frc2/command/WaitCommand.h"
|
|
#include "frc2/command/WaitUntilCommand.h"
|
|
|
|
using namespace frc2;
|
|
|
|
Command::~Command() { CommandScheduler::GetInstance().Cancel(this); }
|
|
|
|
void Command::Initialize() {}
|
|
void Command::Execute() {}
|
|
void Command::End(bool interrupted) {}
|
|
|
|
ParallelRaceGroup Command::WithTimeout(double seconds) && {
|
|
std::vector<std::unique_ptr<Command>> temp;
|
|
temp.emplace_back(std::make_unique<WaitCommand>(seconds));
|
|
temp.emplace_back(std::move(*this).TransferOwnership());
|
|
return ParallelRaceGroup(std::move(temp));
|
|
}
|
|
|
|
ParallelRaceGroup Command::InterruptOn(std::function<bool()> condition) && {
|
|
std::vector<std::unique_ptr<Command>> temp;
|
|
temp.emplace_back(std::make_unique<WaitUntilCommand>(std::move(condition)));
|
|
temp.emplace_back(std::move(*this).TransferOwnership());
|
|
return ParallelRaceGroup(std::move(temp));
|
|
}
|
|
|
|
SequentialCommandGroup Command::BeforeStarting(std::function<void()> toRun) && {
|
|
std::vector<std::unique_ptr<Command>> temp;
|
|
temp.emplace_back(std::make_unique<InstantCommand>(
|
|
std::move(toRun), std::initializer_list<Subsystem*>{}));
|
|
temp.emplace_back(std::move(*this).TransferOwnership());
|
|
return SequentialCommandGroup(std::move(temp));
|
|
}
|
|
|
|
SequentialCommandGroup Command::WhenFinished(std::function<void()> toRun) && {
|
|
std::vector<std::unique_ptr<Command>> temp;
|
|
temp.emplace_back(std::move(*this).TransferOwnership());
|
|
temp.emplace_back(std::make_unique<InstantCommand>(
|
|
std::move(toRun), std::initializer_list<Subsystem*>{}));
|
|
return SequentialCommandGroup(std::move(temp));
|
|
}
|
|
|
|
PerpetualCommand Command::Perpetually() && {
|
|
return PerpetualCommand(std::move(*this).TransferOwnership());
|
|
}
|
|
|
|
ProxyScheduleCommand Command::AsProxy() { return ProxyScheduleCommand(this); }
|
|
|
|
void Command::Schedule(bool interruptible) {
|
|
CommandScheduler::GetInstance().Schedule(interruptible, this);
|
|
}
|
|
|
|
void Command::Cancel() { CommandScheduler::GetInstance().Cancel(this); }
|
|
|
|
bool Command::IsScheduled() const {
|
|
return CommandScheduler::GetInstance().IsScheduled(this);
|
|
}
|
|
|
|
bool Command::HasRequirement(Subsystem* requirement) const {
|
|
bool hasRequirement = false;
|
|
for (auto&& subsystem : GetRequirements()) {
|
|
hasRequirement |= requirement == subsystem;
|
|
}
|
|
return hasRequirement;
|
|
}
|
|
|
|
std::string Command::GetName() const { return GetTypeName(*this); }
|
|
|
|
bool Command::IsGrouped() const { return m_isGrouped; }
|
|
|
|
void Command::SetGrouped(bool grouped) { m_isGrouped = grouped; }
|
|
|
|
namespace frc2 {
|
|
bool RequirementsDisjoint(Command* first, Command* second) {
|
|
bool disjoint = true;
|
|
auto&& requirements = second->GetRequirements();
|
|
for (auto&& requirement : first->GetRequirements()) {
|
|
disjoint &= requirements.find(requirement) == requirements.end();
|
|
}
|
|
return disjoint;
|
|
}
|
|
} // namespace frc2
|