How to use append method of UnkeyedEncodedArguments class

...5struct OptionArgumentEncoding: Encoder {6  class EncodedArguments {7    private(set) var arguments: [String] = []8    9    func append(_ argument: String?) {10      if let argument = argument {11        arguments.append(argument)12      }13    }14    15    func append(_ name: CodingKey?, _ argument: String?) {16      append(name?.longArgumentName)17      append(argument)18    }19  }20  21  struct PathConfiguration {22    let sourceRoot: Path23    let substitutionStyle: SubstitutionStyle24  }25  26  var codingPath: [CodingKey] = []27  var userInfo: [CodingUserInfoKey: Any] = [:]28  let data: EncodedArguments29  let pathConfig: PathConfiguration?30  31  init(arguments: EncodedArguments = EncodedArguments(),32       pathConfig: PathConfiguration? = nil) {33    self.data = arguments34    self.pathConfig = pathConfig35    self.userInfo[Self.pathConfigUserInfoKey] = pathConfig36  }37  38  static var pathConfigUserInfoKey: CodingUserInfoKey {39    CodingUserInfoKey(rawValue: "pathConfig")!40  }41  static func encode(_ path: Path, with encoder: Encoder) throws {42    var container = encoder.singleValueContainer()43    guard let config = encoder.userInfo[Self.pathConfigUserInfoKey] as? PathConfiguration else {44      return try container.encode(path.abbreviated())45    }46    let relativePath = path.abbreviated(root: config.sourceRoot,47                                        variable: "SRCROOT",48                                        style: config.substitutionStyle)49    try container.encode(relativePath)50  }51  52  func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {53    var container = OptionArgumentKeyedEncoding<Key>(arguments: data, pathConfig: pathConfig)54    container.codingPath = codingPath55    return KeyedEncodingContainer<Key>(container)56  }57  58  func unkeyedContainer() -> UnkeyedEncodingContainer {59    var container = OptionArgumentUnkeyedEncoding(arguments: data, pathConfig: pathConfig)60    container.codingPath = codingPath61    return container62  }63  64  func singleValueContainer() -> SingleValueEncodingContainer {65    var container = OptionArgumentSingleValueEncoding(arguments: data, pathConfig: pathConfig)66    container.codingPath = codingPath67    return container68  }69}70struct OptionArgumentKeyedEncoding<Key: CodingKey>: KeyedEncodingContainerProtocol {71  72  var codingPath: [CodingKey] = []73  private let data: OptionArgumentEncoding.EncodedArguments74  private let pathConfig: OptionArgumentEncoding.PathConfiguration?75  76  init(arguments: OptionArgumentEncoding.EncodedArguments,77       pathConfig: OptionArgumentEncoding.PathConfiguration?) {78    self.data = arguments79    self.pathConfig = pathConfig80  }81  82  mutating func encodeNil(forKey key: Key) throws {83    // No-op84  }85  86  mutating func encode(_ value: Bool, forKey key: Key) throws {87    data.append(key, value ? "1" : "0")88  }89  90  mutating func encode(_ value: String, forKey key: Key) throws {91    data.append(key, value.doubleQuoted)92  }93  94  mutating func encode(_ value: Double, forKey key: Key) throws {95    data.append(key, String(describing: value))96  }97  98  mutating func encode(_ value: Float, forKey key: Key) throws {99    data.append(key, String(describing: value))100  }101  102  mutating func encode(_ value: Int, forKey key: Key) throws {103    data.append(key, String(describing: value))104  }105  106  mutating func encode(_ value: Int8, forKey key: Key) throws {107    data.append(key, String(describing: value))108  }109  110  mutating func encode(_ value: Int16, forKey key: Key) throws {111    data.append(key, String(describing: value))112  }113  114  mutating func encode(_ value: Int32, forKey key: Key) throws {115    data.append(key, String(describing: value))116  }117  118  mutating func encode(_ value: Int64, forKey key: Key) throws {119    data.append(key, String(describing: value))120  }121  122  mutating func encode(_ value: UInt, forKey key: Key) throws {123    data.append(key, String(describing: value))124  }125  126  mutating func encode(_ value: UInt8, forKey key: Key) throws {127    data.append(key, String(describing: value))128  }129  130  mutating func encode(_ value: UInt16, forKey key: Key) throws {131    data.append(key, String(describing: value))132  }133  134  mutating func encode(_ value: UInt32, forKey key: Key) throws {135    data.append(key, String(describing: value))136  }137  138  mutating func encode(_ value: UInt64, forKey key: Key) throws {139    data.append(key, String(describing: value))140  }141  142  mutating func encode<T: Encodable>(_ value: T, forKey key: Key) throws {143    var encoding = OptionArgumentEncoding(arguments: data, pathConfig: pathConfig)144    encoding.codingPath = codingPath + [key]145    try value.encode(to: encoding)146  }147  148  mutating func nestedContainer<NestedKey: CodingKey>(149    keyedBy keyType: NestedKey.Type,150    forKey key: Key151  ) -> KeyedEncodingContainer<NestedKey> {152    var container = OptionArgumentKeyedEncoding<NestedKey>(arguments: data, pathConfig: pathConfig)153    container.codingPath = codingPath + [key]154    return KeyedEncodingContainer(container)155  }156  157  mutating func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer {158    var container = OptionArgumentUnkeyedEncoding(arguments: data, pathConfig: pathConfig)159    container.codingPath = codingPath + [key]160    return container161  }162  163  mutating func superEncoder() -> Encoder {164    let superKey = Key(stringValue: "super")!165    return superEncoder(forKey: superKey)166  }167  168  mutating func superEncoder(forKey key: Key) -> Encoder {169    var encoding = OptionArgumentEncoding(arguments: data, pathConfig: pathConfig)170    encoding.codingPath = codingPath + [key]171    return encoding172  }173}174struct OptionArgumentUnkeyedEncoding: UnkeyedEncodingContainer {175  class UnkeyedEncodedArguments: OptionArgumentEncoding.EncodedArguments {176    override func append(_ name: CodingKey?, _ argument: String?) {177      append(argument)178    }179  }180  181  var codingPath: [CodingKey] = []182  var count = 0183  184  let data: OptionArgumentEncoding.EncodedArguments185  let pathConfig: OptionArgumentEncoding.PathConfiguration?186  187  private mutating func appendArgument(_ argument: String) {188    count += 1189    // Handle the current argument parsing strategy for arrays: `--option item1 item2 item3`.190    data.append(count == 1 ? codingPath.last : nil, argument)191  }192  193  init(arguments: OptionArgumentEncoding.EncodedArguments,194       pathConfig: OptionArgumentEncoding.PathConfiguration?) {195    self.data = arguments196    self.pathConfig = pathConfig197  }198  199  mutating func encodeNil() throws {200    // No-op201  }202  203  mutating func encode(_ value: Bool) throws {204    appendArgument(value ? "1" : "0")205  }206  207  mutating func encode(_ value: String) throws {208    appendArgument(value.doubleQuoted)209  }210  211  mutating func encode(_ value: Double) throws {212    appendArgument(String(describing: value))213  }214  215  mutating func encode(_ value: Float) throws {216    appendArgument(String(describing: value))217  }218  219  mutating func encode(_ value: Int) throws {220    appendArgument(String(describing: value))221  }222  223  mutating func encode(_ value: Int8) throws {224    appendArgument(String(describing: value))225  }226  227  mutating func encode(_ value: Int16) throws {228    appendArgument(String(describing: value))229  }230  231  mutating func encode(_ value: Int32) throws {232    appendArgument(String(describing: value))233  }234  235  mutating func encode(_ value: Int64) throws {236    appendArgument(String(describing: value))237  }238  239  mutating func encode(_ value: UInt) throws {240    appendArgument(String(describing: value))241  }242  243  mutating func encode(_ value: UInt8) throws {244    appendArgument(String(describing: value))245  }246  247  mutating func encode(_ value: UInt16) throws {248    appendArgument(String(describing: value))249  }250  251  mutating func encode(_ value: UInt32) throws {252    appendArgument(String(describing: value))253  }254  255  mutating func encode(_ value: UInt64) throws {256    appendArgument(String(describing: value))257  }258  259  mutating func encode<T: Encodable>(_ value: T) throws {260    let subdata = UnkeyedEncodedArguments()261    var encoding = OptionArgumentEncoding(arguments: subdata, pathConfig: pathConfig)262    encoding.codingPath = codingPath263    try value.encode(to: encoding)264    subdata.arguments.forEach({ appendArgument($0) })265  }266  267  mutating func nestedContainer<NestedKey: CodingKey>(268    keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> {269    var container = OptionArgumentKeyedEncoding<NestedKey>(arguments: data, pathConfig: pathConfig)270    container.codingPath = codingPath271    return KeyedEncodingContainer(container)272  }273  274  mutating func nestedUnkeyedContainer() -> UnkeyedEncodingContainer {275    var container = OptionArgumentUnkeyedEncoding(arguments: data, pathConfig: pathConfig)276    container.codingPath = codingPath277    return container278  }279  280  mutating func superEncoder() -> Encoder {281    var encoding = OptionArgumentEncoding(arguments: data, pathConfig: pathConfig)282    encoding.codingPath = codingPath283    return encoding284  }285}286struct OptionArgumentSingleValueEncoding: SingleValueEncodingContainer {287  288  var codingPath: [CodingKey] = []289  let data: OptionArgumentEncoding.EncodedArguments290  let pathConfig: OptionArgumentEncoding.PathConfiguration?291  292  init(arguments: OptionArgumentEncoding.EncodedArguments,293       pathConfig: OptionArgumentEncoding.PathConfiguration?) {294    self.data = arguments295    self.pathConfig = pathConfig296  }297  298  mutating func encodeNil() throws {299    // No-op300  }301  302  mutating func encode(_ value: Bool) throws {303    data.append(codingPath.last, value ? "1" : "0")304  }305  306  mutating func encode(_ value: String) throws {307    data.append(codingPath.last, value.doubleQuoted)308  }309  310  mutating func encode(_ value: Double) throws {311    data.append(codingPath.last, String(describing: value))312  }313  314  mutating func encode(_ value: Float) throws {315    data.append(codingPath.last, String(describing: value))316  }317  318  mutating func encode(_ value: Int) throws {319    data.append(codingPath.last, String(describing: value))320  }321  322  mutating func encode(_ value: Int8) throws {323    data.append(codingPath.last, String(describing: value))324  }325  326  mutating func encode(_ value: Int16) throws {327    data.append(codingPath.last, String(describing: value))328  }329  330  mutating func encode(_ value: Int32) throws {331    data.append(codingPath.last, String(describing: value))332  }333  334  mutating func encode(_ value: Int64) throws {335    data.append(codingPath.last, String(describing: value))336  }337  338  mutating func encode(_ value: UInt) throws {339    data.append(codingPath.last, String(describing: value))340  }341  342  mutating func encode(_ value: UInt8) throws {343    data.append(codingPath.last, String(describing: value))344  }345  346  mutating func encode(_ value: UInt16) throws {347    data.append(codingPath.last, String(describing: value))348  }349  350  mutating func encode(_ value: UInt32) throws {351    data.append(codingPath.last, String(describing: value))352  }353  354  mutating func encode(_ value: UInt64) throws {355    data.append(codingPath.last, String(describing: value))356  }357  358  mutating func encode<T: Encodable>(_ value: T) throws {359    var encoding = OptionArgumentEncoding(arguments: data, pathConfig: pathConfig)360    encoding.codingPath = codingPath361    try value.encode(to: encoding)362  }363}...

1func encode(to encoder: Encoder) throws {2    var container = encoder.unkeyedContainer()3    try container.append(1)4    try container.append(2)5    try container.append(3)6    try container.append(4)7    try container.append(5)8    try container.append(6)9    try container.append(7)10    try container.append(8)11    try container.append(9)12    try container.append(10)13}14func encode(to encoder: Encoder) throws {15    var container = encoder.unkeyedContainer()16    try container.encode(1)17    try container.encode(2)18    try container.encode(3)19    try container.encode(4)20    try container.encode(5)21    try container.encode(6)22    try container.encode(7)23    try container.encode(8)24    try container.encode(9)25    try container.encode(10)26}27func encode(to encoder: Encoder) throws {28    var container = encoder.unkeyedContainer()29    try container.append(1)30    try container.append(2)31    try container.append(3)32    try container.append(4)33    try container.append(5)34    try container.append(6)35    try container.append(7)36    try container.append(8)37    try container.append(9)38    try container.append(10)39}40func encode(to encoder: Encoder) throws {41    var container = encoder.unkeyedContainer()42    try container.encode(1)43    try container.encode(2)44    try container.encode(3)45    try container.encode(4)46    try container.encode(5)47    try container.encode(6)48    try container.encode(7)49    try container.encode(8)50    try container.encode(9)51    try container.encode(10)52}53func encode(to encoder: Encoder) throws {54    var container = encoder.unkeyedContainer()55    try container.append(1)56    try container.append(2)57    try container.append(3)58    try container.append(4)59    try container.append(5)

1var unkeyed = encoder.unkeyedContainer()2unkeyed.append(1)3unkeyed.append(2)4unkeyed.append(3)5unkeyed.append(4)6unkeyed.append(5)7unkeyed.append(6)8unkeyed.append(7)9unkeyed.append(8)10unkeyed.append(9)11unkeyed.append(10)12unkeyed.append(11)13unkeyed.append(12)14unkeyed.append(13)15unkeyed.append(14)16unkeyed.append(15)17unkeyed.append(16)18unkeyed.append(17)19unkeyed.append(18)20unkeyed.append(19)21unkeyed.append(20)22unkeyed.append(21)23unkeyed.append(22)24unkeyed.append(23)25unkeyed.append(24)26unkeyed.append(25)27unkeyed.append(26)28unkeyed.append(27)29unkeyed.append(28)30unkeyed.append(29)31unkeyed.append(30)32unkeyed.append(31)33unkeyed.append(32)34unkeyed.append(33)35unkeyed.append(34)36unkeyed.append(35)37unkeyed.append(36)38unkeyed.append(37)39unkeyed.append(38)40unkeyed.append(39)41unkeyed.append(40)42unkeyed.append(41)43unkeyed.append(42)44unkeyed.append(43)45unkeyed.append(44)46unkeyed.append(45)47unkeyed.append(46)48unkeyed.append(47)49unkeyed.append(48)50unkeyed.append(49)51unkeyed.append(50)52unkeyed.append(51)53unkeyed.append(52)54unkeyed.append(53)55unkeyed.append(54)56unkeyed.append(55)57unkeyed.append(56)58unkeyed.append(57)59unkeyed.append(58)60unkeyed.append(59)61unkeyed.append(60)62unkeyed.append(61)63unkeyed.append(62)64unkeyed.append(63)65unkeyed.append(64)66unkeyed.append(65)67unkeyed.append(66)68unkeyed.append(67)69unkeyed.append(68)70unkeyed.append(69)

1var unkeyedArguments = UnkeyedEncodedArguments()2unkeyedArguments.append(1)3unkeyedArguments.append(2)4unkeyedArguments.append(3)5print(unkeyedArguments)6var keyedArguments = KeyedEncodedArguments()7keyedArguments.append("a", 1)8keyedArguments.append("b", 2)9keyedArguments.append("c", 3)10print(keyedArguments)11var arguments = EncodedArguments()12arguments.append("a", 1)13arguments.append("b", 2)14arguments.append("c", 3)15print(arguments)16var arguments = EncodedArguments()17arguments.append("a", 1)18arguments.append("b", 2)19arguments.append("c", 3)20print(arguments)21var arguments = EncodedArguments()22arguments.append("a", 1)23arguments.append("b", 2)24arguments.append("c", 3)25print(arguments)26var arguments = EncodedArguments()27arguments.append("a", 1)28arguments.append("b", 2)29arguments.append("c", 3)30print(arguments)31var arguments = EncodedArguments()32arguments.append("a", 1)33arguments.append("b", 2)34arguments.append("c", 3)35print(arguments)36var arguments = EncodedArguments()37arguments.append("a", 1)38arguments.append("b", 2)39arguments.append("c", 3)40print(arguments)41var arguments = EncodedArguments()42arguments.append("a", 1)43arguments.append("b", 2)44arguments.append("c", 3)45print(arguments)46var arguments = EncodedArguments()47arguments.append("a", 1)48arguments.append("b", 2)49arguments.append("c", 3)50print(arguments)51var arguments = EncodedArguments()52arguments.append("a", 1)53arguments.append("b

1func append<T>(value: T) throws where T : Encodable2func append<T>(value: T) throws where T : Decodable3func append<T>(value: T) throws where T : Encodable4func append<T>(value: T) throws where T : Decodable5func append<T>(value: T) throws where T : Encodable6func append<T>(value: T) throws where T : Decodable7func append<T>(value: T) throws where T : Encodable8func append<T>(value: T) throws where T : Decodable9func append<T>(value: T) throws where T : Encodable10func append<T>(value: T) throws where T : Decodable11func append<T>(value: T) throws where T : Encodable12func append<T>(value: T) throws where T : Decodable13func append<T>(value: T) throws where T : Encodable14func append<T>(value: T) throws where T : Decodable15func append<T>(value: T) throws where T : Encodable16func append<T>(value:

1func encode(to encoder: Encoder) throws {2    var container = encoder.unkeyedContainer()3    try container.append(1)4    try container.append("abc")5    try container.append(true)6}7func encode(to encoder: Encoder) throws {8    var container = encoder.unkeyedContainer()9    try container.append(1)10    try container.append("abc")11    try container.append(true)12}13func encode(to encoder: Encoder) throws {14    var container = encoder.unkeyedContainer()15    try container.append(1)16    try container.append("abc")17    try container.append(true)18}19func encode(to encoder: Encoder) throws {20    var container = encoder.unkeyedContainer()21    try container.append(1)22    try container.append("abc")23    try container.append(true)24}25func encode(to encoder: Encoder) throws {26    var container = encoder.unkeyedContainer()27    try container.append(1)28    try container.append("abc")29    try container.append(true)30}31func encode(to encoder: Encoder) throws {32    var container = encoder.unkeyedContainer()33    try container.append(1)34    try container.append("abc")35    try container.append(true)36}37func encode(to encoder: Encoder) throws {38    var container = encoder.unkeyedContainer()39    try container.append(1)40    try container.append("abc")41    try container.append(true)42}43func encode(to encoder: Encoder) throws {44    var container = encoder.unkeyedContainer()45    try container.append(1)46    try container.append("abc")47    try container.append(true)48}49func encode(to encoder: Encoder) throws {

1struct Append: Encodable {2    func encode(to encoder: Encoder) throws {3        var container = encoder.unkeyedContainer()4        try container.append(a)5        try container.append(b)6        try container.append(c)7    }8}9let append = Append(a: 1, b: 2, c: 3)10let json = try JSONEncoder().encode(append)11print(String(data: json, encoding: .utf8)!)12struct Encode: Encodable {13    func encode(to encoder: Encoder) throws {14        var container = encoder.singleValueContainer()15        try container.encode([a, b, c])16    }17}18let encode = Encode(a: 1, b: 2, c: 3)19let json = try JSONEncoder().encode(encode)20print(String(data: json, encoding: .utf8)!)21struct Encode2: Encodable {22    func encode(to encoder: Encoder) throws {23        var container = encoder.unkeyedContainer()24        try container.encode(a)25        try container.encode(b)26        try container.encode(c)27    }28}29let encode2 = Encode2(a: 1, b: 2, c: 3)30let json = try JSONEncoder().encode(encode2)31print(String(data: json, encoding: .utf8)!)32struct Encode3: Encodable {33    func encode(to encoder: Encoder) throws {34        var container = encoder.container(keyedBy: CodingKeys.self)35        try container.encode(a, forKey: .a)36        try container.encode(b, forKey: .b)37        try container.encode(c, forKey: .c)38    }39    enum CodingKeys: String, CodingKey {40    }41}42let encode3 = Encode3(a:

1import Foundation2struct Person : Encodable {3}4let person = Person(name: "John", age: 30)5let encoder = JSONEncoder()6let data = try! encoder.encode(person)7let json = String(data: data, encoding: .utf8)!8print(json)9import Foundation10struct Person : Encodable {11}12let person = Person(name: "John", age: 30)13let encoder = JSONEncoder()14let data = try! encoder.encode(person)15let json = String(data: data, encoding: .utf8)!16print(json)17import Foundation18struct Person : Encodable {19}20let person = Person(name: "John", age: 30)21let encoder = JSONEncoder()22let data = try! encoder.encode(person)23let json = String(data: data, encoding: .utf8)!24print(json)25import Foundation26struct Person : Encodable {27}28let person = Person(name: "John", age: 30)29let encoder = JSONEncoder()30let data = try! encoder.encode(person)31let json = String(data: data, encoding: .utf8)!32print(json)33import Foundation34struct Person : Encodable {35}36let person = Person(name: "John", age: 30)37let encoder = JSONEncoder()38let data = try! encoder.encode(person)39let json = String(data: data, encoding: .utf8)!40print(json)

1import Foundation2struct Person: Codable {3}4let person = Person(name: "John", age: 30, address: "123 Main St")5let encoder = JSONEncoder()6let data = try encoder.encode(person)7let json = String(data: data, encoding: .utf8)8print(json!)9import Foundation10struct Person: Codable {11}12let person = Person(name: "John", age: 30, address: "123 Main St")13let encoder = JSONEncoder()14let data = try encoder.encode(person)15let json = String(data: data, encoding: .utf8)16print(json!)17import Foundation18struct Person: Codable {19}20let person = Person(name: "John", age: 30, address: "123 Main St")21let encoder = JSONEncoder()22let data = try encoder.encode(person)23let json = String(data: data, encoding: .utf8)24print(json!)25import Foundation26struct Person: Codable {27}28let person = Person(name: "John", age: 30, address: "123 Main St")29let encoder = JSONEncoder()

1import Foundation2var arguments = UnkeyedEncodingArguments()3arguments.append([1, 2, 3])4print(arguments)5import Foundation6var arguments = UnkeyedEncodingArguments()7arguments.append([1, 2, 3])8print(arguments)9import Foundation10var arguments = UnkeyedEncodingArguments()11arguments.append([1, 2, 3])12print(arguments)13import Foundation14var arguments = UnkeyedEncodingArguments()15arguments.append([1, 2, 3])16print(arguments)17import Foundation18var arguments = UnkeyedEncodingArguments()19arguments.append([1, 2, 3])20print(arguments)21import Foundation22var arguments = UnkeyedEncodingArguments()23arguments.append([1, 2, 3])24print(arguments)25import Foundation26var arguments = UnkeyedEncodingArguments()27arguments.append([1, 2, 3])28print(arguments)29import Foundation30var arguments = UnkeyedEncodingArguments()31arguments.append([1, 2, 3])32print(arguments)

1import Foundation2var unkeyedArguments = UnkeyedEncodingContainer()3unkeyedArguments.append(1)4unkeyedArguments.append(2)5unkeyedArguments.append(3)6unkeyedArguments.append(4)7unkeyedArguments.append(5)8unkeyedArguments.append(6)9unkeyedArguments.append(7)10unkeyedArguments.append(8)11unkeyedArguments.append(9)12unkeyedArguments.append(10)13print(unkeyedArguments.arguments)14print(unkeyedArguments.count)15import Foundation16var unkeyedArguments = UnkeyedEncodingContainer()17unkeyedArguments.append(1)18unkeyedArguments.append(2)19unkeyedArguments.append(3)20unkeyedArguments.append(4)21unkeyedArguments.append(5)22unkeyedArguments.append(6)23unkeyedArguments.append(7)24unkeyedArguments.append(8)25unkeyedArguments.append(9)26unkeyedArguments.append(10)27print(unkeyedArguments.arguments)28print(unkeyedArguments.count)29unkeyedArguments.append(11)30print(unkeyedArguments.arguments)31print(unkeyedArguments.count)32import Foundation33var unkeyedArguments = UnkeyedEncodingContainer()34unkeyedArguments.append(1)