#include <ArduinoJson.h>
#include "TypeOf.h"
#include "LinkedList.h"

String json = "{\"var0\": 64,\"var1\": 521,\"var2\": 123.456,\"var3\": \"Good morning Vietnam\",\"var4\": \"Hello World.\",\"var5\": false}";

char var0;
int var1;
float var2;
String var3;
char var4[16];
bool var5;


void setup() {
  Serial.begin(115200);

  // Init the variables linked list object
  VariableList list;      
  list.addItem(var0, "var0"); 
  list.addItem(var1, "var1"); 
  list.addItem(var2, "var2");
  list.addItem(var3, "var3");
  list.addItem(var4, "var4");
  list.addItem(var5, "var5");

  // Create ArduinoJson object from string (will be a file)
  DynamicJsonDocument doc(512);
  deserializeJson(doc, json);

  Serial.println("Start values:");
  serializeJsonPretty(doc, Serial);

  // Init variable values loading from json
  list.loadValues(doc);

  // Edit the content of some variables
  var1 = -999;
  var3 = "This is a new String";
  strcpy(var4, "HELLO WORLD !!!");
  var5 = true;

  // Save current values to a new ArduinoJson object (will be a file)
  Serial.println("\n\nCurrent values:");
  list.saveValues();  
}

void loop() {
  // put your main code here, to run repeatedly:

}


linked_list.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

ArduinoJson

libraries.txt

    enum { CHAR, UCHAR, CHAR_PT, BOOL, INT, LONG, UINT, ULONG, FLOAT, DOUBLE, STRING};
    uint8_t TypeOf(const bool&)   { return BOOL; }
    uint8_t TypeOf(const char&)   { return CHAR; }
    uint8_t TypeOf(const char*)   { return CHAR_PT; }
    uint8_t TypeOf(const double&) { return DOUBLE; }
    uint8_t TypeOf(const float&)  { return FLOAT; }
    uint8_t TypeOf(const int&)  { return INT; }
    uint8_t TypeOf(const unsigned int&)  { return UINT; }
    uint8_t TypeOf(const unsigned long&)  { return ULONG; }
    uint8_t TypeOf(const unsigned char&)  { return UCHAR; }
    uint8_t TypeOf(const String&)  { return STRING; }

TypeOf.h


////////////////////////////////////////////////////////////////
struct VarNode
{  
  uint8_t type;
  void* var;
  const char* key;
  VarNode* next = nullptr;
};
////////////////////////////////////////////////////////////////
class VariableList
{
  private:
    VarNode* first = nullptr;
    VarNode* last = nullptr;

  public:
    VariableList(){;}
    
    template <class T>
    void addItem(T& var, const char* key)        
    {
      VarNode* node = new VarNode();
      node->var = &var;      
      node->key = key;
      node->type = TypeOf(var);

      if (first == nullptr) {   
        first = node;       
        last = node;  
        return;
      }      
      last->next = node;
      last = node;
    }

    VarNode* getNode(const char* key)
    {
      VarNode* current = first;
      while ( current != nullptr )
      {
        if (strcmp(current->key, key) == 0) {
          return current;      
        }
        current = current->next;
      }
      return nullptr;
    }


    void saveValues() {
      DynamicJsonDocument root(512);
      VarNode* current = first;      
      while ( current != nullptr )
      {
        switch (current->type) {
          case BOOL:  root[current->key] = *(bool*)current->var; break;
          case CHAR:  root[current->key] = *(signed char*)current->var; break;
          case INT:   root[current->key] = *(int*)current->var; break;
          case LONG:  root[current->key] = *(long*)current->var; break;
          case UCHAR: root[current->key] = *(unsigned char*)current->var; break;
          case UINT:  root[current->key] = *(unsigned int*)current->var; break;
          case ULONG: root[current->key] = *(unsigned long*)current->var; break;
          case CHAR_PT: root[current->key] = (unsigned char*)current->var; break;
          case FLOAT:   root[current->key] = *(float*)current->var; break;
          case DOUBLE:  root[current->key] = *(double*)current->var; break;
          case STRING:  root[current->key] = *(String*)current->var; break;
        }
        current = current->next;
      }
      serializeJsonPretty(root, Serial);
    }

    void loadValues(DynamicJsonDocument& doc) {
      
      VarNode* current = first;      
      while ( current != nullptr )
      {                
        switch (current->type) {
          case BOOL:    *(bool*)current->var = doc[current->key]; break;
          case CHAR:    *(signed char*)current->var = doc[current->key]; break;
          case INT:     *(int*)current->var = doc[current->key]; break;
          case LONG:    *(long*)current->var = doc[current->key]; break;
          case UCHAR:   *(unsigned char*)current->var = doc[current->key]; break;
          case UINT:    *(unsigned int*)current->var = doc[current->key]; break;
          case ULONG:   *(unsigned long*)current->var = doc[current->key]; break;
          case CHAR_PT: strcpy((char*)current->var, doc[current->key]); break;
          case FLOAT:   *(float*)current->var = doc[current->key]; break;
          case DOUBLE:  *(double*)current->var = doc[current->key]; break;
          case STRING:  *(String*)current->var = doc[current->key].as<String>(); break;
        }
        current = current->next;
      }
    }

    // inline void getVariable(bool var, const char* key)  { *(bool*)getNode(key)->var;  }  
    // inline void getVariable(char var, const char* key)  { *(char*)getNode(key)->var;  }
    // inline void getVariable(int var, const char* key)   { *(int*)getNode(key)->var;   }
    // inline void getVariable(long var, const char* key)  { *(long*)getNode(key)->var;  }
    // inline void getVariable(float var, const char* key) { *(float*)getNode(key)->var; }  
    // inline void getVariable(double var, const char* key) { *(float*)getNode(key)->var; }  
    // inline void getVariable(unsigned char var, const char* key)  { *(unsigned char*)getNode(key)->var; }
    // inline void getVariable(unsigned int var, const char* key)   { *(unsigned int*)getNode(key)->var;  }
    // inline void getVariable(unsigned long var, const char* key)  { *(unsigned long*)getNode(key)->var; }
    // inline void getVariable(char* var, const char* key)  { *(char*)getNode(key)->var; }
    // inline void getVariable(const char* var, const char* key)  { *(const char*)getNode(key)->var; }
    // inline void getVariable(String var, const char* key)  { *(String*)getNode(key)->var; }    
};