public static bool TryGetNumberValue()

in Microsoft.Azure.Cosmos/src/Json/JsonBinaryEncoding.Numbers.cs [36:198]
133 lines of code
29 McCabe index (conditional complexity)

        public static bool TryGetNumberValue(ReadOnlySpan<byte> numberToken, UniformArrayInfo uniformArrayInfo, out Number64 number64, out int bytesConsumed)
        {
            number64 = 0;
            bytesConsumed = 0;

            if (numberToken.IsEmpty)
            {
                return false;
            }

            if (uniformArrayInfo != null)
            {
                switch (uniformArrayInfo.ItemTypeMarker)
                {
                    case TypeMarker.Int8:
                        number64 = MemoryMarshal.Read<sbyte>(numberToken);
                        bytesConsumed = sizeof(sbyte);
                        break;

                    case TypeMarker.UInt8:
                        number64 = MemoryMarshal.Read<byte>(numberToken);
                        bytesConsumed = sizeof(byte);
                        break;

                    case TypeMarker.Int16:
                        if (numberToken.Length < sizeof(short))
                        {
                            return false;
                        }

                        number64 = MemoryMarshal.Read<short>(numberToken);
                        bytesConsumed = sizeof(short);
                        break;

                    case TypeMarker.Int32:
                        if (numberToken.Length < sizeof(int))
                        {
                            return false;
                        }

                        number64 = MemoryMarshal.Read<int>(numberToken);
                        bytesConsumed = sizeof(int);
                        break;

                    case TypeMarker.Int64:
                        if (numberToken.Length < sizeof(long))
                        {
                            return false;
                        }

                        number64 = MemoryMarshal.Read<long>(numberToken);
                        bytesConsumed = sizeof(long);
                        break;

                    case TypeMarker.Float16:
                        // Currently not supported
                        return false;

                    case TypeMarker.Float32:
                        if (numberToken.Length < sizeof(float))
                        {
                            return false;
                        }

                        number64 = MemoryMarshal.Read<float>(numberToken);
                        bytesConsumed = sizeof(float);
                        break;

                    case TypeMarker.Float64:
                        if (numberToken.Length < sizeof(double))
                        {
                            return false;
                        }

                        number64 = MemoryMarshal.Read<double>(numberToken);
                        bytesConsumed = sizeof(double);
                        break;

                    default:
                        throw new JsonUnexpectedTokenException();
                }
            }
            else
            {
                byte typeMarker = numberToken[0];

                if (JsonBinaryEncoding.TypeMarker.IsEncodedNumberLiteral(typeMarker))
                {
                    number64 = typeMarker - JsonBinaryEncoding.TypeMarker.LiteralIntMin;
                    bytesConsumed = 1;
                }
                else
                {
                    switch (typeMarker)
                    {
                        case JsonBinaryEncoding.TypeMarker.NumberUInt8:
                            if (numberToken.Length < (1 + 1))
                            {
                                return false;
                            }

                            number64 = MemoryMarshal.Read<byte>(numberToken.Slice(1));
                            bytesConsumed = 1 + 1;
                            break;

                        case JsonBinaryEncoding.TypeMarker.NumberInt16:
                            if (numberToken.Length < (1 + 2))
                            {
                                return false;
                            }

                            number64 = MemoryMarshal.Read<short>(numberToken.Slice(1));
                            bytesConsumed = 1 + 2;
                            break;

                        case JsonBinaryEncoding.TypeMarker.NumberInt32:
                            if (numberToken.Length < (1 + 4))
                            {
                                return false;
                            }

                            number64 = MemoryMarshal.Read<int>(numberToken.Slice(1));
                            bytesConsumed = 1 + 4;
                            break;

                        case JsonBinaryEncoding.TypeMarker.NumberInt64:
                            if (numberToken.Length < (1 + 8))
                            {
                                return false;
                            }

                            number64 = MemoryMarshal.Read<long>(numberToken.Slice(1));
                            bytesConsumed = 1 + 8;
                            break;

                        case JsonBinaryEncoding.TypeMarker.NumberUInt64:
                            if (numberToken.Length < (1 + 8))
                            {
                                return false;
                            }

                            number64 = MemoryMarshal.Read<ulong>(numberToken.Slice(1));
                            bytesConsumed = 1 + 8;
                            break;

                        case JsonBinaryEncoding.TypeMarker.NumberDouble:
                            if (numberToken.Length < (1 + 8))
                            {
                                return false;
                            }

                            number64 = MemoryMarshal.Read<double>(numberToken.Slice(1));
                            bytesConsumed = 1 + 8;
                            break;

                        default:
                            throw new JsonInvalidNumberException();
                    }
                }
            }

            return true;
        }