RNBO: src/RNBO_Presets.h Source File

Go to the documentation of this file.
 //
 //  RNBO_Presets.h
 //
  
 #ifndef _RNBO_Presets_H_
 #define _RNBO_Presets_H_
  
 #include "RNBO_Std.h"
 #include "RNBO_PatcherState.h"
  
 #ifdef RNBO_NOSTDLIB
 #define RNBO_NOPRESETS
 #endif
  
 #ifdef RNBO_NOPRESETS
  
 namespace RNBO {
     using Preset = PatcherState;
     using PresetCallback = void(*);
     using UniquePresetPtr = void*;
     using PresetPtr = std::shared_ptr<Preset>;
     using ConstPresetPtr = std::shared_ptr<const Preset>;
 }
  
 #else
  
 RNBO_PUSH_DISABLE_WARNINGS
 #include "3rdparty/json/json.hpp"
 RNBO_POP_DISABLE_WARNINGS
  
 #include "RNBO_Utils.h"
 #include "RNBO_Debug.h"
  
 namespace RNBO {
  
     using PresetMap = StateMap;
  
     using Preset = PatcherState;
  
     using PresetPtr = std::shared_ptr<Preset>;
  
     using PresetCallback = std::function<void(std::shared_ptr<const Preset>)>;
  
     using ConstPresetPtr = std::shared_ptr<const Preset>;
  
     struct NamedPresetEntry {
         std::string name;
         PresetPtr preset;
     };
  
     class DummyPreset : public PatcherState
     {
     public:
         bool isDummy() const override { return true; }
     };
  
 #ifdef RNBO_NOSTDLIB
     using UniquePresetPtr = UniquePtr<Preset>;
 #else
  
     using UniquePresetPtr = std::unique_ptr<Preset>;
 #endif // RNBO_NOSTDLIB
  
 #ifndef RNBO_NOJSONPRESETS
  
     using Json = nlohmann::json;
  
     static Json convertPresetToJSONObj(const Preset& preset) {
         Json json;
         for (auto const& entry : preset) {
             const char *key = entry.first.c_str();
             auto type = entry.second.getType();
             switch (type) {
                 case ValueHolder::FLOAT: {
                     float value = (float)entry.second;
                     json[key] = value;
                     break;
                 }
                 case ValueHolder::DOUBLE: {
                     double value = (double)entry.second;
                     json[key] = value;
                     break;
                 }
                 case ValueHolder::LIST: {
                     Json j;
                     const list& value = entry.second;
                     for (size_t i = 0; i < value.length; i++) {
                         j.push_back(value[i]);
                     }
                     json[key] = j;
                     break;
                 }
                 case ValueHolder::STRING: {
                     const char * str = entry.second;
                     json[key] = str;
                     break;
                 }
                 case ValueHolder::SUBSTATE: {
                     const Preset& subPreset = entry.second;
                     json[key] = convertPresetToJSONObj(subPreset);
                     break;
                 }
                 case ValueHolder::SUBSTATEMAP: {
                     Index size = entry.second.getSubStateMapSize();
                     if (size) {
                         Json j;
                         for (Index i = 0; i < size; i++) {
                             const Preset& subPreset = entry.second[i];
                             j.push_back(convertPresetToJSONObj(subPreset));
                         }
                         json[key] = j;
                     }
                     break;
                 }
                 case ValueHolder::UINT32: {
                     UInt32 value = (UInt32)entry.second;
                     json[key] = value;
                     break;
                 }
                 case ValueHolder::UINT64: {
                     UInt64 value = (UInt64)entry.second;
                     json[key] = value;
                     break;
                 }
                 case ValueHolder::NONE:
                 case ValueHolder::EXTERNAL:
                 case ValueHolder::EVENTTARGET:
                 case ValueHolder::DATAREF:
                 case ValueHolder::MULTIREF:
                 case ValueHolder::SIGNAL:
                 case ValueHolder::BOOLEAN:
                 case ValueHolder::INTVALUE:
                 default:
                     // we do only support numbers, lists and substates
                     RNBO_ASSERT(false);
             }
         }
  
         return json;
     }
  
     ATTRIBUTE_UNUSED
     static std::string convertPresetToJSON(const Preset& preset) {
         return convertPresetToJSONObj(preset).dump();
     }
  
     static void convertJSONObjToPreset(Json& json, Preset& preset) {
         for (Json::iterator it = json.begin(); it != json.end(); it++) {
             const char* key = it.key().c_str();
             if (it->is_number()) {
                 number value = it.value();
                 preset[key] = value;
             }
             else if (it->is_string()) {
                 std::string value = it.value();
                 preset[key] = value.c_str();
             }
             else if (it->is_array()) {
                 Json& j = *it;
                 if (j.size() > 0) {
                     if (j[0].is_number()) {
                         list value;
                         for (Index i = 0; i < j.size(); i++) {
                             value.push(j[i]);
                         }
                         preset[key] = value;
                     }
                     else if (j[0].is_object()) {
                         for (Index i = 0; i < j.size(); i++) {
                             Preset& subPreset = preset[key][i];
                             convertJSONObjToPreset(j[i], subPreset);
                         }
                     }
                 }
             }
             else if (it->is_object()) {
                 Json& j = *it;
                 Preset& subPreset = preset.getSubState(key);
                 convertJSONObjToPreset(j, subPreset);
             }
         }
     }
  
     ATTRIBUTE_UNUSED
     static void convertJSONArrayToPresetList(std::string jsonString, std::vector<std::shared_ptr<NamedPresetEntry>>& presetList) {
         Json json = Json::parse(jsonString);
         for (Json::iterator it = json.begin(); it != json.end(); it++) {
             if (it->is_object()) {
                 Json& j = *it;
                 std::shared_ptr<NamedPresetEntry> entry(new NamedPresetEntry);
                 std::string name = j["name"];
                 Json presetPayload = j["preset"];
                 entry->name = name;
                 PresetPtr preset = std::make_shared<Preset>();
                 convertJSONObjToPreset(presetPayload, *preset);
                 entry->preset = preset;
                 presetList.push_back(entry);
             }
         }
     }
  
     ATTRIBUTE_UNUSED
     static UniquePresetPtr convertJSONToPreset(std::string jsonString) {
         UniquePresetPtr preset = make_unique<Preset>();
         Json json = Json::parse(jsonString);
         convertJSONObjToPreset(json, *preset);
         return preset;
     }
  
     ATTRIBUTE_UNUSED
     static void copyPreset(const Preset& src, Preset &dst)
     {
             for (auto const& entry : src) {
                     const char *key = entry.first.c_str();
                     auto type = entry.second.getType();
                     switch (type) {
                         case ValueHolder::FLOAT: {
                             float value = (float)entry.second;
                             dst[key] = value;
                             break;
                         }
                         case ValueHolder::DOUBLE: {
                             double value = (double)entry.second;
                             dst[key] = value;
                             break;
                         }
                         case ValueHolder::UINT32: {
                             UInt32 value = (UInt32)entry.second;
                             dst[key] = value;
                             break;
                         }
                         case ValueHolder::UINT64: {
                             UInt64 value = (UInt64)entry.second;
                             dst[key] = value;
                             break;
                         }
                         case ValueHolder::LIST: {
                             Json j;
                             const list& srclist = entry.second;
                             list dstlist;
                             for (Index i = 0; i < srclist.length; i++) {
                                     dstlist.push(srclist[i]);
                             }
                             dst[key] = dstlist;
                             break;
                         }
                         case ValueHolder::SUBSTATE: {
                             const Preset& preset = entry.second;
                             copyPreset(preset, dst[key]);
                             break;
                         }
                         case ValueHolder::SUBSTATEMAP: {
                             Index size = entry.second.getSubStateMapSize();
                             if (size) {
                                     for (Index i = 0; i < size; i++) {
                                             const Preset& preset = entry.second[i];
                                             Preset& dstSubPreset = dst[key][i];
                                             copyPreset(preset, dstSubPreset);
                                     }
                             }
                             break;
                         }
                         case ValueHolder::STRING:
                             //presetid
                             RNBO_ASSERT(strcmp(key, "__presetid") == 0);
                             break;
                         case ValueHolder::NONE:
                         case ValueHolder::EXTERNAL:
                         case ValueHolder::EVENTTARGET:
                         case ValueHolder::DATAREF:
                         case ValueHolder::MULTIREF:
                         case ValueHolder::SIGNAL:
                         case ValueHolder::BOOLEAN:
                         case ValueHolder::INTVALUE:
                         default:
                             // we do only support numbers, lists and substates
                             RNBO_ASSERT(false);
                             break;
                     }
             }
     }
  
 #endif // RNBO_NOJSONPRESETS
  
 } // namespace RNBO
  
 #endif // RNBO_NOPRESETS
  
 #endif  // _RNBO_Presets_H_
C++ Guides

RNBO: src/RNBO_Presets.h Source File
