general_client_capabilities.pony

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
use json = "../../../../json"

use ".."

interface val GeneralClientCapabilities
  fun val staleRequestSupport(): (StaleRequestSupport | None)
  fun val regularExpressions(): (RegularExpressionsClientCapabilities | None)
  fun val markdown(): (MarkdownClientCapabilities | None)
  fun val positionEncodings(): (Array[PositionEncodingKind] val | None)

primitive ParseGeneralClientCapabilities
  fun apply(obj: json.Object val): (GeneralClientCapabilities | String) =>
    let staleRequestSupport' =
      try
        match obj("staleRequestSupport")?
        | let srs_obj: json.Object val =>
          match ParseStaleRequestSupport(srs_obj)
          | let srs: StaleRequestSupport =>
            srs
          | let err: String =>
            return err
          end
        else
          return "staleRequestSupport must be a JSON object"
        end
      end
    let regularExpressions' =
      try
        match obj("regularExpressions")?
        | let re_obj: json.Object val =>
          match ParseRegularExpressionsClientCapabilities(re_obj)
          | let re: RegularExpressionsClientCapabilities =>
            re
          | let err: String =>
            return err
          end
        else
          return "regularExpressions must be a JSON object"
        end
      end
    let markdown' =
      try
        match obj("markdown")?
        | let md_obj: json.Object val =>
          match ParseMarkdownClientCapabilities(md_obj)
          | let md: MarkdownClientCapabilities =>
            md
          | let err: String =>
            return err
          end
        else
          return "markdown must be a JSON object"
        end
      end
    let positionEncodings': (Array[PositionEncodingKind] val | None) =
      try
        match obj("positionEncodings")?
        | let pe_seq: json.Sequence val =>
          let encs: Array[PositionEncodingKind] trn =
            Array[PositionEncodingKind]
          for item in pe_seq.values() do
            match ParsePositionEncodingKind(item)
            | let pek: PositionEncodingKind =>
              encs.push(pek)
            | let err: String =>
              return err
            end
          end
          consume encs
        else
          return "positionEncodings must be a JSON object"
        end
      end
    object val is GeneralClientCapabilities
      fun val staleRequestSupport(): (StaleRequestSupport | None) =>
        staleRequestSupport'
      fun val regularExpressions():
        (RegularExpressionsClientCapabilities | None)
      =>
        regularExpressions'
      fun val markdown(): (MarkdownClientCapabilities | None) => markdown'
      fun val positionEncodings(): (Array[PositionEncodingKind] val | None) =>
        positionEncodings'
    end

interface val StaleRequestSupport
  fun val cancel(): Bool
  fun val retryOnContentModified(): Array[String] val

primitive ParseStaleRequestSupport
  fun apply(obj: json.Object val): (StaleRequestSupport | String) =>
    let cancel' =
      try
        match obj("cancel")?
        | let b: Bool =>
          b
        else
          return "staleRequestSupport.cancel must be of type boolean"
        end
      else
        return "staleRequestSupport must contain 'cancel'"
      end
    let retryOnContentModified': Array[String] val =
      try
        match obj("retryOnContentModified")?
        | let r_seq: json.Sequence val =>
          let reqs: Array[String] trn = Array[String]
          for r_item in r_seq.values() do
            match r_item
            | let s: String box =>
              reqs.push(s.clone())
            else
              return "retryOnContentModified must be an array of strings"
            end
          end
          consume reqs
        else
          return "staleRequestSupport.retryOnContentModified must be an array"
        end
      else
        return "staleRequestSupport must contain 'retryOnContentModified'"
      end
    object val is StaleRequestSupport
      fun val cancel(): Bool => cancel'
      fun val retryOnContentModified(): Array[String] val =>
        retryOnContentModified'
    end