get_value()

template<typename T>

parse_result< T > fl::json_value::array_iterator< T >::get_value ( ) const

inlineprivate

Definition at line 1219 of file types.h.

                                                      {
            if (!mVariant || mIndex >= get_size()) {
                return parse_result<T>(task::Error("Index out of bounds"));
            }
            
            if (mVariant->is<json_array>()) {
                auto ptr = mVariant->ptr<json_array>();
                if (ptr && mIndex < ptr->size() && (*ptr)[mIndex]) {
                    auto& val = *((*ptr)[mIndex]);
                    
                    // Try to convert to T using the json_value 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 parse_result<T>(*opt);
                        } else {
                            return parse_result<T>(task::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 parse_result<T>(*opt);
                        } else {
                            return parse_result<T>(task::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 parse_result<T>(*opt);
                        } else {
                            return parse_result<T>(task::Error("Cannot convert to unsigned integer"));
                        }
                    } else if (fl::is_floating_point<T>::value) {
                        auto opt = val.template as_float<T>();
                        if (opt) {
                            return parse_result<T>(*opt);
                        } else {
                            return parse_result<T>(task::Error("Cannot convert to floating point"));
                        }
                    }
                } else {
                    return parse_result<T>(task::Error("Invalid array access"));
                }
            }
            
            if (mVariant->is<fl::vector<i16>>()) {
                auto ptr = mVariant->ptr<fl::vector<i16>>();
                if (ptr && mIndex < ptr->size()) {
                    return parse_result<T>(static_cast<T>((*ptr)[mIndex]));
                } else {
                    return parse_result<T>(task::Error("Index out of bounds in i16 array"));
                }
            }
            
            if (mVariant->is<fl::vector<u8>>()) {
                auto ptr = mVariant->ptr<fl::vector<u8>>();
                if (ptr && mIndex < ptr->size()) {
                    return parse_result<T>(static_cast<T>((*ptr)[mIndex]));
                } else {
                    return parse_result<T>(task::Error("Index out of bounds in u8 array"));
                }
            }
            
            if (mVariant->is<fl::vector<float>>()) {
                auto ptr = mVariant->ptr<fl::vector<float>>();
                if (ptr && mIndex < ptr->size()) {
                    return parse_result<T>(static_cast<T>((*ptr)[mIndex]));
                } else {
                    return parse_result<T>(task::Error("Index out of bounds in float array"));
                }
            }
            
            return parse_result<T>(task::Error("Unknown array type"));
        }

References fl::json_value::as_float(), fl::json_value::as_int(), FL_NOEXCEPT, get_size(), mIndex, mVariant, fl::json_value::size(), fl::fl::is_floating_point< T >::value, fl::fl::is_integral< T >::value, fl::fl::is_same< T, U >::value, and fl::fl::is_signed< T >::value.

Referenced by operator*().

Here is the call graph for this function:

Here is the caller graph for this function: