LlJsonValueType

{{LSL Function |inject-2= |func_id=|func_sleep=0.0|func_energy=0.0 |func=llJsonValueType|return_type=string |p1_type=string|p1_name=json|p1_desc=A string serialization of a json object. |p2_type=list|p2_name=specifiers|p2_desc=A path to a value in the json parameter. |func_footnote |func_desc=Gets the JSON type for the value in json at the location specifiers. |Return_text=specifying the type of the value at specifiers in json. |spec=See Json_usage_in_LSL |constants=

Type Flags	Value	Unicode	Integer	URL Encoded	HTML Encoded	Description
JSON_INVALID	﷐	U+FDDO	64976	"%EF%B7%90"		Value returned when inputs are not well formed.
JSON_OBJECT	﷑	U+FDD1	64977	"%EF%B7%91"	
JSON_ARRAY	﷒	U+FDD2	64978	"%EF%B7%92"	
JSON_NUMBER	﷓	U+FDD3	64979	"%EF%B7%93"	
JSON_STRING	﷔	U+FDD4	64980	"%EF%B7%94"	
JSON_NULL	﷕	U+FDD5	64981	"%EF%B7%95"	
JSON_TRUE	﷖	U+FDD6	64982	"%EF%B7%96"	
JSON_FALSE	﷗	U+FDD7	64983	"%EF%B7%97"	
JSON_DELETE	﷘	U+FDD8	64984	"%EF%B7%98"		Used with llJsonSetValue to remove a key-value pair.

|examples= <lsl>

//all these functions are untested functions //see them as buggy PSEUDO-code and consider yourself lucky if there are less than 10 syntax errors, 2 wrong counters and 4 bad pointers/names. //they are more an example and a concept and unlikely fully functional AS IS.

string JisI(string j){if(llJsonValueType(j,[])==JSON_INTEGER)return 1llJsonGetValue(j,[]);return "";} //return the JSON if "j" is a JSON_INTEGER, like j="1" j="-2" j="0" otherwise return ""; //these would be string representations of an integer because j is a string.

string JisF(string j){if(llJsonValueType(j,[])==JSON_FLOAT )return 1llJsonGetValue(j,[]);return "";} //return the JSON if "j" is a JSON_FLOAT, like j="10.1234" j="-0.1234" j="3.14159" otherwise return ""; //these would be sting representations of an float because j is a string. //storing floats in a JSON will easily lose you a lot of accuracy.

string JisA(string j){if(llJsonValueType(j,[])==JSON_ARRAY )return llJsonGetValue(j,[]);return "";} //return the JSON if "j" is a JSON_ARRAY, like j="[]" j="[1,2]" j="[[1],[3,4]]" otherwise return ""; //these would be string representations of a (nested) list because j is a string.

string JisS(string j){if(llJsonValueType(j,[])==JSON_STRING )return llJsonGetValue(j,[]);return "";} //return the string that is stored in "j" if "j" is a JSON_STRING, like j="\"PI\"" j="\"3.14\"" j="\"-1\"" otherwise return ""; //these would be string representations of a string, typecast with \" as that within itself, //because j is a string that is also able to store numbers and floats and (nested) lists ... as strings. //this returns the string within "j" if "j" is "A string within a string".

/*the above functions return strings to be used in simple if(JisA(j)){} if(JisS(j)){} //conditions as if they are booleans. //the boolean-ish condition works because "" equals FALSE within sls. The functions MAY return a JSON_STRING or JSON_ARRAY can be useful recursively as shown below:

• /

JstringPARSED(string j){

   //j="\"PI\"";
   //j="\"3.14\"";
   //j="\"-1\"";
   string JayWeHaveToGoDeeperS = JisS(JisS(j));
   llOwnerSay( JayWeHaveToGoDeeperS ); // says "PI", or "0" , or "0", because "3.14" is a JSON_FLOAT and "-1" is a JSON_INTEGER.
   string JayWeHaveToGoDeeperI = JisI(JisS(j));
   llOwnerSay( JayWeHaveToGoDeeperI ); // says "0", or "0" , or "-1", because "3.14" is a JSON_FLOAT and "PI" is a JSON_STRING.
   string JayWeHaveToGoDeeperF = JisF(JisS(j));
   llOwnerSay( JayWeHaveToGoDeeperI ); // says "0", or "3.14" , or "0", because "3.14" is a JSON_FLOAT and "-1" is a JSON_INTEGER.

   if (llJsonValueType(j,[])==JSON_INVALID){}//would be TRUE for j="";

}

//==== End of JstringPARSED(j) ===== start of Jnested(j) for nested/recursive lists =====

Jnested(string j){ JisA(JisA(string j){

   //j="[]";
   //j="[[1],[2]]";
   //j="[-1,[2]]";
   //j="[[1],-2]";
   //j="-3,-4";  //the only true case HERE for = JisA(JisA(j)); below
   string JayWeHaveToGoDeeperA = JisA(JisA(j));
   llOwnerSay("you stored a whole list nested as only entry of another list, that was dumb:" JayWeHaveToGoDeeperA ); 
   //just in case your json is poorly formatted to store a whole list within another whole list as its only entry..

   string subJ=JisA(j);
   if (subJ){
       //here you actually have to loop trough each entry of the subJ JSON_LIST to test its TYPE for each entry (if we want to go deeper recursively)
       //You can go deeper once you know if entry number x is a JSON_LIST (NESTED!!!) or JSON_STRING (for some reason)
       first see how many list entries there are; we go trough entries of subJ starting on the left until its a JSON_INVALID
       list types; 
       integer i;
       while (++i){
            string type=llJsonValueType(j,[i]);//stores the TYPE of "j"'s entry at position i as "type"
            if (type==JSON_INVALID) i=-1; //this exits this the while-loop
            else i=i+[type]//the list "types" will store all the JSON types, untill the first invalid one is reached. (which which should also be for "out of bounds"
       }

       //this is split in 2 loops to explain 1 task by splitting it in 2 smaller tasks. Actually the loops above and below could be merged easily. 

       integer i=llListLength(types);//we now have a list that lists all JSON types of j; lets see how long it is; 
       //and we loop trough all types, calling THIS function recursively if the list contains another nested list in it at position i
       while (i--){//i like to go reverse from left to right when ever possible, its faster and costs less memory in sls
            if llList2String(types,i)==JSON_ARRAY){
                 nestedlisttest(llJsonGetValue(j,[i]));//the function calls itself here, recursively...
                 //but only sends the i#th SUB.list of itself trough an instance of itself.
           }
           else{
               //read from your list what json type is at this position and do something with it.
               //maybe you need a global counter that increases each time you go "one nested list deeper" and decreases when you go "one nested list back up"
               //otherwise you may not know how deep you are within nested lists.
           }
       }
   }

} //Jnested(j) should be useful to read from large matrices (as in 300x300 fields) that may even contain complex numbers at some places. //i tried to read very long JSONs with llGetSubString(), but llGetSubString() too easily stack-heap collides on very long strings, //so you have to go trough the nested list using Jnested(j) to read and print it per entry.

</lsl>

|caveats= |helpers |also_functions=|-style="vertical-align:top;" | style="color:gray;" |•  | llList2Json | style="color:gray;" | | | |-style="vertical-align:top;" | style="color:gray;" |•  | llJson2List | style="color:gray;" | | | |-style="vertical-align:top;" | style="color:gray;" |•  | llJsonSetValue | style="color:gray;" | | | |-style="vertical-align:top;" | style="color:gray;" |•  | llJsonGetValue | style="color:gray;" | | | |also_events |also_tests |also_articles=|-style="vertical-align:top;" | style="color:gray;" |•  | Typecast | style="color:gray;" | | | |notes= |permission |negative_index |cat1=List |cat2=String |cat3=Data Conversion |cat4=JSON |history = Date of Release 20/05/2013 }}