parse()

fl::shared_ptr< JsonValue > fl::JsonValue::parse ( const fl::string & txt )

static

Definition at line 81 of file json.cpp.

                                                            {
    #if !FASTLED_ENABLE_JSON
    return fl::make_shared<JsonValue>(fl::string(txt));
    #else
    // Determine the size of the JsonDocument needed.
    FLArduinoJson::JsonDocument doc;
 
    FLArduinoJson::DeserializationError error = FLArduinoJson::deserializeJson(doc, txt.c_str());
 
    if (error) {
        FL_WARN("JSON parsing failed: " << error.c_str());
        return fl::make_shared<JsonValue>(nullptr); // Return null on error
    }
 
    // Helper function to convert FLArduinoJson::JsonVariantConst to fl::Json::JsonValue
    struct Converter {
        static fl::shared_ptr<JsonValue> convert(const FLArduinoJson::JsonVariantConst& src) {
            if (src.isNull()) {
                return fl::make_shared<JsonValue>(nullptr);
            } else if (src.is<bool>()) {
                return fl::make_shared<JsonValue>(src.as<bool>());
            } else if (src.is<int64_t>()) {
                // Handle 64-bit integers
                return fl::make_shared<JsonValue>(src.as<int64_t>());
            } else if (src.is<int32_t>()) {
                // Handle 32-bit integers explicitly for platform compatibility
                return fl::make_shared<JsonValue>(static_cast<int64_t>(src.as<int32_t>()));
            } else if (src.is<uint32_t>()) {
                // Handle unsigned 32-bit integers
                return fl::make_shared<JsonValue>(static_cast<int64_t>(src.as<uint32_t>()));
            } else if (src.is<double>()) {
                // Handle double precision floats - convert to float
                return fl::make_shared<JsonValue>(static_cast<float>(src.as<double>()));
            } else if (src.is<float>()) {
                // Handle single precision floats explicitly
                return fl::make_shared<JsonValue>(src.as<float>());
            } else if (src.is<const char*>()) {
                return fl::make_shared<JsonValue>(fl::string(src.as<const char*>()));
            } else if (src.is<FLArduinoJson::JsonArrayConst>()) {
                FLArduinoJson::JsonArrayConst arr = src.as<FLArduinoJson::JsonArrayConst>();
                
                // Empty arrays should remain regular arrays
                if (arr.size() == 0) {
                    return fl::make_shared<JsonValue>(JsonArray{});
                }
                
                // Enum to represent array optimization types
                enum ArrayType {
                    ALL_UINT8,
                    ALL_INT16,
                    ALL_FLOATS,
                    GENERIC_ARRAY
                };
                
                // Helper struct to track array type info
                struct ArrayTypeInfo {
                    bool isUint8 = true;
                    bool isInt16 = true;
                    bool isFloat = true;
                    
                    void disableAll() {
                        isUint8 = false;
                        isInt16 = false;
                        isFloat = false;
                    }
                    
                    void checkNumericValue(double val) {
                        // Check integer ranges in one pass
                        bool isInteger = val == floor(val);
                        if (!isInteger || val < 0 || val > UINT8_MAX) {
                            isUint8 = false;
                        }
                        if (!isInteger || val < INT16_MIN || val > INT16_MAX) {
                            isInt16 = false;
                        }
                        if (!canBeRepresentedAsFloat(val)) {
                            isFloat = false;
                        }
                    }
                    
                    void checkIntegerValue(int64_t val) {
                        // Check all ranges in one pass
                        if (val < 0 || val > UINT8_MAX) {
                            isUint8 = false;
                        }
                        if (val < INT16_MIN || val > INT16_MAX) {
                            isInt16 = false;
                        }
                        if (val < -16777216 || val > 16777216) {
                            isFloat = false;
                        }
                    }
                    
                    ArrayType getBestType() const {
                        if (isUint8) return ALL_UINT8;
                        if (isInt16) return ALL_INT16;
                        if (isFloat) return ALL_FLOATS;
                        return GENERIC_ARRAY;
                    }
                };
                
                ArrayTypeInfo typeInfo;
                
                #if FASTLED_DEBUG_LEVEL >= 2
                FASTLED_WARN("Array conversion: processing " << arr.size() << " items");
                #endif
                
                for (const auto& item : arr) {
                    // Check if all items are numeric
                    if (!item.is<int32_t>() && !item.is<int64_t>() && !item.is<double>()) {
                        typeInfo.disableAll();
                        #if FASTLED_DEBUG_LEVEL >= 2
                        FASTLED_WARN("Non-numeric value found, no optimization possible");
                        #endif
                        break;
                    }
                    
                    // Update type flags based on item type
                    if (item.is<double>()) {
                        double val = item.as<double>();
                        typeInfo.checkNumericValue(val);
                    } else {
                        int64_t val = item.is<int32_t>() ? item.as<int32_t>() : item.as<int64_t>();
                        typeInfo.checkIntegerValue(val);
                    }
                }
                
                // Determine the optimal array type based on the flags
                ArrayType arrayType = arr.size() > 0 ? typeInfo.getBestType() : GENERIC_ARRAY;
                
                // Apply the most appropriate optimization based on determined type
                switch (arrayType) {
                    case ALL_UINT8: {
                        // All values fit in uint8_t - most compact representation
                        fl::vector<uint8_t> byteData;
                        for (const auto& item : arr) {
                            if (item.is<double>()) {
                                byteData.push_back(static_cast<uint8_t>(item.as<double>()));
                            } else {
                                int64_t val = item.is<int32_t>() ? item.as<int32_t>() : item.as<int64_t>();
                                byteData.push_back(static_cast<uint8_t>(val));
                            }
                        }
                        return fl::make_shared<JsonValue>(fl::move(byteData));
                    }
                    case ALL_INT16: {
                        // All values fit in int16_t - good compression
                        fl::vector<int16_t> intData;
                        for (const auto& item : arr) {
                            if (item.is<double>()) {
                                intData.push_back(static_cast<int16_t>(item.as<double>()));
                            } else {
                                int64_t val = item.is<int32_t>() ? item.as<int32_t>() : item.as<int64_t>();
                                intData.push_back(static_cast<int16_t>(val));
                            }
                        }
                        return fl::make_shared<JsonValue>(fl::move(intData));
                    }
                    case ALL_FLOATS: {
                        // All values can be exactly represented as floats - use float vector
                        fl::vector<float> floatData;
                        for (const auto& item : arr) {
                            if (item.is<double>()) {
                                floatData.push_back(static_cast<float>(item.as<double>()));
                            } else {
                                int64_t val = item.is<int32_t>() ? item.as<int32_t>() : item.as<int64_t>();
                                floatData.push_back(static_cast<float>(val));
                            }
                        }
                        return fl::make_shared<JsonValue>(fl::move(floatData));
                    }
                    case GENERIC_ARRAY:
                    default: {
                        // No optimization possible - use regular array
                        JsonArray regularArr;
                        for (const auto& item : arr) {
                            regularArr.push_back(convert(item));
                        }
                        return fl::make_shared<JsonValue>(fl::move(regularArr));
                    }
                }
            } else if (src.is<FLArduinoJson::JsonObjectConst>()) {
                JsonObject obj;
                for (const auto& kv : src.as<FLArduinoJson::JsonObjectConst>()) {
                    obj[fl::string(kv.key().c_str())] = convert(kv.value());
                }
                return fl::make_shared<JsonValue>(fl::move(obj));
            }
            return fl::make_shared<JsonValue>(nullptr); // Should not happen
        }
    };
 
    return Converter::convert(doc.as<FLArduinoJson::JsonVariantConst>());
    #endif
}

References fl::StrN< SIZE >::c_str(), FASTLED_WARN, FL_WARN, fl::floor(), INT16_MAX, fl::make_shared(), fl::move(), fl::HeapVector< T, Allocator >::push_back(), and UINT8_MAX.

Referenced by fl::Json::parse().

Here is the call graph for this function:

Here is the caller graph for this function: