StrIterFromStr

Documentation

API Reference

StrIterFromStr

Description

Create string iterator from Str object

Parameters

Name	Direction	Description
`s`	in	`Str` object to iterate

Usage example (Cross-references)

Usage examples (Cross-references)

In MisraDoc.c:115:

                    LOG_FATAL("Failed to read config file.");
                }
                StrIter json = StrIterFromStr(config);
                JR_PROJECT(json, project);
            });

In MisraEnum.c:54:

        EnumEntries entries = VecInit();
    
        StrIter json        = StrIterFromStr(code);
        Str     enum_name   = StrInit();
        bool    to_from_str = false;

In Parse.c:13:

                 "debug = true\n"
        );
        StrIter input  = StrIterFromStr(src);
        StrIter si     = KvConfigParse(input, &cfg);
        Str    *host   = KvConfigGetPtr(&cfg, "host");

In Parse.c:43:

                 "empty =\n"
        );
        StrIter input  = StrIterFromStr(src);
        StrIter si     = KvConfigParse(input, &cfg);
        Str    *path   = KvConfigGetPtr(&cfg, "path");

In Parse.c:66:

        KvConfig cfg         = KvConfigInit();
        Str      src         = StrInitFromZstr("host = localhost\n");
        StrIter  input       = StrIterFromStr(src);
        Str      host_copy   = StrInit();
        Str     *stored_host = NULL;

In Parse.c:108:

        bool    disabled = true;
        bool    result   = true;
        StrIter input    = StrIterFromStr(src);
    
        (void)KvConfigParse(input, &cfg);

In Parse.c:132:

                 "later = no\n"
        );
        StrIter input   = StrIterFromStr(src);
        StrIter si      = KvConfigParse(input, &cfg);
        bool    enabled = false;

In Read.Simple.c:63:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"name\": \"Alice\", \"city\": \"New York\"}");
        StrIter si      = StrIterFromStr(json);
    
        Str name = StrInit();

In Read.Simple.c:103:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"count\": 42, \"score\": 95.5, \"year\": 2024}");
        StrIter si      = StrIterFromStr(json);
    
        u32 count = 0;

In Read.Simple.c:140:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"enabled\": true, \"visible\": false}");
        StrIter si      = StrIterFromStr(json);
    
        bool enabled = false;

In Read.Simple.c:171:

        Str  json =
            StrInitFromZstr("{\"id\": 1001, \"name\": \"Bob\", \"age\": 25, \"is_active\": true, \"salary\": 50000.0}");
        StrIter si = StrIterFromStr(json);
    
        Person person = {0};

In Read.Simple.c:224:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"debug_mode\": false, \"timeout\": 30, \"log_level\": \"INFO\"}");
        StrIter si      = StrIterFromStr(json);
    
        Config config    = {0};

In Read.Simple.c:265:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"languages\": [\"C\", \"Python\", \"Rust\"]}");
        StrIter si      = StrIterFromStr(json);
    
        Vec(Str) languages = VecInitWithDeepCopy(NULL, StrDeinit);

In Read.Simple.c:327:

        Str  json =
            StrInitFromZstr("{\"user\": {\"name\": \"Charlie\", \"email\": \"charlie@example.com\"}, \"active\": true}");
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.Simple.c:386:

                "\"portable\"]}"
        );
        StrIter si = StrIterFromStr(json);
    
        SimpleProduct product = {0};

In Read.Nested.c:109:

    
        Str     json = StrInitFromZstr("{\"test\": \"value\"}");
        StrIter si   = StrIterFromStr(json);
    
        bool success = true;

In Read.Nested.c:133:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 12345, \"name\": \"test\", \"active\": true, \"score\": 98.5}");
        StrIter si      = StrIterFromStr(json);
    
        struct {

In Read.Nested.c:186:

            "{\"user\": {\"id\": 123, \"profile\": {\"name\": \"Alice\", \"age\": 30}}, \"status\": \"active\"}"
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.Nested.c:256:

                "\"name\": \"TechCorp\"}}"
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.Nested.c:335:

                "{\"distance\": 0.92, \"name\": \"helper\"}}}}"
        );
        StrIter si = StrIterFromStr(json);
    
        typedef Vec(AnnSymbol) Symbols;

In Read.Nested.c:436:

                "\"nearest_neighbor_function_name_mangled\": \"_Z4main\"}}}}"
        );
        StrIter si = StrIterFromStr(json);
    
        ApiResponse response = {false, StrInit(), VecInitWithDeepCopy(NULL, AnnSymbolDeinit)};

In Read.Nested.c:578:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 12345, \"name\": \"test_func\", \"size\": 1024, \"vaddr\": 4096}");
        StrIter si      = StrIterFromStr(json);
    
        FunctionInfo info = {0};

In Read.Nested.c:625:

        bool    success = true;
        Str     json    = StrInitFromZstr("{\"id\": 54321, \"name\": \"test_model\"}");
        StrIter si      = StrIterFromStr(json);
    
        ModelInfo info = {0};

In Read.Nested.c:663:

                "\"created_at\": \"2024-04-01\", \"model_id\": 12345, \"model_name\": \"test_model\", \"owned_by\": \"user1\"}"
        );
        StrIter si = StrIterFromStr(json);
    
        SearchResult result = {0};

