get_value()

template<typename T>

ParseResult< T > fl::JsonValue::array_iterator< T >::get_value ( ) const

inlineprivate

Definition at line 1218 of file json.h.

                                         {
            if (!m_variant || m_index >= get_size()) {
                return ParseResult<T>(Error("Index out of bounds"));
            }
            
            if (m_variant->is<JsonArray>()) {
                auto ptr = m_variant->ptr<JsonArray>();
                if (ptr && m_index < ptr->size() && (*ptr)[m_index]) {
                    auto& val = *((*ptr)[m_index]);
                    
                    // Try to convert to T using the JsonValue conversion methods
                    // Using FastLED type traits instead of std:: ones
                    if (fl::is_same<T, bool>::value) {
                        auto opt = val.as_bool();
                        if (opt) {
                            return ParseResult<T>(*opt);
                        } else {
                            return ParseResult<T>(Error("Cannot convert to bool"));
                        }
                    } else if (fl::is_integral<T>::value && fl::is_signed<T>::value) {
                        auto opt = val.template as_int<T>();
                        if (opt) {
                            return ParseResult<T>(*opt);
                        } else {
                            return ParseResult<T>(Error("Cannot convert to signed integer"));
                        }
                    } else if (fl::is_integral<T>::value && !fl::is_signed<T>::value) {
                        // For unsigned types, we check that it's integral but not signed
                        auto opt = val.template as_int<T>();
                        if (opt) {
                            return ParseResult<T>(*opt);
                        } else {
                            return ParseResult<T>(Error("Cannot convert to unsigned integer"));
                        }
                    } else if (fl::is_floating_point<T>::value) {
                        auto opt = val.template as_float<T>();
                        if (opt) {
                            return ParseResult<T>(*opt);
                        } else {
                            return ParseResult<T>(Error("Cannot convert to floating point"));
                        }
                    }
                } else {
                    return ParseResult<T>(Error("Invalid array access"));
                }
            }
            
            if (m_variant->is<fl::vector<int16_t>>()) {
                auto ptr = m_variant->ptr<fl::vector<int16_t>>();
                if (ptr && m_index < ptr->size()) {
                    return ParseResult<T>(static_cast<T>((*ptr)[m_index]));
                } else {
                    return ParseResult<T>(Error("Index out of bounds in int16_t array"));
                }
            }
            
            if (m_variant->is<fl::vector<uint8_t>>()) {
                auto ptr = m_variant->ptr<fl::vector<uint8_t>>();
                if (ptr && m_index < ptr->size()) {
                    return ParseResult<T>(static_cast<T>((*ptr)[m_index]));
                } else {
                    return ParseResult<T>(Error("Index out of bounds in uint8_t array"));
                }
            }
            
            if (m_variant->is<fl::vector<float>>()) {
                auto ptr = m_variant->ptr<fl::vector<float>>();
                if (ptr && m_index < ptr->size()) {
                    return ParseResult<T>(static_cast<T>((*ptr)[m_index]));
                } else {
                    return ParseResult<T>(Error("Index out of bounds in float array"));
                }
            }
            

References fl::JsonValue::as_float(), fl::JsonValue::as_int(), get_size(), m_index, m_variant, fl::JsonValue::size(), fl::is_floating_point< T >::value, fl::is_integral< T >::value, fl::is_same< T, U >::value, and fl::is_signed< T >::value.

Here is the call graph for this function: