jetstream 16.0.0

Jetstream is a RPC framework for Rust, based on the 9P protocol and QUIC.
Documentation 
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

// JetStream WireFormat — Composite Type Helpers
// Copyright (c) 2024, Sevki <s@sevki.io>
// SPDX-License-Identifier: BSD-3-Clause

import Foundation

// r[impl jetstream.wireformat.struct]
// r[impl jetstream.wireformat.swift.struct]
// Structs conforming to WireFormat should encode/decode fields sequentially
// in declaration order. No length prefix or field names on the wire.
//
// Example:
//   struct MyStruct: WireFormat {
//       var x: UInt32
//       var y: String
//
//       func byteSize() -> UInt32 {
//           x.byteSize() + y.byteSize()
//       }
//       func encode(writer: inout BinaryWriter) throws {
//           try x.encode(writer: &writer)
//           try y.encode(writer: &writer)
//       }
//       static func decode(reader: inout BinaryReader) throws -> MyStruct {
//           let x = try UInt32.decode(reader: &reader)
//           let y = try String.decode(reader: &reader)
//           return MyStruct(x: x, y: y)
//       }
//   }

// r[impl jetstream.wireformat.enum]
// r[impl jetstream.wireformat.swift.enum]
// Enums conforming to WireFormat should use a u8 variant index (0-based)
// followed by the variant's fields encoded sequentially.
//
// Example:
//   enum MyEnum: WireFormat {
//       case a             // variant 0
//       case b(UInt32)     // variant 1
//       case c(String)     // variant 2
//
//       func byteSize() -> UInt32 {
//           switch self {
//           case .a: return 1
//           case .b(let v): return 1 + v.byteSize()
//           case .c(let s): return 1 + s.byteSize()
//           }
//       }
//       func encode(writer: inout BinaryWriter) throws {
//           switch self {
//           case .a:
//               writer.writeU8(0)
//           case .b(let v):
//               writer.writeU8(1)
//               try v.encode(writer: &writer)
//           case .c(let s):
//               writer.writeU8(2)
//               try s.encode(writer: &writer)
//           }
//       }
//       static func decode(reader: inout BinaryReader) throws -> MyEnum {
//           let variant = try reader.readU8()
//           switch variant {
//           case 0: return .a
//           case 1: return .b(try UInt32.decode(reader: &reader))
//           case 2: return .c(try String.decode(reader: &reader))
//           default: throw WireFormatError.invalidEnumVariant(variant)
//           }
//       }
//   }