View source for InvalidJsonType class

<!-- InvalidJsonType class -->
[[Json class|Json]] objects simulate JavaScript untyped variables. However, many Json functions only make sense for specific underlying Json data. For example, the [[Add (Json function)|Add function]] only makes sense if the underlying json object is an Array. If a function applied to a Json object is invalid for the underlying object, an <var>InvalidJsonType</var> exception is thrown.
 
To create an <var>InvalidjsonType</var> exception yourself, you typically use a SOUL <var>[[Exceptions#Using the Throw statement|Throw]]</var> statement with an <var>InvalidJsonType</var> <var>[[New_(InvalidJsonType_constructor)|New]]</var> constructor.  This statement must be issued from within a method, and it can only be caught by the code that calls the method.  For example, the following statement throws an <var>InvalidJsonType</var> exception:
<p class="code">throw %(invalidJsonType):new(type=array, method="MyJsonMethod")
</p>
 
Remember that you catch an exception with the <var>[[Exceptions#Try and Catch|Catch]]</var> statement; if an exception condition occurs outside a <var>Catch</var> for it, the request is cancelled.
 
The <var>InvalidJsonType</var> class, like the Json class, is available as of <var class="product">Model 204</var> 7.6.
 
==The InvalidJsonTypes methods==
{{Template:List of InvalidJsonType methods}}
 
The methods in the class are described in the subsections that follow. In addition:
<ul>
<li>[[Notation conventions for methods|"Notation conventions for methods"]] has information
about the conventions followed.
<li>[[InvalidJsonType methods syntax|"InvalidJsonType methods syntax"]] is a single page that contains the syntax diagrams of all the methods in the class.
</ul>
==MethodName property==
{{Template:InvalidJsonType:MethodName subtitle}}
 
This <var>[[Classes and Objects#readWrite|ReadOnly]]</var> property returns a string that indicates the name of the failing method.
 
===Syntax===
{{Template:InvalidJsonType:MethodName syntax}}

====Syntax terms====
<table class="syntaxTable">
<tr><th>%string</th>
<td>The name of the failing method.</td></tr>

<tr><th>invalidJsonType</th>
<td>A reference to an instance of an <var>[[InvalidJsonType_class|InvalidJsonType]]</var> object.</td></tr>
</table>

==Type property==
{{Template:InvalidJsonType:Type subtitle}}
 
This <var>[[Classes and Objects#readWrite|ReadOnly]]</var> property returns a [[JsonType enumeration]] value that indicates the underlying Json object type for the object against which the failing method was applied.
 
===Syntax===
{{Template:InvalidJsonType:Type syntax}}

====Syntax terms====
<table class="syntaxTable">
<tr><th>%jsonType</th>
<td>The underlying Json object type for the object against which the failing method was applied.</td></tr>

<tr><th>invalidJsonType</th>
<td>A reference to an instance of an <var>[[InvalidJsonType_class|InvalidJsonType]]</var> object.</td></tr>
</table>

==New constructor==
{{Template:InvalidJsonType:New subtitle}}
 
This <var>Constructor</var> generates an instance of an <var>[[InvalidJsonType_class|InvalidJsonType]]</var> exception. The <var>New</var> method format follows:
===Syntax===
{{Template:InvalidJsonType:New syntax}}
 
====Syntax terms====
<table class="syntaxTable">
<tr><th>%invalidJsonType</th><td>A reference to an instance of an <var>InvalidJsonType</var> object.</td></tr>
<tr><th><var>[%(InvalidJsonType):]</var></th><td>The class name in parentheses denotes a <var>[[Notation conventions for methods#Constructors|Constructor]]</var>.</td></tr>
<tr><th>jsonType</th><td>A [[JsonType enumeration]] value that indicates the underlying JSON type of the object to which the invalid method was applied.</td></tr>
<tr><th>string</th><td>The name of the method that encountered the error.</td></tr>
</table>

===Usage notes===
<ul>
<li>Json object tree can be created from data received from an outside data source that was generated via the [[Parse (Json function)|Json Parse]] function. If the external data source is considered 100% in terms of sending JSON data with a known format, the data could be extracted without worries about InvalidJsonType exceptions. However, if there is a concern that the data will not be exactly what is expected, one should either test each object for the expected datatype via the [[Type (Json function)|Type function]] or wrap the data extraction inside a Try/Catch InvalidJsonType. Obviously, the latter requires less effort and is more efficient. For example, if an application expects an order to come in as an array of objects with a product name, code, quantity, and price but the source is not 100% trustworthy, one can do something like:
<p class="code">try
   for %i from 1 to %order:count
      %name    = %order(%i)("name"):stringValue
      %code    = %order(%i)("code"):stringValue
      %quantity = %order(%i)("quantity"):numberValue
      %price   = %order(%i)("price"):numberValue
      ... process the order item
   end for
catch invalidJsonType
   ... deal with the error
end try
</p>
The Try/Catch adds no overhead to the processing but makes it easy to trap a malformed request.
</ul>
[[Category:System exception classes]]