In Read.Nested.c:752:

                "\"nearest_neighbor_function_name_mangled\": \"_Z4main\"}}}}"
        );
        StrIter si = StrIterFromStr(json);
    
        ApiResponse response = {false, StrInit(), VecInitWithDeepCopy(NULL, AnnSymbolDeinit)};

In Read.Nested.c:921:

                "\"nearest_neighbor_function_name_mangled\": \"_Z4main\"}}}}"
        );
        StrIter si = StrIterFromStr(json);
    
        ApiResponse response = {false, StrInit(), VecInitWithDeepCopy(NULL, AnnSymbolDeinit)};

In RoundTrip.c:117:

        } parsed = {0, 0.0, false, StrInit()};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_INT_KV(si, "count", parsed.count);

In RoundTrip.c:193:

        } parsed = {0};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_INT_KV(si, "big_int", parsed.big_int);

In RoundTrip.c:257:

        } parsed = {false, true, false, true}; // Initialize with opposite values
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_BOOL_KV(si, "flag1", parsed.flag1);

In RoundTrip.c:314:

        } parsed = {StrInit(), StrInit(), StrInit(), StrInit()};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_STR_KV(si, "empty", parsed.empty);

In RoundTrip.c:383:

        Vec(Str) parsed_strings = VecInitWithDeepCopy(NULL, StrDeinit);
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_ARR_KV(si, "numbers", {

In RoundTrip.c:472:

        TestPerson parsed_person = {0, StrInit(), 0, false, 0.0};
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_OBJ_KV(si, "user", {

In RoundTrip.c:568:

        parsed.flags             = VecInitT(parsed.flags);
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_OBJ_KV(si, "user", {

In RoundTrip.c:673:

        bool found_empty_object = false;
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_STR_KV(si, "empty_string", parsed_str);

In RoundTrip.c:753:

        } parsed = {0, 0, 999, 999.0, false, true}; // Initialize with different values
    
        StrIter si = StrIterFromStr(json);
        JR_OBJ(si, {
            JR_INT_KV(si, "max_int", parsed.max_int);

In Read.EdgeCases.c:51:

        // Test completely empty object
        Str     json1 = StrInitFromZstr("{}");
        StrIter si1   = StrIterFromStr(json1);
    
        struct {

In Read.EdgeCases.c:71:

        // Test empty object with whitespace
        Str     json2 = StrInitFromZstr("  {   }  ");
        StrIter si2   = StrIterFromStr(json2);
    
        struct {

In Read.EdgeCases.c:100:

        // Test completely empty array
        Str     json1 = StrInitFromZstr("{\"items\":[]}");
        StrIter si1   = StrIterFromStr(json1);
    
        Vec(i32) items = VecInit();

In Read.EdgeCases.c:121:

        // Test empty array with whitespace
        Str     json2 = StrInitFromZstr("{\"data\": [  ] }");
        StrIter si2   = StrIterFromStr(json2);
    
        Vec(Str) data = VecInitWithDeepCopy(NULL, StrDeinit);

In Read.EdgeCases.c:154:

    
        Str     json = StrInitFromZstr("{\"name\":\"\",\"description\":\"\"}");
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:190:

    
        Str     json = StrInitFromZstr("{\"temp\":-25,\"balance\":-1000.50,\"delta\":-0.001}");
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:235:

            "308}"
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:275:

    
        Str     json = StrInitFromZstr("{\"int_zero\":0,\"float_zero\":0.0,\"bool_false\":false}");
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:321:

            "\\\"World\\\"!\",\"data\":\"line1\\nline2\\ttab\"}"
        );
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:362:

        Str json =
            StrInitFromZstr("{\"escaped\":\"\\\"quotes\\\"\",\"backslash\":\"\\\\\",\"newline\":\"\\n\",\"tab\":\"\\t\"}");
        StrIter si = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:407:

        // Test with lots of different whitespace patterns
        Str     json = StrInitFromZstr("  {\n\t\"name\"  :  \"test\"  ,\n  \"value\": 42\t,\"flag\"\n:\ntrue\n}\t");
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:450:

    
        Str     json = StrInitFromZstr("{\"outer\":{},\"list\":[],\"deep\":{\"inner\":{}}}");
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:496:

    
        Str     json = StrInitFromZstr("{\"empty_obj\":{},\"filled_obj\":{\"x\":1},\"empty_arr\":[],\"filled_arr\":[1,2]}");
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:558:

        // Using smaller values that are safer to work with
        Str     json = StrInitFromZstr("{\"max_int\":2147483647,\"min_int\":-2147483648,\"one\":1,\"minus_one\":-1}");
        StrIter si   = StrIterFromStr(json);
    
        struct {

In Read.EdgeCases.c:604:

    
        Str json   = StrInitFromZstr("{\"tiny\":0.000001,\"huge\":999999.999999,\"zero\":0.0,\"negative_tiny\":-0.000001}");
        StrIter si = StrIterFromStr(json);
    
        struct {

Last updated on April 20, 2026

StrIterFromCstr StrIterFromZstr