src/std/conv.d

13         $(LREF parse)
123     return new ConvException(text("Can't parse string: ", msg), fn, ln);
1983     !isExactSomeString!T && is(typeof(parse!T(value))) &&
1994     return parse!T(value);
2000     isIntegral!T && is(typeof(parse!T(value, radix))))
2009     return parse!T(value, radix);
2054 supported by parse parses the first dchar of the source.
2064 if (isSomeChar!T && !is(typeof(parse!T(value))) &&
2065     is(typeof(parse!dchar(value))))
2069     immutable dchar codepoint = parse!dchar(value);
2259 The `parse` family of functions works quite like the `to`
2285     to `parse` and do not require lvalues.
2287 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source source)
2342     bool b = parse!bool(s);
2345     bool b2 = parse!(bool, string, No.doCount)(s2);
2348     auto b3 = parse!(bool, string, Yes.doCount)(s3);
2351     auto b4 = parse!(bool, string, Yes.doCount)(s4);
2368     assert(parse!bool(s) == true);
2370     assert(parse!bool(s) == false);
2372     assert(parse!bool(s) == true);
2374     assert(parse!bool(s) == false);
2376     assert(parse!bool(s) == true);
2378     assert(parse!bool(s) == false);
2384         assertThrown!ConvException(parse!bool(s));
2406 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref scope Source s)
2413         auto v = .parse!(Select!(Target.min < 0, int, uint), Source, Yes.doCount)(s);
2535     auto a = parse!int(s);
2539     auto a1 = parse!(int, string, Yes.doCount)(s1);
2542     // parse only accepts lvalues
2543     static assert(!__traits(compiles, parse!int("123")));
2552     auto a = parse!uint(test);
2554     assert(test == " \t  76.14"); // parse bumps string
2557     auto b = parse!double(test);
2562     auto a2 = parse!(uint, string, Yes.doCount)(test2);
2564     assert(test2 == " \t  76.14");// parse bumps string
2567     auto b2 = parse!(double, string, Yes.doCount)(test2);
2702         // parse!SomeUnsigned cannot parse head sign.
2776     assertCTFEable!({ string s =  "1234abc"; assert(parse! int(s) ==  1234 && s == "abc"); });
2777     assertCTFEable!({ string s = "-1234abc"; assert(parse! int(s) == -1234 && s == "abc"); });
2778     assertCTFEable!({ string s =  "1234abc"; assert(parse!uint(s) ==  1234 && s == "abc"); });
2780     assertCTFEable!({ string s =  "1234abc"; assert(parse!( int, string, Yes.doCount)(s) ==
2782     assertCTFEable!({ string s = "-1234abc"; assert(parse!( int, string, Yes.doCount)(s) ==
2784     assertCTFEable!({ string s =  "1234abc"; assert(parse!(uint, string, Yes.doCount)(s) ==
2810     assert(parse!int(input) == 777);
2813     assert(parse!(int, StrInputRange, Yes.doCount)(input2) == tuple(777, 3));
2820     assert(parse!(string[])(s1) == ["a", "\0", "!", "!8"]);
2824     assert(parse!(string[], string, Yes.doCount)(s1) == tuple(["a", "\0", "!", "!8"], len));
2828 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source source, uint radix)
2842         return parse!(Target, Source, doCount)(source);
2845     enforce!ConvException(!source.empty, "s must not be empty in integral parse");
2915     string s; // parse doesn't accept rvalues
2918         assert(parse!int(s = "0", i) == 0);
2919         assert(parse!int(s = "1", i) == 1);
2920         assert(parse!byte(s = "10", i) == i);
2921         assert(parse!(int, string, Yes.doCount)(s = "0", i) == tuple(0, 1));
2922         assert(parse!(int, string, Yes.doCount)(s = "1", i) == tuple(1, 1));
2923         assert(parse!(byte, string, Yes.doCount)(s = "10", i) == tuple(i, 2));
2926     assert(parse!int(s = "0011001101101", 2) == 0b0011001101101);
2927     assert(parse!int(s = "765", 8) == octal!765);
2928     assert(parse!int(s = "000135", 8) == octal!"135");
2929     assert(parse!int(s = "fCDe", 16) == 0xfcde);
2932     assert(parse!int(s = "-42", 10) == -42);
2934     assert(parse!ubyte(s = "ff", 16) == 0xFF);
2942     auto u = parse!uint(r, 16);
2947     auto u2 = parse!(uint, typeof(r2), Yes.doCount)(r2, 16);
2957         assertThrown!ConvOverflowException(s.parse!ubyte(16));
2964     assert(parse!uint(str) == 0);
2967     assert(parse!(uint, string, Yes.doCount)(str) == tuple(0, 1));
2976     assertThrown(str.parse!uint(16));
2977     assertThrown(str.parse!(uint, string, Yes.doCount)(16));
2997 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
3042     assert(parse!EnumType(str) == EnumType.a);
3044     assert(parse!(EnumType, string, No.doCount)(str2) == EnumType.a);
3046     assert(parse!(EnumType, string, Yes.doCount)(str3) == tuple(EnumType.a, 1));
3083     assert(parse!A(s) == A.member111 && s == "1");
3085     assert(parse!(A, string, No.doCount)(s2) == A.member111 && s2 == "1");
3087     assert(parse!(A, string, Yes.doCount)(s3) == tuple(A.member111, 9) && s3 == "1");
3108 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source source)
3444     assert(parse!double(str).isClose(123.456));
3446     assert(parse!(double, string, No.doCount)(str2).isClose(123.456));
3448     auto r = parse!(double, string, Yes.doCount)(str3);
3452     r = parse!(double, string, Yes.doCount)(str4);
3456     r = parse!(double, string, Yes.doCount)(str5);
3460     r = parse!(double, string, Yes.doCount)(str6);
3463     auto r2 = parse!(float, string, Yes.doCount)(str7);
3466     auto r3 = parse!(real, string, Yes.doCount)(str8);
3567     assert(feq(parse!real(fullPrecision), pi, 2*real.epsilon));
3569     assert(feq(parse!(real, string, No.doCount)(fullPrecision2), pi, 2*real.epsilon));
3572     auto res = parse!(real, string, Yes.doCount)(fullPrecision3);
3578     assert(parse!real(full) == x);
3580     assert(parse!(real, string, No.doCount)(full2) == x);
3583     assert(parse!(real, string, Yes.doCount)(full3) == tuple(x, len2));
3598         auto x = parse!real(s);
3606         assert(parse!(real, string, Yes.doCount)(s) == tuple(x, len));
3610         x = parse!real(s);
3618         x = parse!real(s);
3626         x = parse!real(s);
3634         x = parse!real(s);
3642         x = parse!real(s);
3650         x = parse!real(s);
3655         assertThrown!ConvException(x = parse!real(s));
3660         x = parse!real(s);
3666         assert(parse!(real, string, Yes.doCount)(s) == tuple(x, len));
3714     ld = parse!real(s2);
3736     ld = parse!real(s2);
3750         auto x = parse!double(s);
3756         auto x = parse!(double, string, Yes.doCount)(s);
3783         parse!double(s);
3785         assertThrown!ConvException(parse!double(s));
3804 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
3826         // Special case: okay so parse a Char off a Char[]
3850                 assert(parse!Char(s) == 'a');
3852                 assert(parse!(Char, typeof(s), No.doCount)(s) == 'a');
3854                 assert(parse!(Char, typeof(s), Yes.doCount)(s) == tuple('a', 1) && s == "");
3861 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
3884     char first = parse!char(s);
3887     char second = parse!(char, string, No.doCount)(s);
3890     auto third = parse!(char, string, Yes.doCount)(s);
3897     Tests for to!bool and parse!bool
3908     assert(parse!bool(t) == true);
3912     assert(parse!bool(f) == false);
3916     assert(parse!(bool, dstring, Yes.doCount)(f) == tuple(false, 5));
3920     assertThrown!ConvException(parse!bool(m));
3921     assertThrown!ConvException(parse!(bool, string, Yes.doCount)(m));
3925     auto b = parse!(const(bool))(s);
3946 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
3976     assert(parse!NullType(s1) is null);
3980     assert(parse!NullType(s2) is null);
3984     assert(parse!(NullType, string, No.doCount)(s3) is null);
3985     auto r = parse!(NullType, string, Yes.doCount)(s3);
3989     assertThrown!ConvException(parse!NullType(m));
3990     assertThrown!ConvException(parse!(NullType, string, Yes.doCount)(m));
3994     assert(parse!(const NullType)(s) is null);
3997 //Used internally by parse Array/AA, to remove ascii whites
4048  *     s = The string to parse
4059 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s, dchar lbracket = '[',
4112     auto a1 = parse!(string[])(s1);
4116     auto a2 = parse!(string[])(s2);
4121     auto a3 = parse!(string[], string, Yes.doCount)(s3);
4133     assert(s0.parse!(int[]) == [1,2]);
4134     assert(s1.parse!(int[]) == [1,2]);
4135     assert(s2.parse!(int[]) == [1,2]);
4143     assert(s0.parse!(int[], string, Yes.doCount) == tuple([1,2], len0));
4144     assert(s1.parse!(int[], string, Yes.doCount) == tuple([1,2], len1));
4145     assert(s2.parse!(int[], string, Yes.doCount) == tuple([1,2], len2));
4149     assert(s3.parse!(string[]) == ["a","b"]);
4150     assert(s4.parse!(string[]) == ["a","b"]);
4154     assert(s3.parse!(string[], string, Yes.doCount) == tuple(["a","b"], len3));
4157     assert(tuple([], s3.length) == s3.parse!(string[], string, Yes.doCount));
4162     assertThrown!ConvException(parse!(string[])(s5));
4163     assertThrown!ConvException(parse!(int[])(s6));
4167     assertThrown!ConvException(parse!(string[], string, Yes.doCount)(s5));
4168     assertThrown!ConvException(parse!(string[], string, Yes.doCount)(s6));
4207         assertThrown!ConvException(parse!(int[])(ss));
4208         assertThrown!ConvException(parse!(int[], string, Yes.doCount)(ss));
4210     int[] arr = parse!(int[])(s);
4211     auto arr2 = parse!(int[], string, Yes.doCount)(s2);
4240     assert(s2 == parse!(string[])(s1));
4242     assert(tuple(s2, s3.length) == parse!(string[], string, Yes.doCount)(s3));
4246 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s, dchar lbracket = '[',
4316     auto sa1 = parse!(int[4])(s1);
4319     assert(tuple([1,2,3,4], s1.length) == parse!(int[4], string, Yes.doCount)(s1));
4322     auto sa2 = parse!(int[][3])(s2);
4325     assert(tuple([[1],[2,3],[4]], s2.length) == parse!(int[][3], string, Yes.doCount)(s2));
4328     assertThrown!ConvException(parse!(int[4])(s3));
4329     assertThrown!ConvException(parse!(int[4], string, Yes.doCount)(s3));
4332     assertThrown!ConvException(parse!(int[4])(s4));
4333     assertThrown!ConvException(parse!(int[4], string, Yes.doCount)(s4));
4342  *     s = the string to parse
4355 auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s, dchar lbracket = '[',
4414     auto aa1 = parse!(int[int])(s1);
4416     assert(tuple([1:10, 2:20, 3:30], copyS1.length) == parse!(int[int], string, Yes.doCount)(copyS1));
4420     auto aa2 = parse!(int[string])(s2);
4423         parse!(int[string], string, Yes.doCount)(copyS2));
4427     auto aa3 = parse!(int[][string])(s3);
4430         parse!(int[][string], string, Yes.doCount)(copyS3));
4434     assert(tuple(emptyAA, s4.length) == parse!(int[int], string, Yes.doCount)(s4));
4447         assertThrown!ConvException(parse!(int[int])(ss));
4448         assertThrown!ConvException(parse!(int[int], string, Yes.doCount)(ss));
4450     int[int] aa = parse!(int[int])(s);
4451     auto aa2 = parse!(int[int], string, Yes.doCount)(s2);
4658     // parse array of chars
4663         return parse!(Target, Source, doCount)(s);
4749     return parse!(Target, Source, doCount)(s);
4863     $(LREF parse) for parsing octal strings at runtime.