renderbug-cpp/src/Platform.h

#pragma once
#include <FastLED.h>
#include <Figments.h>
#include "BootOptions.h"

class Platform : public Task {
    static int s_timezone;
    static char s_deviceID[15];
  public:
    Platform() : Task("Platform") {state = Task::Running;}
    static BootOptions bootopts;
    static void setTimezone(int tz) { s_timezone = tz; }
    static int getTimezone() { return s_timezone; }
    static void addLEDs(CRGB* leds, uint16_t ledCount);

    static const char* name();
    static const char* version();
    static const String model();
    static const String deviceName() {
      static String devName = model() + " " + Platform::deviceID();
      return devName;
    }
    static void preSetup();
    static void bootSplash();
    static void setup();
    void loop() override;
    static bool getLocalTime(struct tm* timedata);
    static const char* deviceID();
    static int freeRam();

    struct TaskRegistration {
      Task* task = 0;
      TaskRegistration* next = 0;

      TaskRegistration(Task* task) : task(task) {}
    };

    static TaskRegistration* firstTask;
    static TaskRegistration* lastTask;

    static void registerTask(TaskRegistration* reg) {
      if (firstTask == NULL) {
        firstTask = reg;
        lastTask = firstTask;
      } else {
        lastTask->next = reg;
        lastTask = reg;
      }
    }

    struct figment_iterator: public std::iterator<std::input_iterator_tag, Figment*> {
      TaskRegistration* cur;
      explicit figment_iterator() : cur(NULL) {}
      explicit figment_iterator(TaskRegistration* head) : cur(head) {
        while (cur && !cur->task->isFigment()) {
          cur = cur->next;
        }
      }
      figment_iterator& operator++() {
        if (cur) {
          do {
            cur = cur->next;
          } while (cur && !cur->task->isFigment());
        }
        return *this;
      }

      figment_iterator operator++(int) {figment_iterator ret = *this; ++(*this); return ret;}
      bool operator==(figment_iterator other) const { return cur == other.cur; }
      bool operator!=(figment_iterator other) const { return !(*this == other); }
      Figment* operator*() const { return static_cast<Figment*>(cur->task); }
    };

    struct task_iterator: public std::iterator<std::input_iterator_tag, Task*> {
      TaskRegistration* cur;
      explicit task_iterator() : cur(NULL) {}
      explicit task_iterator(TaskRegistration* head) : cur(head) {}
      task_iterator& operator++() {
        if (cur) {
          cur = cur->next;
        }
        return *this;
      }

      task_iterator operator++(int) {task_iterator ret = *this; ++(*this); return ret;}
      bool operator==(task_iterator other) const { return cur == other.cur; }
      bool operator!=(task_iterator other) const { return !(*this == other); }
      Task* operator*() const { return cur->task; }
    };

    static figment_iterator beginFigments() {
      return figment_iterator(firstTask);
    }

    static figment_iterator endFigments() {
      return figment_iterator(NULL);
    }

    static task_iterator beginTasks() {
      return task_iterator(firstTask);
    }

    static task_iterator endTasks() {
      return task_iterator(NULL);
    }

    static void restart();
};