to_string_native()

fl::string fl::Json::to_string_native

(

)

const

Definition at line 290 of file json.cpp.

                                      {
    if (!m_value) {
        return "null";
    }
    
    // 🚨 NEW APPROACH: Use fl::deque for memory-efficient JSON serialization
    // This avoids memory fragmentation and bypasses broken ArduinoJson integration
    fl::deque<char> json_chars;
    
    // Helper lambda for appending strings to deque
    auto append_string = [&json_chars](const char* str) {
        while (*str) {
            json_chars.push_back(*str);
            ++str;
        }
    };
    
    // Helper lambda for appending fl::string to deque
    auto append_fl_string = [&json_chars](const fl::string& str) {
        for (size_t i = 0; i < str.size(); ++i) {
            json_chars.push_back(str[i]);
        }
    };
    
    // Helper lambda for appending escaped strings
    auto append_escaped_string = [&](const fl::string& str) {
        json_chars.push_back('"');
        for (size_t i = 0; i < str.size(); ++i) {
            char c = str[i];
            switch (c) {
                case '"':  append_string("\\\""); break;
                case '\\': append_string("\\\\"); break;
                case '\n': append_string("\\n"); break;
                case '\r': append_string("\\r"); break;
                case '\t': append_string("\\t"); break;
                case '\b': append_string("\\b"); break;
                case '\f': append_string("\\f"); break;
                default:
                    json_chars.push_back(c);
                    break;
            }
        }
        json_chars.push_back('"');
    };
    
    // Recursive function to serialize JsonValue to deque
    fl::function<void(const JsonValue&)> serialize_value = [&](const JsonValue& value) {
        if (value.is_null()) {
            append_string("null");
        } else if (value.is_bool()) {
            auto opt = value.as_bool();
            if (opt) {
                append_string(*opt ? "true" : "false");
            } else {
                append_string("null");
            }
        } else if (value.is_int()) {
            auto opt = value.as_int();
            if (opt) {
                fl::string num_str;
                num_str.append(*opt);
                append_fl_string(num_str);
            } else {
                append_string("null");
            }
        } else if (value.is_float()) {
            auto opt = value.as_float();
            if (opt) {
                fl::string num_str;
                // Use fl::string::append which already handles float formatting correctly
                //num_str.append(*opt);
                num_str.append(static_cast<float>(*opt), 3);
                append_fl_string(num_str);
            } else {
                append_string("null");
            }
        } else if (value.is_string()) {
            auto opt = value.as_string();
            if (opt) {
                append_escaped_string(*opt);
            } else {
                append_string("null");
            }
        } else if (value.is_array()) {
            auto opt = value.as_array();
            if (opt) {
                json_chars.push_back('[');
                bool first = true;
                for (const auto& item : *opt) {
                    if (!first) {
                        json_chars.push_back(',');
                    }
                    first = false;
                    if (item) {
                        serialize_value(*item);
                    } else {
                        append_string("null");
                    }
                }
                json_chars.push_back(']');
            } else {
                append_string("null");
            }
        } else if (value.is_object()) {
            auto opt = value.as_object();
            if (opt) {
                json_chars.push_back('{');
                bool first = true;
                for (const auto& kv : *opt) {
                    if (!first) {
                        json_chars.push_back(',');
                    }
                    first = false;
                    append_escaped_string(kv.first);
                    json_chars.push_back(':');
                    if (kv.second) {
                        serialize_value(*kv.second);
                    } else {
                        append_string("null");
                    }
                }
                json_chars.push_back('}');
            } else {
                append_string("null");
            }
        } else {
            // Handle specialized array types
            if (value.is_audio()) {
                auto audioOpt = value.as_audio();
                if (audioOpt) {
                    json_chars.push_back('[');
                    bool first = true;
                    for (const auto& item : *audioOpt) {
                        if (!first) {
                            json_chars.push_back(',');
                        }
                        first = false;
                        fl::string num_str;
                        num_str.append(static_cast<int>(item));
                        append_fl_string(num_str);
                    }
                    json_chars.push_back(']');
                } else {
                    append_string("null");
                }
            } else if (value.is_bytes()) {
                auto bytesOpt = value.as_bytes();
                if (bytesOpt) {
                    json_chars.push_back('[');
                    bool first = true;
                    for (const auto& item : *bytesOpt) {
                        if (!first) {
                            json_chars.push_back(',');
                        }
                        first = false;
                        fl::string num_str;
                        num_str.append(static_cast<int>(item));
                        append_fl_string(num_str);
                    }
                    json_chars.push_back(']');
                } else {
                    append_string("null");
                }
            } else if (value.is_floats()) {
                auto floatsOpt = value.as_floats();
                if (floatsOpt) {
                    json_chars.push_back('[');
                    bool first = true;
                    for (const auto& item : *floatsOpt) {
                        if (!first) {
                            json_chars.push_back(',');
                        }
                        first = false;
                        fl::string num_str;
                        num_str.append(static_cast<float>(item), 6);
                        append_fl_string(num_str);
                    }
                    json_chars.push_back(']');
                } else {
                    append_string("null");
                }
            } else {
                append_string("null");
            }
        }
    };
    
    // Serialize the root value
    serialize_value(*m_value);
    
    // Convert deque to fl::string efficiently
    fl::string result;
    if (!json_chars.empty()) {
        // Get pointer to the underlying data and construct string directly
        result.assign(&json_chars[0], json_chars.size());
    }
    
    return result;
}

References fl::string::append(), fl::deque< T, Allocator >::empty(), m_value, fl::deque< T, Allocator >::push_back(), fl::deque< T, Allocator >::size(), and value().

Referenced by to_string(), fl::JsonValue::to_string(), and to_string_native_public().

Here is the call graph for this function:

Here is the caller graph for this function: