#include <Arduino.h>
#include <memory>
#include "Category.h"
#include "C2.h"

void serialPrintFreeHeap() {
  Serial.println("[APP] Free memory: " + String(esp_get_free_heap_size()) + " bytes");
}

void serialPrintEnum(const Enum *e) {
  Serial.print((int)e->id);
  Serial.print(" ");
  Serial.println(e->name);
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  
  serialPrintFreeHeap();

  serialPrintEnum(Category::getValueById(0x01));
  serialPrintEnum(C2::getValueById(0x00));
}

void loop() {
  // put your main code here, to run repeatedly:
  delay(100); // this speeds up the simulation

  //auto e = std::shared_ptr<Enum>(new Category(0x00, "test"));
  //auto e = Category::CAR_STATUS;
  //Enum *e = new Category(0x00, "test");

  for(uint8_t i = 0; i < Category::getSize(); i++) {
    auto e = Category::getValues()[i];
    serialPrintEnum(e);
  }

  for(uint8_t i = 0; i < C2::getSize(); i++) {
    auto e = C2::getValues()[i];
    serialPrintEnum(e);
  }
  
  //delete e;

  serialPrintFreeHeap();
}


sketch.ino

diagram.json

#include "Category.h"

Category::Category(uint8_t id, char *name) : Enum(id, name) {
  values[index] = this;
  index++;
};

const Enum* Category::getValueById(uint8_t id) {
  for(uint8_t i = 0; i < getSize(); i++) {
    if(values[i]->id == id) {
      return values[i];
    }
  }
}

uint8_t Category::getSize() {
  return index;
}

const Enum** Category::getValues() {
  return values;
}

//const Enum* Enum::values [] = {&Category::CAR_STATUS, &Category::READ_SETTINGS};
const Enum* Category::values [2] = { 0 };
uint8_t Category::index = 0;
const Category Category::CAR_STATUS = Category(0x00, "CAR_STATUS");
const Category Category::READ_SETTINGS = Category(0x01, "READ_SETTINGS");


Category.h

#include "Enum.h"

Enum::Enum() {}

Enum::Enum(uint8_t id, char *name) {
    this->name = name;
    this->id = id;
};


Enum.cpp

#pragma once

#include <Arduino.h>

class Enum {
    public:
        char *name;
        uint8_t id;

        static const Enum* getValues();
        static uint8_t getSize();
        static const Enum** getValueById(uint8_t id);
        
        Enum();
        Enum(uint8_t id, char *name);
};


Enum.h

#pragma once

#include "Enum.h"

class C2 : public Enum {
    public:
        static const C2 C2_0;

        static const Enum* getValueById(uint8_t id);
        static const Enum** getValues();
        static uint8_t getSize();

    private:
        static const Enum* values[];
        static uint8_t index;
        
        C2(uint8_t id, char *name);
};


C2.h

#include "C2.h"

C2::C2(uint8_t id, char *name) : Enum(id, name) {
  values[index] = this;
  index++;
};

const Enum* C2::getValueById(uint8_t id) {
  for(uint8_t i = 0; i < getSize(); i++) {
    if(values[i]->id == id) {
      return values[i];
    }
  }
}

uint8_t C2::getSize() {
  return index;
}

const Enum** C2::getValues() {
  return values;
}

//const Enum* Enum::values [] = {&Category::CAR_STATUS, &Category::READ_SETTINGS};
const Enum* C2::values [1] = { 0 };
uint8_t C2::index = 0;
const C2 C2::C2_0 = C2(0x00, "C2");
