More fixes

modules/common/chowdsp_serialization/Serialization/chowdsp_ByteSerializer.h

@@ -98,9 +98,11 @@ static T deserialize_object (nonstd::span<const std::byte>& bytes)
     const auto serial_bytes = get_bytes_for_deserialization (bytes);
     jassert (serial_bytes.size() == sizeof (T));
 
+    JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wclass-memaccess")
     T object;
     std::memcpy (&object, serial_bytes.data(), serial_bytes.size());
     return object;
+    JUCE_END_IGNORE_WARNINGS_GCC_LIKE
 }
 
 template <typename T>

modules/plugin/chowdsp_plugin_state/Backend/chowdsp_NonParamState.cpp

@@ -43,7 +43,7 @@ void NonParamState::serialize (ChainedArenaAllocator& arena, const NonParamState
     serialize_direct (serialize_num_bytes, num_bytes);
 }
 
-void NonParamState::deserialize (nonstd::span<const std::byte> serial_data, NonParamState& state, ChainedArenaAllocator& arena)
+void NonParamState::deserialize (nonstd::span<const std::byte>& serial_data, NonParamState& state, ChainedArenaAllocator& arena)
 {
     auto num_bytes = deserialize_direct<bytes_detail::size_type> (serial_data);
     if (num_bytes == 0)
@@ -111,7 +111,7 @@ json NonParamState::serialize_json (const NonParamState& state)
 {
     auto serial = nlohmann::json::object();
     for (const auto& value : state.values)
-        serial[value->name] = value->serialize();
+        serial[value->name] = value->serialize_json();
     return serial;
 }
 
@@ -130,7 +130,7 @@ void NonParamState::legacy_deserialize (const json& deserial, const NonParamStat
             {
                 if (name == value->name)
                 {
-                    value->deserialize (valueDeserial);
+                    value->deserialize_json (valueDeserial);
                     namesThatHaveBeenDeserialized.push_back (name);
                 }
             }
@@ -158,7 +158,7 @@ void NonParamState::deserialize_json (const json& deserial, const NonParamState&
     {
         auto iter = deserial.find (value->name);
         if (iter != deserial.end())
-            value->deserialize (*iter);
+            value->deserialize_json (*iter);
         else
             value->reset();
     }

modules/plugin/chowdsp_plugin_state/Backend/chowdsp_NonParamState.h

@@ -39,7 +39,7 @@ class NonParamState
     static void serialize (ChainedArenaAllocator& arena, const NonParamState& state);
 
     /** Custom deserializer */
-    static void deserialize (nonstd::span<const std::byte> serial_data, NonParamState& state, ChainedArenaAllocator& arena);
+    static void deserialize (nonstd::span<const std::byte>& serial_data, NonParamState& state, ChainedArenaAllocator& arena);
 
     /** Custom serializer */
     static json serialize_json (const NonParamState& state);

modules/plugin/chowdsp_plugin_state/Backend/chowdsp_PluginStateImpl.cpp

@@ -31,8 +31,8 @@ void PluginStateImpl<ParameterState, NonParameterState>::serialize (juce::Memory
     serialize_object (int {}, arena);
 #endif
 
-    ParamHolder::serialize (arena, params);
     NonParamState::serialize (arena, nonParams);
+    ParamHolder::serialize (arena, params);
 
     dump_serialized_bytes (data, arena, &frame);
 }
@@ -53,8 +53,8 @@ void PluginStateImpl<ParameterState, NonParameterState>::deserialize (juce::Memo
             else
             {
                 pluginStateVersion = Version::fromVersionHint (deserialize_object<int> (serial_data));
-                ParamHolder::deserialize (serial_data, params);
                 NonParamState::deserialize (serial_data, nonParams, *params.arena);
+                ParamHolder::deserialize (serial_data, params);
             }
 
             params.applyVersionStreaming (pluginStateVersion);

modules/plugin/chowdsp_plugin_state/Backend/chowdsp_StateValue.h

@@ -12,8 +12,8 @@ struct StateValueBase
 
     virtual void reset() {}
 
-    [[nodiscard]] virtual nlohmann::json serialize() const { return {}; }
-    virtual void deserialize (const nlohmann::json&) {}
+    [[nodiscard]] virtual nlohmann::json serialize_json() const { return {}; }
+    virtual void deserialize_json (const nlohmann::json&) {}
 
     [[nodiscard]] virtual size_t serialize (ChainedArenaAllocator&) const { return 0; }
     virtual void deserialize (nonstd::span<const std::byte>&) {}
@@ -74,13 +74,13 @@ struct StateValue : StateValueBase
     void reset() override { set (defaultValue); }
 
     /** JSON Serializer */
-    [[nodiscard]] nlohmann::json serialize() const override
+    [[nodiscard]] nlohmann::json serialize_json() const override
     {
         return get();
     }
 
     /** JSON Deserializer */
-    void deserialize (const nlohmann::json& deserial) override
+    void deserialize_json (const nlohmann::json& deserial) override
     {
         set (deserial.get<element_type>());
     }

modules/plugin/chowdsp_presets_v2/Backend/chowdsp_PresetState.cpp

@@ -37,17 +37,15 @@ void PresetState::reset()
     set ({});
 }
 
-#if CHOWDSP_USE_LEGACY_STATE_SERIALIZATION
-void PresetState::serialize (JSONSerializer::SerializedType& serial) const
+nlohmann::json PresetState::serialize_json() const
 {
-    JSONSerializer::addChildElement (serial, name);
-    if (preset == nullptr)
-        JSONSerializer::addChildElement (serial, {});
-    else
-        JSONSerializer::addChildElement (serial, preset->toJson());
+    if (preset != nullptr)
+        return preset->toJson();
+
+    return {};
 }
 
-void PresetState::deserialize (JSONSerializer::DeserializedType deserial)
+void PresetState::deserialize_json (const nlohmann::json& deserial)
 {
     if (deserial.is_null())
     {
@@ -57,26 +55,33 @@ void PresetState::deserialize (JSONSerializer::DeserializedType deserial)
 
     set (PresetPtr { deserial });
 }
-#else
-nlohmann::json PresetState::serialize() const
+
+[[nodiscard]] size_t PresetState::serialize (ChainedArenaAllocator& arena) const
 {
-    if (preset != nullptr)
-        return preset->toJson();
+    size_t num_bytes = 0;
+    if (preset == nullptr)
+    {
+        num_bytes += serialize_string ("", arena);
+        return num_bytes;
+    }
 
-    return {};
+    num_bytes += serialize_string (preset->toJson().dump(), arena);
+    return num_bytes;
 }
 
-void PresetState::deserialize (const nlohmann::json& deserial)
+void PresetState::deserialize (nonstd::span<const std::byte>& bytes)
 {
-    if (deserial.is_null())
+    try
     {
+        const auto stateJson = json::parse (deserialize_string (bytes));
+        set (PresetPtr { stateJson });
+    }
+    catch (const std::exception& e)
+    {
+        juce::Logger::writeToLog (std::string { "Unable to load preset state: " } + e.what());
         reset();
-        return;
     }
-
-    set (PresetPtr { deserial });
 }
-#endif
 
 bool operator== (const PresetState& presetState, std::nullptr_t)
 {

modules/plugin/chowdsp_presets_v2/Backend/chowdsp_PresetState.h

@@ -41,19 +41,17 @@ class PresetState : public StateValueBase
     /** Internal use only! */
     void reset() override;
 
-#if CHOWDSP_USE_LEGACY_STATE_SERIALIZATION
     /** Internal use only! */
-    void serialize (JSONSerializer::SerializedType& serial) const override;
+    [[nodiscard]] nlohmann::json serialize_json() const override;
 
     /** Internal use only! */
-    void deserialize (JSONSerializer::DeserializedType deserial) override;
-#else
+    void deserialize_json (const nlohmann::json& deserial) override;
+
     /** Internal use only! */
-    [[nodiscard]] nlohmann::json serialize() const override;
+    [[nodiscard]] size_t serialize (ChainedArenaAllocator&) const override;
 
     /** Internal use only! */
-    void deserialize (const nlohmann::json& deserial) override;
-#endif
+    void deserialize (nonstd::span<const std::byte>&) override;
 
 private:
     PresetPtr preset {};

tests/plugin_tests/chowdsp_plugin_state_test/NonParamTest.cpp

@@ -80,6 +80,7 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
 
         std::vector<std::byte> serial_bytes (chowdsp::get_serial_num_bytes (arena));
         chowdsp::dump_serialized_bytes (serial_bytes, arena);
+        nonstd::span<const std::byte> bytes { serial_bytes };
 
         chowdsp::NonParamState state {};
         state.addStateValues ({ &int_val, &atomic_int_val, &bool_vals, &string_val, &string_view_val, &juce_string_val, &json_val });
@@ -95,7 +96,7 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
         REQUIRE (juce_string_val.get() == "juce");
         REQUIRE (json_val.get() == chowdsp::json { { "val1", 100 }, { "val2", "test" } });
 
-        chowdsp::NonParamState::deserialize (serial_bytes, state, arena);
+        chowdsp::NonParamState::deserialize (bytes, state, arena);
         REQUIRE (int_val.get() == 101);
         REQUIRE (atomic_int_val.get() == 102);
         REQUIRE (! bool_vals.get()[0]);
@@ -126,6 +127,7 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
 
         std::vector<std::byte> serial_bytes (chowdsp::get_serial_num_bytes (arena));
         chowdsp::dump_serialized_bytes (serial_bytes, arena);
+        nonstd::span<const std::byte> bytes { serial_bytes };
 
         chowdsp::NonParamState state {};
         state.addStateValues ({ &string_val, &atomic_int_val, &int_val });
@@ -134,7 +136,7 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
         REQUIRE (atomic_int_val.get() == 99);
         REQUIRE (string_val.get() == "blah");
 
-        chowdsp::NonParamState::deserialize (serial_bytes, state, arena);
+        chowdsp::NonParamState::deserialize (bytes, state, arena);
         REQUIRE (int_val.get() == 101);
         REQUIRE (atomic_int_val.get() == 102);
         REQUIRE (string_val.get() == "blah blah");
@@ -156,6 +158,7 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
 
         std::vector<std::byte> serial_bytes (chowdsp::get_serial_num_bytes (arena));
         chowdsp::dump_serialized_bytes (serial_bytes, arena);
+        nonstd::span<const std::byte> bytes { serial_bytes };
 
         chowdsp::StateValue<float> float_val { "float", 90.0f };
         chowdsp::NonParamState state {};
@@ -166,7 +169,7 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
         REQUIRE (float_val.get() == 100.0f);
         REQUIRE (string_val.get() == "blah");
 
-        chowdsp::NonParamState::deserialize (serial_bytes, state, arena);
+        chowdsp::NonParamState::deserialize (bytes, state, arena);
         REQUIRE (int_val.get() == 101);
         REQUIRE (float_val.get() == 90.0f);
         REQUIRE (string_val.get() == "blah blah");
@@ -190,14 +193,15 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
 
         std::vector<std::byte> serial_bytes (chowdsp::get_serial_num_bytes (arena));
         chowdsp::dump_serialized_bytes (serial_bytes, arena);
+        nonstd::span<const std::byte> bytes { serial_bytes };
 
         chowdsp::NonParamState state {};
         state.addStateValues ({ &string_val, &int_val });
         state.reset();
         REQUIRE (int_val.get() == 42);
         REQUIRE (string_val.get() == "blah");
 
-        chowdsp::NonParamState::deserialize (serial_bytes, state, arena);
+        chowdsp::NonParamState::deserialize (bytes, state, arena);
         REQUIRE (int_val.get() == 101);
         REQUIRE (string_val.get() == "blah blah");
     }
@@ -215,9 +219,10 @@ TEST_CASE ("Non-Param Test", "[plugin][state]")
         string_val = "blah blah";
 
         const auto serial = std::array<std::byte, 2> {};
+        nonstd::span<const std::byte> bytes { serial };
 
         chowdsp::ChainedArenaAllocator arena { 1024 };
-        chowdsp::NonParamState::deserialize (serial, state, arena);
+        chowdsp::NonParamState::deserialize (bytes, state, arena);
         REQUIRE (int_val.get() == 42);
         REQUIRE (atomic_int_val.get() == 99);
         REQUIRE (string_val.get() == "blah");