auto_command.h

 
#pragma once
 
#include <atomic>
#include <functional>
#include <queue>
#include <vector>
 
#include "vex/vex.h"

class Condition {
 public:
  Condition* Or(Condition* b);
  Condition* And(Condition* b);
  virtual bool test() = 0;
  virtual std::string toString();
};
 
class OrCondition : public Condition {
 public:
  OrCondition(Condition* A, Condition* B);
  bool test() override;
 
 private:
  Condition* A;
  Condition* B;
};
 
class AndCondition : public Condition {
 public:
  AndCondition(Condition* A, Condition* B);
  bool test() override;
 
 private:
  Condition* A;
  Condition* B;
};
 
class AutoCommand {
 public:
  static constexpr double default_timeout = 10.0;
  virtual bool run();
 
  virtual std::string toString();

  virtual void on_timeout();
  AutoCommand* withTimeout(double t_seconds);
  AutoCommand* withCancelCondition(Condition* true_to_end);
  double timeout_seconds = default_timeout;
  Condition* true_to_end = nullptr;
 
  virtual ~AutoCommand() = default;
};

class FunctionCommand : public AutoCommand {
 public:
  FunctionCommand(std::function<bool(void)> f);
  bool run() override;
  std::string toString() override;
 
 private:
  std::function<bool(void)> f;
};
/*
 * Times tested 3
 * Test 1 -> false
 * Test 2 -> false
 * Test 3 -> true
 * Returns false until the Nth time that it is called
 * This is pretty much only good for implementing RepeatUntil
 */
class TimesTestedCondition : public Condition {
 public:
  TimesTestedCondition(size_t N);
  bool test() override;
 
 private:
  size_t count = 0;
  size_t max;
};

class FunctionCondition : public Condition {
 public:
  FunctionCondition(std::function<bool()> cond, std::function<void(void)> timeout = []() {});
  bool test() override;
 
 private:
  std::function<bool()> cond;
  std::function<void(void)> timeout;
};

class IfTimePassed : public Condition {
 public:
  IfTimePassed(double time_s);
  bool test() override;
 
 private:
  double time_s;
  vex::timer tmr;
};

class WaitUntilCondition : public AutoCommand {
 public:
  WaitUntilCondition(Condition* cond);
  bool run() override;
  std::string toString() override;
 
 private:
  Condition* cond;
};

class InOrder : public AutoCommand {
 public:
  InOrder(const InOrder& other) = default;
  InOrder(std::queue<AutoCommand*> cmds);
  InOrder(std::initializer_list<AutoCommand*> cmds);
  bool run() override;
  void on_timeout() override;
  std::string toString() override;
 
 private:
  AutoCommand* current_command = nullptr;
  std::queue<AutoCommand*> cmds;
  vex::timer tmr;
};

class Parallel : public AutoCommand {
 public:
  Parallel(std::initializer_list<AutoCommand*> cmds);
  bool run() override;
  void on_timeout() override;
  std::string toString() override;
 
 private:
  std::vector<AutoCommand*> cmds;
  std::vector<vex::task*> runners;
};

class Branch : public AutoCommand {
 public:
  Branch(Condition* cond, AutoCommand* false_choice, AutoCommand* true_choice);
  ~Branch();
  bool run() override;
  std::string toString() override;
  void on_timeout() override;
 
 private:
  AutoCommand* false_choice;
  AutoCommand* true_choice;
  Condition* cond;
  bool choice = false;
  bool chosen = false;
  vex::timer tmr;
};

class Async : public AutoCommand {
 public:
  Async(AutoCommand* cmd);
  bool run() override;
  std::string toString() override;
 
 private:
  AutoCommand* cmd = nullptr;
};
 
class RepeatUntil : public AutoCommand {
 public:
  RepeatUntil(InOrder cmds, size_t repeats);
  RepeatUntil(InOrder cmds, Condition* true_to_end);
  bool run() override;
  std::string toString() override;
  void on_timeout() override;
 
 private:
  const InOrder cmds;
  InOrder* working_cmds;
  Condition* cond;
};