mirror of
https://github.com/Smaug123/WoofWare.Myriad
synced 2025-10-05 03:58:40 +00:00
1414 lines
55 KiB
Forth
1414 lines
55 KiB
Forth
//------------------------------------------------------------------------------
|
|
// This code was generated by myriad.
|
|
// Changes to this file will be lost when the code is regenerated.
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the InnerTypeWithBoth type
|
|
[<AutoOpen>]
|
|
module InnerTypeWithBothJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type InnerTypeWithBoth with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : InnerTypeWithBoth) : System.Text.Json.Nodes.JsonNode =
|
|
let node = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
do
|
|
node.Add (
|
|
("it's-a-me"),
|
|
(input.Thing
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<Guid> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type GUID to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"map",
|
|
(input.Map
|
|
|> (fun field ->
|
|
let ret = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
for (KeyValue (key, value)) in field do
|
|
let key = key.ToString ()
|
|
|
|
ret.Add (
|
|
key,
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<Uri> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type URI to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
value
|
|
)
|
|
|
|
ret
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"readOnlyDict",
|
|
(input.ReadOnlyDict
|
|
|> (fun field ->
|
|
let ret = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
for (KeyValue (key, value)) in field do
|
|
let key = key.ToString ()
|
|
|
|
ret.Add (
|
|
key,
|
|
(fun field ->
|
|
let arr = System.Text.Json.Nodes.JsonArray ()
|
|
|
|
for mem in field do
|
|
arr.Add (
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<char> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type char to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
mem
|
|
)
|
|
|
|
arr
|
|
)
|
|
value
|
|
)
|
|
|
|
ret
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"dict",
|
|
(input.Dict
|
|
|> (fun field ->
|
|
let ret = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
for (KeyValue (key, value)) in field do
|
|
let key = key.ToString ()
|
|
|
|
ret.Add (
|
|
key,
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<bool> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type bool to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
value
|
|
)
|
|
|
|
ret
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"concreteDict",
|
|
(input.ConcreteDict
|
|
|> (fun field ->
|
|
let ret = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
for (KeyValue (key, value)) in field do
|
|
let key = key.ToString ()
|
|
ret.Add (key, InnerTypeWithBoth.toJsonNode value)
|
|
|
|
ret
|
|
))
|
|
)
|
|
|
|
node :> _
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the SomeEnum type
|
|
[<AutoOpen>]
|
|
module SomeEnumJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type SomeEnum with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : SomeEnum) : System.Text.Json.Nodes.JsonNode =
|
|
match input with
|
|
| SomeEnum.Blah -> System.Text.Json.Nodes.JsonValue.Create 1
|
|
| SomeEnum.Thing -> System.Text.Json.Nodes.JsonValue.Create 0
|
|
| v -> failwith (sprintf "Unrecognised value for enum: %O" v)
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the JsonRecordTypeWithBoth type
|
|
[<AutoOpen>]
|
|
module JsonRecordTypeWithBothJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type JsonRecordTypeWithBoth with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : JsonRecordTypeWithBoth) : System.Text.Json.Nodes.JsonNode =
|
|
let node = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
do
|
|
node.Add (
|
|
"a",
|
|
(input.A
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32 to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"b",
|
|
(input.B
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<string> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type string to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"c",
|
|
(input.C
|
|
|> (fun field ->
|
|
let arr = System.Text.Json.Nodes.JsonArray ()
|
|
|
|
for mem in field do
|
|
arr.Add (
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32 to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
mem
|
|
)
|
|
|
|
arr
|
|
))
|
|
)
|
|
|
|
node.Add ("d", (input.D |> InnerTypeWithBoth.toJsonNode))
|
|
|
|
node.Add (
|
|
"e",
|
|
(input.E
|
|
|> (fun field ->
|
|
let arr = System.Text.Json.Nodes.JsonArray ()
|
|
|
|
for mem in field do
|
|
arr.Add (
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<string> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type string to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
mem
|
|
)
|
|
|
|
arr
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"arr",
|
|
(input.Arr
|
|
|> (fun field ->
|
|
let arr = System.Text.Json.Nodes.JsonArray ()
|
|
|
|
for mem in field do
|
|
arr.Add (
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32 to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
mem
|
|
)
|
|
|
|
arr
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"byte",
|
|
(input.Byte
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<byte<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type byte<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"sbyte",
|
|
(input.Sbyte
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<sbyte<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type signed byte<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"i",
|
|
(input.I
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"i32",
|
|
(input.I32
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int32<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"i64",
|
|
(input.I64
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int64<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int64<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"u",
|
|
(input.U
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<uint<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type uint32<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"u32",
|
|
(input.U32
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<uint32<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type uint32<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"u64",
|
|
(input.U64
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<uint64<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type uint64<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"f",
|
|
(input.F
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<float<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type double<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"f32",
|
|
(input.F32
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<float32<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type single<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"single",
|
|
(input.Single
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<single<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type single<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"intMeasureOption",
|
|
(input.IntMeasureOption
|
|
|> (fun field ->
|
|
match field with
|
|
| None -> None
|
|
| Some field ->
|
|
(field
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
:> System.Text.Json.Nodes.JsonNode
|
|
|> Some
|
|
)
|
|
|> Option.toObj)
|
|
)
|
|
|
|
node.Add (
|
|
"intMeasureNullable",
|
|
(input.IntMeasureNullable
|
|
|> (fun field ->
|
|
if field.HasValue then
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int<measure>> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32<measure> to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
field.Value
|
|
:> System.Text.Json.Nodes.JsonNode
|
|
|> Some
|
|
else
|
|
None
|
|
)
|
|
|> Option.toObj)
|
|
)
|
|
|
|
node.Add ("enum", (input.Enum |> SomeEnum.toJsonNode))
|
|
|
|
node.Add (
|
|
"timestamp",
|
|
(input.Timestamp
|
|
|> (fun field -> field.ToString "o" |> System.Text.Json.Nodes.JsonValue.Create<string>))
|
|
)
|
|
|
|
node.Add ("unit", (input.Unit |> (fun value -> System.Text.Json.Nodes.JsonObject ())))
|
|
|
|
node :> _
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the FirstDu type
|
|
[<AutoOpen>]
|
|
module FirstDuJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type FirstDu with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : FirstDu) : System.Text.Json.Nodes.JsonNode =
|
|
let node = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
match input with
|
|
| FirstDu.EmptyCase -> node.Add ("type", System.Text.Json.Nodes.JsonValue.Create "emptyCase")
|
|
| FirstDu.Case1 arg0 ->
|
|
node.Add ("type", System.Text.Json.Nodes.JsonValue.Create "case1")
|
|
let dataNode = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
dataNode.Add (
|
|
"data",
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<string> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type string to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
arg0
|
|
)
|
|
|
|
node.Add ("data", dataNode)
|
|
| FirstDu.Case2 (arg0, arg1) ->
|
|
node.Add ("type", System.Text.Json.Nodes.JsonValue.Create "case2")
|
|
let dataNode = System.Text.Json.Nodes.JsonObject ()
|
|
dataNode.Add ("record", JsonRecordTypeWithBoth.toJsonNode arg0)
|
|
|
|
dataNode.Add (
|
|
"i",
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32 to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
arg1
|
|
)
|
|
|
|
node.Add ("data", dataNode)
|
|
|
|
node :> _
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the HeaderAndValue type
|
|
[<AutoOpen>]
|
|
module HeaderAndValueJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type HeaderAndValue with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : HeaderAndValue) : System.Text.Json.Nodes.JsonNode =
|
|
let node = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
do
|
|
node.Add (
|
|
"header",
|
|
(input.Header
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<string> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type string to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node.Add (
|
|
"value",
|
|
(input.Value
|
|
|> (fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<string> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type string to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
))
|
|
)
|
|
|
|
node :> _
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the Foo type
|
|
[<AutoOpen>]
|
|
module FooJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type Foo with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : Foo) : System.Text.Json.Nodes.JsonNode =
|
|
let node = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
do
|
|
node.Add (
|
|
"message",
|
|
(input.Message
|
|
|> (fun field ->
|
|
match field with
|
|
| None -> None
|
|
| Some field -> field |> HeaderAndValue.toJsonNode |> Some
|
|
)
|
|
|> Option.toObj)
|
|
)
|
|
|
|
node :> _
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the CollectRemaining type
|
|
[<AutoOpen>]
|
|
module CollectRemainingJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type CollectRemaining with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : CollectRemaining) : System.Text.Json.Nodes.JsonNode =
|
|
let node = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
do
|
|
node.Add (
|
|
"message",
|
|
(input.Message
|
|
|> (fun field ->
|
|
match field with
|
|
| None -> None
|
|
| Some field -> field |> HeaderAndValue.toJsonNode |> Some
|
|
)
|
|
|> Option.toObj)
|
|
)
|
|
|
|
for KeyValue (key, value) in input.Rest do
|
|
node.Add (key, id value)
|
|
|
|
node :> _
|
|
namespace ConsumePlugin
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Text.Json.Serialization
|
|
|
|
/// Module containing JSON serializing extension members for the OuterCollectRemaining type
|
|
[<AutoOpen>]
|
|
module OuterCollectRemainingJsonSerializeExtension =
|
|
/// Extension methods for JSON parsing
|
|
type OuterCollectRemaining with
|
|
|
|
/// Serialize to a JSON node
|
|
static member toJsonNode (input : OuterCollectRemaining) : System.Text.Json.Nodes.JsonNode =
|
|
let node = System.Text.Json.Nodes.JsonObject ()
|
|
|
|
do
|
|
for KeyValue (key, value) in input.Others do
|
|
node.Add (
|
|
key,
|
|
(fun field ->
|
|
let field = System.Text.Json.Nodes.JsonValue.Create<int> field
|
|
|
|
(match field with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected type int32 to be non-null, but received a null value when serialising"
|
|
)
|
|
| field -> field)
|
|
)
|
|
value
|
|
)
|
|
|
|
node.Add ("remaining", (input.Remaining |> CollectRemaining.toJsonNode))
|
|
|
|
node :> _
|
|
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the InnerTypeWithBoth type
|
|
[<AutoOpen>]
|
|
module InnerTypeWithBothJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type InnerTypeWithBoth with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : InnerTypeWithBoth =
|
|
let arg_4 =
|
|
match node.["concreteDict"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("concreteDict")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsObject ()
|
|
|> Seq.map (fun kvp ->
|
|
let key = (kvp.Key)
|
|
let value = kvp.Value
|
|
|
|
key,
|
|
(match value with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected dictionary value of type InnerTypeWithBoth to be non-null, but it was null"
|
|
)
|
|
| value -> InnerTypeWithBoth.jsonParse value)
|
|
)
|
|
|> Seq.map System.Collections.Generic.KeyValuePair
|
|
|> System.Collections.Generic.Dictionary
|
|
|
|
let arg_3 =
|
|
match node.["dict"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("dict")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsObject ()
|
|
|> Seq.map (fun kvp ->
|
|
let key = (kvp.Key) |> System.Uri
|
|
let value = kvp.Value
|
|
|
|
key,
|
|
(match value with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected dictionary value of type bool to be non-null, but it was null"
|
|
)
|
|
| value -> value.AsValue().GetValue<System.Boolean> ())
|
|
)
|
|
|> dict
|
|
|
|
let arg_2 =
|
|
match node.["readOnlyDict"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("readOnlyDict")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsObject ()
|
|
|> Seq.map (fun kvp ->
|
|
let key = (kvp.Key)
|
|
let value = kvp.Value
|
|
|
|
key,
|
|
(match value with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected dictionary value of type char list to be non-null, but it was null"
|
|
)
|
|
| value ->
|
|
value.AsArray ()
|
|
|> Seq.map (fun elt ->
|
|
(match elt with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected element of array (element type char) to be non-null, but found a null element"
|
|
)
|
|
| elt -> elt.AsValue().GetValue<System.Char> ())
|
|
)
|
|
|> List.ofSeq)
|
|
)
|
|
|> readOnlyDict
|
|
|
|
let arg_1 =
|
|
match node.["map"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("map")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsObject ()
|
|
|> Seq.map (fun kvp ->
|
|
let key = (kvp.Key)
|
|
let value = kvp.Value
|
|
|
|
key,
|
|
(match value with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected dictionary value of type URI to be non-null, but it was null"
|
|
)
|
|
| value -> value.AsValue().GetValue<string> () |> System.Uri)
|
|
)
|
|
|> Map.ofSeq
|
|
|
|
let arg_0 =
|
|
match node.[("it's-a-me")] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" (("it's-a-me"))
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<string> () |> System.Guid.Parse
|
|
|
|
{
|
|
Thing = arg_0
|
|
Map = arg_1
|
|
ReadOnlyDict = arg_2
|
|
Dict = arg_3
|
|
ConcreteDict = arg_4
|
|
}
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the SomeEnum type
|
|
[<AutoOpen>]
|
|
module SomeEnumJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type SomeEnum with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : SomeEnum =
|
|
match node.GetValueKind () with
|
|
| System.Text.Json.JsonValueKind.Number -> node.AsValue().GetValue<int> () |> enum<SomeEnum>
|
|
| System.Text.Json.JsonValueKind.String ->
|
|
match node.AsValue().GetValue<string>().ToLowerInvariant () with
|
|
| "blah" -> SomeEnum.Blah
|
|
| "thing" -> SomeEnum.Thing
|
|
| v -> failwith ("Unrecognised value for enum: %i" + v)
|
|
| _ -> failwith ("Unrecognised kind for enum of type: " + "SomeEnum")
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the JsonRecordTypeWithBoth type
|
|
[<AutoOpen>]
|
|
module JsonRecordTypeWithBothJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type JsonRecordTypeWithBoth with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : JsonRecordTypeWithBoth =
|
|
let arg_21 =
|
|
match node.["unit"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("unit")
|
|
)
|
|
)
|
|
| Some node -> ()
|
|
|
|
let arg_20 =
|
|
match node.["timestamp"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("timestamp")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<string> () |> System.DateTimeOffset.Parse
|
|
|
|
let arg_19 =
|
|
match node.["enum"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("enum")
|
|
)
|
|
)
|
|
| Some node -> SomeEnum.jsonParse node
|
|
|
|
let arg_18 =
|
|
match node.["intMeasureNullable"] |> Option.ofObj with
|
|
| None -> System.Nullable ()
|
|
| Some v ->
|
|
v.AsValue().GetValue<System.Int32> ()
|
|
|> LanguagePrimitives.Int32WithMeasure
|
|
|> System.Nullable
|
|
|
|
let arg_17 =
|
|
match node.["intMeasureOption"] |> Option.ofObj with
|
|
| None -> None
|
|
| Some v ->
|
|
v.AsValue().GetValue<System.Int32> ()
|
|
|> LanguagePrimitives.Int32WithMeasure
|
|
|> Some
|
|
|
|
let arg_16 =
|
|
match node.["single"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("single")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsValue().GetValue<System.Single> ()
|
|
|> LanguagePrimitives.Float32WithMeasure
|
|
|
|
let arg_15 =
|
|
match node.["f32"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("f32")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsValue().GetValue<System.Single> ()
|
|
|> LanguagePrimitives.Float32WithMeasure
|
|
|
|
let arg_14 =
|
|
match node.["f"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("f")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Double> () |> LanguagePrimitives.FloatWithMeasure
|
|
|
|
let arg_13 =
|
|
match node.["u64"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("u64")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsValue().GetValue<System.UInt64> ()
|
|
|> LanguagePrimitives.UInt64WithMeasure
|
|
|
|
let arg_12 =
|
|
match node.["u32"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("u32")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsValue().GetValue<System.UInt32> ()
|
|
|> LanguagePrimitives.UInt32WithMeasure
|
|
|
|
let arg_11 =
|
|
match node.["u"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("u")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsValue().GetValue<System.UInt32> ()
|
|
|> LanguagePrimitives.UInt32WithMeasure
|
|
|
|
let arg_10 =
|
|
match node.["i64"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("i64")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Int64> () |> LanguagePrimitives.Int64WithMeasure
|
|
|
|
let arg_9 =
|
|
match node.["i32"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("i32")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Int32> () |> LanguagePrimitives.Int32WithMeasure
|
|
|
|
let arg_8 =
|
|
match node.["i"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("i")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Int32> () |> LanguagePrimitives.Int32WithMeasure
|
|
|
|
let arg_7 =
|
|
match node.["sbyte"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("sbyte")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.SByte> () |> LanguagePrimitives.SByteWithMeasure
|
|
|
|
let arg_6 =
|
|
match node.["byte"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("byte")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Byte> () |> LanguagePrimitives.ByteWithMeasure
|
|
|
|
let arg_5 =
|
|
match node.["arr"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("arr")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsArray ()
|
|
|> Seq.map (fun elt ->
|
|
(match elt with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected element of array (element type int32) to be non-null, but found a null element"
|
|
)
|
|
| elt -> elt.AsValue().GetValue<System.Int32> ())
|
|
)
|
|
|> Array.ofSeq
|
|
|
|
let arg_4 =
|
|
match node.["e"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("e")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsArray ()
|
|
|> Seq.map (fun elt ->
|
|
(match elt with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected element of array (element type string) to be non-null, but found a null element"
|
|
)
|
|
| elt -> elt.AsValue().GetValue<System.String> ())
|
|
)
|
|
|> Array.ofSeq
|
|
|
|
let arg_3 =
|
|
match node.["d"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("d")
|
|
)
|
|
)
|
|
| Some node -> InnerTypeWithBoth.jsonParse node
|
|
|
|
let arg_2 =
|
|
match node.["c"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("c")
|
|
)
|
|
)
|
|
| Some node ->
|
|
node.AsArray ()
|
|
|> Seq.map (fun elt ->
|
|
(match elt with
|
|
| null ->
|
|
raise (
|
|
System.ArgumentNullException
|
|
"Expected element of array (element type int32) to be non-null, but found a null element"
|
|
)
|
|
| elt -> elt.AsValue().GetValue<System.Int32> ())
|
|
)
|
|
|> List.ofSeq
|
|
|
|
let arg_1 =
|
|
match node.["b"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("b")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.String> ()
|
|
|
|
let arg_0 =
|
|
match node.["a"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("a")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Int32> ()
|
|
|
|
{
|
|
A = arg_0
|
|
B = arg_1
|
|
C = arg_2
|
|
D = arg_3
|
|
E = arg_4
|
|
Arr = arg_5
|
|
Byte = arg_6
|
|
Sbyte = arg_7
|
|
I = arg_8
|
|
I32 = arg_9
|
|
I64 = arg_10
|
|
U = arg_11
|
|
U32 = arg_12
|
|
U64 = arg_13
|
|
F = arg_14
|
|
F32 = arg_15
|
|
Single = arg_16
|
|
IntMeasureOption = arg_17
|
|
IntMeasureNullable = arg_18
|
|
Enum = arg_19
|
|
Timestamp = arg_20
|
|
Unit = arg_21
|
|
}
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the FirstDu type
|
|
[<AutoOpen>]
|
|
module FirstDuJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type FirstDu with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : FirstDu =
|
|
let ty =
|
|
(match node.["type"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("type")
|
|
)
|
|
)
|
|
| Some v -> v)
|
|
|> (fun v -> v.GetValue<string> ())
|
|
|
|
match ty with
|
|
| "emptyCase" -> FirstDu.EmptyCase
|
|
| "case1" ->
|
|
let node =
|
|
(match node.["data"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("data")
|
|
)
|
|
)
|
|
| Some v -> v)
|
|
|
|
FirstDu.Case1 (
|
|
match node.["data"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("data")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.String> ()
|
|
)
|
|
| "case2" ->
|
|
let node =
|
|
(match node.["data"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("data")
|
|
)
|
|
)
|
|
| Some v -> v)
|
|
|
|
FirstDu.Case2 (
|
|
match node.["record"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("record")
|
|
)
|
|
)
|
|
| Some node -> JsonRecordTypeWithBoth.jsonParse node
|
|
, match node.["i"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("i")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Int32> ()
|
|
)
|
|
| v -> failwith ("Unrecognised 'type' field value: " + v)
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the HeaderAndValue type
|
|
[<AutoOpen>]
|
|
module HeaderAndValueJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type HeaderAndValue with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : HeaderAndValue =
|
|
let arg_1 =
|
|
match node.["value"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("value")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.String> ()
|
|
|
|
let arg_0 =
|
|
match node.["header"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("header")
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.String> ()
|
|
|
|
{
|
|
Header = arg_0
|
|
Value = arg_1
|
|
}
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the Foo type
|
|
[<AutoOpen>]
|
|
module FooJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type Foo with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : Foo =
|
|
let arg_0 =
|
|
match node.["message"] |> Option.ofObj with
|
|
| None -> None
|
|
| Some v -> HeaderAndValue.jsonParse v |> Some
|
|
|
|
{
|
|
Message = arg_0
|
|
}
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the CollectRemaining type
|
|
[<AutoOpen>]
|
|
module CollectRemainingJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type CollectRemaining with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : CollectRemaining =
|
|
let arg_1 =
|
|
let result =
|
|
System.Collections.Generic.Dictionary<string, System.Text.Json.Nodes.JsonNode> ()
|
|
|
|
let node = node.AsObject ()
|
|
|
|
for KeyValue (key, value) in node do
|
|
if key = "message" then
|
|
()
|
|
else
|
|
result.Add (
|
|
key,
|
|
match node.[key] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" (key)
|
|
)
|
|
)
|
|
| Some node -> node
|
|
)
|
|
|
|
result
|
|
|
|
let arg_0 =
|
|
match node.["message"] |> Option.ofObj with
|
|
| None -> None
|
|
| Some v -> HeaderAndValue.jsonParse v |> Some
|
|
|
|
{
|
|
Message = arg_0
|
|
Rest = arg_1
|
|
}
|
|
namespace ConsumePlugin
|
|
|
|
/// Module containing JSON parsing extension members for the OuterCollectRemaining type
|
|
[<AutoOpen>]
|
|
module OuterCollectRemainingJsonParseExtension =
|
|
/// Extension methods for JSON parsing
|
|
type OuterCollectRemaining with
|
|
|
|
/// Parse from a JSON node.
|
|
static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : OuterCollectRemaining =
|
|
let arg_1 =
|
|
match node.["remaining"] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" ("remaining")
|
|
)
|
|
)
|
|
| Some node -> CollectRemaining.jsonParse node
|
|
|
|
let arg_0 =
|
|
let result = System.Collections.Generic.Dictionary<string, int> ()
|
|
let node = node.AsObject ()
|
|
|
|
for KeyValue (key, value) in node do
|
|
if key = "remaining" then
|
|
()
|
|
else
|
|
result.Add (
|
|
key,
|
|
match node.[key] |> Option.ofObj with
|
|
| None ->
|
|
raise (
|
|
System.Collections.Generic.KeyNotFoundException (
|
|
sprintf "Required key '%s' not found on JSON object" (key)
|
|
)
|
|
)
|
|
| Some node -> node.AsValue().GetValue<System.Int32> ()
|
|
)
|
|
|
|
result
|
|
|
|
{
|
|
Others = arg_0
|
|
Remaining = arg_1
|
|
}
|