hexsha
stringlengths 40
40
| size
int64 3
1.03M
| content
stringlengths 3
1.03M
| avg_line_length
float64 1.33
100
| max_line_length
int64 2
1k
| alphanum_fraction
float64 0.25
0.99
|
|---|---|---|---|---|---|
d66e852cb9a5e2d31dfa0498603cb7adbb9541e4 | 377 | import Plot
import Vapor
extension SiteMap: ResponseEncodable {
public func encodeResponse(for request: Request) -> EventLoopFuture<Response> {
var headers = HTTPHeaders()
headers.add(name: .contentType, value: "application/xml")
return request.eventLoop.makeSucceededFuture(.init(
status: .ok, headers: headers, body: .init(string: render())
))
}
}
| 29 | 81 | 0.71618 |
1ca8847b4f2b6154ceffeeb01de7566937064967 | 2,714 | //
// Services.swift
// Ryanair
//
// Created by Abraao Nascimento on 21/10/21.
//
import Foundation
class Services: NSObject {
static func searchAvailability(origin: String, destination: String, dateout: String, dateIn: String, adt: String = "1", teen: String = "0", chd: String = "0", completion: @escaping ([Trip]?) -> ()) {
let availabilityRouter = Router.searchAvailability(origin: origin,
destination: destination,
dateout: dateout,
dateIn: dateIn,
adt: adt,
teen: teen,
chd: chd)
let abrequest = ABRequest()
do {
print(try availabilityRouter.request()?.url?.absoluteURL ?? "-")
guard let request = try availabilityRouter.request() else {
return
}
abrequest.requestObject(of: Availability.self, request: request) { (result) in
switch result {
case .success(let availability):
let availability = availability as? Availability
completion(availability?.trips)
case .failure(let error):
completion(nil)
print("[Service]: parser error. \(error.localizedDescription)")
}
}
} catch let error {
completion(nil)
print("[Service]: \(error.localizedDescription)")
}
}
static func getStations(completion: @escaping ([Station]?) -> ()) {
let availabilityRouter = Router.getStations
let abrequest = ABRequest()
do {
guard let request = try availabilityRouter.request() else {
return
}
abrequest.requestObject(of: StationResult.self, request: request) { (result) in
switch result {
case .success(let result):
let stationsResult = result as? StationResult
completion(stationsResult?.stations)
case .failure(let error):
completion(nil)
print("[Service]: parser error. \(error)")
}
}
} catch let error {
completion(nil)
print("[Service]: \(error.localizedDescription)")
}
}
}
| 35.246753 | 203 | 0.453943 |
6aac5da5c88ae1dc68a50b09b87ed7838901dfb3 | 460 | //
// BorderRightColor.swift
// SwiftCss
//
// Created by Tibor Bodecs on 2021. 07. 10..
//
public func BorderRightColor(_ value: String) -> Property {
Property(name: "border-right-color", value: value)
}
/// Sets the color of the right border
public func BorderRightColor(_ value: CSSColorValue) -> Property {
BorderRightColor(value.rawValue)
}
public func BorderRightColor(_ value: CSSColor) -> Property {
BorderRightColor(.color(value))
}
| 23 | 66 | 0.71087 |
7197b463888cb3c7428129b5874b0ff7189434cd | 1,631 | import SwiftUI
enum TileStyle {
case empty
case two
case four
case eigth
case sixteen
case thirtyTwo
case sixtyFour
case max
init(_ value: Int) {
switch value {
case 0: self = .empty
case 2: self = .two
case 4: self = .four
case 8: self = .eigth
case 16: self = .sixteen
case 32: self = .thirtyTwo
case 64: self = .sixtyFour
default: self = .max
}
}
var backgroundColor: Color {
switch self {
case .empty: return (Color(red: 197/255, green: 186/255, blue: 175/255, opacity: 1.0))
case .two: return (Color(red: 235/255, green: 228/255, blue: 220/255, opacity: 1.0))
case .four: return (Color(red: 233/255, green: 223/255, blue: 204/255, opacity: 1.0))
case .eigth: return (Color(red: 225/255, green: 179/255, blue: 135/255, opacity: 1.0))
case .sixteen: return (Color(red: 215/255, green: 151/255, blue: 112/255, opacity: 1.0))
case .thirtyTwo: return (Color(red: 211/255, green: 131/255, blue: 105/255, opacity: 1.0))
case .sixtyFour: return (Color(red: 214/255, green: 113/255, blue: 85/255, opacity: 1.0))
case .max: return (Color(red: 229/255, green: 204/255, blue: 132/255, opacity: 1.0))
}
}
var foregroundColor: Color {
switch self {
case .two, .four: return (Color(red: 116/255, green: 110/255, blue: 103/255, opacity: 1.0))
default: return .white
}
}
}
| 30.203704 | 100 | 0.533415 |
f5f06183e7e49597e4ab68f003fc5ce5fc7cb556 | 878 | //
// JETests.swift
// JETests
//
// Created by JSP_MacBookPro on 2020/10/31.
//
import XCTest
@testable import JE
class JETests: XCTestCase {
override func setUpWithError() throws {
// Put setup code here. This method is called before the invocation of each test method in the class.
}
override func tearDownWithError() throws {
// Put teardown code here. This method is called after the invocation of each test method in the class.
}
func testExample() throws {
// This is an example of a functional test case.
// Use XCTAssert and related functions to verify your tests produce the correct results.
}
func testPerformanceExample() throws {
// This is an example of a performance test case.
self.measure {
// Put the code you want to measure the time of here.
}
}
}
| 25.823529 | 111 | 0.657175 |
db9c3bbabcc34a30d9194faff3ee2f63e5bf389e | 2,659 | //
// IotaNodeSelector.swift
// IotaKit
//
// Created by Pasquale Ambrosini on 14/01/2018.
//
import Foundation
import Dispatch
struct IotaNode: Codable {
let health: Int = 0
let load: Int = 0
let fullAddress: String
let isOnline: Bool
init(from decoder: Decoder) throws {
let additionalValues = try decoder.container(keyedBy: AdditionalInfoKeys.self)
self.fullAddress = try additionalValues.decode(String.self, forKey: .host)
self.isOnline = Int(try additionalValues.decode(String.self, forKey: .online))! == 1 ? true : false
}
// init(from decoder: Decoder) throws {
//
// let values = try decoder.container(keyedBy: CodingKeys.self)
// if let health = try? values.decode(Int.self, forKey: .health) {
// self.health = health
// }else { self.health = 0 }
// if let load = try? values.decode(Int.self, forKey: .load) {
// self.load = load
// }else { self.load = 999999999 }
//
// self.port = try values.decode(String.self, forKey: .port)
//
// let additionalValues = try decoder.container(keyedBy: AdditionalInfoKeys.self)
//
// self.address = try additionalValues.decode(String.self, forKey: .address)
// }
fileprivate enum AdditionalInfoKeys: String, CodingKey {
case address = "node"
case host = "host"
case online = "online"
}
}
struct IotaNodeSelector {
static func bestNode(prefersHTTPS: Bool, _ success: @escaping (_ node: IotaNode) -> Void, error: @escaping (_ error: IotaAPIError) -> Void) {
func testNode(n: [IotaNode], index: Int = 0) {
//print("testing \(n[index].fullAddress)")
let iota = Iota(node: n[index].fullAddress)
iota.nodeInfo({ (nodeInfo) in
success(n[index])
}) { (e) in
let next = index + 1
if next < n.count {
DispatchQueue.global(qos: .userInitiated).async {
testNode(n: n, index: next)
}
}
}
}
self.bestNodes(prefersHTTPS: prefersHTTPS, { (nodes) in
testNode(n: nodes)
}, error: error)
}
static func bestNodes(prefersHTTPS: Bool, _ success: @escaping (_ nodes: [IotaNode]) -> Void, error: @escaping (_ error: IotaAPIError) -> Void) {
//let url = "https://iota.dance/data/node-stats"
let url = "https://iotanode.host/node_table.json"
PAWSRequest.GET(destination: url, successHandler: { (r) in
if var a = try? JSONDecoder().decode([IotaNode].self, from: r.data(using: .utf8)!) {
a = a.filter({ (node) -> Bool in
return node.isOnline
})
if prefersHTTPS {
a = a.filter({ (node) -> Bool in
return node.fullAddress.hasPrefix("https")
})
}
success(a)
}else{
error(IotaAPIError("Malformed JSON"))
}
}) { (e) in
error(e as! IotaAPIError)
}
}
}
| 26.858586 | 146 | 0.652877 |
0e45ac30717a1dd1888c9336ebc1531918ebf29a | 2,232 | //
// AppDelegate.swift
// Practica-3
//
// Created by Universidad Politecnica de Gómez Palacio on 08/03/19.
// Copyright © 2019 Universidad Politecnica de Gómez Palacio. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
func applicationWillResignActive(_ application: UIApplication) {
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game.
}
func applicationDidEnterBackground(_ application: UIApplication) {
// Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
// If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}
func applicationWillEnterForeground(_ application: UIApplication) {
// Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
}
func applicationDidBecomeActive(_ application: UIApplication) {
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}
func applicationWillTerminate(_ application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}
}
| 47.489362 | 285 | 0.758513 |
e5e09870dd8f3c499dbe8206c54d4b13c36397c1 | 591 | //
// MapViewDelegate.swift
// beer-app-ios
//
// Created by daishi nakajima on 2016/02/22.
// Copyright © 2016年 daishi nakajima. All rights reserved.
//
import Foundation
protocol MapViewDelegate: class {
func mapViewWillMove(mapView: MapView)
func mapViewIdlePosition(mapView: MapView)
func mapView(mapView: MapView, didTapInfoWindowOfMarker marker: MapMarker)
}
extension MapViewDelegate {
func mapViewWillMove(mapView: MapView) {}
func mapViewIdlePosition(mapView: MapView) {}
func mapView(mapView: MapView, didTapInfoWindowOfMarker marker: MapMarker) {}
} | 28.142857 | 81 | 0.751269 |
fc9af332b7c7bb9d0d2a583a792e415b9b3dead5 | 234,696 | //// Automatically Generated From SyntaxFactory.swift.gyb.
//// Do Not Edit Directly!
//===------- SyntaxFactory.swift - Syntax Factory implementations ---------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines the SyntaxFactory, one of the most important client-facing
// types in lib/Syntax and likely to be very commonly used.
//
// Effectively a namespace, SyntaxFactory is never instantiated, but is *the*
// one-stop shop for making new Syntax nodes. Putting all of these into a
// collection of static methods provides a single point of API lookup for
// clients' convenience.
//
//===----------------------------------------------------------------------===//
public enum SyntaxFactory {
public static func makeToken(_ kind: TokenKind, presence: SourcePresence,
leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
let raw = RawSyntax.createAndCalcLength(kind: kind, leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia, presence: presence)
let data = SyntaxData.forRoot(raw)
return TokenSyntax(data)
}
public static func makeUnknownSyntax(tokens: [TokenSyntax]) -> UnknownSyntax {
let raw = RawSyntax.createAndCalcLength(kind: .unknown,
layout: tokens.map { $0.raw }, presence: .present)
let data = SyntaxData.forRoot(raw)
return UnknownSyntax(data)
}
/// MARK: Syntax Node Creation APIs
public static func makeBlankUnknownDecl() -> UnknownDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .unknownDecl,
layout: [
], length: .zero, presence: .present))
return UnknownDeclSyntax(data)
}
public static func makeBlankUnknownExpr() -> UnknownExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .unknownExpr,
layout: [
], length: .zero, presence: .present))
return UnknownExprSyntax(data)
}
public static func makeBlankUnknownStmt() -> UnknownStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .unknownStmt,
layout: [
], length: .zero, presence: .present))
return UnknownStmtSyntax(data)
}
public static func makeBlankUnknownType() -> UnknownTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .unknownType,
layout: [
], length: .zero, presence: .present))
return UnknownTypeSyntax(data)
}
public static func makeBlankUnknownPattern() -> UnknownPatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .unknownPattern,
layout: [
], length: .zero, presence: .present))
return UnknownPatternSyntax(data)
}
public static func makeCodeBlockItem(item: Syntax, semicolon: TokenSyntax?, errorTokens: Syntax?) -> CodeBlockItemSyntax {
let layout: [RawSyntax?] = [
item.raw,
semicolon?.raw,
errorTokens?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.codeBlockItem,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CodeBlockItemSyntax(data)
}
public static func makeBlankCodeBlockItem() -> CodeBlockItemSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .codeBlockItem,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
nil,
], length: .zero, presence: .present))
return CodeBlockItemSyntax(data)
}
public static func makeCodeBlockItemList(
_ elements: [CodeBlockItemSyntax]) -> CodeBlockItemListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.codeBlockItemList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CodeBlockItemListSyntax(data)
}
public static func makeBlankCodeBlockItemList() -> CodeBlockItemListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .codeBlockItemList,
layout: [
], length: .zero, presence: .present))
return CodeBlockItemListSyntax(data)
}
public static func makeCodeBlock(leftBrace: TokenSyntax, statements: CodeBlockItemListSyntax, rightBrace: TokenSyntax) -> CodeBlockSyntax {
let layout: [RawSyntax?] = [
leftBrace.raw,
statements.raw,
rightBrace.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.codeBlock,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CodeBlockSyntax(data)
}
public static func makeBlankCodeBlock() -> CodeBlockSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .codeBlock,
layout: [
RawSyntax.missingToken(TokenKind.leftBrace),
RawSyntax.missing(SyntaxKind.codeBlockItemList),
RawSyntax.missingToken(TokenKind.rightBrace),
], length: .zero, presence: .present))
return CodeBlockSyntax(data)
}
public static func makeInOutExpr(ampersand: TokenSyntax, expression: ExprSyntax) -> InOutExprSyntax {
let layout: [RawSyntax?] = [
ampersand.raw,
expression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.inOutExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return InOutExprSyntax(data)
}
public static func makeBlankInOutExpr() -> InOutExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .inOutExpr,
layout: [
RawSyntax.missingToken(TokenKind.prefixAmpersand),
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return InOutExprSyntax(data)
}
public static func makePoundColumnExpr(poundColumn: TokenSyntax) -> PoundColumnExprSyntax {
let layout: [RawSyntax?] = [
poundColumn.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundColumnExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundColumnExprSyntax(data)
}
public static func makeBlankPoundColumnExpr() -> PoundColumnExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundColumnExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundColumnKeyword),
], length: .zero, presence: .present))
return PoundColumnExprSyntax(data)
}
public static func makeTupleExprElementList(
_ elements: [TupleExprElementSyntax]) -> TupleExprElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tupleExprElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TupleExprElementListSyntax(data)
}
public static func makeBlankTupleExprElementList() -> TupleExprElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tupleExprElementList,
layout: [
], length: .zero, presence: .present))
return TupleExprElementListSyntax(data)
}
public static func makeArrayElementList(
_ elements: [ArrayElementSyntax]) -> ArrayElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.arrayElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ArrayElementListSyntax(data)
}
public static func makeBlankArrayElementList() -> ArrayElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .arrayElementList,
layout: [
], length: .zero, presence: .present))
return ArrayElementListSyntax(data)
}
public static func makeDictionaryElementList(
_ elements: [DictionaryElementSyntax]) -> DictionaryElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.dictionaryElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DictionaryElementListSyntax(data)
}
public static func makeBlankDictionaryElementList() -> DictionaryElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .dictionaryElementList,
layout: [
], length: .zero, presence: .present))
return DictionaryElementListSyntax(data)
}
public static func makeStringLiteralSegments(
_ elements: [Syntax]) -> StringLiteralSegmentsSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.stringLiteralSegments,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return StringLiteralSegmentsSyntax(data)
}
public static func makeBlankStringLiteralSegments() -> StringLiteralSegmentsSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .stringLiteralSegments,
layout: [
], length: .zero, presence: .present))
return StringLiteralSegmentsSyntax(data)
}
public static func makeTryExpr(tryKeyword: TokenSyntax, questionOrExclamationMark: TokenSyntax?, expression: ExprSyntax) -> TryExprSyntax {
let layout: [RawSyntax?] = [
tryKeyword.raw,
questionOrExclamationMark?.raw,
expression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tryExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TryExprSyntax(data)
}
public static func makeBlankTryExpr() -> TryExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tryExpr,
layout: [
RawSyntax.missingToken(TokenKind.tryKeyword),
nil,
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return TryExprSyntax(data)
}
public static func makeAwaitExpr(awaitKeyword: TokenSyntax, expression: ExprSyntax) -> AwaitExprSyntax {
let layout: [RawSyntax?] = [
awaitKeyword.raw,
expression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.awaitExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AwaitExprSyntax(data)
}
public static func makeBlankAwaitExpr() -> AwaitExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .awaitExpr,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return AwaitExprSyntax(data)
}
public static func makeDeclNameArgument(name: TokenSyntax, colon: TokenSyntax) -> DeclNameArgumentSyntax {
let layout: [RawSyntax?] = [
name.raw,
colon.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.declNameArgument,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeclNameArgumentSyntax(data)
}
public static func makeBlankDeclNameArgument() -> DeclNameArgumentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .declNameArgument,
layout: [
RawSyntax.missingToken(TokenKind.unknown("")),
RawSyntax.missingToken(TokenKind.colon),
], length: .zero, presence: .present))
return DeclNameArgumentSyntax(data)
}
public static func makeDeclNameArgumentList(
_ elements: [DeclNameArgumentSyntax]) -> DeclNameArgumentListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.declNameArgumentList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeclNameArgumentListSyntax(data)
}
public static func makeBlankDeclNameArgumentList() -> DeclNameArgumentListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .declNameArgumentList,
layout: [
], length: .zero, presence: .present))
return DeclNameArgumentListSyntax(data)
}
public static func makeDeclNameArguments(leftParen: TokenSyntax, arguments: DeclNameArgumentListSyntax, rightParen: TokenSyntax) -> DeclNameArgumentsSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
arguments.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.declNameArguments,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeclNameArgumentsSyntax(data)
}
public static func makeBlankDeclNameArguments() -> DeclNameArgumentsSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .declNameArguments,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.declNameArgumentList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return DeclNameArgumentsSyntax(data)
}
public static func makeIdentifierExpr(identifier: TokenSyntax, declNameArguments: DeclNameArgumentsSyntax?) -> IdentifierExprSyntax {
let layout: [RawSyntax?] = [
identifier.raw,
declNameArguments?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.identifierExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IdentifierExprSyntax(data)
}
public static func makeBlankIdentifierExpr() -> IdentifierExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .identifierExpr,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return IdentifierExprSyntax(data)
}
public static func makeSuperRefExpr(superKeyword: TokenSyntax) -> SuperRefExprSyntax {
let layout: [RawSyntax?] = [
superKeyword.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.superRefExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SuperRefExprSyntax(data)
}
public static func makeBlankSuperRefExpr() -> SuperRefExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .superRefExpr,
layout: [
RawSyntax.missingToken(TokenKind.superKeyword),
], length: .zero, presence: .present))
return SuperRefExprSyntax(data)
}
public static func makeNilLiteralExpr(nilKeyword: TokenSyntax) -> NilLiteralExprSyntax {
let layout: [RawSyntax?] = [
nilKeyword.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.nilLiteralExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return NilLiteralExprSyntax(data)
}
public static func makeBlankNilLiteralExpr() -> NilLiteralExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .nilLiteralExpr,
layout: [
RawSyntax.missingToken(TokenKind.nilKeyword),
], length: .zero, presence: .present))
return NilLiteralExprSyntax(data)
}
public static func makeDiscardAssignmentExpr(wildcard: TokenSyntax) -> DiscardAssignmentExprSyntax {
let layout: [RawSyntax?] = [
wildcard.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.discardAssignmentExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DiscardAssignmentExprSyntax(data)
}
public static func makeBlankDiscardAssignmentExpr() -> DiscardAssignmentExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .discardAssignmentExpr,
layout: [
RawSyntax.missingToken(TokenKind.wildcardKeyword),
], length: .zero, presence: .present))
return DiscardAssignmentExprSyntax(data)
}
public static func makeAssignmentExpr(assignToken: TokenSyntax) -> AssignmentExprSyntax {
let layout: [RawSyntax?] = [
assignToken.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.assignmentExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AssignmentExprSyntax(data)
}
public static func makeBlankAssignmentExpr() -> AssignmentExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .assignmentExpr,
layout: [
RawSyntax.missingToken(TokenKind.equal),
], length: .zero, presence: .present))
return AssignmentExprSyntax(data)
}
public static func makeSequenceExpr(elements: ExprListSyntax) -> SequenceExprSyntax {
let layout: [RawSyntax?] = [
elements.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.sequenceExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SequenceExprSyntax(data)
}
public static func makeBlankSequenceExpr() -> SequenceExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .sequenceExpr,
layout: [
RawSyntax.missing(SyntaxKind.exprList),
], length: .zero, presence: .present))
return SequenceExprSyntax(data)
}
public static func makeExprList(
_ elements: [ExprSyntax]) -> ExprListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.exprList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ExprListSyntax(data)
}
public static func makeBlankExprList() -> ExprListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .exprList,
layout: [
], length: .zero, presence: .present))
return ExprListSyntax(data)
}
public static func makePoundLineExpr(poundLine: TokenSyntax) -> PoundLineExprSyntax {
let layout: [RawSyntax?] = [
poundLine.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundLineExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundLineExprSyntax(data)
}
public static func makeBlankPoundLineExpr() -> PoundLineExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundLineExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundLineKeyword),
], length: .zero, presence: .present))
return PoundLineExprSyntax(data)
}
public static func makePoundFileExpr(poundFile: TokenSyntax) -> PoundFileExprSyntax {
let layout: [RawSyntax?] = [
poundFile.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundFileExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundFileExprSyntax(data)
}
public static func makeBlankPoundFileExpr() -> PoundFileExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundFileExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundFileKeyword),
], length: .zero, presence: .present))
return PoundFileExprSyntax(data)
}
public static func makePoundFileIDExpr(poundFileID: TokenSyntax) -> PoundFileIDExprSyntax {
let layout: [RawSyntax?] = [
poundFileID.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundFileIDExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundFileIDExprSyntax(data)
}
public static func makeBlankPoundFileIDExpr() -> PoundFileIDExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundFileIDExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundFileIDKeyword),
], length: .zero, presence: .present))
return PoundFileIDExprSyntax(data)
}
public static func makePoundFilePathExpr(poundFilePath: TokenSyntax) -> PoundFilePathExprSyntax {
let layout: [RawSyntax?] = [
poundFilePath.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundFilePathExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundFilePathExprSyntax(data)
}
public static func makeBlankPoundFilePathExpr() -> PoundFilePathExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundFilePathExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundFilePathKeyword),
], length: .zero, presence: .present))
return PoundFilePathExprSyntax(data)
}
public static func makePoundFunctionExpr(poundFunction: TokenSyntax) -> PoundFunctionExprSyntax {
let layout: [RawSyntax?] = [
poundFunction.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundFunctionExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundFunctionExprSyntax(data)
}
public static func makeBlankPoundFunctionExpr() -> PoundFunctionExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundFunctionExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundFunctionKeyword),
], length: .zero, presence: .present))
return PoundFunctionExprSyntax(data)
}
public static func makePoundDsohandleExpr(poundDsohandle: TokenSyntax) -> PoundDsohandleExprSyntax {
let layout: [RawSyntax?] = [
poundDsohandle.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundDsohandleExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundDsohandleExprSyntax(data)
}
public static func makeBlankPoundDsohandleExpr() -> PoundDsohandleExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundDsohandleExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundDsohandleKeyword),
], length: .zero, presence: .present))
return PoundDsohandleExprSyntax(data)
}
public static func makeSymbolicReferenceExpr(identifier: TokenSyntax, genericArgumentClause: GenericArgumentClauseSyntax?) -> SymbolicReferenceExprSyntax {
let layout: [RawSyntax?] = [
identifier.raw,
genericArgumentClause?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.symbolicReferenceExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SymbolicReferenceExprSyntax(data)
}
public static func makeBlankSymbolicReferenceExpr() -> SymbolicReferenceExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .symbolicReferenceExpr,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return SymbolicReferenceExprSyntax(data)
}
public static func makePrefixOperatorExpr(operatorToken: TokenSyntax?, postfixExpression: ExprSyntax) -> PrefixOperatorExprSyntax {
let layout: [RawSyntax?] = [
operatorToken?.raw,
postfixExpression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.prefixOperatorExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrefixOperatorExprSyntax(data)
}
public static func makeBlankPrefixOperatorExpr() -> PrefixOperatorExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .prefixOperatorExpr,
layout: [
nil,
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return PrefixOperatorExprSyntax(data)
}
public static func makeBinaryOperatorExpr(operatorToken: TokenSyntax) -> BinaryOperatorExprSyntax {
let layout: [RawSyntax?] = [
operatorToken.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.binaryOperatorExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return BinaryOperatorExprSyntax(data)
}
public static func makeBlankBinaryOperatorExpr() -> BinaryOperatorExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .binaryOperatorExpr,
layout: [
RawSyntax.missingToken(TokenKind.unknown("")),
], length: .zero, presence: .present))
return BinaryOperatorExprSyntax(data)
}
public static func makeArrowExpr(asyncKeyword: TokenSyntax?, throwsToken: TokenSyntax?, arrowToken: TokenSyntax) -> ArrowExprSyntax {
let layout: [RawSyntax?] = [
asyncKeyword?.raw,
throwsToken?.raw,
arrowToken.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.arrowExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ArrowExprSyntax(data)
}
public static func makeBlankArrowExpr() -> ArrowExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .arrowExpr,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.arrow),
], length: .zero, presence: .present))
return ArrowExprSyntax(data)
}
public static func makeFloatLiteralExpr(floatingDigits: TokenSyntax) -> FloatLiteralExprSyntax {
let layout: [RawSyntax?] = [
floatingDigits.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.floatLiteralExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FloatLiteralExprSyntax(data)
}
public static func makeBlankFloatLiteralExpr() -> FloatLiteralExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .floatLiteralExpr,
layout: [
RawSyntax.missingToken(TokenKind.floatingLiteral("")),
], length: .zero, presence: .present))
return FloatLiteralExprSyntax(data)
}
public static func makeTupleExpr(leftParen: TokenSyntax, elementList: TupleExprElementListSyntax, rightParen: TokenSyntax) -> TupleExprSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
elementList.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tupleExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TupleExprSyntax(data)
}
public static func makeBlankTupleExpr() -> TupleExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tupleExpr,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.tupleExprElementList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return TupleExprSyntax(data)
}
public static func makeArrayExpr(leftSquare: TokenSyntax, elements: ArrayElementListSyntax, rightSquare: TokenSyntax) -> ArrayExprSyntax {
let layout: [RawSyntax?] = [
leftSquare.raw,
elements.raw,
rightSquare.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.arrayExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ArrayExprSyntax(data)
}
public static func makeBlankArrayExpr() -> ArrayExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .arrayExpr,
layout: [
RawSyntax.missingToken(TokenKind.leftSquareBracket),
RawSyntax.missing(SyntaxKind.arrayElementList),
RawSyntax.missingToken(TokenKind.rightSquareBracket),
], length: .zero, presence: .present))
return ArrayExprSyntax(data)
}
public static func makeDictionaryExpr(leftSquare: TokenSyntax, content: Syntax, rightSquare: TokenSyntax) -> DictionaryExprSyntax {
let layout: [RawSyntax?] = [
leftSquare.raw,
content.raw,
rightSquare.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.dictionaryExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DictionaryExprSyntax(data)
}
public static func makeBlankDictionaryExpr() -> DictionaryExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .dictionaryExpr,
layout: [
RawSyntax.missingToken(TokenKind.leftSquareBracket),
RawSyntax.missing(SyntaxKind.unknown),
RawSyntax.missingToken(TokenKind.rightSquareBracket),
], length: .zero, presence: .present))
return DictionaryExprSyntax(data)
}
public static func makeTupleExprElement(label: TokenSyntax?, colon: TokenSyntax?, expression: ExprSyntax, trailingComma: TokenSyntax?) -> TupleExprElementSyntax {
let layout: [RawSyntax?] = [
label?.raw,
colon?.raw,
expression.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tupleExprElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TupleExprElementSyntax(data)
}
public static func makeBlankTupleExprElement() -> TupleExprElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tupleExprElement,
layout: [
nil,
nil,
RawSyntax.missing(SyntaxKind.expr),
nil,
], length: .zero, presence: .present))
return TupleExprElementSyntax(data)
}
public static func makeArrayElement(expression: ExprSyntax, trailingComma: TokenSyntax?) -> ArrayElementSyntax {
let layout: [RawSyntax?] = [
expression.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.arrayElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ArrayElementSyntax(data)
}
public static func makeBlankArrayElement() -> ArrayElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .arrayElement,
layout: [
RawSyntax.missing(SyntaxKind.expr),
nil,
], length: .zero, presence: .present))
return ArrayElementSyntax(data)
}
public static func makeDictionaryElement(keyExpression: ExprSyntax, colon: TokenSyntax, valueExpression: ExprSyntax, trailingComma: TokenSyntax?) -> DictionaryElementSyntax {
let layout: [RawSyntax?] = [
keyExpression.raw,
colon.raw,
valueExpression.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.dictionaryElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DictionaryElementSyntax(data)
}
public static func makeBlankDictionaryElement() -> DictionaryElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .dictionaryElement,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.expr),
nil,
], length: .zero, presence: .present))
return DictionaryElementSyntax(data)
}
public static func makeIntegerLiteralExpr(digits: TokenSyntax) -> IntegerLiteralExprSyntax {
let layout: [RawSyntax?] = [
digits.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.integerLiteralExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IntegerLiteralExprSyntax(data)
}
public static func makeBlankIntegerLiteralExpr() -> IntegerLiteralExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .integerLiteralExpr,
layout: [
RawSyntax.missingToken(TokenKind.integerLiteral("")),
], length: .zero, presence: .present))
return IntegerLiteralExprSyntax(data)
}
public static func makeBooleanLiteralExpr(booleanLiteral: TokenSyntax) -> BooleanLiteralExprSyntax {
let layout: [RawSyntax?] = [
booleanLiteral.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.booleanLiteralExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return BooleanLiteralExprSyntax(data)
}
public static func makeBlankBooleanLiteralExpr() -> BooleanLiteralExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .booleanLiteralExpr,
layout: [
RawSyntax.missingToken(TokenKind.trueKeyword),
], length: .zero, presence: .present))
return BooleanLiteralExprSyntax(data)
}
public static func makeTernaryExpr(conditionExpression: ExprSyntax, questionMark: TokenSyntax, firstChoice: ExprSyntax, colonMark: TokenSyntax, secondChoice: ExprSyntax) -> TernaryExprSyntax {
let layout: [RawSyntax?] = [
conditionExpression.raw,
questionMark.raw,
firstChoice.raw,
colonMark.raw,
secondChoice.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.ternaryExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TernaryExprSyntax(data)
}
public static func makeBlankTernaryExpr() -> TernaryExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .ternaryExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.infixQuestionMark),
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return TernaryExprSyntax(data)
}
public static func makeMemberAccessExpr(base: ExprSyntax?, dot: TokenSyntax, name: TokenSyntax, declNameArguments: DeclNameArgumentsSyntax?) -> MemberAccessExprSyntax {
let layout: [RawSyntax?] = [
base?.raw,
dot.raw,
name.raw,
declNameArguments?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.memberAccessExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MemberAccessExprSyntax(data)
}
public static func makeBlankMemberAccessExpr() -> MemberAccessExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .memberAccessExpr,
layout: [
nil,
RawSyntax.missingToken(TokenKind.period),
RawSyntax.missingToken(TokenKind.unknown("")),
nil,
], length: .zero, presence: .present))
return MemberAccessExprSyntax(data)
}
public static func makeIsExpr(isTok: TokenSyntax, typeName: TypeSyntax) -> IsExprSyntax {
let layout: [RawSyntax?] = [
isTok.raw,
typeName.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.isExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IsExprSyntax(data)
}
public static func makeBlankIsExpr() -> IsExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .isExpr,
layout: [
RawSyntax.missingToken(TokenKind.isKeyword),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return IsExprSyntax(data)
}
public static func makeAsExpr(asTok: TokenSyntax, questionOrExclamationMark: TokenSyntax?, typeName: TypeSyntax) -> AsExprSyntax {
let layout: [RawSyntax?] = [
asTok.raw,
questionOrExclamationMark?.raw,
typeName.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.asExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AsExprSyntax(data)
}
public static func makeBlankAsExpr() -> AsExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .asExpr,
layout: [
RawSyntax.missingToken(TokenKind.asKeyword),
nil,
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return AsExprSyntax(data)
}
public static func makeTypeExpr(type: TypeSyntax) -> TypeExprSyntax {
let layout: [RawSyntax?] = [
type.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.typeExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TypeExprSyntax(data)
}
public static func makeBlankTypeExpr() -> TypeExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .typeExpr,
layout: [
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return TypeExprSyntax(data)
}
public static func makeClosureCaptureItem(specifier: TokenListSyntax?, name: TokenSyntax?, assignToken: TokenSyntax?, expression: ExprSyntax, trailingComma: TokenSyntax?) -> ClosureCaptureItemSyntax {
let layout: [RawSyntax?] = [
specifier?.raw,
name?.raw,
assignToken?.raw,
expression.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.closureCaptureItem,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClosureCaptureItemSyntax(data)
}
public static func makeBlankClosureCaptureItem() -> ClosureCaptureItemSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .closureCaptureItem,
layout: [
nil,
nil,
nil,
RawSyntax.missing(SyntaxKind.expr),
nil,
], length: .zero, presence: .present))
return ClosureCaptureItemSyntax(data)
}
public static func makeClosureCaptureItemList(
_ elements: [ClosureCaptureItemSyntax]) -> ClosureCaptureItemListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.closureCaptureItemList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClosureCaptureItemListSyntax(data)
}
public static func makeBlankClosureCaptureItemList() -> ClosureCaptureItemListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .closureCaptureItemList,
layout: [
], length: .zero, presence: .present))
return ClosureCaptureItemListSyntax(data)
}
public static func makeClosureCaptureSignature(leftSquare: TokenSyntax, items: ClosureCaptureItemListSyntax?, rightSquare: TokenSyntax) -> ClosureCaptureSignatureSyntax {
let layout: [RawSyntax?] = [
leftSquare.raw,
items?.raw,
rightSquare.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.closureCaptureSignature,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClosureCaptureSignatureSyntax(data)
}
public static func makeBlankClosureCaptureSignature() -> ClosureCaptureSignatureSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .closureCaptureSignature,
layout: [
RawSyntax.missingToken(TokenKind.leftSquareBracket),
nil,
RawSyntax.missingToken(TokenKind.rightSquareBracket),
], length: .zero, presence: .present))
return ClosureCaptureSignatureSyntax(data)
}
public static func makeClosureParam(name: TokenSyntax, trailingComma: TokenSyntax?) -> ClosureParamSyntax {
let layout: [RawSyntax?] = [
name.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.closureParam,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClosureParamSyntax(data)
}
public static func makeBlankClosureParam() -> ClosureParamSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .closureParam,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return ClosureParamSyntax(data)
}
public static func makeClosureParamList(
_ elements: [ClosureParamSyntax]) -> ClosureParamListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.closureParamList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClosureParamListSyntax(data)
}
public static func makeBlankClosureParamList() -> ClosureParamListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .closureParamList,
layout: [
], length: .zero, presence: .present))
return ClosureParamListSyntax(data)
}
public static func makeClosureSignature(attributes: AttributeListSyntax?, capture: ClosureCaptureSignatureSyntax?, input: Syntax?, asyncKeyword: TokenSyntax?, throwsTok: TokenSyntax?, output: ReturnClauseSyntax?, inTok: TokenSyntax) -> ClosureSignatureSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
capture?.raw,
input?.raw,
asyncKeyword?.raw,
throwsTok?.raw,
output?.raw,
inTok.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.closureSignature,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClosureSignatureSyntax(data)
}
public static func makeBlankClosureSignature() -> ClosureSignatureSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .closureSignature,
layout: [
nil,
nil,
nil,
nil,
nil,
nil,
RawSyntax.missingToken(TokenKind.inKeyword),
], length: .zero, presence: .present))
return ClosureSignatureSyntax(data)
}
public static func makeClosureExpr(leftBrace: TokenSyntax, signature: ClosureSignatureSyntax?, statements: CodeBlockItemListSyntax, rightBrace: TokenSyntax) -> ClosureExprSyntax {
let layout: [RawSyntax?] = [
leftBrace.raw,
signature?.raw,
statements.raw,
rightBrace.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.closureExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClosureExprSyntax(data)
}
public static func makeBlankClosureExpr() -> ClosureExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .closureExpr,
layout: [
RawSyntax.missingToken(TokenKind.leftBrace),
nil,
RawSyntax.missing(SyntaxKind.codeBlockItemList),
RawSyntax.missingToken(TokenKind.rightBrace),
], length: .zero, presence: .present))
return ClosureExprSyntax(data)
}
public static func makeUnresolvedPatternExpr(pattern: PatternSyntax) -> UnresolvedPatternExprSyntax {
let layout: [RawSyntax?] = [
pattern.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.unresolvedPatternExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return UnresolvedPatternExprSyntax(data)
}
public static func makeBlankUnresolvedPatternExpr() -> UnresolvedPatternExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .unresolvedPatternExpr,
layout: [
RawSyntax.missing(SyntaxKind.pattern),
], length: .zero, presence: .present))
return UnresolvedPatternExprSyntax(data)
}
public static func makeMultipleTrailingClosureElement(label: TokenSyntax, colon: TokenSyntax, closure: ClosureExprSyntax) -> MultipleTrailingClosureElementSyntax {
let layout: [RawSyntax?] = [
label.raw,
colon.raw,
closure.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.multipleTrailingClosureElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MultipleTrailingClosureElementSyntax(data)
}
public static func makeBlankMultipleTrailingClosureElement() -> MultipleTrailingClosureElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .multipleTrailingClosureElement,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.closureExpr),
], length: .zero, presence: .present))
return MultipleTrailingClosureElementSyntax(data)
}
public static func makeMultipleTrailingClosureElementList(
_ elements: [MultipleTrailingClosureElementSyntax]) -> MultipleTrailingClosureElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.multipleTrailingClosureElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MultipleTrailingClosureElementListSyntax(data)
}
public static func makeBlankMultipleTrailingClosureElementList() -> MultipleTrailingClosureElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .multipleTrailingClosureElementList,
layout: [
], length: .zero, presence: .present))
return MultipleTrailingClosureElementListSyntax(data)
}
public static func makeFunctionCallExpr(calledExpression: ExprSyntax, leftParen: TokenSyntax?, argumentList: TupleExprElementListSyntax, rightParen: TokenSyntax?, trailingClosure: ClosureExprSyntax?, additionalTrailingClosures: MultipleTrailingClosureElementListSyntax?) -> FunctionCallExprSyntax {
let layout: [RawSyntax?] = [
calledExpression.raw,
leftParen?.raw,
argumentList.raw,
rightParen?.raw,
trailingClosure?.raw,
additionalTrailingClosures?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.functionCallExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FunctionCallExprSyntax(data)
}
public static func makeBlankFunctionCallExpr() -> FunctionCallExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .functionCallExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
nil,
RawSyntax.missing(SyntaxKind.tupleExprElementList),
nil,
nil,
nil,
], length: .zero, presence: .present))
return FunctionCallExprSyntax(data)
}
public static func makeSubscriptExpr(calledExpression: ExprSyntax, leftBracket: TokenSyntax, argumentList: TupleExprElementListSyntax, rightBracket: TokenSyntax, trailingClosure: ClosureExprSyntax?, additionalTrailingClosures: MultipleTrailingClosureElementListSyntax?) -> SubscriptExprSyntax {
let layout: [RawSyntax?] = [
calledExpression.raw,
leftBracket.raw,
argumentList.raw,
rightBracket.raw,
trailingClosure?.raw,
additionalTrailingClosures?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.subscriptExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SubscriptExprSyntax(data)
}
public static func makeBlankSubscriptExpr() -> SubscriptExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .subscriptExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.leftSquareBracket),
RawSyntax.missing(SyntaxKind.tupleExprElementList),
RawSyntax.missingToken(TokenKind.rightSquareBracket),
nil,
nil,
], length: .zero, presence: .present))
return SubscriptExprSyntax(data)
}
public static func makeOptionalChainingExpr(expression: ExprSyntax, questionMark: TokenSyntax) -> OptionalChainingExprSyntax {
let layout: [RawSyntax?] = [
expression.raw,
questionMark.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.optionalChainingExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return OptionalChainingExprSyntax(data)
}
public static func makeBlankOptionalChainingExpr() -> OptionalChainingExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .optionalChainingExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.postfixQuestionMark),
], length: .zero, presence: .present))
return OptionalChainingExprSyntax(data)
}
public static func makeForcedValueExpr(expression: ExprSyntax, exclamationMark: TokenSyntax) -> ForcedValueExprSyntax {
let layout: [RawSyntax?] = [
expression.raw,
exclamationMark.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.forcedValueExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ForcedValueExprSyntax(data)
}
public static func makeBlankForcedValueExpr() -> ForcedValueExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .forcedValueExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.exclamationMark),
], length: .zero, presence: .present))
return ForcedValueExprSyntax(data)
}
public static func makePostfixUnaryExpr(expression: ExprSyntax, operatorToken: TokenSyntax) -> PostfixUnaryExprSyntax {
let layout: [RawSyntax?] = [
expression.raw,
operatorToken.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.postfixUnaryExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PostfixUnaryExprSyntax(data)
}
public static func makeBlankPostfixUnaryExpr() -> PostfixUnaryExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .postfixUnaryExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.postfixOperator("")),
], length: .zero, presence: .present))
return PostfixUnaryExprSyntax(data)
}
public static func makeSpecializeExpr(expression: ExprSyntax, genericArgumentClause: GenericArgumentClauseSyntax) -> SpecializeExprSyntax {
let layout: [RawSyntax?] = [
expression.raw,
genericArgumentClause.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.specializeExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SpecializeExprSyntax(data)
}
public static func makeBlankSpecializeExpr() -> SpecializeExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .specializeExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missing(SyntaxKind.genericArgumentClause),
], length: .zero, presence: .present))
return SpecializeExprSyntax(data)
}
public static func makeStringSegment(content: TokenSyntax) -> StringSegmentSyntax {
let layout: [RawSyntax?] = [
content.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.stringSegment,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return StringSegmentSyntax(data)
}
public static func makeBlankStringSegment() -> StringSegmentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .stringSegment,
layout: [
RawSyntax.missingToken(TokenKind.stringSegment("")),
], length: .zero, presence: .present))
return StringSegmentSyntax(data)
}
public static func makeExpressionSegment(backslash: TokenSyntax, delimiter: TokenSyntax?, leftParen: TokenSyntax, expressions: TupleExprElementListSyntax, rightParen: TokenSyntax) -> ExpressionSegmentSyntax {
let layout: [RawSyntax?] = [
backslash.raw,
delimiter?.raw,
leftParen.raw,
expressions.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.expressionSegment,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ExpressionSegmentSyntax(data)
}
public static func makeBlankExpressionSegment() -> ExpressionSegmentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .expressionSegment,
layout: [
RawSyntax.missingToken(TokenKind.backslash),
nil,
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.tupleExprElementList),
RawSyntax.missingToken(TokenKind.stringInterpolationAnchor),
], length: .zero, presence: .present))
return ExpressionSegmentSyntax(data)
}
public static func makeStringLiteralExpr(openDelimiter: TokenSyntax?, openQuote: TokenSyntax, segments: StringLiteralSegmentsSyntax, closeQuote: TokenSyntax, closeDelimiter: TokenSyntax?) -> StringLiteralExprSyntax {
let layout: [RawSyntax?] = [
openDelimiter?.raw,
openQuote.raw,
segments.raw,
closeQuote.raw,
closeDelimiter?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.stringLiteralExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return StringLiteralExprSyntax(data)
}
public static func makeBlankStringLiteralExpr() -> StringLiteralExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .stringLiteralExpr,
layout: [
nil,
RawSyntax.missingToken(TokenKind.stringQuote),
RawSyntax.missing(SyntaxKind.stringLiteralSegments),
RawSyntax.missingToken(TokenKind.stringQuote),
nil,
], length: .zero, presence: .present))
return StringLiteralExprSyntax(data)
}
public static func makeKeyPathExpr(backslash: TokenSyntax, rootExpr: ExprSyntax?, expression: ExprSyntax) -> KeyPathExprSyntax {
let layout: [RawSyntax?] = [
backslash.raw,
rootExpr?.raw,
expression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.keyPathExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return KeyPathExprSyntax(data)
}
public static func makeBlankKeyPathExpr() -> KeyPathExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .keyPathExpr,
layout: [
RawSyntax.missingToken(TokenKind.backslash),
nil,
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return KeyPathExprSyntax(data)
}
public static func makeKeyPathBaseExpr(period: TokenSyntax) -> KeyPathBaseExprSyntax {
let layout: [RawSyntax?] = [
period.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.keyPathBaseExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return KeyPathBaseExprSyntax(data)
}
public static func makeBlankKeyPathBaseExpr() -> KeyPathBaseExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .keyPathBaseExpr,
layout: [
RawSyntax.missingToken(TokenKind.period),
], length: .zero, presence: .present))
return KeyPathBaseExprSyntax(data)
}
public static func makeObjcNamePiece(name: TokenSyntax, dot: TokenSyntax?) -> ObjcNamePieceSyntax {
let layout: [RawSyntax?] = [
name.raw,
dot?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.objcNamePiece,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ObjcNamePieceSyntax(data)
}
public static func makeBlankObjcNamePiece() -> ObjcNamePieceSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .objcNamePiece,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return ObjcNamePieceSyntax(data)
}
public static func makeObjcName(
_ elements: [ObjcNamePieceSyntax]) -> ObjcNameSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.objcName,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ObjcNameSyntax(data)
}
public static func makeBlankObjcName() -> ObjcNameSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .objcName,
layout: [
], length: .zero, presence: .present))
return ObjcNameSyntax(data)
}
public static func makeObjcKeyPathExpr(keyPath: TokenSyntax, leftParen: TokenSyntax, name: ObjcNameSyntax, rightParen: TokenSyntax) -> ObjcKeyPathExprSyntax {
let layout: [RawSyntax?] = [
keyPath.raw,
leftParen.raw,
name.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.objcKeyPathExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ObjcKeyPathExprSyntax(data)
}
public static func makeBlankObjcKeyPathExpr() -> ObjcKeyPathExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .objcKeyPathExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundKeyPathKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.objcName),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return ObjcKeyPathExprSyntax(data)
}
public static func makeObjcSelectorExpr(poundSelector: TokenSyntax, leftParen: TokenSyntax, kind: TokenSyntax?, colon: TokenSyntax?, name: ExprSyntax, rightParen: TokenSyntax) -> ObjcSelectorExprSyntax {
let layout: [RawSyntax?] = [
poundSelector.raw,
leftParen.raw,
kind?.raw,
colon?.raw,
name.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.objcSelectorExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ObjcSelectorExprSyntax(data)
}
public static func makeBlankObjcSelectorExpr() -> ObjcSelectorExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .objcSelectorExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundSelectorKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
nil,
nil,
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return ObjcSelectorExprSyntax(data)
}
public static func makePostfixIfConfigExpr(base: ExprSyntax, config: IfConfigDeclSyntax) -> PostfixIfConfigExprSyntax {
let layout: [RawSyntax?] = [
base.raw,
config.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.postfixIfConfigExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PostfixIfConfigExprSyntax(data)
}
public static func makeBlankPostfixIfConfigExpr() -> PostfixIfConfigExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .postfixIfConfigExpr,
layout: [
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missing(SyntaxKind.ifConfigDecl),
], length: .zero, presence: .present))
return PostfixIfConfigExprSyntax(data)
}
public static func makeEditorPlaceholderExpr(identifier: TokenSyntax) -> EditorPlaceholderExprSyntax {
let layout: [RawSyntax?] = [
identifier.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.editorPlaceholderExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return EditorPlaceholderExprSyntax(data)
}
public static func makeBlankEditorPlaceholderExpr() -> EditorPlaceholderExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .editorPlaceholderExpr,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
], length: .zero, presence: .present))
return EditorPlaceholderExprSyntax(data)
}
public static func makeObjectLiteralExpr(identifier: TokenSyntax, leftParen: TokenSyntax, arguments: TupleExprElementListSyntax, rightParen: TokenSyntax) -> ObjectLiteralExprSyntax {
let layout: [RawSyntax?] = [
identifier.raw,
leftParen.raw,
arguments.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.objectLiteralExpr,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ObjectLiteralExprSyntax(data)
}
public static func makeBlankObjectLiteralExpr() -> ObjectLiteralExprSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .objectLiteralExpr,
layout: [
RawSyntax.missingToken(TokenKind.poundColorLiteralKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.tupleExprElementList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return ObjectLiteralExprSyntax(data)
}
public static func makeTypeInitializerClause(equal: TokenSyntax, value: TypeSyntax) -> TypeInitializerClauseSyntax {
let layout: [RawSyntax?] = [
equal.raw,
value.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.typeInitializerClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TypeInitializerClauseSyntax(data)
}
public static func makeBlankTypeInitializerClause() -> TypeInitializerClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .typeInitializerClause,
layout: [
RawSyntax.missingToken(TokenKind.equal),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return TypeInitializerClauseSyntax(data)
}
public static func makeTypealiasDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, typealiasKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, initializer: TypeInitializerClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?) -> TypealiasDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
typealiasKeyword.raw,
identifier.raw,
genericParameterClause?.raw,
initializer?.raw,
genericWhereClause?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.typealiasDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TypealiasDeclSyntax(data)
}
public static func makeBlankTypealiasDecl() -> TypealiasDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .typealiasDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.typealiasKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
], length: .zero, presence: .present))
return TypealiasDeclSyntax(data)
}
public static func makeAssociatedtypeDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, associatedtypeKeyword: TokenSyntax, identifier: TokenSyntax, inheritanceClause: TypeInheritanceClauseSyntax?, initializer: TypeInitializerClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?) -> AssociatedtypeDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
associatedtypeKeyword.raw,
identifier.raw,
inheritanceClause?.raw,
initializer?.raw,
genericWhereClause?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.associatedtypeDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AssociatedtypeDeclSyntax(data)
}
public static func makeBlankAssociatedtypeDecl() -> AssociatedtypeDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .associatedtypeDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.associatedtypeKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
], length: .zero, presence: .present))
return AssociatedtypeDeclSyntax(data)
}
public static func makeFunctionParameterList(
_ elements: [FunctionParameterSyntax]) -> FunctionParameterListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.functionParameterList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FunctionParameterListSyntax(data)
}
public static func makeBlankFunctionParameterList() -> FunctionParameterListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .functionParameterList,
layout: [
], length: .zero, presence: .present))
return FunctionParameterListSyntax(data)
}
public static func makeParameterClause(leftParen: TokenSyntax, parameterList: FunctionParameterListSyntax, rightParen: TokenSyntax) -> ParameterClauseSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
parameterList.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.parameterClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ParameterClauseSyntax(data)
}
public static func makeBlankParameterClause() -> ParameterClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .parameterClause,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.functionParameterList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return ParameterClauseSyntax(data)
}
public static func makeReturnClause(arrow: TokenSyntax, returnType: TypeSyntax) -> ReturnClauseSyntax {
let layout: [RawSyntax?] = [
arrow.raw,
returnType.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.returnClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ReturnClauseSyntax(data)
}
public static func makeBlankReturnClause() -> ReturnClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .returnClause,
layout: [
RawSyntax.missingToken(TokenKind.arrow),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return ReturnClauseSyntax(data)
}
public static func makeFunctionSignature(input: ParameterClauseSyntax, asyncOrReasyncKeyword: TokenSyntax?, throwsOrRethrowsKeyword: TokenSyntax?, output: ReturnClauseSyntax?) -> FunctionSignatureSyntax {
let layout: [RawSyntax?] = [
input.raw,
asyncOrReasyncKeyword?.raw,
throwsOrRethrowsKeyword?.raw,
output?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.functionSignature,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FunctionSignatureSyntax(data)
}
public static func makeBlankFunctionSignature() -> FunctionSignatureSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .functionSignature,
layout: [
RawSyntax.missing(SyntaxKind.parameterClause),
nil,
nil,
nil,
], length: .zero, presence: .present))
return FunctionSignatureSyntax(data)
}
public static func makeIfConfigClause(poundKeyword: TokenSyntax, condition: ExprSyntax?, elements: Syntax) -> IfConfigClauseSyntax {
let layout: [RawSyntax?] = [
poundKeyword.raw,
condition?.raw,
elements.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.ifConfigClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IfConfigClauseSyntax(data)
}
public static func makeBlankIfConfigClause() -> IfConfigClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .ifConfigClause,
layout: [
RawSyntax.missingToken(TokenKind.poundIfKeyword),
nil,
RawSyntax.missing(SyntaxKind.unknown),
], length: .zero, presence: .present))
return IfConfigClauseSyntax(data)
}
public static func makeIfConfigClauseList(
_ elements: [IfConfigClauseSyntax]) -> IfConfigClauseListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.ifConfigClauseList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IfConfigClauseListSyntax(data)
}
public static func makeBlankIfConfigClauseList() -> IfConfigClauseListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .ifConfigClauseList,
layout: [
], length: .zero, presence: .present))
return IfConfigClauseListSyntax(data)
}
public static func makeIfConfigDecl(clauses: IfConfigClauseListSyntax, poundEndif: TokenSyntax) -> IfConfigDeclSyntax {
let layout: [RawSyntax?] = [
clauses.raw,
poundEndif.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.ifConfigDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IfConfigDeclSyntax(data)
}
public static func makeBlankIfConfigDecl() -> IfConfigDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .ifConfigDecl,
layout: [
RawSyntax.missing(SyntaxKind.ifConfigClauseList),
RawSyntax.missingToken(TokenKind.poundEndifKeyword),
], length: .zero, presence: .present))
return IfConfigDeclSyntax(data)
}
public static func makePoundErrorDecl(poundError: TokenSyntax, leftParen: TokenSyntax, message: StringLiteralExprSyntax, rightParen: TokenSyntax) -> PoundErrorDeclSyntax {
let layout: [RawSyntax?] = [
poundError.raw,
leftParen.raw,
message.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundErrorDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundErrorDeclSyntax(data)
}
public static func makeBlankPoundErrorDecl() -> PoundErrorDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundErrorDecl,
layout: [
RawSyntax.missingToken(TokenKind.poundErrorKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.stringLiteralExpr),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return PoundErrorDeclSyntax(data)
}
public static func makePoundWarningDecl(poundWarning: TokenSyntax, leftParen: TokenSyntax, message: StringLiteralExprSyntax, rightParen: TokenSyntax) -> PoundWarningDeclSyntax {
let layout: [RawSyntax?] = [
poundWarning.raw,
leftParen.raw,
message.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundWarningDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundWarningDeclSyntax(data)
}
public static func makeBlankPoundWarningDecl() -> PoundWarningDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundWarningDecl,
layout: [
RawSyntax.missingToken(TokenKind.poundWarningKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.stringLiteralExpr),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return PoundWarningDeclSyntax(data)
}
public static func makePoundSourceLocation(poundSourceLocation: TokenSyntax, leftParen: TokenSyntax, args: PoundSourceLocationArgsSyntax?, rightParen: TokenSyntax) -> PoundSourceLocationSyntax {
let layout: [RawSyntax?] = [
poundSourceLocation.raw,
leftParen.raw,
args?.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundSourceLocation,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundSourceLocationSyntax(data)
}
public static func makeBlankPoundSourceLocation() -> PoundSourceLocationSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundSourceLocation,
layout: [
RawSyntax.missingToken(TokenKind.poundSourceLocationKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
nil,
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return PoundSourceLocationSyntax(data)
}
public static func makePoundSourceLocationArgs(fileArgLabel: TokenSyntax, fileArgColon: TokenSyntax, fileName: TokenSyntax, comma: TokenSyntax, lineArgLabel: TokenSyntax, lineArgColon: TokenSyntax, lineNumber: TokenSyntax) -> PoundSourceLocationArgsSyntax {
let layout: [RawSyntax?] = [
fileArgLabel.raw,
fileArgColon.raw,
fileName.raw,
comma.raw,
lineArgLabel.raw,
lineArgColon.raw,
lineNumber.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundSourceLocationArgs,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundSourceLocationArgsSyntax(data)
}
public static func makeBlankPoundSourceLocationArgs() -> PoundSourceLocationArgsSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundSourceLocationArgs,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missingToken(TokenKind.stringLiteral("")),
RawSyntax.missingToken(TokenKind.comma),
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missingToken(TokenKind.integerLiteral("")),
], length: .zero, presence: .present))
return PoundSourceLocationArgsSyntax(data)
}
public static func makeDeclModifier(name: TokenSyntax, detailLeftParen: TokenSyntax?, detail: TokenSyntax?, detailRightParen: TokenSyntax?) -> DeclModifierSyntax {
let layout: [RawSyntax?] = [
name.raw,
detailLeftParen?.raw,
detail?.raw,
detailRightParen?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.declModifier,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeclModifierSyntax(data)
}
public static func makeBlankDeclModifier() -> DeclModifierSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .declModifier,
layout: [
RawSyntax.missingToken(TokenKind.unknown("")),
nil,
nil,
nil,
], length: .zero, presence: .present))
return DeclModifierSyntax(data)
}
public static func makeInheritedType(typeName: TypeSyntax, trailingComma: TokenSyntax?) -> InheritedTypeSyntax {
let layout: [RawSyntax?] = [
typeName.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.inheritedType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return InheritedTypeSyntax(data)
}
public static func makeBlankInheritedType() -> InheritedTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .inheritedType,
layout: [
RawSyntax.missing(SyntaxKind.type),
nil,
], length: .zero, presence: .present))
return InheritedTypeSyntax(data)
}
public static func makeInheritedTypeList(
_ elements: [InheritedTypeSyntax]) -> InheritedTypeListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.inheritedTypeList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return InheritedTypeListSyntax(data)
}
public static func makeBlankInheritedTypeList() -> InheritedTypeListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .inheritedTypeList,
layout: [
], length: .zero, presence: .present))
return InheritedTypeListSyntax(data)
}
public static func makeTypeInheritanceClause(colon: TokenSyntax, inheritedTypeCollection: InheritedTypeListSyntax) -> TypeInheritanceClauseSyntax {
let layout: [RawSyntax?] = [
colon.raw,
inheritedTypeCollection.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.typeInheritanceClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TypeInheritanceClauseSyntax(data)
}
public static func makeBlankTypeInheritanceClause() -> TypeInheritanceClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .typeInheritanceClause,
layout: [
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.inheritedTypeList),
], length: .zero, presence: .present))
return TypeInheritanceClauseSyntax(data)
}
public static func makeClassDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, classOrActorKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ClassDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
classOrActorKeyword.raw,
identifier.raw,
genericParameterClause?.raw,
inheritanceClause?.raw,
genericWhereClause?.raw,
members.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.classDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClassDeclSyntax(data)
}
public static func makeBlankClassDecl() -> ClassDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .classDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.classKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
RawSyntax.missing(SyntaxKind.memberDeclBlock),
], length: .zero, presence: .present))
return ClassDeclSyntax(data)
}
public static func makeStructDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, structKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> StructDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
structKeyword.raw,
identifier.raw,
genericParameterClause?.raw,
inheritanceClause?.raw,
genericWhereClause?.raw,
members.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.structDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return StructDeclSyntax(data)
}
public static func makeBlankStructDecl() -> StructDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .structDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.structKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
RawSyntax.missing(SyntaxKind.memberDeclBlock),
], length: .zero, presence: .present))
return StructDeclSyntax(data)
}
public static func makeProtocolDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, protocolKeyword: TokenSyntax, identifier: TokenSyntax, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ProtocolDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
protocolKeyword.raw,
identifier.raw,
inheritanceClause?.raw,
genericWhereClause?.raw,
members.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.protocolDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ProtocolDeclSyntax(data)
}
public static func makeBlankProtocolDecl() -> ProtocolDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .protocolDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.protocolKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
RawSyntax.missing(SyntaxKind.memberDeclBlock),
], length: .zero, presence: .present))
return ProtocolDeclSyntax(data)
}
public static func makeExtensionDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, extensionKeyword: TokenSyntax, extendedType: TypeSyntax, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ExtensionDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
extensionKeyword.raw,
extendedType.raw,
inheritanceClause?.raw,
genericWhereClause?.raw,
members.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.extensionDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ExtensionDeclSyntax(data)
}
public static func makeBlankExtensionDecl() -> ExtensionDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .extensionDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.extensionKeyword),
RawSyntax.missing(SyntaxKind.type),
nil,
nil,
RawSyntax.missing(SyntaxKind.memberDeclBlock),
], length: .zero, presence: .present))
return ExtensionDeclSyntax(data)
}
public static func makeMemberDeclBlock(leftBrace: TokenSyntax, members: MemberDeclListSyntax, rightBrace: TokenSyntax) -> MemberDeclBlockSyntax {
let layout: [RawSyntax?] = [
leftBrace.raw,
members.raw,
rightBrace.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.memberDeclBlock,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MemberDeclBlockSyntax(data)
}
public static func makeBlankMemberDeclBlock() -> MemberDeclBlockSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .memberDeclBlock,
layout: [
RawSyntax.missingToken(TokenKind.leftBrace),
RawSyntax.missing(SyntaxKind.memberDeclList),
RawSyntax.missingToken(TokenKind.rightBrace),
], length: .zero, presence: .present))
return MemberDeclBlockSyntax(data)
}
public static func makeMemberDeclList(
_ elements: [MemberDeclListItemSyntax]) -> MemberDeclListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.memberDeclList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MemberDeclListSyntax(data)
}
public static func makeBlankMemberDeclList() -> MemberDeclListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .memberDeclList,
layout: [
], length: .zero, presence: .present))
return MemberDeclListSyntax(data)
}
public static func makeMemberDeclListItem(decl: DeclSyntax, semicolon: TokenSyntax?) -> MemberDeclListItemSyntax {
let layout: [RawSyntax?] = [
decl.raw,
semicolon?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.memberDeclListItem,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MemberDeclListItemSyntax(data)
}
public static func makeBlankMemberDeclListItem() -> MemberDeclListItemSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .memberDeclListItem,
layout: [
RawSyntax.missing(SyntaxKind.decl),
nil,
], length: .zero, presence: .present))
return MemberDeclListItemSyntax(data)
}
public static func makeSourceFile(statements: CodeBlockItemListSyntax, eofToken: TokenSyntax) -> SourceFileSyntax {
let layout: [RawSyntax?] = [
statements.raw,
eofToken.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.sourceFile,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SourceFileSyntax(data)
}
public static func makeBlankSourceFile() -> SourceFileSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .sourceFile,
layout: [
RawSyntax.missing(SyntaxKind.codeBlockItemList),
RawSyntax.missingToken(TokenKind.unknown("")),
], length: .zero, presence: .present))
return SourceFileSyntax(data)
}
public static func makeInitializerClause(equal: TokenSyntax, value: ExprSyntax) -> InitializerClauseSyntax {
let layout: [RawSyntax?] = [
equal.raw,
value.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.initializerClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return InitializerClauseSyntax(data)
}
public static func makeBlankInitializerClause() -> InitializerClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .initializerClause,
layout: [
RawSyntax.missingToken(TokenKind.equal),
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return InitializerClauseSyntax(data)
}
public static func makeFunctionParameter(attributes: AttributeListSyntax?, firstName: TokenSyntax?, secondName: TokenSyntax?, colon: TokenSyntax?, type: TypeSyntax?, ellipsis: TokenSyntax?, defaultArgument: InitializerClauseSyntax?, trailingComma: TokenSyntax?) -> FunctionParameterSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
firstName?.raw,
secondName?.raw,
colon?.raw,
type?.raw,
ellipsis?.raw,
defaultArgument?.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.functionParameter,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FunctionParameterSyntax(data)
}
public static func makeBlankFunctionParameter() -> FunctionParameterSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .functionParameter,
layout: [
nil,
nil,
nil,
nil,
nil,
nil,
nil,
nil,
], length: .zero, presence: .present))
return FunctionParameterSyntax(data)
}
public static func makeModifierList(
_ elements: [DeclModifierSyntax]) -> ModifierListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.modifierList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ModifierListSyntax(data)
}
public static func makeBlankModifierList() -> ModifierListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .modifierList,
layout: [
], length: .zero, presence: .present))
return ModifierListSyntax(data)
}
public static func makeFunctionDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, funcKeyword: TokenSyntax, identifier: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, signature: FunctionSignatureSyntax, genericWhereClause: GenericWhereClauseSyntax?, body: CodeBlockSyntax?) -> FunctionDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
funcKeyword.raw,
identifier.raw,
genericParameterClause?.raw,
signature.raw,
genericWhereClause?.raw,
body?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.functionDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FunctionDeclSyntax(data)
}
public static func makeBlankFunctionDecl() -> FunctionDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .functionDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.funcKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
RawSyntax.missing(SyntaxKind.functionSignature),
nil,
nil,
], length: .zero, presence: .present))
return FunctionDeclSyntax(data)
}
public static func makeInitializerDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, initKeyword: TokenSyntax, optionalMark: TokenSyntax?, genericParameterClause: GenericParameterClauseSyntax?, parameters: ParameterClauseSyntax, throwsOrRethrowsKeyword: TokenSyntax?, genericWhereClause: GenericWhereClauseSyntax?, body: CodeBlockSyntax?) -> InitializerDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
initKeyword.raw,
optionalMark?.raw,
genericParameterClause?.raw,
parameters.raw,
throwsOrRethrowsKeyword?.raw,
genericWhereClause?.raw,
body?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.initializerDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return InitializerDeclSyntax(data)
}
public static func makeBlankInitializerDecl() -> InitializerDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .initializerDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.initKeyword),
nil,
nil,
RawSyntax.missing(SyntaxKind.parameterClause),
nil,
nil,
nil,
], length: .zero, presence: .present))
return InitializerDeclSyntax(data)
}
public static func makeDeinitializerDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, deinitKeyword: TokenSyntax, body: CodeBlockSyntax) -> DeinitializerDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
deinitKeyword.raw,
body.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.deinitializerDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeinitializerDeclSyntax(data)
}
public static func makeBlankDeinitializerDecl() -> DeinitializerDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .deinitializerDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.deinitKeyword),
RawSyntax.missing(SyntaxKind.codeBlock),
], length: .zero, presence: .present))
return DeinitializerDeclSyntax(data)
}
public static func makeSubscriptDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, subscriptKeyword: TokenSyntax, genericParameterClause: GenericParameterClauseSyntax?, indices: ParameterClauseSyntax, result: ReturnClauseSyntax, genericWhereClause: GenericWhereClauseSyntax?, accessor: Syntax?) -> SubscriptDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
subscriptKeyword.raw,
genericParameterClause?.raw,
indices.raw,
result.raw,
genericWhereClause?.raw,
accessor?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.subscriptDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SubscriptDeclSyntax(data)
}
public static func makeBlankSubscriptDecl() -> SubscriptDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .subscriptDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.subscriptKeyword),
nil,
RawSyntax.missing(SyntaxKind.parameterClause),
RawSyntax.missing(SyntaxKind.returnClause),
nil,
nil,
], length: .zero, presence: .present))
return SubscriptDeclSyntax(data)
}
public static func makeAccessLevelModifier(name: TokenSyntax, leftParen: TokenSyntax?, modifier: TokenSyntax?, rightParen: TokenSyntax?) -> AccessLevelModifierSyntax {
let layout: [RawSyntax?] = [
name.raw,
leftParen?.raw,
modifier?.raw,
rightParen?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.accessLevelModifier,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AccessLevelModifierSyntax(data)
}
public static func makeBlankAccessLevelModifier() -> AccessLevelModifierSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .accessLevelModifier,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
], length: .zero, presence: .present))
return AccessLevelModifierSyntax(data)
}
public static func makeAccessPathComponent(name: TokenSyntax, trailingDot: TokenSyntax?) -> AccessPathComponentSyntax {
let layout: [RawSyntax?] = [
name.raw,
trailingDot?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.accessPathComponent,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AccessPathComponentSyntax(data)
}
public static func makeBlankAccessPathComponent() -> AccessPathComponentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .accessPathComponent,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return AccessPathComponentSyntax(data)
}
public static func makeAccessPath(
_ elements: [AccessPathComponentSyntax]) -> AccessPathSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.accessPath,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AccessPathSyntax(data)
}
public static func makeBlankAccessPath() -> AccessPathSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .accessPath,
layout: [
], length: .zero, presence: .present))
return AccessPathSyntax(data)
}
public static func makeImportDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, importTok: TokenSyntax, importKind: TokenSyntax?, path: AccessPathSyntax) -> ImportDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
importTok.raw,
importKind?.raw,
path.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.importDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ImportDeclSyntax(data)
}
public static func makeBlankImportDecl() -> ImportDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .importDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.importKeyword),
nil,
RawSyntax.missing(SyntaxKind.accessPath),
], length: .zero, presence: .present))
return ImportDeclSyntax(data)
}
public static func makeAccessorParameter(leftParen: TokenSyntax, name: TokenSyntax, rightParen: TokenSyntax) -> AccessorParameterSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
name.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.accessorParameter,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AccessorParameterSyntax(data)
}
public static func makeBlankAccessorParameter() -> AccessorParameterSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .accessorParameter,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return AccessorParameterSyntax(data)
}
public static func makeAccessorDecl(attributes: AttributeListSyntax?, modifier: DeclModifierSyntax?, accessorKind: TokenSyntax, parameter: AccessorParameterSyntax?, asyncKeyword: TokenSyntax?, throwsKeyword: TokenSyntax?, body: CodeBlockSyntax?) -> AccessorDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifier?.raw,
accessorKind.raw,
parameter?.raw,
asyncKeyword?.raw,
throwsKeyword?.raw,
body?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.accessorDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AccessorDeclSyntax(data)
}
public static func makeBlankAccessorDecl() -> AccessorDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .accessorDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.unknown("")),
nil,
nil,
nil,
nil,
], length: .zero, presence: .present))
return AccessorDeclSyntax(data)
}
public static func makeAccessorList(
_ elements: [AccessorDeclSyntax]) -> AccessorListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.accessorList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AccessorListSyntax(data)
}
public static func makeBlankAccessorList() -> AccessorListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .accessorList,
layout: [
], length: .zero, presence: .present))
return AccessorListSyntax(data)
}
public static func makeAccessorBlock(leftBrace: TokenSyntax, accessors: AccessorListSyntax, rightBrace: TokenSyntax) -> AccessorBlockSyntax {
let layout: [RawSyntax?] = [
leftBrace.raw,
accessors.raw,
rightBrace.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.accessorBlock,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AccessorBlockSyntax(data)
}
public static func makeBlankAccessorBlock() -> AccessorBlockSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .accessorBlock,
layout: [
RawSyntax.missingToken(TokenKind.leftBrace),
RawSyntax.missing(SyntaxKind.accessorList),
RawSyntax.missingToken(TokenKind.rightBrace),
], length: .zero, presence: .present))
return AccessorBlockSyntax(data)
}
public static func makePatternBinding(pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax?, accessor: Syntax?, trailingComma: TokenSyntax?) -> PatternBindingSyntax {
let layout: [RawSyntax?] = [
pattern.raw,
typeAnnotation?.raw,
initializer?.raw,
accessor?.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.patternBinding,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PatternBindingSyntax(data)
}
public static func makeBlankPatternBinding() -> PatternBindingSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .patternBinding,
layout: [
RawSyntax.missing(SyntaxKind.pattern),
nil,
nil,
nil,
nil,
], length: .zero, presence: .present))
return PatternBindingSyntax(data)
}
public static func makePatternBindingList(
_ elements: [PatternBindingSyntax]) -> PatternBindingListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.patternBindingList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PatternBindingListSyntax(data)
}
public static func makeBlankPatternBindingList() -> PatternBindingListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .patternBindingList,
layout: [
], length: .zero, presence: .present))
return PatternBindingListSyntax(data)
}
public static func makeVariableDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, letOrVarKeyword: TokenSyntax, bindings: PatternBindingListSyntax) -> VariableDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
letOrVarKeyword.raw,
bindings.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.variableDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return VariableDeclSyntax(data)
}
public static func makeBlankVariableDecl() -> VariableDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .variableDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.letKeyword),
RawSyntax.missing(SyntaxKind.patternBindingList),
], length: .zero, presence: .present))
return VariableDeclSyntax(data)
}
public static func makeEnumCaseElement(identifier: TokenSyntax, associatedValue: ParameterClauseSyntax?, rawValue: InitializerClauseSyntax?, trailingComma: TokenSyntax?) -> EnumCaseElementSyntax {
let layout: [RawSyntax?] = [
identifier.raw,
associatedValue?.raw,
rawValue?.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.enumCaseElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return EnumCaseElementSyntax(data)
}
public static func makeBlankEnumCaseElement() -> EnumCaseElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .enumCaseElement,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
], length: .zero, presence: .present))
return EnumCaseElementSyntax(data)
}
public static func makeEnumCaseElementList(
_ elements: [EnumCaseElementSyntax]) -> EnumCaseElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.enumCaseElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return EnumCaseElementListSyntax(data)
}
public static func makeBlankEnumCaseElementList() -> EnumCaseElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .enumCaseElementList,
layout: [
], length: .zero, presence: .present))
return EnumCaseElementListSyntax(data)
}
public static func makeEnumCaseDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, caseKeyword: TokenSyntax, elements: EnumCaseElementListSyntax) -> EnumCaseDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
caseKeyword.raw,
elements.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.enumCaseDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return EnumCaseDeclSyntax(data)
}
public static func makeBlankEnumCaseDecl() -> EnumCaseDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .enumCaseDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.caseKeyword),
RawSyntax.missing(SyntaxKind.enumCaseElementList),
], length: .zero, presence: .present))
return EnumCaseDeclSyntax(data)
}
public static func makeEnumDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, enumKeyword: TokenSyntax, identifier: TokenSyntax, genericParameters: GenericParameterClauseSyntax?, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> EnumDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
enumKeyword.raw,
identifier.raw,
genericParameters?.raw,
inheritanceClause?.raw,
genericWhereClause?.raw,
members.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.enumDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return EnumDeclSyntax(data)
}
public static func makeBlankEnumDecl() -> EnumDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .enumDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.enumKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
RawSyntax.missing(SyntaxKind.memberDeclBlock),
], length: .zero, presence: .present))
return EnumDeclSyntax(data)
}
public static func makeOperatorDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, operatorKeyword: TokenSyntax, identifier: TokenSyntax, operatorPrecedenceAndTypes: OperatorPrecedenceAndTypesSyntax?) -> OperatorDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
operatorKeyword.raw,
identifier.raw,
operatorPrecedenceAndTypes?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.operatorDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return OperatorDeclSyntax(data)
}
public static func makeBlankOperatorDecl() -> OperatorDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .operatorDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.operatorKeyword),
RawSyntax.missingToken(TokenKind.unspacedBinaryOperator("")),
nil,
], length: .zero, presence: .present))
return OperatorDeclSyntax(data)
}
public static func makeIdentifierList(
_ elements: [TokenSyntax]) -> IdentifierListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.identifierList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IdentifierListSyntax(data)
}
public static func makeBlankIdentifierList() -> IdentifierListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .identifierList,
layout: [
], length: .zero, presence: .present))
return IdentifierListSyntax(data)
}
public static func makeOperatorPrecedenceAndTypes(colon: TokenSyntax, precedenceGroupAndDesignatedTypes: IdentifierListSyntax) -> OperatorPrecedenceAndTypesSyntax {
let layout: [RawSyntax?] = [
colon.raw,
precedenceGroupAndDesignatedTypes.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.operatorPrecedenceAndTypes,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return OperatorPrecedenceAndTypesSyntax(data)
}
public static func makeBlankOperatorPrecedenceAndTypes() -> OperatorPrecedenceAndTypesSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .operatorPrecedenceAndTypes,
layout: [
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.identifierList),
], length: .zero, presence: .present))
return OperatorPrecedenceAndTypesSyntax(data)
}
public static func makePrecedenceGroupDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, precedencegroupKeyword: TokenSyntax, identifier: TokenSyntax, leftBrace: TokenSyntax, groupAttributes: PrecedenceGroupAttributeListSyntax, rightBrace: TokenSyntax) -> PrecedenceGroupDeclSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
modifiers?.raw,
precedencegroupKeyword.raw,
identifier.raw,
leftBrace.raw,
groupAttributes.raw,
rightBrace.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.precedenceGroupDecl,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrecedenceGroupDeclSyntax(data)
}
public static func makeBlankPrecedenceGroupDecl() -> PrecedenceGroupDeclSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .precedenceGroupDecl,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.precedencegroupKeyword),
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.leftBrace),
RawSyntax.missing(SyntaxKind.precedenceGroupAttributeList),
RawSyntax.missingToken(TokenKind.rightBrace),
], length: .zero, presence: .present))
return PrecedenceGroupDeclSyntax(data)
}
public static func makePrecedenceGroupAttributeList(
_ elements: [Syntax]) -> PrecedenceGroupAttributeListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.precedenceGroupAttributeList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrecedenceGroupAttributeListSyntax(data)
}
public static func makeBlankPrecedenceGroupAttributeList() -> PrecedenceGroupAttributeListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .precedenceGroupAttributeList,
layout: [
], length: .zero, presence: .present))
return PrecedenceGroupAttributeListSyntax(data)
}
public static func makePrecedenceGroupRelation(higherThanOrLowerThan: TokenSyntax, colon: TokenSyntax, otherNames: PrecedenceGroupNameListSyntax) -> PrecedenceGroupRelationSyntax {
let layout: [RawSyntax?] = [
higherThanOrLowerThan.raw,
colon.raw,
otherNames.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.precedenceGroupRelation,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrecedenceGroupRelationSyntax(data)
}
public static func makeBlankPrecedenceGroupRelation() -> PrecedenceGroupRelationSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .precedenceGroupRelation,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.precedenceGroupNameList),
], length: .zero, presence: .present))
return PrecedenceGroupRelationSyntax(data)
}
public static func makePrecedenceGroupNameList(
_ elements: [PrecedenceGroupNameElementSyntax]) -> PrecedenceGroupNameListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.precedenceGroupNameList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrecedenceGroupNameListSyntax(data)
}
public static func makeBlankPrecedenceGroupNameList() -> PrecedenceGroupNameListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .precedenceGroupNameList,
layout: [
], length: .zero, presence: .present))
return PrecedenceGroupNameListSyntax(data)
}
public static func makePrecedenceGroupNameElement(name: TokenSyntax, trailingComma: TokenSyntax?) -> PrecedenceGroupNameElementSyntax {
let layout: [RawSyntax?] = [
name.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.precedenceGroupNameElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrecedenceGroupNameElementSyntax(data)
}
public static func makeBlankPrecedenceGroupNameElement() -> PrecedenceGroupNameElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .precedenceGroupNameElement,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return PrecedenceGroupNameElementSyntax(data)
}
public static func makePrecedenceGroupAssignment(assignmentKeyword: TokenSyntax, colon: TokenSyntax, flag: TokenSyntax) -> PrecedenceGroupAssignmentSyntax {
let layout: [RawSyntax?] = [
assignmentKeyword.raw,
colon.raw,
flag.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.precedenceGroupAssignment,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrecedenceGroupAssignmentSyntax(data)
}
public static func makeBlankPrecedenceGroupAssignment() -> PrecedenceGroupAssignmentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .precedenceGroupAssignment,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missingToken(TokenKind.trueKeyword),
], length: .zero, presence: .present))
return PrecedenceGroupAssignmentSyntax(data)
}
public static func makePrecedenceGroupAssociativity(associativityKeyword: TokenSyntax, colon: TokenSyntax, value: TokenSyntax) -> PrecedenceGroupAssociativitySyntax {
let layout: [RawSyntax?] = [
associativityKeyword.raw,
colon.raw,
value.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.precedenceGroupAssociativity,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PrecedenceGroupAssociativitySyntax(data)
}
public static func makeBlankPrecedenceGroupAssociativity() -> PrecedenceGroupAssociativitySyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .precedenceGroupAssociativity,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missingToken(TokenKind.identifier("")),
], length: .zero, presence: .present))
return PrecedenceGroupAssociativitySyntax(data)
}
public static func makeTokenList(
_ elements: [TokenSyntax]) -> TokenListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tokenList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TokenListSyntax(data)
}
public static func makeBlankTokenList() -> TokenListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tokenList,
layout: [
], length: .zero, presence: .present))
return TokenListSyntax(data)
}
public static func makeNonEmptyTokenList(
_ elements: [TokenSyntax]) -> NonEmptyTokenListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.nonEmptyTokenList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return NonEmptyTokenListSyntax(data)
}
public static func makeBlankNonEmptyTokenList() -> NonEmptyTokenListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .nonEmptyTokenList,
layout: [
], length: .zero, presence: .present))
return NonEmptyTokenListSyntax(data)
}
public static func makeCustomAttribute(atSignToken: TokenSyntax, attributeName: TypeSyntax, leftParen: TokenSyntax?, argumentList: TupleExprElementListSyntax?, rightParen: TokenSyntax?) -> CustomAttributeSyntax {
let layout: [RawSyntax?] = [
atSignToken.raw,
attributeName.raw,
leftParen?.raw,
argumentList?.raw,
rightParen?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.customAttribute,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CustomAttributeSyntax(data)
}
public static func makeBlankCustomAttribute() -> CustomAttributeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .customAttribute,
layout: [
RawSyntax.missingToken(TokenKind.atSign),
RawSyntax.missing(SyntaxKind.type),
nil,
nil,
nil,
], length: .zero, presence: .present))
return CustomAttributeSyntax(data)
}
public static func makeAttribute(atSignToken: TokenSyntax, attributeName: TokenSyntax, leftParen: TokenSyntax?, argument: Syntax?, rightParen: TokenSyntax?, tokenList: TokenListSyntax?) -> AttributeSyntax {
let layout: [RawSyntax?] = [
atSignToken.raw,
attributeName.raw,
leftParen?.raw,
argument?.raw,
rightParen?.raw,
tokenList?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.attribute,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AttributeSyntax(data)
}
public static func makeBlankAttribute() -> AttributeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .attribute,
layout: [
RawSyntax.missingToken(TokenKind.atSign),
RawSyntax.missingToken(TokenKind.unknown("")),
nil,
nil,
nil,
nil,
], length: .zero, presence: .present))
return AttributeSyntax(data)
}
public static func makeAttributeList(
_ elements: [Syntax]) -> AttributeListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.attributeList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AttributeListSyntax(data)
}
public static func makeBlankAttributeList() -> AttributeListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .attributeList,
layout: [
], length: .zero, presence: .present))
return AttributeListSyntax(data)
}
public static func makeSpecializeAttributeSpecList(
_ elements: [Syntax]) -> SpecializeAttributeSpecListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.specializeAttributeSpecList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SpecializeAttributeSpecListSyntax(data)
}
public static func makeBlankSpecializeAttributeSpecList() -> SpecializeAttributeSpecListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .specializeAttributeSpecList,
layout: [
], length: .zero, presence: .present))
return SpecializeAttributeSpecListSyntax(data)
}
public static func makeLabeledSpecializeEntry(label: TokenSyntax, colon: TokenSyntax, value: TokenSyntax, trailingComma: TokenSyntax?) -> LabeledSpecializeEntrySyntax {
let layout: [RawSyntax?] = [
label.raw,
colon.raw,
value.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.labeledSpecializeEntry,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return LabeledSpecializeEntrySyntax(data)
}
public static func makeBlankLabeledSpecializeEntry() -> LabeledSpecializeEntrySyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .labeledSpecializeEntry,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missingToken(TokenKind.unknown("")),
nil,
], length: .zero, presence: .present))
return LabeledSpecializeEntrySyntax(data)
}
public static func makeTargetFunctionEntry(label: TokenSyntax, colon: TokenSyntax, delcname: DeclNameSyntax, trailingComma: TokenSyntax?) -> TargetFunctionEntrySyntax {
let layout: [RawSyntax?] = [
label.raw,
colon.raw,
delcname.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.targetFunctionEntry,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TargetFunctionEntrySyntax(data)
}
public static func makeBlankTargetFunctionEntry() -> TargetFunctionEntrySyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .targetFunctionEntry,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.declName),
nil,
], length: .zero, presence: .present))
return TargetFunctionEntrySyntax(data)
}
public static func makeNamedAttributeStringArgument(nameTok: TokenSyntax, colon: TokenSyntax, stringOrDeclname: Syntax) -> NamedAttributeStringArgumentSyntax {
let layout: [RawSyntax?] = [
nameTok.raw,
colon.raw,
stringOrDeclname.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.namedAttributeStringArgument,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return NamedAttributeStringArgumentSyntax(data)
}
public static func makeBlankNamedAttributeStringArgument() -> NamedAttributeStringArgumentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .namedAttributeStringArgument,
layout: [
RawSyntax.missingToken(TokenKind.unknown("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.unknown),
], length: .zero, presence: .present))
return NamedAttributeStringArgumentSyntax(data)
}
public static func makeDeclName(declBaseName: Syntax, declNameArguments: DeclNameArgumentsSyntax?) -> DeclNameSyntax {
let layout: [RawSyntax?] = [
declBaseName.raw,
declNameArguments?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.declName,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeclNameSyntax(data)
}
public static func makeBlankDeclName() -> DeclNameSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .declName,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
], length: .zero, presence: .present))
return DeclNameSyntax(data)
}
public static func makeImplementsAttributeArguments(type: SimpleTypeIdentifierSyntax, comma: TokenSyntax, declBaseName: Syntax, declNameArguments: DeclNameArgumentsSyntax?) -> ImplementsAttributeArgumentsSyntax {
let layout: [RawSyntax?] = [
type.raw,
comma.raw,
declBaseName.raw,
declNameArguments?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.implementsAttributeArguments,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ImplementsAttributeArgumentsSyntax(data)
}
public static func makeBlankImplementsAttributeArguments() -> ImplementsAttributeArgumentsSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .implementsAttributeArguments,
layout: [
RawSyntax.missing(SyntaxKind.simpleTypeIdentifier),
RawSyntax.missingToken(TokenKind.comma),
RawSyntax.missing(SyntaxKind.unknown),
nil,
], length: .zero, presence: .present))
return ImplementsAttributeArgumentsSyntax(data)
}
public static func makeObjCSelectorPiece(name: TokenSyntax?, colon: TokenSyntax?) -> ObjCSelectorPieceSyntax {
let layout: [RawSyntax?] = [
name?.raw,
colon?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.objCSelectorPiece,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ObjCSelectorPieceSyntax(data)
}
public static func makeBlankObjCSelectorPiece() -> ObjCSelectorPieceSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .objCSelectorPiece,
layout: [
nil,
nil,
], length: .zero, presence: .present))
return ObjCSelectorPieceSyntax(data)
}
public static func makeObjCSelector(
_ elements: [ObjCSelectorPieceSyntax]) -> ObjCSelectorSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.objCSelector,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ObjCSelectorSyntax(data)
}
public static func makeBlankObjCSelector() -> ObjCSelectorSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .objCSelector,
layout: [
], length: .zero, presence: .present))
return ObjCSelectorSyntax(data)
}
public static func makeDifferentiableAttributeArguments(diffKind: TokenSyntax?, diffKindComma: TokenSyntax?, diffParams: DifferentiabilityParamsClauseSyntax?, diffParamsComma: TokenSyntax?, whereClause: GenericWhereClauseSyntax?) -> DifferentiableAttributeArgumentsSyntax {
let layout: [RawSyntax?] = [
diffKind?.raw,
diffKindComma?.raw,
diffParams?.raw,
diffParamsComma?.raw,
whereClause?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.differentiableAttributeArguments,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DifferentiableAttributeArgumentsSyntax(data)
}
public static func makeBlankDifferentiableAttributeArguments() -> DifferentiableAttributeArgumentsSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .differentiableAttributeArguments,
layout: [
nil,
nil,
nil,
nil,
nil,
], length: .zero, presence: .present))
return DifferentiableAttributeArgumentsSyntax(data)
}
public static func makeDifferentiabilityParamsClause(wrtLabel: TokenSyntax, colon: TokenSyntax, parameters: Syntax) -> DifferentiabilityParamsClauseSyntax {
let layout: [RawSyntax?] = [
wrtLabel.raw,
colon.raw,
parameters.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.differentiabilityParamsClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DifferentiabilityParamsClauseSyntax(data)
}
public static func makeBlankDifferentiabilityParamsClause() -> DifferentiabilityParamsClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .differentiabilityParamsClause,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.unknown),
], length: .zero, presence: .present))
return DifferentiabilityParamsClauseSyntax(data)
}
public static func makeDifferentiabilityParams(leftParen: TokenSyntax, diffParams: DifferentiabilityParamListSyntax, rightParen: TokenSyntax) -> DifferentiabilityParamsSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
diffParams.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.differentiabilityParams,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DifferentiabilityParamsSyntax(data)
}
public static func makeBlankDifferentiabilityParams() -> DifferentiabilityParamsSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .differentiabilityParams,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.differentiabilityParamList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return DifferentiabilityParamsSyntax(data)
}
public static func makeDifferentiabilityParamList(
_ elements: [DifferentiabilityParamSyntax]) -> DifferentiabilityParamListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.differentiabilityParamList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DifferentiabilityParamListSyntax(data)
}
public static func makeBlankDifferentiabilityParamList() -> DifferentiabilityParamListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .differentiabilityParamList,
layout: [
], length: .zero, presence: .present))
return DifferentiabilityParamListSyntax(data)
}
public static func makeDifferentiabilityParam(parameter: Syntax, trailingComma: TokenSyntax?) -> DifferentiabilityParamSyntax {
let layout: [RawSyntax?] = [
parameter.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.differentiabilityParam,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DifferentiabilityParamSyntax(data)
}
public static func makeBlankDifferentiabilityParam() -> DifferentiabilityParamSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .differentiabilityParam,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
], length: .zero, presence: .present))
return DifferentiabilityParamSyntax(data)
}
public static func makeDerivativeRegistrationAttributeArguments(ofLabel: TokenSyntax, colon: TokenSyntax, originalDeclName: QualifiedDeclNameSyntax, period: TokenSyntax?, accessorKind: TokenSyntax?, comma: TokenSyntax?, diffParams: DifferentiabilityParamsClauseSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax {
let layout: [RawSyntax?] = [
ofLabel.raw,
colon.raw,
originalDeclName.raw,
period?.raw,
accessorKind?.raw,
comma?.raw,
diffParams?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.derivativeRegistrationAttributeArguments,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DerivativeRegistrationAttributeArgumentsSyntax(data)
}
public static func makeBlankDerivativeRegistrationAttributeArguments() -> DerivativeRegistrationAttributeArgumentsSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .derivativeRegistrationAttributeArguments,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.qualifiedDeclName),
nil,
nil,
nil,
nil,
], length: .zero, presence: .present))
return DerivativeRegistrationAttributeArgumentsSyntax(data)
}
public static func makeQualifiedDeclName(baseType: TypeSyntax?, dot: TokenSyntax?, name: TokenSyntax, arguments: DeclNameArgumentsSyntax?) -> QualifiedDeclNameSyntax {
let layout: [RawSyntax?] = [
baseType?.raw,
dot?.raw,
name.raw,
arguments?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.qualifiedDeclName,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return QualifiedDeclNameSyntax(data)
}
public static func makeBlankQualifiedDeclName() -> QualifiedDeclNameSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .qualifiedDeclName,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return QualifiedDeclNameSyntax(data)
}
public static func makeFunctionDeclName(name: Syntax, arguments: DeclNameArgumentsSyntax?) -> FunctionDeclNameSyntax {
let layout: [RawSyntax?] = [
name.raw,
arguments?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.functionDeclName,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FunctionDeclNameSyntax(data)
}
public static func makeBlankFunctionDeclName() -> FunctionDeclNameSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .functionDeclName,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
], length: .zero, presence: .present))
return FunctionDeclNameSyntax(data)
}
public static func makeContinueStmt(continueKeyword: TokenSyntax, label: TokenSyntax?) -> ContinueStmtSyntax {
let layout: [RawSyntax?] = [
continueKeyword.raw,
label?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.continueStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ContinueStmtSyntax(data)
}
public static func makeBlankContinueStmt() -> ContinueStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .continueStmt,
layout: [
RawSyntax.missingToken(TokenKind.continueKeyword),
nil,
], length: .zero, presence: .present))
return ContinueStmtSyntax(data)
}
public static func makeWhileStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, whileKeyword: TokenSyntax, conditions: ConditionElementListSyntax, body: CodeBlockSyntax) -> WhileStmtSyntax {
let layout: [RawSyntax?] = [
labelName?.raw,
labelColon?.raw,
whileKeyword.raw,
conditions.raw,
body.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.whileStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return WhileStmtSyntax(data)
}
public static func makeBlankWhileStmt() -> WhileStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .whileStmt,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.whileKeyword),
RawSyntax.missing(SyntaxKind.conditionElementList),
RawSyntax.missing(SyntaxKind.codeBlock),
], length: .zero, presence: .present))
return WhileStmtSyntax(data)
}
public static func makeDeferStmt(deferKeyword: TokenSyntax, body: CodeBlockSyntax) -> DeferStmtSyntax {
let layout: [RawSyntax?] = [
deferKeyword.raw,
body.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.deferStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeferStmtSyntax(data)
}
public static func makeBlankDeferStmt() -> DeferStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .deferStmt,
layout: [
RawSyntax.missingToken(TokenKind.deferKeyword),
RawSyntax.missing(SyntaxKind.codeBlock),
], length: .zero, presence: .present))
return DeferStmtSyntax(data)
}
public static func makeExpressionStmt(expression: ExprSyntax) -> ExpressionStmtSyntax {
let layout: [RawSyntax?] = [
expression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.expressionStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ExpressionStmtSyntax(data)
}
public static func makeBlankExpressionStmt() -> ExpressionStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .expressionStmt,
layout: [
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return ExpressionStmtSyntax(data)
}
public static func makeSwitchCaseList(
_ elements: [Syntax]) -> SwitchCaseListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.switchCaseList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SwitchCaseListSyntax(data)
}
public static func makeBlankSwitchCaseList() -> SwitchCaseListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .switchCaseList,
layout: [
], length: .zero, presence: .present))
return SwitchCaseListSyntax(data)
}
public static func makeRepeatWhileStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, repeatKeyword: TokenSyntax, body: CodeBlockSyntax, whileKeyword: TokenSyntax, condition: ExprSyntax) -> RepeatWhileStmtSyntax {
let layout: [RawSyntax?] = [
labelName?.raw,
labelColon?.raw,
repeatKeyword.raw,
body.raw,
whileKeyword.raw,
condition.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.repeatWhileStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return RepeatWhileStmtSyntax(data)
}
public static func makeBlankRepeatWhileStmt() -> RepeatWhileStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .repeatWhileStmt,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.repeatKeyword),
RawSyntax.missing(SyntaxKind.codeBlock),
RawSyntax.missingToken(TokenKind.whileKeyword),
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return RepeatWhileStmtSyntax(data)
}
public static func makeGuardStmt(guardKeyword: TokenSyntax, conditions: ConditionElementListSyntax, elseKeyword: TokenSyntax, body: CodeBlockSyntax) -> GuardStmtSyntax {
let layout: [RawSyntax?] = [
guardKeyword.raw,
conditions.raw,
elseKeyword.raw,
body.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.guardStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GuardStmtSyntax(data)
}
public static func makeBlankGuardStmt() -> GuardStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .guardStmt,
layout: [
RawSyntax.missingToken(TokenKind.guardKeyword),
RawSyntax.missing(SyntaxKind.conditionElementList),
RawSyntax.missingToken(TokenKind.elseKeyword),
RawSyntax.missing(SyntaxKind.codeBlock),
], length: .zero, presence: .present))
return GuardStmtSyntax(data)
}
public static func makeWhereClause(whereKeyword: TokenSyntax, guardResult: ExprSyntax) -> WhereClauseSyntax {
let layout: [RawSyntax?] = [
whereKeyword.raw,
guardResult.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.whereClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return WhereClauseSyntax(data)
}
public static func makeBlankWhereClause() -> WhereClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .whereClause,
layout: [
RawSyntax.missingToken(TokenKind.whereKeyword),
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return WhereClauseSyntax(data)
}
public static func makeForInStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, forKeyword: TokenSyntax, tryKeyword: TokenSyntax?, awaitKeyword: TokenSyntax?, caseKeyword: TokenSyntax?, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, inKeyword: TokenSyntax, sequenceExpr: ExprSyntax, whereClause: WhereClauseSyntax?, body: CodeBlockSyntax) -> ForInStmtSyntax {
let layout: [RawSyntax?] = [
labelName?.raw,
labelColon?.raw,
forKeyword.raw,
tryKeyword?.raw,
awaitKeyword?.raw,
caseKeyword?.raw,
pattern.raw,
typeAnnotation?.raw,
inKeyword.raw,
sequenceExpr.raw,
whereClause?.raw,
body.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.forInStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ForInStmtSyntax(data)
}
public static func makeBlankForInStmt() -> ForInStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .forInStmt,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.forKeyword),
nil,
nil,
nil,
RawSyntax.missing(SyntaxKind.pattern),
nil,
RawSyntax.missingToken(TokenKind.inKeyword),
RawSyntax.missing(SyntaxKind.expr),
nil,
RawSyntax.missing(SyntaxKind.codeBlock),
], length: .zero, presence: .present))
return ForInStmtSyntax(data)
}
public static func makeSwitchStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, switchKeyword: TokenSyntax, expression: ExprSyntax, leftBrace: TokenSyntax, cases: SwitchCaseListSyntax, rightBrace: TokenSyntax) -> SwitchStmtSyntax {
let layout: [RawSyntax?] = [
labelName?.raw,
labelColon?.raw,
switchKeyword.raw,
expression.raw,
leftBrace.raw,
cases.raw,
rightBrace.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.switchStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SwitchStmtSyntax(data)
}
public static func makeBlankSwitchStmt() -> SwitchStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .switchStmt,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.switchKeyword),
RawSyntax.missing(SyntaxKind.expr),
RawSyntax.missingToken(TokenKind.leftBrace),
RawSyntax.missing(SyntaxKind.switchCaseList),
RawSyntax.missingToken(TokenKind.rightBrace),
], length: .zero, presence: .present))
return SwitchStmtSyntax(data)
}
public static func makeCatchClauseList(
_ elements: [CatchClauseSyntax]) -> CatchClauseListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.catchClauseList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CatchClauseListSyntax(data)
}
public static func makeBlankCatchClauseList() -> CatchClauseListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .catchClauseList,
layout: [
], length: .zero, presence: .present))
return CatchClauseListSyntax(data)
}
public static func makeDoStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, doKeyword: TokenSyntax, body: CodeBlockSyntax, catchClauses: CatchClauseListSyntax?) -> DoStmtSyntax {
let layout: [RawSyntax?] = [
labelName?.raw,
labelColon?.raw,
doKeyword.raw,
body.raw,
catchClauses?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.doStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DoStmtSyntax(data)
}
public static func makeBlankDoStmt() -> DoStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .doStmt,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.doKeyword),
RawSyntax.missing(SyntaxKind.codeBlock),
nil,
], length: .zero, presence: .present))
return DoStmtSyntax(data)
}
public static func makeReturnStmt(returnKeyword: TokenSyntax, expression: ExprSyntax?) -> ReturnStmtSyntax {
let layout: [RawSyntax?] = [
returnKeyword.raw,
expression?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.returnStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ReturnStmtSyntax(data)
}
public static func makeBlankReturnStmt() -> ReturnStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .returnStmt,
layout: [
RawSyntax.missingToken(TokenKind.returnKeyword),
nil,
], length: .zero, presence: .present))
return ReturnStmtSyntax(data)
}
public static func makeYieldStmt(yieldKeyword: TokenSyntax, yields: Syntax) -> YieldStmtSyntax {
let layout: [RawSyntax?] = [
yieldKeyword.raw,
yields.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.yieldStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return YieldStmtSyntax(data)
}
public static func makeBlankYieldStmt() -> YieldStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .yieldStmt,
layout: [
RawSyntax.missingToken(TokenKind.yield),
RawSyntax.missing(SyntaxKind.unknown),
], length: .zero, presence: .present))
return YieldStmtSyntax(data)
}
public static func makeYieldList(leftParen: TokenSyntax, elementList: ExprListSyntax, trailingComma: TokenSyntax?, rightParen: TokenSyntax) -> YieldListSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
elementList.raw,
trailingComma?.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.yieldList,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return YieldListSyntax(data)
}
public static func makeBlankYieldList() -> YieldListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .yieldList,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.exprList),
nil,
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return YieldListSyntax(data)
}
public static func makeFallthroughStmt(fallthroughKeyword: TokenSyntax) -> FallthroughStmtSyntax {
let layout: [RawSyntax?] = [
fallthroughKeyword.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.fallthroughStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FallthroughStmtSyntax(data)
}
public static func makeBlankFallthroughStmt() -> FallthroughStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .fallthroughStmt,
layout: [
RawSyntax.missingToken(TokenKind.fallthroughKeyword),
], length: .zero, presence: .present))
return FallthroughStmtSyntax(data)
}
public static func makeBreakStmt(breakKeyword: TokenSyntax, label: TokenSyntax?) -> BreakStmtSyntax {
let layout: [RawSyntax?] = [
breakKeyword.raw,
label?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.breakStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return BreakStmtSyntax(data)
}
public static func makeBlankBreakStmt() -> BreakStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .breakStmt,
layout: [
RawSyntax.missingToken(TokenKind.breakKeyword),
nil,
], length: .zero, presence: .present))
return BreakStmtSyntax(data)
}
public static func makeCaseItemList(
_ elements: [CaseItemSyntax]) -> CaseItemListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.caseItemList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CaseItemListSyntax(data)
}
public static func makeBlankCaseItemList() -> CaseItemListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .caseItemList,
layout: [
], length: .zero, presence: .present))
return CaseItemListSyntax(data)
}
public static func makeCatchItemList(
_ elements: [CatchItemSyntax]) -> CatchItemListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.catchItemList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CatchItemListSyntax(data)
}
public static func makeBlankCatchItemList() -> CatchItemListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .catchItemList,
layout: [
], length: .zero, presence: .present))
return CatchItemListSyntax(data)
}
public static func makeConditionElement(condition: Syntax, trailingComma: TokenSyntax?) -> ConditionElementSyntax {
let layout: [RawSyntax?] = [
condition.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.conditionElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ConditionElementSyntax(data)
}
public static func makeBlankConditionElement() -> ConditionElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .conditionElement,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
], length: .zero, presence: .present))
return ConditionElementSyntax(data)
}
public static func makeAvailabilityCondition(poundAvailableKeyword: TokenSyntax, leftParen: TokenSyntax, availabilitySpec: AvailabilitySpecListSyntax, rightParen: TokenSyntax) -> AvailabilityConditionSyntax {
let layout: [RawSyntax?] = [
poundAvailableKeyword.raw,
leftParen.raw,
availabilitySpec.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.availabilityCondition,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AvailabilityConditionSyntax(data)
}
public static func makeBlankAvailabilityCondition() -> AvailabilityConditionSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .availabilityCondition,
layout: [
RawSyntax.missingToken(TokenKind.poundAvailableKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.availabilitySpecList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return AvailabilityConditionSyntax(data)
}
public static func makeMatchingPatternCondition(caseKeyword: TokenSyntax, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax) -> MatchingPatternConditionSyntax {
let layout: [RawSyntax?] = [
caseKeyword.raw,
pattern.raw,
typeAnnotation?.raw,
initializer.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.matchingPatternCondition,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MatchingPatternConditionSyntax(data)
}
public static func makeBlankMatchingPatternCondition() -> MatchingPatternConditionSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .matchingPatternCondition,
layout: [
RawSyntax.missingToken(TokenKind.caseKeyword),
RawSyntax.missing(SyntaxKind.pattern),
nil,
RawSyntax.missing(SyntaxKind.initializerClause),
], length: .zero, presence: .present))
return MatchingPatternConditionSyntax(data)
}
public static func makeOptionalBindingCondition(letOrVarKeyword: TokenSyntax, pattern: PatternSyntax, typeAnnotation: TypeAnnotationSyntax?, initializer: InitializerClauseSyntax) -> OptionalBindingConditionSyntax {
let layout: [RawSyntax?] = [
letOrVarKeyword.raw,
pattern.raw,
typeAnnotation?.raw,
initializer.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.optionalBindingCondition,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return OptionalBindingConditionSyntax(data)
}
public static func makeBlankOptionalBindingCondition() -> OptionalBindingConditionSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .optionalBindingCondition,
layout: [
RawSyntax.missingToken(TokenKind.letKeyword),
RawSyntax.missing(SyntaxKind.pattern),
nil,
RawSyntax.missing(SyntaxKind.initializerClause),
], length: .zero, presence: .present))
return OptionalBindingConditionSyntax(data)
}
public static func makeConditionElementList(
_ elements: [ConditionElementSyntax]) -> ConditionElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.conditionElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ConditionElementListSyntax(data)
}
public static func makeBlankConditionElementList() -> ConditionElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .conditionElementList,
layout: [
], length: .zero, presence: .present))
return ConditionElementListSyntax(data)
}
public static func makeDeclarationStmt(declaration: DeclSyntax) -> DeclarationStmtSyntax {
let layout: [RawSyntax?] = [
declaration.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.declarationStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DeclarationStmtSyntax(data)
}
public static func makeBlankDeclarationStmt() -> DeclarationStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .declarationStmt,
layout: [
RawSyntax.missing(SyntaxKind.decl),
], length: .zero, presence: .present))
return DeclarationStmtSyntax(data)
}
public static func makeThrowStmt(throwKeyword: TokenSyntax, expression: ExprSyntax) -> ThrowStmtSyntax {
let layout: [RawSyntax?] = [
throwKeyword.raw,
expression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.throwStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ThrowStmtSyntax(data)
}
public static func makeBlankThrowStmt() -> ThrowStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .throwStmt,
layout: [
RawSyntax.missingToken(TokenKind.throwKeyword),
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return ThrowStmtSyntax(data)
}
public static func makeIfStmt(labelName: TokenSyntax?, labelColon: TokenSyntax?, ifKeyword: TokenSyntax, conditions: ConditionElementListSyntax, body: CodeBlockSyntax, elseKeyword: TokenSyntax?, elseBody: Syntax?) -> IfStmtSyntax {
let layout: [RawSyntax?] = [
labelName?.raw,
labelColon?.raw,
ifKeyword.raw,
conditions.raw,
body.raw,
elseKeyword?.raw,
elseBody?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.ifStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IfStmtSyntax(data)
}
public static func makeBlankIfStmt() -> IfStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .ifStmt,
layout: [
nil,
nil,
RawSyntax.missingToken(TokenKind.ifKeyword),
RawSyntax.missing(SyntaxKind.conditionElementList),
RawSyntax.missing(SyntaxKind.codeBlock),
nil,
nil,
], length: .zero, presence: .present))
return IfStmtSyntax(data)
}
public static func makeElseIfContinuation(ifStatement: IfStmtSyntax) -> ElseIfContinuationSyntax {
let layout: [RawSyntax?] = [
ifStatement.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.elseIfContinuation,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ElseIfContinuationSyntax(data)
}
public static func makeBlankElseIfContinuation() -> ElseIfContinuationSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .elseIfContinuation,
layout: [
RawSyntax.missing(SyntaxKind.ifStmt),
], length: .zero, presence: .present))
return ElseIfContinuationSyntax(data)
}
public static func makeElseBlock(elseKeyword: TokenSyntax, body: CodeBlockSyntax) -> ElseBlockSyntax {
let layout: [RawSyntax?] = [
elseKeyword.raw,
body.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.elseBlock,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ElseBlockSyntax(data)
}
public static func makeBlankElseBlock() -> ElseBlockSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .elseBlock,
layout: [
RawSyntax.missingToken(TokenKind.elseKeyword),
RawSyntax.missing(SyntaxKind.codeBlock),
], length: .zero, presence: .present))
return ElseBlockSyntax(data)
}
public static func makeSwitchCase(unknownAttr: AttributeSyntax?, label: Syntax, statements: CodeBlockItemListSyntax) -> SwitchCaseSyntax {
let layout: [RawSyntax?] = [
unknownAttr?.raw,
label.raw,
statements.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.switchCase,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SwitchCaseSyntax(data)
}
public static func makeBlankSwitchCase() -> SwitchCaseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .switchCase,
layout: [
nil,
RawSyntax.missing(SyntaxKind.unknown),
RawSyntax.missing(SyntaxKind.codeBlockItemList),
], length: .zero, presence: .present))
return SwitchCaseSyntax(data)
}
public static func makeSwitchDefaultLabel(defaultKeyword: TokenSyntax, colon: TokenSyntax) -> SwitchDefaultLabelSyntax {
let layout: [RawSyntax?] = [
defaultKeyword.raw,
colon.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.switchDefaultLabel,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SwitchDefaultLabelSyntax(data)
}
public static func makeBlankSwitchDefaultLabel() -> SwitchDefaultLabelSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .switchDefaultLabel,
layout: [
RawSyntax.missingToken(TokenKind.defaultKeyword),
RawSyntax.missingToken(TokenKind.colon),
], length: .zero, presence: .present))
return SwitchDefaultLabelSyntax(data)
}
public static func makeCaseItem(pattern: PatternSyntax, whereClause: WhereClauseSyntax?, trailingComma: TokenSyntax?) -> CaseItemSyntax {
let layout: [RawSyntax?] = [
pattern.raw,
whereClause?.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.caseItem,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CaseItemSyntax(data)
}
public static func makeBlankCaseItem() -> CaseItemSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .caseItem,
layout: [
RawSyntax.missing(SyntaxKind.pattern),
nil,
nil,
], length: .zero, presence: .present))
return CaseItemSyntax(data)
}
public static func makeCatchItem(pattern: PatternSyntax?, whereClause: WhereClauseSyntax?, trailingComma: TokenSyntax?) -> CatchItemSyntax {
let layout: [RawSyntax?] = [
pattern?.raw,
whereClause?.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.catchItem,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CatchItemSyntax(data)
}
public static func makeBlankCatchItem() -> CatchItemSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .catchItem,
layout: [
nil,
nil,
nil,
], length: .zero, presence: .present))
return CatchItemSyntax(data)
}
public static func makeSwitchCaseLabel(caseKeyword: TokenSyntax, caseItems: CaseItemListSyntax, colon: TokenSyntax) -> SwitchCaseLabelSyntax {
let layout: [RawSyntax?] = [
caseKeyword.raw,
caseItems.raw,
colon.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.switchCaseLabel,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SwitchCaseLabelSyntax(data)
}
public static func makeBlankSwitchCaseLabel() -> SwitchCaseLabelSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .switchCaseLabel,
layout: [
RawSyntax.missingToken(TokenKind.caseKeyword),
RawSyntax.missing(SyntaxKind.caseItemList),
RawSyntax.missingToken(TokenKind.colon),
], length: .zero, presence: .present))
return SwitchCaseLabelSyntax(data)
}
public static func makeCatchClause(catchKeyword: TokenSyntax, catchItems: CatchItemListSyntax?, body: CodeBlockSyntax) -> CatchClauseSyntax {
let layout: [RawSyntax?] = [
catchKeyword.raw,
catchItems?.raw,
body.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.catchClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CatchClauseSyntax(data)
}
public static func makeBlankCatchClause() -> CatchClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .catchClause,
layout: [
RawSyntax.missingToken(TokenKind.catchKeyword),
nil,
RawSyntax.missing(SyntaxKind.codeBlock),
], length: .zero, presence: .present))
return CatchClauseSyntax(data)
}
public static func makePoundAssertStmt(poundAssert: TokenSyntax, leftParen: TokenSyntax, condition: ExprSyntax, comma: TokenSyntax?, message: TokenSyntax?, rightParen: TokenSyntax) -> PoundAssertStmtSyntax {
let layout: [RawSyntax?] = [
poundAssert.raw,
leftParen.raw,
condition.raw,
comma?.raw,
message?.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundAssertStmt,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return PoundAssertStmtSyntax(data)
}
public static func makeBlankPoundAssertStmt() -> PoundAssertStmtSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundAssertStmt,
layout: [
RawSyntax.missingToken(TokenKind.poundAssertKeyword),
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.expr),
nil,
nil,
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return PoundAssertStmtSyntax(data)
}
public static func makeGenericWhereClause(whereKeyword: TokenSyntax, requirementList: GenericRequirementListSyntax) -> GenericWhereClauseSyntax {
let layout: [RawSyntax?] = [
whereKeyword.raw,
requirementList.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericWhereClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericWhereClauseSyntax(data)
}
public static func makeBlankGenericWhereClause() -> GenericWhereClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericWhereClause,
layout: [
RawSyntax.missingToken(TokenKind.whereKeyword),
RawSyntax.missing(SyntaxKind.genericRequirementList),
], length: .zero, presence: .present))
return GenericWhereClauseSyntax(data)
}
public static func makeGenericRequirementList(
_ elements: [GenericRequirementSyntax]) -> GenericRequirementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericRequirementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericRequirementListSyntax(data)
}
public static func makeBlankGenericRequirementList() -> GenericRequirementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericRequirementList,
layout: [
], length: .zero, presence: .present))
return GenericRequirementListSyntax(data)
}
public static func makeGenericRequirement(body: Syntax, trailingComma: TokenSyntax?) -> GenericRequirementSyntax {
let layout: [RawSyntax?] = [
body.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericRequirement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericRequirementSyntax(data)
}
public static func makeBlankGenericRequirement() -> GenericRequirementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericRequirement,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
], length: .zero, presence: .present))
return GenericRequirementSyntax(data)
}
public static func makeSameTypeRequirement(leftTypeIdentifier: TypeSyntax, equalityToken: TokenSyntax, rightTypeIdentifier: TypeSyntax) -> SameTypeRequirementSyntax {
let layout: [RawSyntax?] = [
leftTypeIdentifier.raw,
equalityToken.raw,
rightTypeIdentifier.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.sameTypeRequirement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SameTypeRequirementSyntax(data)
}
public static func makeBlankSameTypeRequirement() -> SameTypeRequirementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .sameTypeRequirement,
layout: [
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.spacedBinaryOperator("")),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return SameTypeRequirementSyntax(data)
}
public static func makeGenericParameterList(
_ elements: [GenericParameterSyntax]) -> GenericParameterListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericParameterList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericParameterListSyntax(data)
}
public static func makeBlankGenericParameterList() -> GenericParameterListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericParameterList,
layout: [
], length: .zero, presence: .present))
return GenericParameterListSyntax(data)
}
public static func makeGenericParameter(attributes: AttributeListSyntax?, name: TokenSyntax, colon: TokenSyntax?, inheritedType: TypeSyntax?, trailingComma: TokenSyntax?) -> GenericParameterSyntax {
let layout: [RawSyntax?] = [
attributes?.raw,
name.raw,
colon?.raw,
inheritedType?.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericParameter,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericParameterSyntax(data)
}
public static func makeBlankGenericParameter() -> GenericParameterSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericParameter,
layout: [
nil,
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
nil,
nil,
], length: .zero, presence: .present))
return GenericParameterSyntax(data)
}
public static func makeGenericParameterClause(leftAngleBracket: TokenSyntax, genericParameterList: GenericParameterListSyntax, rightAngleBracket: TokenSyntax) -> GenericParameterClauseSyntax {
let layout: [RawSyntax?] = [
leftAngleBracket.raw,
genericParameterList.raw,
rightAngleBracket.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericParameterClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericParameterClauseSyntax(data)
}
public static func makeBlankGenericParameterClause() -> GenericParameterClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericParameterClause,
layout: [
RawSyntax.missingToken(TokenKind.leftAngle),
RawSyntax.missing(SyntaxKind.genericParameterList),
RawSyntax.missingToken(TokenKind.rightAngle),
], length: .zero, presence: .present))
return GenericParameterClauseSyntax(data)
}
public static func makeConformanceRequirement(leftTypeIdentifier: TypeSyntax, colon: TokenSyntax, rightTypeIdentifier: TypeSyntax) -> ConformanceRequirementSyntax {
let layout: [RawSyntax?] = [
leftTypeIdentifier.raw,
colon.raw,
rightTypeIdentifier.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.conformanceRequirement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ConformanceRequirementSyntax(data)
}
public static func makeBlankConformanceRequirement() -> ConformanceRequirementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .conformanceRequirement,
layout: [
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return ConformanceRequirementSyntax(data)
}
public static func makeSimpleTypeIdentifier(name: TokenSyntax, genericArgumentClause: GenericArgumentClauseSyntax?) -> SimpleTypeIdentifierSyntax {
let layout: [RawSyntax?] = [
name.raw,
genericArgumentClause?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.simpleTypeIdentifier,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SimpleTypeIdentifierSyntax(data)
}
public static func makeBlankSimpleTypeIdentifier() -> SimpleTypeIdentifierSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .simpleTypeIdentifier,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return SimpleTypeIdentifierSyntax(data)
}
public static func makeMemberTypeIdentifier(baseType: TypeSyntax, period: TokenSyntax, name: TokenSyntax, genericArgumentClause: GenericArgumentClauseSyntax?) -> MemberTypeIdentifierSyntax {
let layout: [RawSyntax?] = [
baseType.raw,
period.raw,
name.raw,
genericArgumentClause?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.memberTypeIdentifier,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MemberTypeIdentifierSyntax(data)
}
public static func makeBlankMemberTypeIdentifier() -> MemberTypeIdentifierSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .memberTypeIdentifier,
layout: [
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.period),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return MemberTypeIdentifierSyntax(data)
}
public static func makeClassRestrictionType(classKeyword: TokenSyntax) -> ClassRestrictionTypeSyntax {
let layout: [RawSyntax?] = [
classKeyword.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.classRestrictionType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ClassRestrictionTypeSyntax(data)
}
public static func makeBlankClassRestrictionType() -> ClassRestrictionTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .classRestrictionType,
layout: [
RawSyntax.missingToken(TokenKind.classKeyword),
], length: .zero, presence: .present))
return ClassRestrictionTypeSyntax(data)
}
public static func makeArrayType(leftSquareBracket: TokenSyntax, elementType: TypeSyntax, rightSquareBracket: TokenSyntax) -> ArrayTypeSyntax {
let layout: [RawSyntax?] = [
leftSquareBracket.raw,
elementType.raw,
rightSquareBracket.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.arrayType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ArrayTypeSyntax(data)
}
public static func makeBlankArrayType() -> ArrayTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .arrayType,
layout: [
RawSyntax.missingToken(TokenKind.leftSquareBracket),
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.rightSquareBracket),
], length: .zero, presence: .present))
return ArrayTypeSyntax(data)
}
public static func makeDictionaryType(leftSquareBracket: TokenSyntax, keyType: TypeSyntax, colon: TokenSyntax, valueType: TypeSyntax, rightSquareBracket: TokenSyntax) -> DictionaryTypeSyntax {
let layout: [RawSyntax?] = [
leftSquareBracket.raw,
keyType.raw,
colon.raw,
valueType.raw,
rightSquareBracket.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.dictionaryType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return DictionaryTypeSyntax(data)
}
public static func makeBlankDictionaryType() -> DictionaryTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .dictionaryType,
layout: [
RawSyntax.missingToken(TokenKind.leftSquareBracket),
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.rightSquareBracket),
], length: .zero, presence: .present))
return DictionaryTypeSyntax(data)
}
public static func makeMetatypeType(baseType: TypeSyntax, period: TokenSyntax, typeOrProtocol: TokenSyntax) -> MetatypeTypeSyntax {
let layout: [RawSyntax?] = [
baseType.raw,
period.raw,
typeOrProtocol.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.metatypeType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return MetatypeTypeSyntax(data)
}
public static func makeBlankMetatypeType() -> MetatypeTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .metatypeType,
layout: [
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.period),
RawSyntax.missingToken(TokenKind.identifier("")),
], length: .zero, presence: .present))
return MetatypeTypeSyntax(data)
}
public static func makeOptionalType(wrappedType: TypeSyntax, questionMark: TokenSyntax) -> OptionalTypeSyntax {
let layout: [RawSyntax?] = [
wrappedType.raw,
questionMark.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.optionalType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return OptionalTypeSyntax(data)
}
public static func makeBlankOptionalType() -> OptionalTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .optionalType,
layout: [
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.postfixQuestionMark),
], length: .zero, presence: .present))
return OptionalTypeSyntax(data)
}
public static func makeSomeType(someSpecifier: TokenSyntax, baseType: TypeSyntax) -> SomeTypeSyntax {
let layout: [RawSyntax?] = [
someSpecifier.raw,
baseType.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.someType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return SomeTypeSyntax(data)
}
public static func makeBlankSomeType() -> SomeTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .someType,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return SomeTypeSyntax(data)
}
public static func makeImplicitlyUnwrappedOptionalType(wrappedType: TypeSyntax, exclamationMark: TokenSyntax) -> ImplicitlyUnwrappedOptionalTypeSyntax {
let layout: [RawSyntax?] = [
wrappedType.raw,
exclamationMark.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.implicitlyUnwrappedOptionalType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ImplicitlyUnwrappedOptionalTypeSyntax(data)
}
public static func makeBlankImplicitlyUnwrappedOptionalType() -> ImplicitlyUnwrappedOptionalTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .implicitlyUnwrappedOptionalType,
layout: [
RawSyntax.missing(SyntaxKind.type),
RawSyntax.missingToken(TokenKind.exclamationMark),
], length: .zero, presence: .present))
return ImplicitlyUnwrappedOptionalTypeSyntax(data)
}
public static func makeCompositionTypeElement(type: TypeSyntax, ampersand: TokenSyntax?) -> CompositionTypeElementSyntax {
let layout: [RawSyntax?] = [
type.raw,
ampersand?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.compositionTypeElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CompositionTypeElementSyntax(data)
}
public static func makeBlankCompositionTypeElement() -> CompositionTypeElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .compositionTypeElement,
layout: [
RawSyntax.missing(SyntaxKind.type),
nil,
], length: .zero, presence: .present))
return CompositionTypeElementSyntax(data)
}
public static func makeCompositionTypeElementList(
_ elements: [CompositionTypeElementSyntax]) -> CompositionTypeElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.compositionTypeElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CompositionTypeElementListSyntax(data)
}
public static func makeBlankCompositionTypeElementList() -> CompositionTypeElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .compositionTypeElementList,
layout: [
], length: .zero, presence: .present))
return CompositionTypeElementListSyntax(data)
}
public static func makeCompositionType(elements: CompositionTypeElementListSyntax) -> CompositionTypeSyntax {
let layout: [RawSyntax?] = [
elements.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.compositionType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return CompositionTypeSyntax(data)
}
public static func makeBlankCompositionType() -> CompositionTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .compositionType,
layout: [
RawSyntax.missing(SyntaxKind.compositionTypeElementList),
], length: .zero, presence: .present))
return CompositionTypeSyntax(data)
}
public static func makeTupleTypeElement(inOut: TokenSyntax?, name: TokenSyntax?, secondName: TokenSyntax?, colon: TokenSyntax?, type: TypeSyntax, ellipsis: TokenSyntax?, initializer: InitializerClauseSyntax?, trailingComma: TokenSyntax?) -> TupleTypeElementSyntax {
let layout: [RawSyntax?] = [
inOut?.raw,
name?.raw,
secondName?.raw,
colon?.raw,
type.raw,
ellipsis?.raw,
initializer?.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tupleTypeElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TupleTypeElementSyntax(data)
}
public static func makeBlankTupleTypeElement() -> TupleTypeElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tupleTypeElement,
layout: [
nil,
nil,
nil,
nil,
RawSyntax.missing(SyntaxKind.type),
nil,
nil,
nil,
], length: .zero, presence: .present))
return TupleTypeElementSyntax(data)
}
public static func makeTupleTypeElementList(
_ elements: [TupleTypeElementSyntax]) -> TupleTypeElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tupleTypeElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TupleTypeElementListSyntax(data)
}
public static func makeBlankTupleTypeElementList() -> TupleTypeElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tupleTypeElementList,
layout: [
], length: .zero, presence: .present))
return TupleTypeElementListSyntax(data)
}
public static func makeTupleType(leftParen: TokenSyntax, elements: TupleTypeElementListSyntax, rightParen: TokenSyntax) -> TupleTypeSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
elements.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tupleType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TupleTypeSyntax(data)
}
public static func makeBlankTupleType() -> TupleTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tupleType,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.tupleTypeElementList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return TupleTypeSyntax(data)
}
public static func makeFunctionType(leftParen: TokenSyntax, arguments: TupleTypeElementListSyntax, rightParen: TokenSyntax, asyncKeyword: TokenSyntax?, throwsOrRethrowsKeyword: TokenSyntax?, arrow: TokenSyntax, returnType: TypeSyntax) -> FunctionTypeSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
arguments.raw,
rightParen.raw,
asyncKeyword?.raw,
throwsOrRethrowsKeyword?.raw,
arrow.raw,
returnType.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.functionType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return FunctionTypeSyntax(data)
}
public static func makeBlankFunctionType() -> FunctionTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .functionType,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.tupleTypeElementList),
RawSyntax.missingToken(TokenKind.rightParen),
nil,
nil,
RawSyntax.missingToken(TokenKind.arrow),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return FunctionTypeSyntax(data)
}
public static func makeAttributedType(specifier: TokenSyntax?, attributes: AttributeListSyntax?, baseType: TypeSyntax) -> AttributedTypeSyntax {
let layout: [RawSyntax?] = [
specifier?.raw,
attributes?.raw,
baseType.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.attributedType,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AttributedTypeSyntax(data)
}
public static func makeBlankAttributedType() -> AttributedTypeSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .attributedType,
layout: [
nil,
nil,
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return AttributedTypeSyntax(data)
}
public static func makeGenericArgumentList(
_ elements: [GenericArgumentSyntax]) -> GenericArgumentListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericArgumentList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericArgumentListSyntax(data)
}
public static func makeBlankGenericArgumentList() -> GenericArgumentListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericArgumentList,
layout: [
], length: .zero, presence: .present))
return GenericArgumentListSyntax(data)
}
public static func makeGenericArgument(argumentType: TypeSyntax, trailingComma: TokenSyntax?) -> GenericArgumentSyntax {
let layout: [RawSyntax?] = [
argumentType.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericArgument,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericArgumentSyntax(data)
}
public static func makeBlankGenericArgument() -> GenericArgumentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericArgument,
layout: [
RawSyntax.missing(SyntaxKind.type),
nil,
], length: .zero, presence: .present))
return GenericArgumentSyntax(data)
}
public static func makeGenericArgumentClause(leftAngleBracket: TokenSyntax, arguments: GenericArgumentListSyntax, rightAngleBracket: TokenSyntax) -> GenericArgumentClauseSyntax {
let layout: [RawSyntax?] = [
leftAngleBracket.raw,
arguments.raw,
rightAngleBracket.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericArgumentClause,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return GenericArgumentClauseSyntax(data)
}
public static func makeBlankGenericArgumentClause() -> GenericArgumentClauseSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .genericArgumentClause,
layout: [
RawSyntax.missingToken(TokenKind.leftAngle),
RawSyntax.missing(SyntaxKind.genericArgumentList),
RawSyntax.missingToken(TokenKind.rightAngle),
], length: .zero, presence: .present))
return GenericArgumentClauseSyntax(data)
}
public static func makeTypeAnnotation(colon: TokenSyntax, type: TypeSyntax) -> TypeAnnotationSyntax {
let layout: [RawSyntax?] = [
colon.raw,
type.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.typeAnnotation,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TypeAnnotationSyntax(data)
}
public static func makeBlankTypeAnnotation() -> TypeAnnotationSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .typeAnnotation,
layout: [
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return TypeAnnotationSyntax(data)
}
public static func makeEnumCasePattern(type: TypeSyntax?, period: TokenSyntax, caseName: TokenSyntax, associatedTuple: TuplePatternSyntax?) -> EnumCasePatternSyntax {
let layout: [RawSyntax?] = [
type?.raw,
period.raw,
caseName.raw,
associatedTuple?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.enumCasePattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return EnumCasePatternSyntax(data)
}
public static func makeBlankEnumCasePattern() -> EnumCasePatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .enumCasePattern,
layout: [
nil,
RawSyntax.missingToken(TokenKind.period),
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return EnumCasePatternSyntax(data)
}
public static func makeIsTypePattern(isKeyword: TokenSyntax, type: TypeSyntax) -> IsTypePatternSyntax {
let layout: [RawSyntax?] = [
isKeyword.raw,
type.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.isTypePattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IsTypePatternSyntax(data)
}
public static func makeBlankIsTypePattern() -> IsTypePatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .isTypePattern,
layout: [
RawSyntax.missingToken(TokenKind.isKeyword),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return IsTypePatternSyntax(data)
}
public static func makeOptionalPattern(subPattern: PatternSyntax, questionMark: TokenSyntax) -> OptionalPatternSyntax {
let layout: [RawSyntax?] = [
subPattern.raw,
questionMark.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.optionalPattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return OptionalPatternSyntax(data)
}
public static func makeBlankOptionalPattern() -> OptionalPatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .optionalPattern,
layout: [
RawSyntax.missing(SyntaxKind.pattern),
RawSyntax.missingToken(TokenKind.postfixQuestionMark),
], length: .zero, presence: .present))
return OptionalPatternSyntax(data)
}
public static func makeIdentifierPattern(identifier: TokenSyntax) -> IdentifierPatternSyntax {
let layout: [RawSyntax?] = [
identifier.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.identifierPattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return IdentifierPatternSyntax(data)
}
public static func makeBlankIdentifierPattern() -> IdentifierPatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .identifierPattern,
layout: [
RawSyntax.missingToken(TokenKind.selfKeyword),
], length: .zero, presence: .present))
return IdentifierPatternSyntax(data)
}
public static func makeAsTypePattern(pattern: PatternSyntax, asKeyword: TokenSyntax, type: TypeSyntax) -> AsTypePatternSyntax {
let layout: [RawSyntax?] = [
pattern.raw,
asKeyword.raw,
type.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.asTypePattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AsTypePatternSyntax(data)
}
public static func makeBlankAsTypePattern() -> AsTypePatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .asTypePattern,
layout: [
RawSyntax.missing(SyntaxKind.pattern),
RawSyntax.missingToken(TokenKind.asKeyword),
RawSyntax.missing(SyntaxKind.type),
], length: .zero, presence: .present))
return AsTypePatternSyntax(data)
}
public static func makeTuplePattern(leftParen: TokenSyntax, elements: TuplePatternElementListSyntax, rightParen: TokenSyntax) -> TuplePatternSyntax {
let layout: [RawSyntax?] = [
leftParen.raw,
elements.raw,
rightParen.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tuplePattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TuplePatternSyntax(data)
}
public static func makeBlankTuplePattern() -> TuplePatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tuplePattern,
layout: [
RawSyntax.missingToken(TokenKind.leftParen),
RawSyntax.missing(SyntaxKind.tuplePatternElementList),
RawSyntax.missingToken(TokenKind.rightParen),
], length: .zero, presence: .present))
return TuplePatternSyntax(data)
}
public static func makeWildcardPattern(wildcard: TokenSyntax, typeAnnotation: TypeAnnotationSyntax?) -> WildcardPatternSyntax {
let layout: [RawSyntax?] = [
wildcard.raw,
typeAnnotation?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.wildcardPattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return WildcardPatternSyntax(data)
}
public static func makeBlankWildcardPattern() -> WildcardPatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .wildcardPattern,
layout: [
RawSyntax.missingToken(TokenKind.wildcardKeyword),
nil,
], length: .zero, presence: .present))
return WildcardPatternSyntax(data)
}
public static func makeTuplePatternElement(labelName: TokenSyntax?, labelColon: TokenSyntax?, pattern: PatternSyntax, trailingComma: TokenSyntax?) -> TuplePatternElementSyntax {
let layout: [RawSyntax?] = [
labelName?.raw,
labelColon?.raw,
pattern.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tuplePatternElement,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TuplePatternElementSyntax(data)
}
public static func makeBlankTuplePatternElement() -> TuplePatternElementSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tuplePatternElement,
layout: [
nil,
nil,
RawSyntax.missing(SyntaxKind.pattern),
nil,
], length: .zero, presence: .present))
return TuplePatternElementSyntax(data)
}
public static func makeExpressionPattern(expression: ExprSyntax) -> ExpressionPatternSyntax {
let layout: [RawSyntax?] = [
expression.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.expressionPattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ExpressionPatternSyntax(data)
}
public static func makeBlankExpressionPattern() -> ExpressionPatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .expressionPattern,
layout: [
RawSyntax.missing(SyntaxKind.expr),
], length: .zero, presence: .present))
return ExpressionPatternSyntax(data)
}
public static func makeTuplePatternElementList(
_ elements: [TuplePatternElementSyntax]) -> TuplePatternElementListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.tuplePatternElementList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return TuplePatternElementListSyntax(data)
}
public static func makeBlankTuplePatternElementList() -> TuplePatternElementListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .tuplePatternElementList,
layout: [
], length: .zero, presence: .present))
return TuplePatternElementListSyntax(data)
}
public static func makeValueBindingPattern(letOrVarKeyword: TokenSyntax, valuePattern: PatternSyntax) -> ValueBindingPatternSyntax {
let layout: [RawSyntax?] = [
letOrVarKeyword.raw,
valuePattern.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.valueBindingPattern,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return ValueBindingPatternSyntax(data)
}
public static func makeBlankValueBindingPattern() -> ValueBindingPatternSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .valueBindingPattern,
layout: [
RawSyntax.missingToken(TokenKind.letKeyword),
RawSyntax.missing(SyntaxKind.pattern),
], length: .zero, presence: .present))
return ValueBindingPatternSyntax(data)
}
public static func makeAvailabilitySpecList(
_ elements: [AvailabilityArgumentSyntax]) -> AvailabilitySpecListSyntax {
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.availabilitySpecList,
layout: elements.map { $0.raw }, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AvailabilitySpecListSyntax(data)
}
public static func makeBlankAvailabilitySpecList() -> AvailabilitySpecListSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .availabilitySpecList,
layout: [
], length: .zero, presence: .present))
return AvailabilitySpecListSyntax(data)
}
public static func makeAvailabilityArgument(entry: Syntax, trailingComma: TokenSyntax?) -> AvailabilityArgumentSyntax {
let layout: [RawSyntax?] = [
entry.raw,
trailingComma?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.availabilityArgument,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AvailabilityArgumentSyntax(data)
}
public static func makeBlankAvailabilityArgument() -> AvailabilityArgumentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .availabilityArgument,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
], length: .zero, presence: .present))
return AvailabilityArgumentSyntax(data)
}
public static func makeAvailabilityLabeledArgument(label: TokenSyntax, colon: TokenSyntax, value: Syntax) -> AvailabilityLabeledArgumentSyntax {
let layout: [RawSyntax?] = [
label.raw,
colon.raw,
value.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.availabilityLabeledArgument,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AvailabilityLabeledArgumentSyntax(data)
}
public static func makeBlankAvailabilityLabeledArgument() -> AvailabilityLabeledArgumentSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .availabilityLabeledArgument,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
RawSyntax.missingToken(TokenKind.colon),
RawSyntax.missing(SyntaxKind.unknown),
], length: .zero, presence: .present))
return AvailabilityLabeledArgumentSyntax(data)
}
public static func makeAvailabilityVersionRestriction(platform: TokenSyntax, version: VersionTupleSyntax?) -> AvailabilityVersionRestrictionSyntax {
let layout: [RawSyntax?] = [
platform.raw,
version?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.availabilityVersionRestriction,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return AvailabilityVersionRestrictionSyntax(data)
}
public static func makeBlankAvailabilityVersionRestriction() -> AvailabilityVersionRestrictionSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .availabilityVersionRestriction,
layout: [
RawSyntax.missingToken(TokenKind.identifier("")),
nil,
], length: .zero, presence: .present))
return AvailabilityVersionRestrictionSyntax(data)
}
public static func makeVersionTuple(majorMinor: Syntax, patchPeriod: TokenSyntax?, patchVersion: TokenSyntax?) -> VersionTupleSyntax {
let layout: [RawSyntax?] = [
majorMinor.raw,
patchPeriod?.raw,
patchVersion?.raw,
]
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.versionTuple,
layout: layout, presence: SourcePresence.present)
let data = SyntaxData.forRoot(raw)
return VersionTupleSyntax(data)
}
public static func makeBlankVersionTuple() -> VersionTupleSyntax {
let data = SyntaxData.forRoot(RawSyntax.create(kind: .versionTuple,
layout: [
RawSyntax.missing(SyntaxKind.unknown),
nil,
nil,
], length: .zero, presence: .present))
return VersionTupleSyntax(data)
}
/// MARK: Token Creation APIs
public static func makeAssociatedtypeKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.associatedtypeKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeClassKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.classKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeDeinitKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.deinitKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeEnumKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.enumKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeExtensionKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.extensionKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeFuncKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.funcKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeImportKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.importKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeInitKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.initKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeInoutKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.inoutKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeLetKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.letKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeOperatorKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.operatorKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePrecedencegroupKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.precedencegroupKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeProtocolKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.protocolKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeStructKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.structKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSubscriptKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.subscriptKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeTypealiasKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.typealiasKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeVarKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.varKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeFileprivateKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.fileprivateKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeInternalKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.internalKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePrivateKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.privateKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePublicKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.publicKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeStaticKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.staticKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeDeferKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.deferKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeIfKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.ifKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeGuardKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.guardKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeDoKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.doKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeRepeatKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.repeatKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeElseKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.elseKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeForKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.forKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeInKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.inKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeWhileKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.whileKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeReturnKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.returnKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeBreakKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.breakKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeContinueKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.continueKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeFallthroughKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.fallthroughKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSwitchKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.switchKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeCaseKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.caseKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeDefaultKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.defaultKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeWhereKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.whereKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeCatchKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.catchKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeThrowKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.throwKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeAsKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.asKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeAnyKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.anyKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeFalseKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.falseKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeIsKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.isKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeNilKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.nilKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeRethrowsKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.rethrowsKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSuperKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.superKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSelfKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.selfKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeCapitalSelfKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.capitalSelfKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeTrueKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.trueKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeTryKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.tryKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeThrowsKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.throwsKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func make__FILE__Keyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.__file__Keyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func make__LINE__Keyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.__line__Keyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func make__COLUMN__Keyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.__column__Keyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func make__FUNCTION__Keyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.__function__Keyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func make__DSO_HANDLE__Keyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.__dso_handle__Keyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeWildcardKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.wildcardKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeLeftParenToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.leftParen, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeRightParenToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.rightParen, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeLeftBraceToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.leftBrace, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeRightBraceToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.rightBrace, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeLeftSquareBracketToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.leftSquareBracket, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeRightSquareBracketToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.rightSquareBracket, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeLeftAngleToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.leftAngle, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeRightAngleToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.rightAngle, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePeriodToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.period, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePrefixPeriodToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.prefixPeriod, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeCommaToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.comma, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeEllipsisToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.ellipsis, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeColonToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.colon, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSemicolonToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.semicolon, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeEqualToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.equal, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeAtSignToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.atSign, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.pound, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePrefixAmpersandToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.prefixAmpersand, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeArrowToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.arrow, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeBacktickToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.backtick, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeBackslashToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.backslash, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeExclamationMarkToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.exclamationMark, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePostfixQuestionMarkToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.postfixQuestionMark, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeInfixQuestionMarkToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.infixQuestionMark, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeStringQuoteToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.stringQuote, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSingleQuoteToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.singleQuote, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeMultilineStringQuoteToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.multilineStringQuote, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundKeyPathKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundKeyPathKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundLineKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundLineKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundSelectorKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundSelectorKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundFileKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundFileKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundFileIDKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundFileIDKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundFilePathKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundFilePathKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundColumnKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundColumnKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundFunctionKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundFunctionKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundDsohandleKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundDsohandleKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundAssertKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundAssertKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundSourceLocationKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundSourceLocationKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundWarningKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundWarningKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundErrorKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundErrorKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundIfKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundIfKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundElseKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundElseKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundElseifKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundElseifKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundEndifKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundEndifKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundAvailableKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundAvailableKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundFileLiteralKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundFileLiteralKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundImageLiteralKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundImageLiteralKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePoundColorLiteralKeyword(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.poundColorLiteralKeyword, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeIntegerLiteral(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.integerLiteral(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeFloatingLiteral(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.floatingLiteral(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeStringLiteral(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.stringLiteral(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeUnknown(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.unknown(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeIdentifier(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.identifier(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeUnspacedBinaryOperator(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.unspacedBinaryOperator(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSpacedBinaryOperator(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.spacedBinaryOperator(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePostfixOperator(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.postfixOperator(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makePrefixOperator(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.prefixOperator(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeDollarIdentifier(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.dollarIdentifier(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeContextualKeyword(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.contextualKeyword(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeRawStringDelimiter(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.rawStringDelimiter(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeStringSegment(_ text: String,
leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.stringSegment(text), presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeStringInterpolationAnchorToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.stringInterpolationAnchor, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeYieldToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.yield, presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
/// MARK: Convenience APIs
public static func makeVoidTupleType() -> TupleTypeSyntax {
return makeTupleType(leftParen: makeLeftParenToken(),
elements: makeBlankTupleTypeElementList(),
rightParen: makeRightParenToken())
}
public static func makeTupleTypeElement(name: TokenSyntax?,
colon: TokenSyntax?, type: TypeSyntax,
trailingComma: TokenSyntax?) -> TupleTypeElementSyntax {
return makeTupleTypeElement(inOut: nil, name: name, secondName: nil,
colon: colon, type: type, ellipsis: nil,
initializer: nil, trailingComma: trailingComma)
}
public static func makeTupleTypeElement(type: TypeSyntax,
trailingComma: TokenSyntax?) -> TupleTypeElementSyntax {
return makeTupleTypeElement(name: nil, colon: nil,
type: type, trailingComma: trailingComma)
}
public static func makeGenericParameter(name: TokenSyntax,
trailingComma: TokenSyntax) -> GenericParameterSyntax {
return makeGenericParameter(attributes: nil, name: name, colon: nil,
inheritedType: nil,
trailingComma: trailingComma)
}
public static func makeTypeIdentifier(_ name: String,
leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TypeSyntax {
let identifier = makeIdentifier(name, leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
let typeIdentifier = makeSimpleTypeIdentifier(name: identifier,
genericArgumentClause: nil)
return TypeSyntax(typeIdentifier)
}
public static func makeAnyTypeIdentifier(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TypeSyntax {
return makeTypeIdentifier("Any", leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeSelfTypeIdentifier(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TypeSyntax {
return makeTypeIdentifier("Self", leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeTypeToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeIdentifier("Type", leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeProtocolToken(leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeIdentifier("Protocol", leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeBinaryOperator(_ name: String,
leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> TokenSyntax {
return makeToken(.spacedBinaryOperator(name),
presence: .present,
leadingTrivia: leadingTrivia,
trailingTrivia: trailingTrivia)
}
public static func makeStringLiteralExpr(_ text: String,
leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> StringLiteralExprSyntax {
let string = makeStringSegment(text)
let segment = makeStringSegment(content: string)
let segments = makeStringLiteralSegments([Syntax(segment)])
let openQuote = makeStringQuoteToken(leadingTrivia: leadingTrivia)
let closeQuote = makeStringQuoteToken(trailingTrivia: trailingTrivia)
return makeStringLiteralExpr(openDelimiter: nil,
openQuote: openQuote,
segments: segments,
closeQuote: closeQuote,
closeDelimiter: nil)
}
public static func makeVariableExpr(_ text: String,
leadingTrivia: Trivia = [],
trailingTrivia: Trivia = []) -> IdentifierExprSyntax {
let string = makeIdentifier(text,
leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia)
return makeIdentifierExpr(identifier: string,
declNameArguments: nil)
}
}
| 41.6423 | 387 | 0.711708 |
4a6f6c64b9ac36ea7cee71a55541f8c14d07fd96 | 590 | //
// URLComponents+Endpoint.swift
// thanos menu
//
// Created by Lucas Moreton on 22/07/20.
// Copyright © 2020 Lucas Moreton. All rights reserved.
//
import Foundation
extension URLComponents {
init?(endpoint: EndpointProtocol) {
self.init()
scheme = endpoint.scheme
host = endpoint.host
path = endpoint.path
guard let parameters = endpoint.parameters else {
return
}
queryItems = parameters.map { key, value in
return URLQueryItem(name: key, value: String(describing: value))
}
}
}
| 21.851852 | 76 | 0.615254 |
89749ca6c530f8a0d54fd8319014d5d9f6d278ab | 1,945 | //
// YCRefreshConst.swift
// YCRefreshDemo
//
// Created by Codyy.YY on 2020/5/8.
// Copyright © 2020 Codyy.YY. All rights reserved.
//
import UIKit
public struct YCRefreshConst {
static let labelLeftInset : CGFloat = 25.0
static let headerHeight : CGFloat = 54.0
static let footerHeight : CGFloat = 44.0
static let leaderWidth : CGFloat = 44.0
static let trailerWidth : CGFloat = 44.0
static let fastAnimationDuration = 0.25
static let slowAnimationDuration = 0.4
}
struct YCRefreshKeyPath {
static let contentOffset = "contentOffset"
static let contentInset = "contentInset"
static let contentSize = "contentSize"
static let panState = "state"
}
public struct YCRefreshHeaderConst {
static let lastUpdateTimeKey = "YCRefreshHeaderLastUpdateTimeKey"
static let idleText = "YCRefreshHeaderIdleText"
static let pullingText = "YCRefreshHeaderPullingText"
static let refreshingText = "YCRefreshHeaderRefreshingText"
static let lastTimeText = "YCRefreshHeaderLastTimeText"
static let dateTodayText = "YCRefreshHeaderDateTodayText"
static let noneLastDateText = "YCRefreshHeaderNoneLastDateText"
}
public struct YCRefreshAutoFooterConst {
static let idleText = "YCRefreshAutoFooterIdleText"
static let refreshingText = "YCRefreshAutoFooterRefreshingText"
static let noMoreDataText = "YCRefreshAutoFooterNoMoreDataText"
}
public struct YCRefreshBackFooterConst {
static let idleText = "YCRefreshBackFooterIdleText"
static let pullingText = "YCRefreshBackFooterPullingText"
static let refreshingText = "YCRefreshBackFooterRefreshingText"
static let noMoreDataText = "YCRefreshBackFooterNoMoreDataText"
}
public let YCRefreshLabelFont = UIFont.boldSystemFont(ofSize: 14)
public let YCRefreshLabelTextColor = UIColor.lightGray
| 34.732143 | 70 | 0.726478 |
3380868e2697ba589b07a5dbf44469165b3713c6 | 14,951 | import XCTest
import CZUtils
import CZTestUtils
@testable import CZNetworking
final class CZHTTPManagerTests: XCTestCase {
public typealias GetRequestSuccess = (Data?) -> Void
private enum Constant {
static let timeOut: TimeInterval = 10
}
private enum MockData {
static let urlForGet = URL(string: "https://www.apple.com/newsroom/rss-feed-GET.rss")!
static let urlForGetCodable = URL(string: "https://www.apple.com/newsroom/rss-feed-GETCodable.rss")!
static let urlForGetDictionaryable = URL(string: "https://www.apple.com/newsroom/rss-feed-GetDictionaryable.rss")!
static let urlForGetDictionaryableOneModel = URL(string: "https://www.apple.com/newsroom/rss-feed-GetDictionaryableOneModel.rss")!
static let dictionary: [String: AnyHashable] = [
"a": "sdlfjas",
"c": "sdlksdf",
"b": "239823sd",
"d": 189298723,
]
static let array: [AnyHashable] = [
"sdlfjas",
"sdlksdf",
"239823sd",
189298723,
]
static let models = (0..<10).map { TestModel(id: $0, name: "Model\($0)") }
static let oneModel = TestModel(id: 1, name: "Model1")
}
static let queueLable = "com.tests.queue"
@ThreadSafe
private var executionSuccessCount = 0
private var czHTTPManager: CZHTTPManager!
override func setUp() {
CZNetworkingConstants.shouldJoinOnFlightOperation = false
czHTTPManager = CZHTTPManager()
executionSuccessCount = 0
}
// MARK: - GETCodable
/**
Test GET() method.
*/
func testGET() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CZHTTPJsonSerializer.jsonData(with: MockData.dictionary)!
let mockDataMap = [MockData.urlForGet: mockData]
// Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// Get the data with `MockData.urlForGet`.
CZHTTPManager.shared.GET(
MockData.urlForGet.absoluteString,
success: { (data) in
let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
expectation.fulfill()
})
// Wait for expectatation.
waitForExpectatation()
}
// func testGETByJoinOnFlightOperation() {
// let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
//
// // Create mockDataMap.
// let mockData = CZHTTPJsonSerializer.jsonData(with: MockData.dictionary)!
// let mockDataMap = [MockData.urlForGet: mockData]
//
// // Stub MockData.
// CZHTTPManager.stubMockData(dict: mockDataMap)
//
// // 1-1. Get the data with `MockData.urlForGet`.
// CZHTTPManager.shared.GET(
// MockData.urlForGet.absoluteString,
// success: { (data) in
// // XCTFail()
// })
//
// // 1-2. Get the data with `MockData.urlForGet`.
// CZHTTPManager.shared.GET(
// MockData.urlForGet.absoluteString,
// success: { (data) in
// let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
// XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
// expectation.fulfill()
// })
//
// // Wait for expectatation.
// waitForExpectatation()
// }
/**
Test GET() method with `cached` handler.
*/
func testGETWithCache1() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CZHTTPJsonSerializer.jsonData(with: MockData.dictionary)!
let mockDataMap = [MockData.urlForGet: mockData]
let success: GetRequestSuccess = { (data) in
let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
}
let cached: GetRequestSuccess = { (data) in
let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
}
// 0. Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// 1. Fetch with stub URLSession.
CZHTTPManager.shared.GET(
MockData.urlForGet.absoluteString,
success: success,
cached: cached)
// 2. Verify cache: fetch again.
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
CZHTTPManager.shared.GET(
MockData.urlForGet.absoluteString,
success: success,
cached: { (data) in
cached(data)
// Fullfill the expectatation.
expectation.fulfill()
})
}
// Wait for expectatation.
waitForExpectatation()
}
/// [Written by the previous test] Test read from cache after relaunching App / ColdStart.
/// It verifies both DiskCache and MemCache.
///
/// - Note: MUST run `testGETWithCache1` first!
///
/// As Swift doesn't support `testInvocations` override, so can only order tests by alphabet names
/// to simulate relaunching App.
func testGETWithCache2AfterRelaunchingApp() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CZHTTPJsonSerializer.jsonData(with: MockData.dictionary)!
let mockDataMap = [MockData.urlForGet: mockData]
let success: GetRequestSuccess = { (data) in
let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
}
let cached = success
// 0. Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// 1. Fetch with stub URLSession.
CZHTTPManager.shared.GET(
MockData.urlForGet.absoluteString,
success: success,
cached: { (data) in
// 2. Verify cache: read from disk after ColdLaunch.
cached(data)
expectation.fulfill()
})
// Wait for expectatation.
waitForExpectatation()
}
/**
Verify GET() method: without `cached` handler, it shouldn't cache data to disk.
*/
func testGETWithoutCache() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Clear disk cache.
czHTTPManager.httpCache.clearCache()
// Create mockDataMap.
let mockData = CZHTTPJsonSerializer.jsonData(with: MockData.dictionary)!
let mockDataMap = [MockData.urlForGet: mockData]
let success: GetRequestSuccess = { (data) in
let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
}
// 0. Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// 1. Fetch with stub URLSession: `cached` handler is nil.
czHTTPManager.GET(
MockData.urlForGet.absoluteString,
success: success,
cached: nil)
// 2. Verify cache(shouldn't cache): fetch again.
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
self.czHTTPManager.GET(
MockData.urlForGet.absoluteString,
success: { (data) in
// Fullfill the expectatation.
expectation.fulfill()
},
cached: { (data) in
XCTFail("Second time `cached` shouldn't be called - because the first time `cached` wasn't set.")
})
}
// Wait for expectatation.
waitForExpectatation()
}
/**
Test GET() method with `cached` handler on multi threads.
*/
func testGETWithCacheMultiThreads() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CZHTTPJsonSerializer.jsonData(with: MockData.dictionary)!
let mockDataMap = [MockData.urlForGet: mockData]
let success: GetRequestSuccess = { (data) in
let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
}
let cached: GetRequestSuccess = { (data) in
let res: [String: AnyHashable]? = CZHTTPJsonSerializer.deserializedObject(with: data)
XCTAssert(res == MockData.dictionary, "Actual result = \(res), Expected result = \(MockData.dictionary)")
}
// 1. Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// 2. Fetch with stub URLSession on multi threads.
let totalCount = 1000
let dispatchGroup = DispatchGroup()
(0..<totalCount).forEach { _ in
dispatchGroup.enter()
CZHTTPManager.shared.GET(
MockData.urlForGet.absoluteString,
success: { (data) in
success(data)
self._executionSuccessCount.threadLock {
$0 = $0 + 1
print("Success count = \($0)")
}
dispatchGroup.leave()
}, cached: cached)
}
// 3. Wait till group multi thread tasks complete.
dispatchGroup.notify(queue: .main) {
let successCount = self._executionSuccessCount.threadLock { $0 }
// Verify success `count` with the expected value.
XCTAssert(
successCount == totalCount,
"Not all executions succeed! Actual result = \(successCount), Expected result = \(totalCount)")
expectation.fulfill()
}
// 4. Wait for expectatation.
waitForExpectatation()
}
// MARK: - GETCodable
/**
Test GETCodable() method.
*/
func testGETCodableModel() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CodableHelper.encode(MockData.models)!
let mockDataMap = [MockData.urlForGetCodable: mockData]
// Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// Verify data.
CZHTTPManager.shared.GETCodableModel(MockData.urlForGetCodable.absoluteString, success: { (models: [TestModel], _) in
XCTAssert(
models.isEqual(toCodable: MockData.models),
"Actual result = \n\(models) \n\nExpected result = \n\(MockData.models)")
expectation.fulfill()
})
// Wait for expectatation.
waitForExpectatation()
}
/**
Test GETCodableModels() method.
*/
func testGETCodableModels() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CodableHelper.encode(MockData.models)!
let mockDataMap = [MockData.urlForGetCodable: mockData]
// Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// Verify data.
CZHTTPManager.shared.GETCodableModels(MockData.urlForGetCodable.absoluteString, success: { (models: [TestModel], data) in
XCTAssert(
models.isEqual(toCodable: MockData.models),
"Actual result = \n\(models) \n\nExpected result = \n\(MockData.models)")
expectation.fulfill()
})
// Wait for expectatation.
waitForExpectatation()
}
/**
Test GETCodableModels() method with `cached` handler.
*/
func testGETCodableModelsWithCache() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CodableHelper.encode(MockData.models)!
let mockDataMap = [MockData.urlForGetCodable: mockData]
let success = { (models: [TestModel], data: Data?) in
XCTAssert(
models.isEqual(toCodable: MockData.models),
"Actual result = \n\(models) \n\nExpected result = \n\(MockData.models)")
}
let cached = success
// 0. Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// 1. Fetch with stub URLSession.
CZHTTPManager.shared.GETCodableModels(
MockData.urlForGetCodable.absoluteString,
success: success,
cached: cached)
// 2. Verify cache: fetch again.
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
CZHTTPManager.shared.GETCodableModels(
MockData.urlForGetCodable.absoluteString,
success: success,
cached: { (models: [TestModel], data: Data?) in
cached(models, data)
// Fullfill the expectatation.
expectation.fulfill()
})
}
// Wait for expectatation.
waitForExpectatation()
}
// MARK: - GetDictionaryable
/**
Test GetOneModel() method.
*/
func testGetOneModel() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CodableHelper.encode(MockData.oneModel)!
let mockDataMap = [MockData.urlForGetDictionaryableOneModel: mockData]
// Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// Verify data.
CZHTTPManager.shared.GetOneModel(MockData.urlForGetDictionaryableOneModel.absoluteString, success: { (model: TestModel) in
XCTAssert(
model.isEqual(toCodable: MockData.oneModel),
"Actual result = \n\(model) \n\nExpected result = \n\(MockData.oneModel)")
expectation.fulfill()
})
// Wait for expectatation.
waitForExpectatation()
}
/**
Test GetManyModels() method.
*/
func testGetManyModels() {
let (waitForExpectatation, expectation) = CZTestUtils.waitWithInterval(Constant.timeOut, testCase: self)
// Create mockDataMap.
let mockData = CodableHelper.encode(MockData.models)!
let mockDataMap = [MockData.urlForGetDictionaryable: mockData]
// Stub MockData.
CZHTTPManager.stubMockData(dict: mockDataMap)
// Verify data.
CZHTTPManager.shared.GetManyModels(MockData.urlForGetDictionaryable.absoluteString, success: { (models: [TestModel]) in
XCTAssert(
models.isEqual(toCodable: MockData.models),
"Actual result = \n\(models) \n\nExpected result = \n\(MockData.models)")
expectation.fulfill()
})
// Wait for expectatation.
waitForExpectatation()
}
}
struct TestModel: Codable, CZDictionaryable {
let id: Int
let name: String
init(id: Int, name: String) {
self.id = id
self.name = name
}
init(dictionary: CZDictionary) {
self.id = dictionary["id"] as! Int
self.name = dictionary["name"] as! String
}
}
| 33.522422 | 134 | 0.65815 |
9c12a47fe3421772c37bd53e5d4338cd790dd7f6 | 19,412 | // DO NOT EDIT.
// swift-format-ignore-file
//
// Generated by the Swift generator plugin for the protocol buffer compiler.
// Source: syft_proto/execution/v1/type_wrapper.proto
//
// For information on using the generated types, please see the documentation:
// https://github.com/apple/swift-protobuf/
import Foundation
import SwiftProtobuf
// If the compiler emits an error on this type, it is because this file
// was generated by a version of the `protoc` Swift plug-in that is
// incompatible with the version of SwiftProtobuf to which you are linking.
// Please ensure that you are building against the same version of the API
// that was used to generate this file.
fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
typealias Version = _2
}
public struct SyftProto_Execution_V1_InputTypeDescriptor {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
///
///A type contains the serialization id and string bytes.
public var typeName: String = String()
public var unknownFields = SwiftProtobuf.UnknownStorage()
public init() {}
}
///
///Message to bufferize a nested type. In a nested type we can have:
///1. A type.
///2. A list of nested types.
///3. A tuple of nested types.
///4. A dict of nested types.
public struct SyftProto_Execution_V1_NestedTypeWrapper {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
public var nestedTypes: SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer {
get {return _nestedTypes ?? SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer()}
set {_nestedTypes = newValue}
}
/// Returns true if `nestedTypes` has been explicitly set.
public var hasNestedTypes: Bool {return self._nestedTypes != nil}
/// Clears the value of `nestedTypes`. Subsequent reads from it will return its default value.
public mutating func clearNestedTypes() {self._nestedTypes = nil}
public var unknownFields = SwiftProtobuf.UnknownStorage()
///Wrapper to simulate the behavior of a list in oneof.
public struct TypeList {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
public var nestedTypes: [SyftProto_Execution_V1_NestedTypeWrapper] = []
public var unknownFields = SwiftProtobuf.UnknownStorage()
public init() {}
}
///Wrapper to simulate the behavior of a tuple in oneof.
public struct TypeTuple {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
public var nestedTypes: [SyftProto_Execution_V1_NestedTypeWrapper] = []
public var unknownFields = SwiftProtobuf.UnknownStorage()
public init() {}
}
///Wrapper to simulate the behavior of a map in oneof.
public struct TypeMap {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
public var nestedTypes: Dictionary<String,SyftProto_Execution_V1_NestedTypeWrapper> = [:]
public var unknownFields = SwiftProtobuf.UnknownStorage()
public init() {}
}
/// To create the behavior described above, we need a new message, as
/// oneof will not permit repeated fields.
public struct TypeContainer {
// SwiftProtobuf.Message conformance is added in an extension below. See the
// `Message` and `Message+*Additions` files in the SwiftProtobuf library for
// methods supported on all messages.
public var nestedContainer: SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer.OneOf_NestedContainer? = nil
/// First scenario, acts like a list with one element, the type.
public var nestedType: SyftProto_Execution_V1_InputTypeDescriptor {
get {
if case .nestedType(let v)? = nestedContainer {return v}
return SyftProto_Execution_V1_InputTypeDescriptor()
}
set {nestedContainer = .nestedType(newValue)}
}
/// Second scenario, a list of possibly nested elements.
public var nestedTypeList: SyftProto_Execution_V1_NestedTypeWrapper.TypeList {
get {
if case .nestedTypeList(let v)? = nestedContainer {return v}
return SyftProto_Execution_V1_NestedTypeWrapper.TypeList()
}
set {nestedContainer = .nestedTypeList(newValue)}
}
/// Third scenario, a tuple of possibly nested elements.
public var nestedTypeTuple: SyftProto_Execution_V1_NestedTypeWrapper.TypeTuple {
get {
if case .nestedTypeTuple(let v)? = nestedContainer {return v}
return SyftProto_Execution_V1_NestedTypeWrapper.TypeTuple()
}
set {nestedContainer = .nestedTypeTuple(newValue)}
}
/// Last scenario, a dict of possible nested elements.
public var nestedTypeDict: SyftProto_Execution_V1_NestedTypeWrapper.TypeMap {
get {
if case .nestedTypeDict(let v)? = nestedContainer {return v}
return SyftProto_Execution_V1_NestedTypeWrapper.TypeMap()
}
set {nestedContainer = .nestedTypeDict(newValue)}
}
public var unknownFields = SwiftProtobuf.UnknownStorage()
public enum OneOf_NestedContainer: Equatable {
/// First scenario, acts like a list with one element, the type.
case nestedType(SyftProto_Execution_V1_InputTypeDescriptor)
/// Second scenario, a list of possibly nested elements.
case nestedTypeList(SyftProto_Execution_V1_NestedTypeWrapper.TypeList)
/// Third scenario, a tuple of possibly nested elements.
case nestedTypeTuple(SyftProto_Execution_V1_NestedTypeWrapper.TypeTuple)
/// Last scenario, a dict of possible nested elements.
case nestedTypeDict(SyftProto_Execution_V1_NestedTypeWrapper.TypeMap)
#if !swift(>=4.1)
public static func ==(lhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer.OneOf_NestedContainer, rhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer.OneOf_NestedContainer) -> Bool {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch (lhs, rhs) {
case (.nestedType, .nestedType): return {
guard case .nestedType(let l) = lhs, case .nestedType(let r) = rhs else { preconditionFailure() }
return l == r
}()
case (.nestedTypeList, .nestedTypeList): return {
guard case .nestedTypeList(let l) = lhs, case .nestedTypeList(let r) = rhs else { preconditionFailure() }
return l == r
}()
case (.nestedTypeTuple, .nestedTypeTuple): return {
guard case .nestedTypeTuple(let l) = lhs, case .nestedTypeTuple(let r) = rhs else { preconditionFailure() }
return l == r
}()
case (.nestedTypeDict, .nestedTypeDict): return {
guard case .nestedTypeDict(let l) = lhs, case .nestedTypeDict(let r) = rhs else { preconditionFailure() }
return l == r
}()
default: return false
}
}
#endif
}
public init() {}
}
public init() {}
fileprivate var _nestedTypes: SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer? = nil
}
// MARK: - Code below here is support for the SwiftProtobuf runtime.
fileprivate let _protobuf_package = "syft_proto.execution.v1"
extension SyftProto_Execution_V1_InputTypeDescriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
public static let protoMessageName: String = _protobuf_package + ".InputTypeDescriptor"
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .standard(proto: "type_name"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
while let fieldNumber = try decoder.nextFieldNumber() {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch fieldNumber {
case 1: try { try decoder.decodeSingularStringField(value: &self.typeName) }()
default: break
}
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
if !self.typeName.isEmpty {
try visitor.visitSingularStringField(value: self.typeName, fieldNumber: 1)
}
try unknownFields.traverse(visitor: &visitor)
}
public static func ==(lhs: SyftProto_Execution_V1_InputTypeDescriptor, rhs: SyftProto_Execution_V1_InputTypeDescriptor) -> Bool {
if lhs.typeName != rhs.typeName {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
extension SyftProto_Execution_V1_NestedTypeWrapper: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
public static let protoMessageName: String = _protobuf_package + ".NestedTypeWrapper"
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .standard(proto: "nested_types"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
while let fieldNumber = try decoder.nextFieldNumber() {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch fieldNumber {
case 1: try { try decoder.decodeSingularMessageField(value: &self._nestedTypes) }()
default: break
}
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
if let v = self._nestedTypes {
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
}
try unknownFields.traverse(visitor: &visitor)
}
public static func ==(lhs: SyftProto_Execution_V1_NestedTypeWrapper, rhs: SyftProto_Execution_V1_NestedTypeWrapper) -> Bool {
if lhs._nestedTypes != rhs._nestedTypes {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
extension SyftProto_Execution_V1_NestedTypeWrapper.TypeList: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
public static let protoMessageName: String = SyftProto_Execution_V1_NestedTypeWrapper.protoMessageName + ".TypeList"
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .standard(proto: "nested_types"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
while let fieldNumber = try decoder.nextFieldNumber() {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch fieldNumber {
case 1: try { try decoder.decodeRepeatedMessageField(value: &self.nestedTypes) }()
default: break
}
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
if !self.nestedTypes.isEmpty {
try visitor.visitRepeatedMessageField(value: self.nestedTypes, fieldNumber: 1)
}
try unknownFields.traverse(visitor: &visitor)
}
public static func ==(lhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeList, rhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeList) -> Bool {
if lhs.nestedTypes != rhs.nestedTypes {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
extension SyftProto_Execution_V1_NestedTypeWrapper.TypeTuple: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
public static let protoMessageName: String = SyftProto_Execution_V1_NestedTypeWrapper.protoMessageName + ".TypeTuple"
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .standard(proto: "nested_types"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
while let fieldNumber = try decoder.nextFieldNumber() {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch fieldNumber {
case 1: try { try decoder.decodeRepeatedMessageField(value: &self.nestedTypes) }()
default: break
}
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
if !self.nestedTypes.isEmpty {
try visitor.visitRepeatedMessageField(value: self.nestedTypes, fieldNumber: 1)
}
try unknownFields.traverse(visitor: &visitor)
}
public static func ==(lhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeTuple, rhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeTuple) -> Bool {
if lhs.nestedTypes != rhs.nestedTypes {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
extension SyftProto_Execution_V1_NestedTypeWrapper.TypeMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
public static let protoMessageName: String = SyftProto_Execution_V1_NestedTypeWrapper.protoMessageName + ".TypeMap"
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .standard(proto: "nested_types"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
while let fieldNumber = try decoder.nextFieldNumber() {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch fieldNumber {
case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SyftProto_Execution_V1_NestedTypeWrapper>.self, value: &self.nestedTypes) }()
default: break
}
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
if !self.nestedTypes.isEmpty {
try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap<SwiftProtobuf.ProtobufString,SyftProto_Execution_V1_NestedTypeWrapper>.self, value: self.nestedTypes, fieldNumber: 1)
}
try unknownFields.traverse(visitor: &visitor)
}
public static func ==(lhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeMap, rhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeMap) -> Bool {
if lhs.nestedTypes != rhs.nestedTypes {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
extension SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
public static let protoMessageName: String = SyftProto_Execution_V1_NestedTypeWrapper.protoMessageName + ".TypeContainer"
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .standard(proto: "nested_type"),
2: .standard(proto: "nested_type_list"),
3: .standard(proto: "nested_type_tuple"),
4: .standard(proto: "nested_type_dict"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
while let fieldNumber = try decoder.nextFieldNumber() {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch fieldNumber {
case 1: try {
var v: SyftProto_Execution_V1_InputTypeDescriptor?
if let current = self.nestedContainer {
try decoder.handleConflictingOneOf()
if case .nestedType(let m) = current {v = m}
}
try decoder.decodeSingularMessageField(value: &v)
if let v = v {self.nestedContainer = .nestedType(v)}
}()
case 2: try {
var v: SyftProto_Execution_V1_NestedTypeWrapper.TypeList?
if let current = self.nestedContainer {
try decoder.handleConflictingOneOf()
if case .nestedTypeList(let m) = current {v = m}
}
try decoder.decodeSingularMessageField(value: &v)
if let v = v {self.nestedContainer = .nestedTypeList(v)}
}()
case 3: try {
var v: SyftProto_Execution_V1_NestedTypeWrapper.TypeTuple?
if let current = self.nestedContainer {
try decoder.handleConflictingOneOf()
if case .nestedTypeTuple(let m) = current {v = m}
}
try decoder.decodeSingularMessageField(value: &v)
if let v = v {self.nestedContainer = .nestedTypeTuple(v)}
}()
case 4: try {
var v: SyftProto_Execution_V1_NestedTypeWrapper.TypeMap?
if let current = self.nestedContainer {
try decoder.handleConflictingOneOf()
if case .nestedTypeDict(let m) = current {v = m}
}
try decoder.decodeSingularMessageField(value: &v)
if let v = v {self.nestedContainer = .nestedTypeDict(v)}
}()
default: break
}
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every case branch when no optimizations are
// enabled. https://github.com/apple/swift-protobuf/issues/1034
switch self.nestedContainer {
case .nestedType?: try {
guard case .nestedType(let v)? = self.nestedContainer else { preconditionFailure() }
try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
}()
case .nestedTypeList?: try {
guard case .nestedTypeList(let v)? = self.nestedContainer else { preconditionFailure() }
try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
}()
case .nestedTypeTuple?: try {
guard case .nestedTypeTuple(let v)? = self.nestedContainer else { preconditionFailure() }
try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
}()
case .nestedTypeDict?: try {
guard case .nestedTypeDict(let v)? = self.nestedContainer else { preconditionFailure() }
try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
}()
case nil: break
}
try unknownFields.traverse(visitor: &visitor)
}
public static func ==(lhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer, rhs: SyftProto_Execution_V1_NestedTypeWrapper.TypeContainer) -> Bool {
if lhs.nestedContainer != rhs.nestedContainer {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
| 43.819413 | 203 | 0.727591 |
f94300d6b0f86fd78f93a864714cbd47905ec5b0 | 2,190 | //
// AppDelegate.swift
// CPCollectionViewCardLayoutDemo
//
// Created by Parsifal on 2017/2/13.
// Copyright © 2017年 Parsifal. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
func applicationWillResignActive(_ application: UIApplication) {
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game.
}
func applicationDidEnterBackground(_ application: UIApplication) {
// Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
// If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}
func applicationWillEnterForeground(_ application: UIApplication) {
// Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
}
func applicationDidBecomeActive(_ application: UIApplication) {
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}
func applicationWillTerminate(_ application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}
}
| 46.595745 | 285 | 0.757991 |
e91eafabfeff388bb97b8158241a2420d9feab7a | 1,472 | //
// This source file is part of the Web3Swift.io open source project
// Copyright 2018 The Web3Swift Authors
// Licensed under Apache License v2.0
//
// EthRLPTests.swift
//
// Created by Timofey Solonin on 10/05/2018
//
import Nimble
import Quick
@testable import Web3Swift
final class EthRLPTests: XCTestCase {
func testEncodesZeroCorrectly() {
expect{
try EthRLP(
number: EthNumber(
value: 0
)
).value()
}.to(
equal(
Data(
[0x80]
)
),
description: "EthRLP encoded 0 is expected to match empty byte RLP encoding (0x80)"
)
}
func testEncodingPersistsForOtherValues() {
Array<
(
Int,
Array<UInt8>
)
>(
[
(1, [0x01]),
(15, [0x0f]),
(1024, [0x82, 0x04, 0x00])
]
).forEach{ value, bytes in
expect{
try EthRLP(
number: EthNumber(
value: value
)
).value()
}.to(
equal(
Data(
bytes
)
),
description: "Value \(value) is expected to be encoded as \(bytes)"
)
}
}
}
| 22.646154 | 95 | 0.408967 |
d7721b75f4e4376a489062253de91a9d1316c51c | 9,658 | //
// DocumentManifest.swift
// HealthSoftware
//
// Generated from FHIR 4.5.0-a621ed4bdc (http://hl7.org/fhir/StructureDefinition/DocumentManifest)
// Copyright 2020 Apple Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import FMCore
/**
A list that defines a set of documents.
A collection of documents compiled for a purpose together with metadata that applies to the collection.
*/
open class DocumentManifest: DomainResource {
override open class var resourceType: ResourceType { return .documentManifest }
/// Unique Identifier for the set of documents
public var masterIdentifier: Identifier?
/// Other identifiers for the manifest
public var identifier: [Identifier]?
/// The status of this document manifest.
public var status: FHIRPrimitive<DocumentReferenceStatus>
/// Kind of document set
public var type: CodeableConcept?
/// The subject of the set of documents
public var subject: Reference?
/// When this document manifest created
public var created: FHIRPrimitive<DateTime>?
/// Who and/or what authored the DocumentManifest
public var author: [Reference]?
/// Intended to get notified about this set of documents
public var recipient: [Reference]?
/// The source system/application/software
public var source: FHIRPrimitive<FHIRURI>?
/// Human-readable description (title)
public var description_fhir: FHIRPrimitive<FHIRString>?
/// Items in manifest
public var content: [Reference]
/// Related things
public var related: [DocumentManifestRelated]?
/// Designated initializer taking all required properties
public init(content: [Reference], status: FHIRPrimitive<DocumentReferenceStatus>) {
self.content = content
self.status = status
super.init()
}
/// Convenience initializer
public convenience init(
author: [Reference]? = nil,
contained: [ResourceProxy]? = nil,
content: [Reference],
created: FHIRPrimitive<DateTime>? = nil,
description_fhir: FHIRPrimitive<FHIRString>? = nil,
`extension`: [Extension]? = nil,
id: FHIRPrimitive<FHIRString>? = nil,
identifier: [Identifier]? = nil,
implicitRules: FHIRPrimitive<FHIRURI>? = nil,
language: FHIRPrimitive<FHIRString>? = nil,
masterIdentifier: Identifier? = nil,
meta: Meta? = nil,
modifierExtension: [Extension]? = nil,
recipient: [Reference]? = nil,
related: [DocumentManifestRelated]? = nil,
source: FHIRPrimitive<FHIRURI>? = nil,
status: FHIRPrimitive<DocumentReferenceStatus>,
subject: Reference? = nil,
text: Narrative? = nil,
type: CodeableConcept? = nil)
{
self.init(content: content, status: status)
self.author = author
self.contained = contained
self.created = created
self.description_fhir = description_fhir
self.`extension` = `extension`
self.id = id
self.identifier = identifier
self.implicitRules = implicitRules
self.language = language
self.masterIdentifier = masterIdentifier
self.meta = meta
self.modifierExtension = modifierExtension
self.recipient = recipient
self.related = related
self.source = source
self.subject = subject
self.text = text
self.type = type
}
// MARK: - Codable
private enum CodingKeys: String, CodingKey {
case author
case content
case created; case _created
case description_fhir = "description"; case _description_fhir = "_description"
case identifier
case masterIdentifier
case recipient
case related
case source; case _source
case status; case _status
case subject
case type
}
/// Initializer for Decodable
public required init(from decoder: Decoder) throws {
let _container = try decoder.container(keyedBy: CodingKeys.self)
// Decode all our properties
self.author = try [Reference](from: _container, forKeyIfPresent: .author)
self.content = try [Reference](from: _container, forKey: .content)
self.created = try FHIRPrimitive<DateTime>(from: _container, forKeyIfPresent: .created, auxiliaryKey: ._created)
self.description_fhir = try FHIRPrimitive<FHIRString>(from: _container, forKeyIfPresent: .description_fhir, auxiliaryKey: ._description_fhir)
self.identifier = try [Identifier](from: _container, forKeyIfPresent: .identifier)
self.masterIdentifier = try Identifier(from: _container, forKeyIfPresent: .masterIdentifier)
self.recipient = try [Reference](from: _container, forKeyIfPresent: .recipient)
self.related = try [DocumentManifestRelated](from: _container, forKeyIfPresent: .related)
self.source = try FHIRPrimitive<FHIRURI>(from: _container, forKeyIfPresent: .source, auxiliaryKey: ._source)
self.status = try FHIRPrimitive<DocumentReferenceStatus>(from: _container, forKey: .status, auxiliaryKey: ._status)
self.subject = try Reference(from: _container, forKeyIfPresent: .subject)
self.type = try CodeableConcept(from: _container, forKeyIfPresent: .type)
try super.init(from: decoder)
}
/// Encodable
public override func encode(to encoder: Encoder) throws {
var _container = encoder.container(keyedBy: CodingKeys.self)
// Encode all our properties
try author?.encode(on: &_container, forKey: .author)
try content.encode(on: &_container, forKey: .content)
try created?.encode(on: &_container, forKey: .created, auxiliaryKey: ._created)
try description_fhir?.encode(on: &_container, forKey: .description_fhir, auxiliaryKey: ._description_fhir)
try identifier?.encode(on: &_container, forKey: .identifier)
try masterIdentifier?.encode(on: &_container, forKey: .masterIdentifier)
try recipient?.encode(on: &_container, forKey: .recipient)
try related?.encode(on: &_container, forKey: .related)
try source?.encode(on: &_container, forKey: .source, auxiliaryKey: ._source)
try status.encode(on: &_container, forKey: .status, auxiliaryKey: ._status)
try subject?.encode(on: &_container, forKey: .subject)
try type?.encode(on: &_container, forKey: .type)
try super.encode(to: encoder)
}
// MARK: - Equatable & Hashable
public override func isEqual(to _other: Any?) -> Bool {
guard let _other = _other as? DocumentManifest else {
return false
}
guard super.isEqual(to: _other) else {
return false
}
return author == _other.author
&& content == _other.content
&& created == _other.created
&& description_fhir == _other.description_fhir
&& identifier == _other.identifier
&& masterIdentifier == _other.masterIdentifier
&& recipient == _other.recipient
&& related == _other.related
&& source == _other.source
&& status == _other.status
&& subject == _other.subject
&& type == _other.type
}
public override func hash(into hasher: inout Hasher) {
super.hash(into: &hasher)
hasher.combine(author)
hasher.combine(content)
hasher.combine(created)
hasher.combine(description_fhir)
hasher.combine(identifier)
hasher.combine(masterIdentifier)
hasher.combine(recipient)
hasher.combine(related)
hasher.combine(source)
hasher.combine(status)
hasher.combine(subject)
hasher.combine(type)
}
}
/**
Related things.
Related identifiers or resources associated with the DocumentManifest.
*/
open class DocumentManifestRelated: BackboneElement {
/// Identifiers of things that are related
public var identifier: Identifier?
/// Related Resource
public var ref: Reference?
/// Designated initializer taking all required properties
override public init() {
super.init()
}
/// Convenience initializer
public convenience init(
`extension`: [Extension]? = nil,
id: FHIRPrimitive<FHIRString>? = nil,
identifier: Identifier? = nil,
modifierExtension: [Extension]? = nil,
ref: Reference? = nil)
{
self.init()
self.`extension` = `extension`
self.id = id
self.identifier = identifier
self.modifierExtension = modifierExtension
self.ref = ref
}
// MARK: - Codable
private enum CodingKeys: String, CodingKey {
case identifier
case ref
}
/// Initializer for Decodable
public required init(from decoder: Decoder) throws {
let _container = try decoder.container(keyedBy: CodingKeys.self)
// Decode all our properties
self.identifier = try Identifier(from: _container, forKeyIfPresent: .identifier)
self.ref = try Reference(from: _container, forKeyIfPresent: .ref)
try super.init(from: decoder)
}
/// Encodable
public override func encode(to encoder: Encoder) throws {
var _container = encoder.container(keyedBy: CodingKeys.self)
// Encode all our properties
try identifier?.encode(on: &_container, forKey: .identifier)
try ref?.encode(on: &_container, forKey: .ref)
try super.encode(to: encoder)
}
// MARK: - Equatable & Hashable
public override func isEqual(to _other: Any?) -> Bool {
guard let _other = _other as? DocumentManifestRelated else {
return false
}
guard super.isEqual(to: _other) else {
return false
}
return identifier == _other.identifier
&& ref == _other.ref
}
public override func hash(into hasher: inout Hasher) {
super.hash(into: &hasher)
hasher.combine(identifier)
hasher.combine(ref)
}
}
| 32.738983 | 143 | 0.722303 |
eb019f4850894d359f75ee8a25ee597f88de6c82 | 472 | import CSDL2
public struct ImageType: OptionSet {
public let rawValue : Int32
public init(rawValue: Int32) {
self.rawValue = rawValue
}
public static let jpg = ImageType(rawValue: Int32(IMG_INIT_JPG.rawValue))
public static let png = ImageType(rawValue: Int32(IMG_INIT_PNG.rawValue))
public static let tif = ImageType(rawValue: Int32(IMG_INIT_TIF.rawValue))
public static let webp = ImageType(rawValue: Int32(IMG_INIT_WEBP.rawValue))
} | 39.333333 | 79 | 0.737288 |
9bc51e400d9f0d4a69c49ac03321387f48ef9618 | 1,162 | //
// creationalUITests.swift
// creationalUITests
//
// Created by Hung Truong on 10/5/19.
// Copyright © 2020 hungtq. All rights reserved.
//
import XCTest
class creationalUITests: XCTestCase {
override func setUp() {
// Put setup code here. This method is called before the invocation of each test method in the class.
// In UI tests it is usually best to stop immediately when a failure occurs.
continueAfterFailure = false
// UI tests must launch the application that they test. Doing this in setup will make sure it happens for each test method.
XCUIApplication().launch()
// In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this.
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class.
}
func testExample() {
// Use recording to get started writing UI tests.
// Use XCTAssert and related functions to verify your tests produce the correct results.
}
}
| 33.2 | 182 | 0.69105 |
2fce65bc839ea5bcc3f48ca42b68bd4353a4e7fa | 531 | //
// UIColor+UIImage.swift
// Sluthware
//
// Created by Pat Sluth on 2017-12-02.
// Copyright © 2017 Pat Sluth. All rights reserved.
//
import Foundation
public extension UIColor
{
var uiImage: UIImage? {
let rect = CGRect(x: 0, y: 0, width: 1, height: 1)
UIGraphicsBeginImageContext(rect.size)
defer {
UIGraphicsEndImageContext()
}
let context = UIGraphicsGetCurrentContext()
context?.setFillColor(self.cgColor)
context?.fill(rect)
return UIGraphicsGetImageFromCurrentImageContext()
}
}
| 15.171429 | 52 | 0.700565 |
9bdfeb4ab85d79a37087c25b8d944523f174c7a1 | 4,792 | //
// Week6 BestTimeToBuyAndSellStockWithTransactionFee.swift
// LeetCodeProblems-Swift
//
// Created by Ficow on 2021/9/12.
//
import Foundation
/*
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/
1. dp
Time: O(n), Space: O(n) / O(1)
2. greedy
Time: O(n), Space: O(1)
*/
final class Week6BestTimeToBuyAndSellStockWithTransactionFee {
func run() {
let f = greedy3
func judge(prices: [Int], fee: Int, result: Int) {
printAndAssert(result: f(prices, fee), expected: result)
}
judge(prices: [1,3,2,8,4,9], fee: 2, result: 8)
// judge(prices: [1,3,7,5,10,3], fee: 3, result: 6)
}
func greedy5(_ prices: [Int], _ fee: Int) -> Int {
fatalError()
}
func dp5(_ prices: [Int], _ fee: Int) -> Int {
fatalError()
}
func rawDP5(_ prices: [Int], _ fee: Int) -> Int {
fatalError()
}
func greedy4(_ prices: [Int], _ fee: Int) -> Int {
fatalError()
}
func dp4(_ prices: [Int], _ fee: Int) -> Int {
fatalError()
}
func rawDP4(_ prices: [Int], _ fee: Int) -> Int {
fatalError()
}
func greedy3(_ prices: [Int], _ fee: Int) -> Int {
var buy = prices[0] + fee, profit = 0
for i in 1..<prices.count {
if prices[i] + fee < buy { // prices going down
buy = prices[i] + fee // buy at the lowest
} else if prices[i] > buy { // prices going up
profit += prices[i] - buy // sell the the highest
buy = prices[i]
}
}
return profit
}
func dp3(_ prices: [Int], _ fee: Int) -> Int {
var noStock = 0, hasStock = -prices[0]
for i in 1..<prices.count {
(noStock, hasStock) = (
max(noStock, hasStock + prices[i] - fee),
max(hasStock, noStock - prices[i])
)
}
return noStock
}
func rawDP3(_ prices: [Int], _ fee: Int) -> Int {
let n = prices.count
var noStock = [Int](repeating: 0, count: n), hasStock = noStock
hasStock[0] = -prices[0]
for i in 1..<n {
noStock[i] = max(noStock[i - 1], hasStock[i - 1] + prices[i] - fee)
hasStock[i] = max(hasStock[i - 1], noStock[i - 1] - prices[i])
}
return noStock[n - 1]
}
func greedy2(_ prices: [Int], _ fee: Int) -> Int {
var buy = prices[0] + fee, profit = 0
for i in 1..<prices.count {
if prices[i] + fee < buy {
buy = prices[i] + fee
} else if prices[i] > buy {
profit += prices[i] - buy
buy = prices[i]
}
}
return profit
}
func dp2(_ prices: [Int], _ fee: Int) -> Int {
var noStock = 0, hasStock = -prices[0]
for i in 1..<prices.count {
(noStock, hasStock) = (
max(noStock, hasStock + prices[i] - fee),
max(hasStock, noStock - prices[i])
)
}
return noStock
}
func rawDP2(_ prices: [Int], _ fee: Int) -> Int {
let n = prices.count
var noStock = [Int](repeating: 0, count: n), hasStock = noStock
hasStock[0] = -prices[0]
for i in 1..<n {
noStock[i] = max(noStock[i - 1], hasStock[i - 1] + prices[i] - fee)
hasStock[i] = max(hasStock[i - 1], noStock[i - 1] - prices[i])
}
return noStock[n - 1]
}
func greedy1(_ prices: [Int], _ fee: Int) -> Int {
let n = prices.count
var buy = prices[0] + fee, profit = 0
for i in 1..<n {
if prices[i] + fee < buy { // price goes down
buy = prices[i] + fee // buy at the lowest
} else if prices[i] > buy { // price goes up
profit += prices[i] - buy // sell at the highest
buy = prices[i] // record
}
}
return profit
}
func dp1(_ prices: [Int], _ fee: Int) -> Int {
var noStock = 0, hasStock = -prices[0]
for i in 1..<prices.count {
(noStock, hasStock) = (
max(noStock, hasStock + prices[i] - fee),
max(hasStock, noStock - prices[i])
)
}
return noStock
}
func rawDP1(_ prices: [Int], _ fee: Int) -> Int {
let n = prices.count
var noStock = [Int](repeating: 0, count: n), hasStock = noStock
hasStock[0] = -prices[0]
for i in 1..<n {
noStock[i] = max(noStock[i - 1], hasStock[i - 1] + prices[i] - fee)
hasStock[i] = max(hasStock[i - 1], noStock[i - 1] - prices[i])
}
return noStock[n - 1]
}
}
| 24.829016 | 87 | 0.485392 |
e66fca9754b5ca9fcadf9a7c6d680aaedbb2fc56 | 1,426 | //
// Array+matchingRequestTests.swift
//
//
// Created by Kane Cheshire on 05/12/2019.
//
import XCTest
@testable import Peasy
final class Array_matchingRequestTests: XCTestCase {
func test_noMatchingRequest() {
let configs: [Server.Configuration] = [.init(response: { _ in fatalError() }, rules: [.path(matches: "/"), .method(matches: .get)], removeAfterResponding: true)]
let invalidRequest = Request(method: .post, headers: [], path: "/", queryParameters: [], body: Data())
XCTAssertNil(configs.matching(invalidRequest))
let validRequest = Request(method: .get, headers: [], path: "/", queryParameters: [], body: Data())
XCTAssertEqual(configs.matching(validRequest), configs.first!)
}
func test_multipleMatchingRequests() {
let configs: [Server.Configuration] = [.init(response: { _ in fatalError() }, rules: [.path(matches: "/"), .method(matches: .post)], removeAfterResponding: true),
.init(response: { _ in fatalError() }, rules: [.path(matches: "/"), .method(matches: .get)], removeAfterResponding: true),
.init(response: { _ in fatalError() }, rules: [.path(matches: "/"), .method(matches: .get)], removeAfterResponding: true)]
let request = Request(method: .get, headers: [], path: "/", queryParameters: [], body: Data())
XCTAssertEqual(configs.matching(request), configs[1])
XCTAssertNotEqual(configs.matching(request), configs[2])
}
}
| 46 | 164 | 0.674614 |
33c305624bbd60e0e0c02598bf9dd9fdf4e5fd87 | 1,547 | //
// File.swift
//
//
// Created by Yehor Popovych on 12/16/20.
//
import Foundation
import NIO
import NIOWebSocket
private extension WebSocketErrorCode {
init(_ error: NIOWebSocketError) {
switch error {
case .invalidFrameLength:
self = .messageTooLarge
case .fragmentedControlFrame, .multiByteControlFrameLength:
self = .protocolError
}
}
}
class WebSocketHandler: ChannelInboundHandler {
typealias InboundIn = WebSocketFrame
typealias OutboundOut = WebSocketFrame
private var webSocket: WebSocket
init(webSocket: WebSocket) {
self.webSocket = webSocket
}
func channelRead(context: ChannelHandlerContext, data: NIOAny) {
let frame = unwrapInboundIn(data)
webSocket.handle(frame: frame)
}
func errorCaught(context: ChannelHandlerContext, error: Error) {
let errorCode: WebSocketErrorCode
if let error = error as? NIOWebSocketError {
errorCode = WebSocketErrorCode(error)
} else {
errorCode = .unexpectedServerError
}
_ = webSocket.close(code: errorCode)
// We always forward the error on to let others see it.
context.fireErrorCaught(error)
}
func channelInactive(context: ChannelHandlerContext) {
let closedAbnormally = WebSocketErrorCode.unknown(1006)
_ = webSocket.close(code: closedAbnormally)
// We always forward the error on to let others see it.
context.fireChannelInactive()
}
}
| 26.672414 | 68 | 0.663219 |
69917367d15c0652bec790d23888dd828c3ab821 | 15,146 | //
// MapTests.swift
//
//
// Created by Anton Nazarov on 25/06/2019.
//
import XCTest
#if OPENCOMBINE_COMPATIBILITY_TEST
import Combine
#else
import OpenCombine
#endif
@available(macOS 10.15, iOS 13.0, *)
final class MapTests: XCTestCase {
func testEmpty() {
// Given
let tracking = TrackingSubscriberBase<String, TestingError>(
receiveSubscription: { $0.request(.unlimited) }
)
let publisher = TrackingSubject<Int>(
receiveSubscriber: {
XCTAssertEqual(String(describing: $0), "Map")
}
)
// When
publisher.map(String.init).subscribe(tracking)
// Then
XCTAssertEqual(tracking.history, [.subscription("PassthroughSubject")])
}
func testError() {
// Given
let expectedError = TestingError.oops
let tracking = TrackingSubscriber(receiveSubscription: { $0.request(.unlimited) })
let publisher = CustomPublisher(subscription: CustomSubscription())
// When
publisher.map { $0 * 2 }.subscribe(tracking)
publisher.send(completion: .failure(expectedError))
publisher.send(completion: .failure(expectedError))
// Then
XCTAssertEqual(tracking.history, [
.subscription("CustomSubscription"),
.completion(.failure(expectedError)),
.completion(.failure(expectedError))
])
}
func testTryMapFailureBecauseOfThrow() {
var counter = 0 // How many times the transform is called?
let publisher = PassthroughSubject<Int, Error>()
let map = publisher.tryMap { value -> Int in
counter += 1
if value == 100 {
throw "too much" as TestingError
}
return value * 2
}
let tracking = TrackingSubscriberBase<Int, Error>(
receiveSubscription: { $0.request(.unlimited) }
)
publisher.send(1)
map.subscribe(tracking)
publisher.send(2)
publisher.send(3)
publisher.send(100)
publisher.send(9)
publisher.send(completion: .finished)
XCTAssertEqual(tracking.history,
[.subscription("TryMap"),
.value(4),
.value(6),
.completion(.failure("too much" as TestingError))])
XCTAssertEqual(counter, 3)
}
func testTryMapFailureOnCompletion() {
let publisher = PassthroughSubject<Int, Error>()
let map = publisher.tryMap { $0 * 2 }
let tracking = TrackingSubscriberBase<Int, Error>()
publisher.send(1)
map.subscribe(tracking)
publisher.send(completion: .failure(TestingError.oops))
publisher.send(2)
XCTAssertEqual(tracking.history,
[.subscription("TryMap"),
.completion(.failure(TestingError.oops))])
}
func testTryMapSuccess() {
let publisher = PassthroughSubject<Int, Error>()
let map = publisher.tryMap { $0 * 2 }
let tracking = TrackingSubscriberBase<Int, Error>()
publisher.send(1)
map.subscribe(tracking)
publisher.send(completion: .finished)
publisher.send(2)
XCTAssertEqual(tracking.history,
[.subscription("TryMap"),
.completion(.finished)])
}
func testRange() {
// Given
let publisher = PassthroughSubject<Int, TestingError>()
let map = publisher.map { $0 * 2 }
let tracking = TrackingSubscriber(receiveSubscription: { $0.request(.unlimited) })
// When
publisher.send(1)
map.subscribe(tracking)
publisher.send(2)
publisher.send(3)
publisher.send(completion: .finished)
publisher.send(5)
// Then
XCTAssertEqual(tracking.history, [
.subscription("PassthroughSubject"),
.value(4),
.value(6),
.completion(.finished)
])
}
func testNoDemand() {
// Given
let subscription = CustomSubscription()
let publisher = CustomPublisher(subscription: subscription)
let map = publisher.map { $0 * 2 }
let tracking = TrackingSubscriber()
// When
map.subscribe(tracking)
// Then
XCTAssertTrue(subscription.history.isEmpty)
}
func testDemandSubscribe() {
// Given
let expectedSubscribeDemand = 42
let subscription = CustomSubscription()
let publisher = CustomPublisher(subscription: subscription)
let map = publisher.map { $0 * 2 }
let tracking = TrackingSubscriber(
receiveSubscription: { $0.request(.max(expectedSubscribeDemand)) }
)
// When
map.subscribe(tracking)
// Then
XCTAssertEqual(subscription.history, [.requested(.max(expectedSubscribeDemand))])
}
func testDemandSend() {
var expectedReceiveValueDemand = 4
let subscription = CustomSubscription()
let publisher = CustomPublisher(subscription: subscription)
let map = publisher.map { $0 * 2 }
let tracking = TrackingSubscriber(
receiveSubscription: { $0.request(.unlimited) },
receiveValue: { _ in .max(expectedReceiveValueDemand) }
)
map.subscribe(tracking)
XCTAssertEqual(publisher.send(0), .max(4))
expectedReceiveValueDemand = 120
XCTAssertEqual(publisher.send(0), .max(120))
}
func testCompletion() {
// Given
let subscription = CustomSubscription()
let publisher = CustomPublisher(subscription: subscription)
let map = publisher.map { $0 * 2 }
let tracking = TrackingSubscriber(receiveSubscription: { $0.request(.unlimited) })
// When
map.subscribe(tracking)
publisher.send(completion: .finished)
// Then
XCTAssertEqual(subscription.history, [.requested(.unlimited)])
XCTAssertEqual(
tracking.history,
[.subscription("CustomSubscription"), .completion(.finished)]
)
}
func testMapCancel() throws {
// Given
let subscription = CustomSubscription()
let publisher = CustomPublisher(subscription: subscription)
let map = publisher.map { $0 * 2 }
var downstreamSubscription: Subscription?
let tracking = TrackingSubscriber(receiveSubscription: {
$0.request(.unlimited)
downstreamSubscription = $0
})
// When
map.subscribe(tracking)
try XCTUnwrap(downstreamSubscription).cancel()
XCTAssertEqual(publisher.send(1), .none)
publisher.send(completion: .finished)
// Then
XCTAssertEqual(subscription.history, [.requested(.unlimited), .cancelled])
}
func testTryMapCancel() throws {
// Given
let subscription = CustomSubscription()
let publisher = CustomPublisher(subscription: subscription)
let map = publisher.tryMap { $0 * 2 }
var downstreamSubscription: Subscription?
let tracking = TrackingSubscriberBase<Int, Error>(receiveSubscription: {
$0.request(.unlimited)
downstreamSubscription = $0
})
// When
map.subscribe(tracking)
try XCTUnwrap(downstreamSubscription).cancel()
XCTAssertEqual(publisher.send(1), .none)
publisher.send(completion: .finished)
// Then
XCTAssertEqual(subscription.history, [.requested(.unlimited), .cancelled])
}
func testCancelAlreadyCancelled() throws {
// Given
let subscription = CustomSubscription()
let publisher = CustomPublisher(subscription: subscription)
let map = publisher.map { $0 * 2 }
var downstreamSubscription: Subscription?
let tracking = TrackingSubscriber(receiveSubscription: {
$0.request(.unlimited)
downstreamSubscription = $0
})
// When
map.subscribe(tracking)
try XCTUnwrap(downstreamSubscription).cancel()
downstreamSubscription?.request(.unlimited)
try XCTUnwrap(downstreamSubscription).cancel()
// Then
XCTAssertEqual(subscription.history, [.requested(.unlimited),
.cancelled,
.requested(.unlimited),
.cancelled])
}
func testLifecycle() throws {
var deinitCounter = 0
let onDeinit = { deinitCounter += 1 }
do {
let passthrough = PassthroughSubject<Int, TestingError>()
let map = passthrough.map { $0 * 2 }
let emptySubscriber = TrackingSubscriber(onDeinit: onDeinit)
XCTAssertTrue(emptySubscriber.history.isEmpty)
map.subscribe(emptySubscriber)
XCTAssertEqual(emptySubscriber.subscriptions.count, 1)
passthrough.send(31)
XCTAssertEqual(emptySubscriber.inputs.count, 0)
passthrough.send(completion: .failure("failure"))
XCTAssertEqual(emptySubscriber.completions.count, 1)
}
XCTAssertEqual(deinitCounter, 1)
do {
let passthrough = PassthroughSubject<Int, TestingError>()
let map = passthrough.map { $0 * 2 }
let emptySubscriber = TrackingSubscriber(onDeinit: onDeinit)
XCTAssertTrue(emptySubscriber.history.isEmpty)
map.subscribe(emptySubscriber)
XCTAssertEqual(emptySubscriber.subscriptions.count, 1)
XCTAssertEqual(emptySubscriber.inputs.count, 0)
XCTAssertEqual(emptySubscriber.completions.count, 0)
}
XCTAssertEqual(deinitCounter, 1)
var subscription: Subscription?
do {
let passthrough = PassthroughSubject<Int, TestingError>()
let map = passthrough.map { $0 * 2 }
let emptySubscriber = TrackingSubscriber(
receiveSubscription: { subscription = $0; $0.request(.unlimited) },
onDeinit: onDeinit
)
XCTAssertTrue(emptySubscriber.history.isEmpty)
map.subscribe(emptySubscriber)
XCTAssertEqual(emptySubscriber.subscriptions.count, 1)
passthrough.send(31)
XCTAssertEqual(emptySubscriber.inputs.count, 1)
XCTAssertEqual(emptySubscriber.completions.count, 0)
XCTAssertNotNil(subscription)
}
XCTAssertEqual(deinitCounter, 1)
try XCTUnwrap(subscription).cancel()
XCTAssertEqual(deinitCounter, 2)
}
func testMapOperatorSpecializationForMap() {
let tracking = TrackingSubscriberBase<Int, Never>(
receiveSubscription: { $0.request(.unlimited) }
)
let publisher = PassthroughSubject<Int, Never>()
let map1 = publisher.map { $0 * 2 }
let map2 = map1.map { $0 + 1 }
map2.subscribe(tracking)
publisher.send(2)
publisher.send(3)
publisher.send(5)
publisher.send(completion: .finished)
XCTAssert(map1.upstream === map2.upstream)
XCTAssertEqual(tracking.history, [.subscription("PassthroughSubject"),
.value(5),
.value(7),
.value(11),
.completion(.finished)])
}
func testTryMapOperatorSpecializationForMap() {
let tracking = TrackingSubscriberBase<Int, Error>(
receiveSubscription: { $0.request(.unlimited) }
)
let publisher = PassthroughSubject<Int, Never>()
let map1 = publisher.map { $0 * 2 }
let tryMap2 = map1.tryMap { input -> Int in
if input == 12 { throw TestingError.oops }
return input + 1
}
tryMap2.subscribe(tracking)
publisher.send(2)
publisher.send(3)
publisher.send(5)
XCTAssert(map1.upstream === tryMap2.upstream)
XCTAssertEqual(tracking.history, [.subscription("TryMap"),
.value(5),
.value(7),
.value(11)])
publisher.send(6)
XCTAssertEqual(tracking.history, [.subscription("TryMap"),
.value(5),
.value(7),
.value(11),
.completion(.failure(TestingError.oops))])
}
func testMapOperatorSpecializationForTryMap() {
let tracking = TrackingSubscriberBase<Int, Error>(
receiveSubscription: { $0.request(.unlimited) }
)
let publisher = PassthroughSubject<Int, Never>()
let tryMap1 = publisher.tryMap { input -> Int in
if input == 6 { throw TestingError.oops }
return input * 2
}
let tryMap2 = tryMap1.map { $0 + 1 }
tryMap2.subscribe(tracking)
publisher.send(2)
publisher.send(3)
publisher.send(5)
XCTAssert(tryMap1.upstream === tryMap2.upstream)
XCTAssertEqual(tracking.history, [.subscription("TryMap"),
.value(5),
.value(7),
.value(11)])
publisher.send(6)
XCTAssertEqual(tracking.history, [.subscription("TryMap"),
.value(5),
.value(7),
.value(11),
.completion(.failure(TestingError.oops))])
}
func testTryMapOperatorSpecializationForTryMap() {
let tracking = TrackingSubscriberBase<Int, Error>(
receiveSubscription: { $0.request(.unlimited) }
)
let publisher = PassthroughSubject<Int, Never>()
let tryMap1 = publisher.tryMap { input -> Int in
if input == 6 { throw TestingError.oops }
return input * 2
}
let tryMap2 = tryMap1.tryMap { $0 + 1 }
tryMap2.subscribe(tracking)
publisher.send(2)
publisher.send(3)
publisher.send(5)
XCTAssert(tryMap1.upstream === tryMap2.upstream)
XCTAssertEqual(tracking.history, [.subscription("TryMap"),
.value(5),
.value(7),
.value(11)])
publisher.send(6)
XCTAssertEqual(tracking.history, [.subscription("TryMap"),
.value(5),
.value(7),
.value(11),
.completion(.failure(TestingError.oops))])
}
}
| 34.344671 | 90 | 0.558629 |
3ae4a6b7b44e8b65a62b9d08fbf4e35b272f37db | 1,032 | //
// PaymentsWireframe.swift
// ModuleArchitectureDemo
//
// Created by Mladen Despotovic on 29.06.18.
// Copyright © 2018 Mladen Despotovic. All rights reserved.
//
import Foundation
import UIKit
class PaymentWireframe: WireframeType {
// We use the default storyboard, which can be changed later by injected parameter
lazy var storyboard: UIStoryboard = UIStoryboard(name: "PaymentsStoryboard", bundle: nil)
var presentedViewControllers = [WeakContainer<UIViewController>]()
var presentationMode: ModulePresentationMode = .none
func presentPayViewController(with presenter: PaymentsPresenter, parameters: ModuleParameters?) {
setPresentationMode(from: parameters)
if let viewController = viewController(from: parameters) {
present(viewController: viewController)
guard let paymentsViewController = viewController as? PaymentsViewController else { return }
paymentsViewController.presenter = presenter
}
}
}
| 34.4 | 104 | 0.717054 |
72b51c165ef961731b536fb9b0c62c3047e2f3b8 | 14,486 | //
// Badger.swift
// IconBadger
//
// Created by iOS Developer on 18/3/21.
//
import Cocoa
let kJsonContentsFileName = "Contents.json"
let KRibbonWidthFactor: CGFloat = 283 / 450
let KRibbonHeightFactor: CGFloat = 87.68 / 450
let π: CGFloat = .pi
// MARK: - Conf
/// Style of the Badge
public struct BadgeStyle: CustomStringConvertible {
let text: String
let textColor: NSColor
let textFontName: String
let textAsMask: Bool
let ribbonPosition: RibbonPosition
let ribbonColor: RibbonColor
public var description: String {
var aString = String(format: "%@ : %@\n", "text".padded(toWidth: 40), text)
aString += String(format: "%20@ : %@\n", "text color".padded(toWidth: 40), textColor)
aString += String(format: "%20@ : %@\n", "font name".padded(toWidth: 40), textFontName)
aString += String(format: "%20@ : %@\n", "text as mask".padded(toWidth: 40), textAsMask ? "true" : "false")
aString += String(format: "%20@ : %@\n", "ribbon position".padded(toWidth: 40), ribbonPosition.rawValue)
aString += String(format: "%20@ : %@\n", "ribbon color".padded(toWidth: 40), ribbonColor.rawValue)
return aString
}
func ribbonImage(config: ScriptConfig) -> NSImage {
let ribbonFileName = "\(ribbonColor)-\(ribbonPosition).png"
let baseDir = config.resourcesRootPath.appendingPathComponent(path: "resources/ribbons")
let ribbonPath = baseDir.appendingPathComponent(path: ribbonFileName)
guard let image = NSImage(contentsOfFile: ribbonPath) else {
print("Could not read ribbon file located at \(ribbonPath)")
exit(EXIT_FAILURE)
}
return image
}
}
// MARK: - Image JSON structs
/// Structure of Contents.json
struct IconMetadata: Decodable {
var images: [ImageInfo]
func imageInfo(forSize size: String, scale: String, idiom: String) -> ImageInfo? {
for image in images {
if image.size == size, image.scale == scale, image.idiom == idiom {
return image
}
}
return nil
}
}
/// Image description structure
struct ImageInfo: Decodable {
var size: String
var idiom: String
var filename: String?
var scale: String
}
public struct Badger {
// MARK: - Properties
let style: BadgeStyle
let config: ScriptConfig
// MARK: - Image processing
private func generateBadgeImage(maxWidth: CGFloat, maxHeight: CGFloat) -> NSImage {
// vars
let drawText = getText(text: style.text, config: config)
let xPadding = maxWidth * 0.1
var textFontSize = maxWidth * 0.15
// make sure we can handle the font name
guard let _ = NSFont(name: style.textFontName, size: textFontSize) else {
print("Can't get the font named \(style.textFontName). Please make sure the font exists in the \"Font Book.app\"")
exit(EXIT_FAILURE)
}
// text shadow
let shadow = NSShadow()
shadow.shadowColor = .black
shadow.shadowBlurRadius = 5
shadow.shadowOffset = .zero
// text attributes
var textAttributes: [NSAttributedString.Key : Any] = [
.font: NSFont(name: style.textFontName, size: textFontSize)!,
.foregroundColor: style.textColor,
.shadow: shadow
]
// badge image
let badgeImage = NSImage(size: NSSize(width: maxWidth, height: maxHeight), flipped: false) { rect -> Bool in
// draw the ribbon image first
let ribbonWidth = KRibbonWidthFactor * maxWidth
let ribbonHeight = KRibbonHeightFactor * maxHeight
let ribbonImage = style.ribbonImage(config: config)
ribbonImage.draw(in: rect)
guard let context = NSGraphicsContext.current?.cgContext else {
print("Unable to get the current image context while trying to generate the badge image")
exit(EXIT_FAILURE)
}
var textSize = drawText.size(withAttributes: textAttributes)
while (textSize.width > ribbonWidth - xPadding || textSize.height > ribbonHeight) {
textFontSize -= 0.25
textAttributes[NSAttributedString.Key.font] = NSFont(name: style.textFontName, size: textFontSize)!
textSize = drawText.size(withAttributes: textAttributes)
}
// badge rect
var rotateBy = π/4
let dx = maxWidth * 0.2745
let dy = maxHeight * 0.2745
var badgeRect = rect.center(size: CGSize(width: ribbonWidth, height: ribbonHeight))
switch style.ribbonPosition {
case .topLeft:
badgeRect.center.x -= dx
badgeRect.center.y += dy
case .topRight:
rotateBy = -rotateBy
badgeRect.center.x += dx
badgeRect.center.y += dy
case .bottomRight:
badgeRect.center.x += dx
badgeRect.center.y -= dy
case .bottomLeft:
rotateBy = -rotateBy
badgeRect.center.x -= dx
badgeRect.center.y -= dy
}
context.translateBy(x: badgeRect.center.x, y: badgeRect.center.y)
context.rotate(by: rotateBy)
context.translateBy(x: -badgeRect.center.x, y: -badgeRect.center.y)
var textRect = badgeRect.center(size: textSize)
let bias = config.textVerticalBias * ribbonHeight
textRect.origin.y += bias
if style.textAsMask { context.setBlendMode(.destinationOut) }
drawText.draw(in: textRect, withAttributes: textAttributes)
return true
}
return badgeImage
}
private func generateOutputImage(source inputFile: String) -> NSImage {
guard let inputIcon = NSImage(contentsOfFile: inputFile) else {
print("Could not read input file located at \(inputFile)")
exit(EXIT_FAILURE)
}
let cgimage = inputIcon.cgImage(forProposedRect: nil, context: nil, hints: nil)
let realWidth = cgimage == nil ? inputIcon.size.width : CGFloat(cgimage!.width)
let realHeight = cgimage == nil ? inputIcon.size.height : CGFloat(cgimage!.height)
// debug print
if config.verbose {
print("Generating the badge image...")
}
let badgeIcon = generateBadgeImage(maxWidth: realWidth, maxHeight: realHeight)
// debug print
if config.verbose {
print("Merging the badge image with the app icon...")
}
let outputImage = NSImage(size: CGSize(width: realWidth, height: realHeight), flipped: false) { rect -> Bool in
inputIcon.draw(in: rect)
badgeIcon.draw(in: rect)
return true
}
return outputImage
}
// MARK: - Public
func processIcon() {
// make sure we got the right config
guard let config = config as? IconBadger.Icon.Config else {
print("Wrong configuration for the running script")
exit(EXIT_FAILURE)
}
// debug print
if config.verbose {
print("Config ===================================")
print(config)
print("Style ====================================")
print(style)
}
let outputImage = generateOutputImage(source: config.inputFile)
// debug print
if config.verbose {
print("Copying the generated icon to the destination path...")
}
writeImageFile(image: outputImage, filePath: config.outputFile)
// debug print
if config.verbose {
print("Success ✅")
}
exit(EXIT_SUCCESS)
}
func processTarget() {
// make sure we got the right config
guard let config = config as? IconBadger.Target.Config else {
print("Wrong configuration for the running script")
exit(EXIT_FAILURE)
}
// debug print
if config.verbose {
print("Config ===================================")
print(config)
print("Style ====================================")
print(style)
}
for image in config.appIconOriginalContents.images {
generateIcon(config: config, size: image.size, scale: image.scale, idiom: image.idiom, restore: config.restoreOriginal)
}
exit(EXIT_SUCCESS)
}
// MARK: - Helpers
private func generateIcon(config: IconBadger.Target.Config, size: String, scale: String, idiom: String, restore: Bool) {
// retreive the original file name according to the given size and scale
guard let originalFileName = config.appIconOriginalContents.imageInfo(forSize: size, scale: scale, idiom: idiom)?.filename else {
print("The original icon \"\(idiom)\" size \"\(size)\" and scale \"\(scale)\" doesn't exist")
print("Discarded ⚠️\n")
return
}
// retreive the destination file name according to the given size and scale
guard let destinationFileName = config.appIconContents.imageInfo(forSize: size, scale: scale, idiom: idiom)?.filename else {
print("The app icon \"\(idiom)\" size \"\(size)\" and scale \"\(scale)\" doesn't exist")
print("Discarded ⚠️\n")
return
}
// get files URLs
let originalFileUrl = config.appIconOriginalUrl.appendingPathComponent(originalFileName)
let destinationFileUrl = config.appIconUrl.appendingPathComponent(destinationFileName)
// generate the badged icon
guard restore else {
// debug print
if config.verbose {
print(originalFileUrl.lastPathComponent)
print("Generating badge image for \"\(idiom)\" size \"\(size)\" scale \"\(scale)\"")
}
let outPutIcon = generateOutputImage(source: originalFileUrl.path)
// debug print
if config.verbose {
print("Copying the generated icon to the destination path...")
}
writeImageFile(image: outPutIcon, filePath: destinationFileUrl.path)
// debug print
if config.verbose {
print("Success ✅\n")
}
return
}
// debug print
if config.verbose {
print(originalFileUrl.lastPathComponent)
print("Restoring the original image \"\(idiom)\" size \"\(size)\" scale \"\(scale)\"")
}
// restore the original icon
writeImageFile(originalFileUrl, toUrl: destinationFileUrl)
// debug print
if config.verbose {
print("Success ✅\n")
}
}
private func writeImageFile(image: NSImage, filePath: String) {
if let data = image.tiffRepresentation, let png = NSBitmapImageRep(data: data)?.representation(using: .png, properties: [:]) {
do {
try NSData(data: png).write(toFile: filePath, options: [.atomic])
} catch {
print("Error while saving image to disk at \(filePath)")
if config.verbose { print(error) }
exit(EXIT_FAILURE)
}
}
}
private func writeImageFile(_ imageFile: URL, toUrl destination: URL) {
do {
let data = try Data(contentsOf: imageFile)
try data.write(to: destination, options: [.atomic])
} catch {
print("Error while copying image at \(imageFile.path) to \(destination.path)")
if config.verbose { print(error) }
exit(EXIT_FAILURE)
}
}
private func getText(text: String, config: ScriptConfig) -> String {
if let type = TextType(rawValue: text) {
switch type {
case .alpha, .beta: return text.capitalized
case .version, .build, .versionAndBuild:
guard let infoDict = NSDictionary(contentsOfFile: config.infoPlistUrl.path) else {
print("Unable to read the content of \(config.infoPlistUrl.lastPathComponent)")
exit(EXIT_FAILURE)
}
var version = infoDict["CFBundleShortVersionString"] as? String
var build = infoDict["CFBundleVersion"] as? String
version = version == "$(MARKETING_VERSION)" ? config.mainEnv["MARKETING_VERSION"] : version
build = build == "$(CURRENT_PROJECT_VERSION)" ? config.mainEnv["CURRENT_PROJECT_VERSION"] : build
guard let appVersion = version, let buildNumber = build else {
print("Missing required environment variables \"MARKETING_VERSION\" and/or \"CURRENT_PROJECT_VERSION\". Please run script from Xcode script build phase or enter the Version/Build numbers manually.")
exit(EXIT_FAILURE)
}
if type == .version {
return appVersion
} else if type == .build {
return buildNumber
} else {
return "\(appVersion) - \(buildNumber)"
}
}
} else {
return text
}
}
// MARK: - Static
/// Getting information about the app icon images
static func iconMetadata(iconFolder: URL) throws -> IconMetadata {
let fileUrl = iconFolder.appendingPathComponent(kJsonContentsFileName)
do {
let jsonData = try Data(contentsOf: fileUrl)
let metadata = try JSONDecoder().decode(IconMetadata.self, from: jsonData)
return metadata
} catch {
print("An error occured while trying to get the app's icons metadata from the file located at \"\(fileUrl.path)\"")
exit(EXIT_FAILURE)
}
}
}
| 37.239075 | 218 | 0.563095 |
b9c62f433615029a95e19f7bc47e66a69dd41f10 | 736 | // TaskEditViewModel.swift
// MVVMDemo
//
// Creado el 21/7/21 por Vicente Úbeda (@vicentube)
// Copyright © 2021 Vicente Úbeda. Todos los derechos reservados.
import SwiftUI
import Combine
struct TaskEditView {
let task: Task?
@Environment(\.presentationMode) var presentation
@EnvironmentObject private var model: TaskStore
@State var draft = Task()
var title: String {
task == nil ? "New task" : "Edit task"
}
func viewSetup() {
guard let task = task else { return }
draft = task
}
func dismiss() { presentation.wrappedValue.dismiss() }
func saveTaskAndClose() {
if task == nil {
model.addTask(draft)
} else {
model.updateTask(draft)
}
dismiss()
}
}
| 18.871795 | 65 | 0.646739 |
29767b53037910cee12a5e6428bdf252295902be | 4,770 | //
// Storage.swift
// DTModelStorage
//
// Created by Denys Telezhkin on 06.07.15.
// Copyright (c) 2015 Denys Telezhkin. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import Foundation
import UIKit
/// `Storage` protocol is used to define common interface for storage classes.
public protocol Storage : class
{
/// Array of sections, conforming to `Section` protocol.
var sections: [Section] { get }
/// Returns item at concrete indexPath.
func item(at indexPath: IndexPath) -> Any?
/// Delegate property used to notify about current data storage changes.
var delegate: StorageUpdating? { get set }
}
/// `SupplementaryStorage` protocol defines interface for storages, that can hold supplementary objects(like header and footer models).
public protocol SupplementaryStorage : class
{
/// Returns supplementary model of `kind` for section at `indexPath`.
func supplementaryModel(ofKind kind: String, forSectionAt indexPath: IndexPath) -> Any?
}
/// `HeaderFooterStorage` protocol defines interface for storages, that can hold header and footer objects of specific supplementary type(for example like UICollectionElementKindSectionHeader)
public protocol HeaderFooterStorage : class
{
/// Returns header model for section with section `index` or nil if not found.
func headerModel(forSection index: Int) -> Any?
/// Returns footer model for section with section `index` or nil if not found.
func footerModel(forSection index: Int) -> Any?
/// Supplementary kind for header in current storage
var supplementaryHeaderKind: String? { get set }
/// Supplementary kind for footer in current storage
var supplementaryFooterKind: String? { get set }
}
/// Allows setting supplementaries for kind for various storage subclasses.
public protocol HeaderFooterSettable : HeaderFooterStorage {
func setSupplementaries(_ models: [[Int: Any]], forKind kind: String)
}
extension HeaderFooterSettable {
/// Sets section header `models`, using `supplementaryHeaderKind`.
///
/// - Note: `supplementaryHeaderKind` property should be set before calling this method.
public func setSectionHeaderModels<T>(_ models: [T])
{
guard let headerKind = supplementaryHeaderKind else {
assertionFailure("Please set supplementaryHeaderKind property before setting section header models"); return
}
var supplementaries = [[Int: Any]]()
for model in models {
supplementaries.append([0: model])
}
setSupplementaries(supplementaries, forKind: headerKind)
}
/// Sets section footer `models`, using `supplementaryFooterKind`.
///
/// - Note: `supplementaryFooterKind` property should be set before calling this method.
public func setSectionFooterModels<T>(_ models: [T])
{
guard let footerKind = supplementaryFooterKind else {
assertionFailure("Please set supplementaryFooterKind property before setting section footer models"); return
}
var supplementaries = [[Int: Any]]()
for model in models {
supplementaries.append([0: model])
}
setSupplementaries(supplementaries, forKind: footerKind)
}
}
/// `StorageUpdating` protocol is used to transfer data storage updates.
public protocol StorageUpdating : class
{
/// Transfers data storage updates.
///
/// Object, that implements this method, may react to received update by updating UI for current storage.
func storageDidPerformUpdate(_ update: StorageUpdate)
/// Method is called when UI needs to be fully updated for data storage changes.
func storageNeedsReloading()
}
| 41.842105 | 192 | 0.722432 |
87db2387a70c717e2067f5d533edaef0149f4949 | 535 | //
// Q8LocalizedTintedUIImageView.swift
// Q8Car
//
// Created by Nahla Mortada on 8/31/16.
// Copyright © 2016 Technivance. All rights reserved.
//
import Foundation
import UIKit
import GeneralLocalization
public class LocalizedTintedUIImageView: TintedUIImageView {
override public func awakeFromNib() {
super.awakeFromNib()
self.flip()
}
public func flip() {
if LanguageManager.shared.isArabic {
self.transform = CGAffineTransform(scaleX: -1, y: 1)
}
}
}
| 20.576923 | 64 | 0.657944 |
4874ced9a998440880d95e1b20db5581515786c1 | 3,227 | //
// KeyboardReactable.swift
// Fastlee
//
// Created by Lukasz Szarkowicz on 11/02/2022.
// Copyright © 2022 Mobilee. All rights reserved.
//
import UIKit
public protocol KeyboardReactable {
var scrollView: UIScrollView { get }
}
public extension KeyboardReactable where Self: UIView {
/**
Default implementation with animation when keyboard show
Example of usage:
```
NotificationCenter.default.publisher(for: UIApplication.keyboardWillShowNotification)
.receive(on: RunLoop.main)
.sink { notification in
self.handleKeyboardWillShow(notification)
}
.store(in: &bag)
```
- parameter notification: Pass received keyboard notification.
- Author: Mobilee - Łukasz Szarkowicz
*/
func handleKeyboardWillShow(_ notification: Notification) {
let safeOffset = 32.0
guard let info = notification.userInfo as? [String: AnyObject] else { return }
guard let keyboardSize = (info[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect)?.size, keyboardSize.height > 0 else { return }
// Create content insets by substracting keyboard height
var contentInsets = scrollView.contentInset
contentInsets.bottom = keyboardSize.height
var contentOffset = scrollView.contentOffset
// calculate scroll position
if let firstResponsder = findFirstResponder() as? UITextField {
let screenHeight = frame.size.height
let keyboardTopPoint = screenHeight - keyboardSize.height
let offset = keyboardTopPoint / 4.0 + safeOffset
let posY = scrollView.convert(firstResponsder.frame.origin, from: firstResponsder).y
contentOffset.y = (posY - offset).clamped(to: 0...100000)
}
DispatchQueue.main.async {
UIView.animate(withDuration: 0.3, delay: 0, options: .curveEaseInOut, animations: {
self.scrollView.contentOffset = contentOffset
self.scrollView.contentInset = contentInsets
self.scrollView.scrollIndicatorInsets = contentInsets
self.layoutIfNeeded()
}, completion: nil)
}
}
/**
Default implementation with animation when keyboard hide
Example of usage:
```
NotificationCenter.default.publisher(for: UIApplication.keyboardWillHideNotification)
.receive(on: RunLoop.main)
.sink { notification in
self.handleKeyboardWillHide(notification)
}
.store(in: &bag)
```
- parameter notification: Pass received keyboard notification.
- Author: Mobilee - Łukasz Szarkowicz
*/
func handleKeyboardWillHide(_ notification: Notification) {
DispatchQueue.main.async {
UIView.animate(withDuration: 0.35, delay: 0, options: .curveEaseInOut, animations: {
self.scrollView.contentInset = UIEdgeInsets.zero
self.scrollView.scrollIndicatorInsets = UIEdgeInsets.zero
self.layoutIfNeeded()
}, completion: nil)
}
}
}
| 33.968421 | 138 | 0.630307 |
5bc2c344783e306ab3a0f8f0eb2d07e48a049bcc | 725 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
import Foundation
// StatefulServicePropertiesProtocol is the properties of a stateful service resource.
public protocol StatefulServicePropertiesProtocol : ServicePropertiesProtocol {
var hasPersistedState: Bool? { get set }
var targetReplicaSetSize: Int32? { get set }
var minReplicaSetSize: Int32? { get set }
var replicaRestartWaitDuration: Date? { get set }
var quorumLossWaitDuration: Date? { get set }
var standByReplicaKeepDuration: Date? { get set }
}
| 48.333333 | 96 | 0.743448 |
8fdee24f18145fe79dca0e164ba79e8a2a94a418 | 876 | //
// MallViewController.swift
// TestKitchen
//
// Created by qianfeng on 16/8/15.
// Copyright © 2016年 qianfeng. All rights reserved.
//
import UIKit
class MallViewController: KTCHomeViewController {
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
/*
// MARK: - Navigation
// In a storyboard-based application, you will often want to do a little preparation before navigation
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
// Get the new view controller using segue.destinationViewController.
// Pass the selected object to the new view controller.
}
*/
}
| 24.333333 | 106 | 0.678082 |
bfe8a1d9da21f7698676d3b9ed5ac17a6ceb967e | 2,098 | //// Copyright 2018 Esri
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import Foundation
import ArcGIS
extension Collection where Iterator.Element == AGSArcGISFeature {
/// Build an array of `AGSPopup` objects of same-table feature (`AGSArcGISFeature`) objects.
///
/// - Returns: An array of pop-up objects that can be empty.
///
/// - Throws: An error if the first feature table in the collection is not popup enabled
/// or if subsequent features are not of the same table as the first.
func asPopups() throws -> [AGSPopup] {
try map { (feature: AGSArcGISFeature) -> AGSPopup in
guard let featureTable = feature.featureTable else {
throw AGSArcGISFeature.MissingTableError(feature: feature)
}
guard featureTable.isPopupActuallyEnabled else {
throw AGSFeatureTable.PopupsAreNotEnabledError(table: featureTable)
}
return AGSPopup(
geoElement: feature,
popupDefinition: featureTable.popupDefinition
)
}
}
}
// MARK:- Errors
extension AGSArcGISFeature {
struct MissingTableError: LocalizedError {
let feature: AGSArcGISFeature
var errorDescription: String? { "Feature is missing it's table." }
}
}
extension AGSFeatureTable {
struct PopupsAreNotEnabledError: LocalizedError {
let table: AGSFeatureTable
var errorDescription: String? { "Pop-ups are not enabled for feature table." }
}
}
| 33.83871 | 96 | 0.658246 |
7aa61257335aac1cc5d4a8fd2b8d102c30955163 | 4,325 | //
// ChatRegistry.swift
// imcore-rest
//
// Created by Eric Rabil on 7/23/20.
// Copyright © 2020 Eric Rabil. All rights reserved.
//
import Foundation
import IMCore
private extension Array where Element: Hashable {
var unique: [Element] {
Array(Set(self))
}
}
public class Registry {
public static let sharedInstance = Registry()
public func account(withUniqueID uniqueID: String) -> IMAccount {
return IMAccountController.shared.account(forUniqueID: uniqueID)
}
public func imHandle(withID id: String) -> IMHandle? {
if let account = IMAccountController.shared.iMessageAccount, let handle = imHandle(withID: id, onAccount: account) {
return handle
} else if let SMSAccount = IMAccountController.shared.activeSMSAccount, let handle = imHandle(withID: id, onAccount: SMSAccount) {
return handle
} else {
return nil
}
}
public func imHandles(forContact contact: CNContact) -> [IMHandle] {
Array(IMHandleRegistrar.sharedInstance().handles(forCNIdentifier: contact.id))
}
public func imHandleIDs(forContact contact: CNContact) -> [String] {
imHandles(forContact: contact).map(\.id).unique
}
public var allMeHandles: [IMHandle] {
allAccounts.flatMap { account in
account.aliases.compactMap(account.imHandle(withID:))
}
}
public var uniqueMeHandleIDs: [String] {
allAccounts.flatMap(\.aliases).unique
}
public var allAccounts: [IMAccount] {
IMAccountController.shared.accounts
}
public func imHandle(withID id: String, onService service: String) -> IMHandle? {
guard let account = bestAccount(for: service) else {
return nil
}
return imHandle(withID: id, onAccount: account)
}
public func imHandle(withID id: String, onService service: IMService) -> IMHandle? {
guard let account = bestAccount(for: service) else {
return nil
}
return imHandle(withID: id, onAccount: account)
}
public func imHandle(withID id: String, onAccount account: IMAccount) -> IMHandle? {
account.imHandle(withID: id) ?? account.existingIMHandle(withID: id)
}
public func suitableHandle(for service: String) -> IMHandle? {
guard let impl = self.resolve(service: service) else {
return nil
}
return suitableHandle(for: impl)
}
public func suitableHandle(for service: IMService) -> IMHandle? {
guard let account = bestAccount(for: service) else {
return nil
}
return account.loginIMHandle
}
public func bestAccount(for service: String) -> IMAccount? {
guard let service = resolve(service: service) else {
return nil
}
return bestAccount(for: service)
}
public func bestAccount(for service: IMService) -> IMAccount? {
if let serviceImpl = service as? IMServiceImpl, let account = serviceImpl.value(forKey: "bestAccount") as? IMAccount {
return account
}
return IMAccountController.shared.bestAccount(forService: service)
}
public func resolve(service: String) -> IMService? {
let IMServiceAgentImpl = NSClassFromString("IMServiceAgentImpl") as! IMServiceAgent.Type
return IMServiceAgentImpl.shared()?.service(withName: service)
}
public func iMessageAccount() -> IMAccount? {
return IMAccountController.shared.iMessageAccount
}
public func SMSAccount() -> IMAccount? {
return IMAccountController.shared.activeSMSAccount
}
private func _connect() {
if _fastPath(IMDaemonController.shared().isConnected) {
return
}
IMDaemonController.shared().connectToDaemon(withLaunch: true, capabilities: FZListenerCapabilities.defaults_, blockUntilConnected: true)
}
public var smsServiceEnabled: Bool {
_connect()
return IMService.sms()?.isEnabled() ?? false
}
public var callServiceEnabled: Bool {
_connect()
return IMService.call()?.isEnabled() ?? false
}
}
| 30.673759 | 144 | 0.629827 |
1d1254c3d396e1b393c6c9999c9a7ecbca12e7c1 | 1,098 | //
// AsyncOperation.swift
// LaunchXIV
//
// Created by Tyrone Trevorrow on 19/7/17.
// Copyright © 2017 Tyrone Trevorrow. All rights reserved.
//
import Foundation
open class AsyncOperation: Operation {
public enum State: String {
case ready, executing, finished
}
override open var isAsynchronous: Bool {
return true
}
public var state = State.ready {
willSet {
willChangeValue(forKey: "isExecuting")
willChangeValue(forKey: "isFinished")
}
didSet {
didChangeValue(forKey: "isExecuting")
didChangeValue(forKey: "isFinished")
}
}
override open var isExecuting: Bool {
return state == .executing
}
override open var isFinished: Bool {
return state == .finished
}
override open func start() {
if self.isCancelled {
state = .finished
} else {
state = .ready
main()
}
}
override open func main() {
// override in subclasses
}
}
| 21.115385 | 59 | 0.555556 |
ff6cd85e728cc20f25280e91310267d99e645472 | 732 | //
// GameDetailsSceneResolver.swift
// KOMvvmSampleLogic
//
// Copyright (c) 2020 Kuba Ostrowski
// Licensed under the MIT License. See LICENSE file in the project root for full license information.
import UIKit
import KOInject
struct GameDetailsSceneResolver: SceneResolverProtocol {
let game: GameModel
init(game: GameModel) {
self.game = game
}
func resolve(withAppCoordinator appCoordinator: AppCoordinatorProtocol, resolver: KOIResolverProtocol) -> UIViewController {
guard let viewController: GameDetailsViewControllerProtocol = resolver.resolve(arg1: appCoordinator, arg2: game) else {
fatalError(fatalErrorMessage)
}
return viewController
}
}
| 29.28 | 128 | 0.724044 |
3a335c76fa1a3e4c6628685b50ce862698b9b4bf | 216 | // Distributed under the terms of the MIT license
// Test case submitted to project by https://github.com/practicalswift (practicalswift)
// Test case found by fuzzing
init( = {
protocol C {
"
enum S {
class
case ,
| 19.636364 | 87 | 0.731481 |
1aa98923f12854b8f03c9bbf0183a2ed5c67737e | 2,178 | //
// AppDelegate.swift
// ZJMAlertView
//
// Created by simplismvip on 03/28/2020.
// Copyright (c) 2020 simplismvip. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
func applicationWillResignActive(_ application: UIApplication) {
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
}
func applicationDidEnterBackground(_ application: UIApplication) {
// Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
// If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}
func applicationWillEnterForeground(_ application: UIApplication) {
// Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
}
func applicationDidBecomeActive(_ application: UIApplication) {
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}
func applicationWillTerminate(_ application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}
}
| 46.340426 | 285 | 0.75528 |
79cbf8629188eca39a555efca9d3cf59d444aebc | 962 | //
// Helper.swift
// Pachinko
//
// Created by Hudzilla on 22/11/2014.
// Copyright (c) 2014 Hudzilla. All rights reserved.
//
import Foundation
import UIKit
func RandomInt(min min: Int, max: Int) -> Int
{
if max < min { return min }
return Int(arc4random_uniform(UInt32((max - min) + 1))) + min
}
func RandomFloat() -> Float
{
return Float(arc4random()) / Float(UInt32.max)
}
func RandomFloat(min min: Float, max: Float) -> Float
{
return (Float(arc4random()) / Float(UInt32.max)) * (max - min) + min
}
func RandomDouble(min min: Double, max: Double) -> Double
{
return (Double(arc4random()) / Double(UInt32.max)) * (max - min) + min
}
func RandomCGFloat() -> CGFloat
{
return CGFloat(RandomFloat())
}
func RandomCGFloat(min min: Float, max: Float) -> CGFloat
{
return CGFloat(RandomFloat(min: min, max: max))
}
func RandomColor() -> UIColor
{
return UIColor(red: RandomCGFloat(), green: RandomCGFloat(), blue: RandomCGFloat(), alpha: 1)
} | 20.913043 | 94 | 0.674636 |
c195f12dcf779ca744dd4fa3b992b1ea71d66e5d | 106 | import XCTest
@testable import DispatchPQTestSuite
XCTMain([
testCase(DispatchPQTests.allTests),
])
| 15.142857 | 40 | 0.783019 |
28f03a7761c184667b2f12d21e42362c7206271f | 163 | //
// PermissionViewController.swift
// AppsaurusUIKit
//
// Created by Brian Strobach on 1/24/18.
//
import Swiftest
import UIKitExtensions
import UIKitTheme
| 14.818182 | 41 | 0.754601 |
33b6c1cf341c65f61b121b2fce5562e35404c30a | 11,775 | //
// ProfileViewController.swift
// Twitter
//
// Created by Xiang Yu on 10/6/17.
// Copyright © 2017 Xiang Yu. All rights reserved.
//
import UIKit
//import FLEX
class ProfileViewController: UIViewController {
@IBOutlet weak var headerImgView: UIImageView!
@IBOutlet weak var profileImgView: UIImageView!
@IBOutlet weak var headerBlurView: UIVisualEffectView!
@IBOutlet weak var usernameLabel: UILabel!
@IBOutlet weak var screennameLabel: UILabel!
@IBOutlet weak var tweetsCountLabel: UILabel!
@IBOutlet weak var followingCountLabel: UILabel!
@IBOutlet weak var followersCountLabel: UILabel!
@IBOutlet weak var descriptionLabel: UILabel!
@IBOutlet weak var infoScrollView: UIScrollView!
@IBOutlet weak var tweetTableView: UITableView!
@IBOutlet weak var pageControl: UIPageControl!
@IBOutlet weak var usernamePageWidthConstraint: NSLayoutConstraint!
@IBOutlet weak var descriptionPageWidthConstraint: NSLayoutConstraint!
@IBOutlet weak var profileImgTopConstraint: NSLayoutConstraint!
@IBOutlet var panGestureRecognizer: UIPanGestureRecognizer!
@IBOutlet weak var headerImgHeightConstraint: NSLayoutConstraint!
var screenname: String!
private var originalProfileImgTopMargin: CGFloat!
private var originalHeaderImgHeight: CGFloat!
private enum AdjustType {
case none
case toFront
case toBack
}
private var adjustBlurView: AdjustType = .none
private enum UIState {
case stretchingHeaderImg
case initial
case shrinkingHeaderImg
case movingUnderHeaderImg
}
private var uiState: UIState = .initial
var user: User! {
didSet {
screennameLabel.text = "@\(user.screenname ?? "null")"
usernameLabel.text = user.name
self.navigationItem.title = user.name
descriptionLabel.text = user.tagline
tweetsCountLabel.text = String(user.tweetsCount ?? 0)
followingCountLabel.text = String(user.followingCount ?? 0)
followersCountLabel.text = String(user.followersCount ?? 0)
if let imageURL = user.profileImgUrl {
profileImgView.setImageWith(imageURL)
} else {
profileImgView.image = nil
}
if let imageURL = user.headerImgUrl {
headerImgView.setImageWith(imageURL)
} else {
headerImgView.backgroundColor = Utils.blue
}
}
}
var tweets: [Tweet] = []
override func viewDidLoad() {
super.viewDidLoad()
//FLEXManager.shared().showExplorer()
//pageControl.transform = CGAffineTransform(scaleX: 1, y: 1)
tweetTableView.delegate = self
tweetTableView.dataSource = self
infoScrollView.delegate = self
panGestureRecognizer.delegate = self
let twitterService = TwitterService.sharedInstance
twitterService?.getUser(byScreenName: screenname, orByUserId: nil, success: { (user: User) in
self.user = user
twitterService?.getTimeline(.user, olderthan: nil, forScreenName: user.screenname, success: { (tweets: [Tweet]) in
self.tweets = tweets
self.tweetTableView.reloadData()
}, failure: { (error: Error) in
Utils.popAlertWith(msg: "error in getting user timeline: \(error.localizedDescription)", in: self)
})
}, failure: { (error: Error) in
Utils.popAlertWith(msg: "error in getting user info: \(error.localizedDescription)", in: self)
})
self.navigationController?.navigationBar.setBackgroundImage(UIImage(), for: UIBarMetrics.default)
self.navigationController?.navigationBar.shadowImage = UIImage()
self.navigationController?.navigationBar.isTranslucent = true
self.navigationController?.view.backgroundColor = UIColor.clear
originalProfileImgTopMargin = profileImgTopConstraint.constant
headerImgHeightConstraint.constant = view.frame.width/3
originalHeaderImgHeight = headerImgView.frame.height
}
override func viewDidLayoutSubviews() {
//print(infoScrollView.frame.width)
usernamePageWidthConstraint.constant = infoScrollView.bounds.width
descriptionPageWidthConstraint.constant = infoScrollView.bounds.width
headerBlurView.frame = headerImgView.bounds
infoScrollView.layoutIfNeeded()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
@IBAction func onPageChanged(_ sender: Any) {
let xOffset = infoScrollView.bounds.width * CGFloat(pageControl.currentPage)
infoScrollView.setContentOffset(CGPoint(x: xOffset, y:0) , animated: true)
}
@IBAction func onPanGesture(_ sender: UIPanGestureRecognizer) {
UIView.animate(withDuration: 0.3, animations: {
//let velocity = sender.velocity(in: self.view)
let translation = sender.translation(in: self.view)
if sender.state == .began {
} else if sender.state == .changed {
switch self.uiState {
case .stretchingHeaderImg:
self.stretchHeaderImg(translation.y)
break
case .initial:
if translation.y > 0 {
self.uiState = .stretchingHeaderImg
self.stretchHeaderImg(translation.y)
} else {
self.uiState = .shrinkingHeaderImg
self.shrinkHeaderImg(translation.y)
}
break
case .shrinkingHeaderImg:
self.shrinkHeaderImg(translation.y)
break
case .movingUnderHeaderImg:
// this is negative
let marginFromHeaderImgToTableview = self.headerImgView.frame.maxY - self.tweetTableView.frame.minY
var newTopMargin = self.profileImgTopConstraint.constant + translation.y
if newTopMargin > self.originalProfileImgTopMargin {
newTopMargin = self.originalProfileImgTopMargin
self.uiState = .shrinkingHeaderImg
self.adjustBlurView = .toBack
} else if translation.y < marginFromHeaderImgToTableview {
newTopMargin = self.profileImgTopConstraint.constant + marginFromHeaderImgToTableview
}
self.profileImgTopConstraint.constant = newTopMargin
break
}
sender.setTranslation(CGPoint.zero, in: self.view)
} else if sender.state == .ended {
if self.uiState == .stretchingHeaderImg {
UIView.animate(withDuration: 0.3) {
self.uiState = .initial
self.headerImgHeightConstraint.constant = self.originalHeaderImgHeight
}
}
}
self.view.layoutIfNeeded()
}) { (completed) in
self.adjustBlurViewIfNeeded()
}
}
private func adjustBlurViewIfNeeded() {
if self.adjustBlurView == .toFront {
self.view.bringSubview(toFront: self.headerBlurView)
} else if self.adjustBlurView == .toBack {
self.view.sendSubview(toBack: self.headerBlurView)
}
self.adjustBlurView = .none
}
private func stretchHeaderImg(_ translationy: CGFloat) {
//maximux stretchable
let maxHeight = self.originalHeaderImgHeight + 40
var newHeight = self.headerImgView.frame.height + translationy
if newHeight <= self.originalHeaderImgHeight {
newHeight = self.originalHeaderImgHeight
self.uiState = .initial
} else if newHeight > maxHeight {
newHeight = maxHeight
}
self.headerImgHeightConstraint.constant = newHeight
}
private func shrinkHeaderImg(_ translationy: CGFloat) {
//maximux stretchable
let minHeight = self.navigationController?.navigationBar.frame.maxY ?? 40
var newHeight = self.headerImgView.frame.height + translationy
if newHeight >= self.originalHeaderImgHeight {
newHeight = self.originalHeaderImgHeight
self.uiState = .initial
} else if newHeight < minHeight {
newHeight = minHeight
self.uiState = .movingUnderHeaderImg
adjustBlurView = .toFront
}
self.headerImgHeightConstraint.constant = newHeight
}
// MARK: - Navigation
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
if let destinationViewController = segue.destination as? TweetViewController {
let indexPath = tweetTableView.indexPath(for: sender as! UITableViewCell)!
destinationViewController.tweet = tweets[indexPath.row]
//destinationViewController.composeViewDelegate = self
}
}
}
extension ProfileViewController: UITableViewDelegate, UITableViewDataSource {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return tweets.count
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tweetTableView.dequeueReusableCell(withIdentifier: "TweetCell", for: indexPath) as! TweetCell
cell.tweet = tweets[indexPath.row]
return cell
}
}
extension ProfileViewController: UIScrollViewDelegate {
func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
pageControl.currentPage = Int(scrollView.contentOffset.x / scrollView.bounds.width)
}
func scrollViewDidScroll(_ scrollView: UIScrollView) {
let alpha = 1 - (scrollView.contentOffset.x / scrollView.bounds.width) * 0.5
headerImgView.alpha = alpha
}
}
extension ProfileViewController: UIGestureRecognizerDelegate {
func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
if otherGestureRecognizer.view?.restorationIdentifier == "userInfoScrollView"
&& otherGestureRecognizer is UIPanGestureRecognizer {
return false
} else if let panGes = gestureRecognizer as? UIPanGestureRecognizer {
let translation = panGes.translation(in: self.view)
if abs(translation.x) < abs(translation.y) {
if !(otherGestureRecognizer.view is UITableView) {
return false
}
}
}
return true;
}
func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
if let panGes = gestureRecognizer as? UIPanGestureRecognizer {
let translation = panGes.translation(in: self.view)
if abs(translation.x) > abs(translation.y) {
return false
}
}
return true
}
}
| 37.380952 | 157 | 0.611805 |
f80ea91ed7395a3da9b829778e3da27269e5eb2e | 888 | //
// ImageViewModel.swift
// Pinterest
//
// Created by iSlide on 2021/6/23.
//
import SwiftUI
class ImageViewModel: ObservableObject {
@Published var images : [ImageModel] = []
init() {
let url = "https://picsum.photos/v2/list";
let session = URLSession(configuration: .default)
session.dataTask(with: URL(string: url)!) { (data, _, _) in
guard let json = data else{return}
do{
let images = try JSONDecoder().decode([ImageModel].self, from: json)
print(images)
DispatchQueue.main.async {
self.images = images
}
}
catch{
print(error.localizedDescription)
}
}
.resume()
}
}
| 22.2 | 84 | 0.460586 |
c1b3124dac48ee1c91e2f596a6389c0af9146ae6 | 1,072 | //
// ActivePhpInstallation.swift
// PHP Monitor
//
// Created by Nico Verbruggen on 21/12/2021.
// Copyright © 2021 Nico Verbruggen. All rights reserved.
//
import Foundation
extension ActivePhpInstallation {
/**
It is always possible that the system configuration for PHP-FPM has not been set up for Valet.
This can occur when a user manually installs a new PHP version, but does not run `valet install`.
In that case, we should alert the user!
- Important: The underlying check is `checkPhpFpmStatus`, which can be run multiple times.
This method actively presents a modal if said checks fails, so don't call this method too many times.
*/
public func notifyAboutBrokenPhpFpm() {
if !self.checkPhpFpmStatus() {
DispatchQueue.main.async {
Alert.notify(
message: "alert.php_fpm_broken.title".localized,
info: "alert.php_fpm_broken.info".localized,
style: .critical
)
}
}
}
}
| 31.529412 | 106 | 0.626866 |
dde6958a05474b1e13c211961cea1bed71829d4f | 460 | //
// CALayerExtension.swift
// BoxPress
//
// Created by Yoshikuni Kato on 3/21/16.
// Copyright © 2016 Yoshikuni Kato. All rights reserved.
//
import UIKit
extension CALayer {
convenience init(image: CGImage, frame: CGRect) {
self.init()
self.contents = image
self.frame = frame
self.bounds = CGRect(x: 0, y: 0, width: frame.width, height: frame.height)
self.contentsGravity = kCAGravityResizeAspect
}
}
| 23 | 82 | 0.647826 |
142d1495e9a504fecc3042ca0569dd645b5465dd | 16,031 | import Foundation
#if os(Linux)
public enum BaudRate: Int {
case baud0 = 0
case baud50 = 50
case baud75 = 75
case baud110 = 110
case baud134 = 134
case baud150 = 150
case baud200 = 200
case baud300 = 300
case baud600 = 600
case baud1200 = 1200
case baud1800 = 1800
case baud2400 = 2400
case baud4800 = 4800
case baud9600 = 9600
case baud19200 = 19200
case baud38400 = 38400
case baud57600 = 57600
case baud115200 = 115200
case baud230400 = 230400
case baud460800 = 460800
case baud500000 = 500000
case baud576000 = 576000
case baud921600 = 921600
case baud1000000 = 1000000
case baud1152000 = 1152000
case baud1500000 = 1500000
case baud2000000 = 2000000
case baud2500000 = 2500000
case baud3500000 = 3500000
case baud4000000 = 4000000
var speedValue: speed_t {
switch self {
case .baud0:
return speed_t(B0)
case .baud50:
return speed_t(B50)
case .baud75:
return speed_t(B75)
case .baud110:
return speed_t(B110)
case .baud134:
return speed_t(B134)
case .baud150:
return speed_t(B150)
case .baud200:
return speed_t(B200)
case .baud300:
return speed_t(B300)
case .baud600:
return speed_t(B600)
case .baud1200:
return speed_t(B1200)
case .baud1800:
return speed_t(B1800)
case .baud2400:
return speed_t(B2400)
case .baud4800:
return speed_t(B4800)
case .baud9600:
return speed_t(B9600)
case .baud19200:
return speed_t(B19200)
case .baud38400:
return speed_t(B38400)
case .baud57600:
return speed_t(B57600)
case .baud115200:
return speed_t(B115200)
case .baud230400:
return speed_t(B230400)
case .baud460800:
return speed_t(B460800)
case .baud500000:
return speed_t(B500000)
case .baud576000:
return speed_t(B576000)
case .baud921600:
return speed_t(B921600)
case .baud1000000:
return speed_t(B1000000)
case .baud1152000:
return speed_t(B1152000)
case .baud1500000:
return speed_t(B1500000)
case .baud2000000:
return speed_t(B2000000)
case .baud2500000:
return speed_t(B2500000)
case .baud3500000:
return speed_t(B3500000)
case .baud4000000:
return speed_t(B4000000)
}
}
}
#elseif os(OSX)
public enum BaudRate: Int {
case baud0 = 0
case baud50 = 50
case baud75 = 75
case baud110 = 110
case baud134 = 134
case baud150 = 150
case baud200 = 200
case baud300 = 300
case baud600 = 600
case baud1200 = 1200
case baud1800 = 1800
case baud2400 = 2400
case baud4800 = 4800
case baud9600 = 9600
case baud19200 = 19200
case baud38400 = 38400
case baud57600 = 57600
case baud115200 = 115200
case baud230400 = 230400
var speedValue: speed_t {
switch self {
case .baud0:
return speed_t(B0)
case .baud50:
return speed_t(B50)
case .baud75:
return speed_t(B75)
case .baud110:
return speed_t(B110)
case .baud134:
return speed_t(B134)
case .baud150:
return speed_t(B150)
case .baud200:
return speed_t(B200)
case .baud300:
return speed_t(B300)
case .baud600:
return speed_t(B600)
case .baud1200:
return speed_t(B1200)
case .baud1800:
return speed_t(B1800)
case .baud2400:
return speed_t(B2400)
case .baud4800:
return speed_t(B4800)
case .baud9600:
return speed_t(B9600)
case .baud19200:
return speed_t(B19200)
case .baud38400:
return speed_t(B38400)
case .baud57600:
return speed_t(B57600)
case .baud115200:
return speed_t(B115200)
case .baud230400:
return speed_t(B230400)
}
}
}
#endif
public enum DataBitsSize {
case bits5
case bits6
case bits7
case bits8
var flagValue: tcflag_t {
switch self {
case .bits5:
return tcflag_t(CS5)
case .bits6:
return tcflag_t(CS6)
case .bits7:
return tcflag_t(CS7)
case .bits8:
return tcflag_t(CS8)
}
}
}
public enum ParityType {
case none
case even
case odd
var parityValue: tcflag_t {
switch self {
case .none:
return 0
case .even:
return tcflag_t(PARENB)
case .odd:
return tcflag_t(PARENB | PARODD)
}
}
}
public enum PortError: Int32, Error {
case failedToOpen = -1 // refer to open()
case invalidPath
case mustReceiveOrTransmit
case mustBeOpen
case stringsMustBeUTF8
case unableToConvertByteToCharacter
case deviceNotConnected
}
public class SerialPort {
var path: String
var fileDescriptor: Int32?
public init(path: String) {
self.path = path
}
public func openPort() throws {
try openPort(toReceive: true, andTransmit: true)
}
public func openPort(toReceive receive: Bool, andTransmit transmit: Bool) throws {
guard !path.isEmpty else {
throw PortError.invalidPath
}
guard receive || transmit else {
throw PortError.mustReceiveOrTransmit
}
var readWriteParam : Int32
if receive && transmit {
readWriteParam = O_RDWR
} else if receive {
readWriteParam = O_RDONLY
} else if transmit {
readWriteParam = O_WRONLY
} else {
fatalError()
}
#if os(Linux)
fileDescriptor = open(path, readWriteParam | O_NOCTTY | O_NONBLOCK)
#elseif os(OSX)
fileDescriptor = open(path, readWriteParam | O_NOCTTY | O_EXLOCK | O_NONBLOCK)
#endif
// Throw error if open() failed
if fileDescriptor == PortError.failedToOpen.rawValue {
throw PortError.failedToOpen
}
}
public func setSettings(receiveRate: BaudRate,
transmitRate: BaudRate,
minimumBytesToRead: Int,
timeout: Int = 0, /* 0 means wait indefinitely */
parityType: ParityType = .none,
sendTwoStopBits: Bool = false, /* 1 stop bit is the default */
dataBitsSize: DataBitsSize = .bits8,
useHardwareFlowControl: Bool = false,
useSoftwareFlowControl: Bool = false,
processOutput: Bool = false) {
guard let fileDescriptor = fileDescriptor else {
return
}
// Set up the control structure
var settings = termios()
// Get options structure for the port
tcgetattr(fileDescriptor, &settings)
// Set baud rates
cfsetispeed(&settings, receiveRate.speedValue)
cfsetospeed(&settings, transmitRate.speedValue)
// Enable parity (even/odd) if needed
settings.c_cflag |= parityType.parityValue
// Set stop bit flag
if sendTwoStopBits {
settings.c_cflag |= tcflag_t(CSTOPB)
} else {
settings.c_cflag &= ~tcflag_t(CSTOPB)
}
// Set data bits size flag
settings.c_cflag &= ~tcflag_t(CSIZE)
settings.c_cflag |= dataBitsSize.flagValue
//Disable input mapping of CR to NL, mapping of NL into CR, and ignoring CR
settings.c_iflag &= ~tcflag_t(ICRNL | INLCR | IGNCR)
// Set hardware flow control flag
#if os(Linux)
if useHardwareFlowControl {
settings.c_cflag |= tcflag_t(CRTSCTS)
} else {
settings.c_cflag &= ~tcflag_t(CRTSCTS)
}
#elseif os(OSX)
if useHardwareFlowControl {
settings.c_cflag |= tcflag_t(CRTS_IFLOW)
settings.c_cflag |= tcflag_t(CCTS_OFLOW)
} else {
settings.c_cflag &= ~tcflag_t(CRTS_IFLOW)
settings.c_cflag &= ~tcflag_t(CCTS_OFLOW)
}
#endif
// Set software flow control flags
let softwareFlowControlFlags = tcflag_t(IXON | IXOFF | IXANY)
if useSoftwareFlowControl {
settings.c_iflag |= softwareFlowControlFlags
} else {
settings.c_iflag &= ~softwareFlowControlFlags
}
// Turn on the receiver of the serial port, and ignore modem control lines
settings.c_cflag |= tcflag_t(CREAD | CLOCAL)
// Turn off canonical mode
settings.c_lflag &= ~tcflag_t(ICANON | ECHO | ECHOE | ISIG)
// Set output processing flag
if processOutput {
settings.c_oflag |= tcflag_t(OPOST)
} else {
settings.c_oflag &= ~tcflag_t(OPOST)
}
//Special characters
//We do this as c_cc is a C-fixed array which is imported as a tuple in Swift.
//To avoid hardcoding the VMIN or VTIME value to access the tuple value, we use the typealias instead
#if os(Linux)
typealias specialCharactersTuple = (VINTR: cc_t, VQUIT: cc_t, VERASE: cc_t, VKILL: cc_t, VEOF: cc_t, VTIME: cc_t, VMIN: cc_t, VSWTC: cc_t, VSTART: cc_t, VSTOP: cc_t, VSUSP: cc_t, VEOL: cc_t, VREPRINT: cc_t, VDISCARD: cc_t, VWERASE: cc_t, VLNEXT: cc_t, VEOL2: cc_t, spare1: cc_t, spare2: cc_t, spare3: cc_t, spare4: cc_t, spare5: cc_t, spare6: cc_t, spare7: cc_t, spare8: cc_t, spare9: cc_t, spare10: cc_t, spare11: cc_t, spare12: cc_t, spare13: cc_t, spare14: cc_t, spare15: cc_t)
var specialCharacters: specialCharactersTuple = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) // NCCS = 32
#elseif os(OSX)
typealias specialCharactersTuple = (VEOF: cc_t, VEOL: cc_t, VEOL2: cc_t, VERASE: cc_t, VWERASE: cc_t, VKILL: cc_t, VREPRINT: cc_t, spare1: cc_t, VINTR: cc_t, VQUIT: cc_t, VSUSP: cc_t, VDSUSP: cc_t, VSTART: cc_t, VSTOP: cc_t, VLNEXT: cc_t, VDISCARD: cc_t, VMIN: cc_t, VTIME: cc_t, VSTATUS: cc_t, spare: cc_t)
var specialCharacters: specialCharactersTuple = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) // NCCS = 20
#endif
specialCharacters.VMIN = cc_t(minimumBytesToRead)
specialCharacters.VTIME = cc_t(timeout)
settings.c_cc = specialCharacters
// Commit settings
tcsetattr(fileDescriptor, TCSANOW, &settings)
}
public func closePort() {
if let fileDescriptor = fileDescriptor {
close(fileDescriptor)
}
fileDescriptor = nil
}
}
// MARK: Receiving
extension SerialPort {
public func readBytes(into buffer: UnsafeMutablePointer<UInt8>, size: Int) throws -> Int {
guard let fileDescriptor = fileDescriptor else {
throw PortError.mustBeOpen
}
var s: stat = stat()
fstat(fileDescriptor, &s)
if s.st_nlink != 1 {
throw PortError.deviceNotConnected
}
let bytesRead = read(fileDescriptor, buffer, size)
return bytesRead
}
public func readData(ofLength length: Int) throws -> Data {
let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: length)
defer {
buffer.deallocate()
}
let bytesRead = try readBytes(into: buffer, size: length)
var data : Data
if bytesRead > 0 {
data = Data(bytes: buffer, count: bytesRead)
} else {
//This is to avoid the case where bytesRead can be negative causing problems allocating the Data buffer
data = Data(bytes: buffer, count: 0)
}
return data
}
public func readString(ofLength length: Int) throws -> String {
var remainingBytesToRead = length
var result = ""
while remainingBytesToRead > 0 {
let data = try readData(ofLength: remainingBytesToRead)
if let string = String(data: data, encoding: String.Encoding.utf8) {
result += string
remainingBytesToRead -= data.count
} else {
return result
}
}
return result
}
public func readUntilChar(_ terminator: CChar) throws -> String {
var data = Data()
let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: 1)
defer {
buffer.deallocate()
}
while true {
let bytesRead = try readBytes(into: buffer, size: 1)
if bytesRead > 0 {
if ( buffer[0] > 127) {
throw PortError.unableToConvertByteToCharacter
}
let character = CChar(buffer[0])
if character == terminator {
break
} else {
data.append(buffer, count: 1)
}
}
}
if let string = String(data: data, encoding: String.Encoding.utf8) {
return string
} else {
throw PortError.stringsMustBeUTF8
}
}
@discardableResult public func readLine() throws -> String {
let newlineChar = CChar(10) // Newline/Line feed character `\n` is 10
return try readUntilChar(newlineChar)
}
public func readByte() throws -> UInt8 {
let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: 1)
defer {
buffer.deallocate()
}
while true {
let bytesRead = try readBytes(into: buffer, size: 1)
if bytesRead > 0 {
return buffer[0]
}
}
}
public func readChar() throws -> UnicodeScalar {
let byteRead = try readByte()
let character = UnicodeScalar(byteRead)
return character
}
}
// MARK: Transmitting
extension SerialPort {
public func writeBytes(from buffer: UnsafeMutablePointer<UInt8>, size: Int) throws -> Int {
guard let fileDescriptor = fileDescriptor else {
throw PortError.mustBeOpen
}
let bytesWritten = write(fileDescriptor, buffer, size)
return bytesWritten
}
public func writeData(_ data: Data) throws -> Int {
let size = data.count
let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
defer {
buffer.deallocate()
}
data.copyBytes(to: buffer, count: size)
let bytesWritten = try writeBytes(from: buffer, size: size)
return bytesWritten
}
public func writeString(_ string: String) throws -> Int {
guard let data = string.data(using: String.Encoding.utf8) else {
throw PortError.stringsMustBeUTF8
}
return try writeData(data)
}
public func writeChar(_ character: UnicodeScalar) throws -> Int{
let stringEquiv = String(character)
let bytesWritten = try writeString(stringEquiv)
return bytesWritten
}
}
| 30.419355 | 489 | 0.557545 |
ef7505807d29b74d7c7f5ebf8a74701fb5108bff | 2,203 | //
// 33SearchInRotatedSortedArray.swift
// Algorithm
//
// Created by vchan on 2021/2/9.
//
import Foundation
extension Solution {
//直接利用二分思想
func search(_ nums: [Int], _ target: Int) -> Int {
var left = 0
var right = nums.count - 1
while left <= right {
let mid = left + (right - left + 1) / 2
if nums[mid] == target {
return mid
}
if nums[mid] < nums.first! {
if nums[mid] < target && nums.last! >= target {
left = mid + 1
} else {
right = mid - 1
}
} else {
if nums[mid] > target && nums.first! <= target {
right = mid - 1
} else {
left = mid + 1
}
}
}
return -1
}
/*
//先拆分，再二分
func search(_ nums: [Int], _ target: Int) -> Int {
var left = 0
var right = nums.count - 1
var index = -1
var middle = 0
while left < right {
let mid = left + (right - left + 1) / 2
if nums[mid - 1] > nums[mid] {
middle = mid
break
}
if (nums.first! < nums[mid]) {
left = mid
} else {
right = mid
}
}
if middle > 0 && nums.first! <= target && target <= nums[middle - 1] {
left = 0
right = middle - 1
} else if nums[middle] <= target && target <= nums.last! {
left = middle
right = nums.count - 1
} else {
return -1
}
while left <= right {
let mid = left + (right - left + 1) / 2
if nums[mid] == target {
index = mid
break
}
if (nums[mid] < target) {
left = mid + 1
} else {
right = mid - 1
}
}
return index
}
*/
}
| 23.688172 | 79 | 0.352247 |
5b6b1a56fa9af45e98d6a2f7bc3ed6f92b4325f2 | 2,178 | //
// AppDelegate.swift
// fingerGame
//
// Created by Arsalan Wahid Asghar on 9/15/17.
// Copyright © 2017 ASGHARS. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
func applicationWillResignActive(_ application: UIApplication) {
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game.
}
func applicationDidEnterBackground(_ application: UIApplication) {
// Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
// If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}
func applicationWillEnterForeground(_ application: UIApplication) {
// Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
}
func applicationDidBecomeActive(_ application: UIApplication) {
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}
func applicationWillTerminate(_ application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}
}
| 46.340426 | 285 | 0.755739 |
697c9d4a9b740a996059a50522cbf5dd9e75df3c | 1,517 | //
// ExchangeJDCodeViewModel.swift
// PeasNovel
//
// Created by lieon on 2019/8/19.
// Copyright © 2019 NotBroken. All rights reserved.
//
import Foundation
import RxSwift
import RxCocoa
import Moya
class ExchangeJDCodeViewModel {
let viewDidLoad: PublishSubject<Void> = .init()
let enterBtninput: PublishSubject<String> = .init()
let bag = DisposeBag()
let exchangeResult: PublishSubject<NullResponse> = .init()
let activityDriver: Driver<Bool>
let errorDriver: Driver<HUDValue>
init() {
let provider = MoyaProvider<Payservice>.init()
let activity = ActivityIndicator()
let errorTracttor = ErrorTracker()
activityDriver = activity.asDriver()
errorDriver = errorTracttor.asDriver()
enterBtninput.flatMap {
provider.rx.request(.jdExchange(["code": $0]))
.model(NullResponse.self)
.asObservable()
.trackActivity(activity)
.trackError(errorTracttor)
.catchError { Observable.just(NullResponse.commonError($0))}
}
.debug()
.bind(to: exchangeResult)
.disposed(by: bag)
exchangeResult
.map { $0.status?.code == 0}
.subscribe(onNext: { (user) in
NotificationCenter.default.post(name: NSNotification.Name.Account.needUpdate, object: nil, userInfo: nil)
})
.disposed(by: bag)
}
}
| 29.745098 | 121 | 0.591958 |
e946026468386adc8dbddabddb3a2c14059f4be6 | 2,227 | /**
Copyright IBM Corporation 2017
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import Socket
protocol ControlPacket {
var description: String { get }
mutating func write(writer: SocketWriter) throws
mutating func unpack(reader: SocketReader)
func validate() -> MQTTErrors
}
public enum ControlCode: Byte {
case connect = 0x10
case connack = 0x20
case publish = 0x30
case puback = 0x40
case pubrec = 0x50
case pubrel = 0x60
case pubcomp = 0x70
case subscribe = 0x82
case suback = 0x90
case unsubscribe = 0xa2
case unsuback = 0xb0
case pingreq = 0xc0
case pingresp = 0xd0
case disconnect = 0xe0
case reserved = 0xf0
}
public enum MQTTErrors: Byte, Error {
case accepted = 0x00
case refusedBadProtocolVersion = 0x01
case refusedIDRejected = 0x02
case serverUnavailable = 0x03
case badUsernameOrPassword = 0x04
case notAuthorize = 0x05
case unknown = 0x06
}
public enum Errors: Byte, Error {
case connectionNotMade
case alreadyDisconnected
case socketNotOpen
case invalidTopicName
case couldNotInitializeData
case unrecognizedOpcode
case couldNotParsePacket
}
public enum ConnectionStatus: Int {
case connected = 1
case disconnected = -1
case connecting = 0
}
public struct LastWill {
let topic: String
let message: String?
let qos: QosType
let retain: Bool
}
public enum QosType: Byte {
case atMostOnce = 0x00 // At Most One Delivery
case atLeastOnce = 0x01 // At Least Deliver Once
case exactlyOnce = 0x02 // Deliver Exactly Once
}
| 26.831325 | 73 | 0.676246 |
4aac94d0d2744ab597a17d73eda5cb2be5f2a804 | 1,418 | //
// SQDownloadConstants.swift
// Quran App
//
// Created by Hussein Ryalat on 10/20/17.
// Copyright © 2017 Sketch Studio. All rights reserved.
//
import Foundation
private let alAfasyURL = URL(string: "http://www.everyayah.com/data/Alafasy_128kbps/")!
private let alDussary = URL(string: "http://www.everyayah.com/data/Yasser_Ad-Dussary_128kbps/")!
let SQSourceBaseURL = alDussary
let SQDestinationBaseURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
let SQMP3Extension = "mp3"
let SQPLISTExtension = "plist"
let SQDownloadInfoMissedIndexesKey = "contents"
let SQDownloadInfoCurrentIndexKey = "current_index"
let SQDownloadInfoTotalItemsCountKey = "total"
let SQDownloadInfoIsThereSomethingMissedKey = "is_there_something_missed"
func ayahUrl(for ayah: SQAyah) -> URL {
return url(for: ayah.surah).appendingPathComponent(ayah.id).appendingPathExtension(SQMP3Extension)
}
func url(for surah: SQSurah) -> URL {
return SQDestinationBaseURL.appendingPathComponent(surah.id, isDirectory: true)
}
func canPlay(surah: SQSurah) -> Bool {
if kAvailableIndexes.contains(surah.index){
return true
}
guard let info = SQDownloadInfo.read(id: surah.id) else {
return false
}
return !info.isThereSomethingMissed
}
func canPlay(ayah: SQAyah) -> Bool {
return FileManager.default.fileExists(atPath: ayahUrl(for: ayah).path)
}
| 29.541667 | 104 | 0.748942 |
877e620465db16d2a7b538bdb6eb51438c5e82f5 | 18,060 | //
// liveStreamer.swift
// HaishinKit iOS
//
// Created by st on 18/07/2018.
// Copyright © 2018 James Lee. All rights reserved.
//
import UIKit
import AVFoundation
@available(iOSApplicationExtension 9.0, *)
open class LiveStreamer: NSObject, LiveStreamerControlInterface, LiveStreamerConfigureInterface {
// MARK: Control Interface
public weak var delegate: LiveStreamingDelegate?
public weak var recorderDelegate: LiveRecorderDelegate?
required public init(with view: GLHKView) {
lfView = view
rtmpStream = RTMPStream(connection: rtmpConnection)
super.init()
configureDefaultBroadcast()
}
public func startCapturingIfCan() -> Bool {
guard lfView.streamLoaded == false else { return false }
attachStream()
addTapGesture()
broadcastStatusForUser = .ready
return true
}
public func startStreamingIfCan(with uri: String, _ streamName: String) -> Bool {
guard rtmpStream.readyState == .closed || rtmpStream.readyState == .initialized else { return false }
isUserWantConnect = true
liveStreamAddress = LiveStreamAddress(uri: uri, streamName: streamName)
startStreaming()
broadcastStatusForUser = .startTrying
return true
}
public func stopStreamingIfCan() -> Bool {
if rtmpStream.readyState == .closed || rtmpStream.readyState == .initialized { return false }
isUserWantConnect = false
stopStreaming()
broadcastStatusForUser = .stop
return true
}
public func pauseStreaming() {
rtmpStream.togglePause()
broadcastStatusForUser = .pause
}
public func startRecordingIfCan() {
guard rtmpStream.recordingState == .ready else { return }
syncOrientation = false
rtmpStream.startRecording()
}
public func stopRecordingIfCan() {
guard rtmpStream.recordingState == .recording else { return }
// Prevent rotation while recording
syncOrientation = true
rtmpStream.stopRecording()
}
private var currentEffect: VisualEffect?
public func applyEffectorIfCan(_ effector: VisualEffect) -> Bool {
guard removeCurrentEffectorIfCan() == true else { return false }
guard rtmpStream.registerEffect(video: effector) == true else { return false }
currentEffect = effector
return true
}
public func removeCurrentEffectorIfCan() -> Bool {
guard let currentEffect: VisualEffect = currentEffect else { return true }
return rtmpStream.unregisterEffect(video: currentEffect)
}
// MARK: Configure Interface
// Changeable while recording/streaming
public var cameraPosition: AVCaptureDevice.Position {
get { return rtmpStream.mixer.videoIO.position }
set (newValue) {
guard rtmpStream.mixer.videoIO.position != newValue else { return }
guard let newDevice = DeviceUtil.device(withPosition: newValue) else { return }
rtmpStream.attachCamera(newDevice) { error in
printLog(error)
}
}
}
private let qosDelegate = LiveStreamerRTMPStreamQoSDelegate()
public var abrOn: Bool = true {
didSet {
if abrOn == true {
rtmpStream.qosDelegate = qosDelegate
} else {
rtmpStream.qosDelegate = nil
rtmpStream.videoSettings["bitrate"] = videoBitrate
}
}
}
public var videoMuted: Bool = false {
didSet { (videoMuted == true) ? rtmpStream.toggleVideoPause() : rtmpStream.toggleVideoResume() }
}
public var audioMuted: Bool = false {
didSet { (audioMuted == true) ? rtmpStream.toggleAudioPause() : rtmpStream.toggleAudioResume() }
}
public var videoBitrate: UInt32 = Preference.videoDefaultBitrate {
didSet { rtmpStream.videoSettings["bitrate"] = videoBitrate }
}
public var audioBitrate: UInt32 = Preference.audioDefaultBitrate {
didSet { rtmpStream.audioSettings["bitrate"] = audioBitrate }
}
public var maximumVideoBitrate: UInt32 = Preference.videoMaximumBitrate {
didSet { rtmpStream.maximumBitrate = maximumVideoBitrate }
}
public var minimumVideoBitrate: UInt32 = Preference.videoMinimumBitrate {
didSet { rtmpStream.minimumBitrate = minimumVideoBitrate }
}
public var zoomRate: Float = 1.0 {
didSet { rtmpStream.setZoomFactor(CGFloat(zoomRate), ramping: true, withRate: 5.0) }
}
public var torch: Bool = false {
didSet { rtmpStream.torch = torch }
}
public var torchModeSupported: Bool {
get { return rtmpStream.isTorchModeSupported() }
}
public var sampleRate: Double = Preference.sampleRate {
didSet {
rtmpStream.audioSettings = [
"sampleRate": sampleRate
]
}
}
public var sessionPreset: AVCaptureSession.Preset = Preference.sessionPreset {
didSet {
guard let currentDevice: AVCaptureDevice = DeviceUtil.device(withPosition: cameraPosition) else { return }
let supportedPreset: AVCaptureSession.Preset = currentDevice.supportedPreset(sessionPreset)
rtmpStream.captureSettings["sessionPreset"] = supportedPreset.rawValue
captureSettings = [
// for 4:3 resolution
//"sessionPreset": AVCaptureSession.Preset.photo.rawValue,
"sessionPreset": sessionPreset,
"continuousAutofocus": true,
"continuousExposure": true
]
}
}
public var videoSize: CGSize = Preference.videoSize {
didSet { setScreenRatio(with: videoSize) }
}
public var recordFileName: String = Preference.recordFileName {
didSet { rtmpStream.mixer.recorder.fileName = recordFileName }
}
public var videoFPS: Float = Preference.defaultFPS {
didSet { rtmpStream.captureSettings["fps"] = videoFPS }
}
public var syncOrientation: Bool = true {
didSet { rtmpStream.syncOrientation = syncOrientation }
}
// MARK: Retry Protocol
public var broadcastTimeout: TimeInterval = 150
public var retryConnectInterval: TimeInterval = 4
public var unableTimeCount: TimeInterval = 0
// MARK: Configure
private func configureDefaultBroadcast() {
try? AVAudioSession.sharedInstance().setPreferredSampleRate(Preference.sampleRate)
try? AVAudioSession.sharedInstance().setCategory(.playAndRecord, mode: .default, options: [])
try? AVAudioSession.sharedInstance().setActive(true)
configureRecorder()
videoSize = Preference.videoSize
sessionPreset = Preference.sessionPreset
sampleRate = Preference.sampleRate
videoBitrate = Preference.videoDefaultBitrate
audioBitrate = Preference.audioDefaultBitrate
maximumVideoBitrate = Preference.videoMaximumBitrate
minimumVideoBitrate = Preference.videoMinimumBitrate
audioMuted = false
zoomRate = 1.0
abrOn = true
torch = false
syncOrientation = true
registerFPSObserver()
}
private func configureRecorder() {
rtmpStream.mixer.recorder.outerDelegate = self
recordFileName = Preference.recordFileName
}
private func setScreenRatio(with size: CGSize) {
var longerSize: CGFloat = 0.0
var shorterSize: CGFloat = 0.0
if size.width > size.height {
longerSize = size.width
shorterSize = size.height
} else {
longerSize = size.height
shorterSize = size.width
}
if rtmpStream.orientation == .portrait || rtmpStream.orientation == .portraitUpsideDown {
rtmpStream.videoSettings = [
"width": shorterSize,
"height": longerSize
]
} else {
rtmpStream.videoSettings = [
"width": longerSize,
"height": shorterSize
]
}
}
// Unchangeable while recording/streaming
private var captureSettings: [String: Any] = [:] {
didSet {
guard rtmpStream.readyState == .closed || rtmpStream.readyState == .initialized else { return }
rtmpStream.captureSettings = captureSettings
}
}
// MARK: Control
private let rtmpConnection: RTMPConnection = RTMPConnection()
private let rtmpStream: RTMPStream
private var liveStreamAddress: LiveStreamAddress?
private(set) var isUserWantConnect = false
private func attachStream() {
rtmpStream.attachAudio(AVCaptureDevice.default(for: .audio)) { error in
printLog(error)
}
rtmpStream.attachCamera(DeviceUtil.device(withPosition: cameraPosition)) { error in
printLog(error)
}
lfView.attachStream(rtmpStream)
}
private func startRTMPConnection(with uri: String?) {
guard let uri = uri else { return }
// Need time to prepare service. will callback at rtmpStatusHandler()
rtmpConnection.start(uri)
}
private func publishRTMPConnection(with name: String?, type: RTMPStream.HowToPublish) {
rtmpStream.publish(name, type: type)
}
private func stopRTMPConnection() {
rtmpConnection.stop()
}
private func startStreaming() {
startRetryConnectionTimer(timeInterval: retryConnectInterval)
setScreenRatio(with: videoSize)
// Prevent rotation while recording
syncOrientation = false
addRTMPObserver()
startRTMPConnection(with: liveStreamAddress?.uri)
}
private func stopStreaming() {
stopRetryConnectionTimer()
syncOrientation = true
stopRTMPConnection()
removeRTMPObserver()
}
private func addRTMPObserver() {
//rtmpConnection.addEventListener(Event.SYNC, selector: #selector(rtmpStatusHandler), observer: self)
//rtmpConnection.addEventListener(Event.EVENT, selector: #selector(rtmpStatusHandler), observer: self)
rtmpConnection.addEventListener(Event.IO_ERROR, selector: #selector(rtmpIOErrorHandler), observer: self)
rtmpConnection.addEventListener(Event.RTMP_STATUS, selector: #selector(rtmpStatusHandler), observer: self)
}
private func removeRTMPObserver() {
//rtmpConnection.removeEventListener(Event.SYNC, selector: #selector(rtmpStatusHandler), observer: self)
//rtmpConnection.removeEventListener(Event.EVENT, selector: #selector(rtmpStatusHandler), observer: self)
rtmpConnection.removeEventListener(Event.IO_ERROR, selector: #selector(rtmpIOErrorHandler), observer: self)
rtmpConnection.removeEventListener(Event.RTMP_STATUS, selector: #selector(rtmpStatusHandler), observer: self)
}
private func addTapGesture() {
let singleTap = UITapGestureRecognizer(target: self, action: #selector(tapScreen(_:)))
lfView.addGestureRecognizer(singleTap)
}
private var broadcastStatusForUser: BroadcastStatusForUser = .initialize {
didSet { delegate?.broadcastStatusForUserWith(code: broadcastStatusForUser.rawValue) }
}
private let lfView: GLHKView
deinit {
printLog("deinit")
try? AVAudioSession.sharedInstance().setActive(false)
timer = nil
_ = stopStreamingIfCan()
stopRecordingIfCan()
rtmpStream.close()
rtmpStream.dispose()
unRegisterFPSObserver()
}
open override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
if keyPath == "currentFPS" {
delegate?.fpsChanged(fps: Float(rtmpStream.currentFPS))
}
}
private func registerFPSObserver() {
rtmpStream.addObserver(self, forKeyPath: "currentFPS", options: .new, context: nil)
}
private func unRegisterFPSObserver() {
rtmpStream.removeObserver(self, forKeyPath: "currentFPS")
}
@objc func tapScreen(_ gesture: UIGestureRecognizer) {
guard let gestureView = gesture.view, gesture.state == .ended else { return }
let touchPoint: CGPoint = gesture.location(in: gestureView)
let pointOfInterest: CGPoint = CGPoint(x: touchPoint.x/gestureView.bounds.size.width,
y: touchPoint.y/gestureView.bounds.size.height)
rtmpStream.setPointOfInterest(pointOfInterest, exposure: pointOfInterest)
}
// MARK: Auto retry
private var timer: Timer? {
didSet {
oldValue?.invalidate()
guard let timer: Timer = timer else { return }
RunLoop.main.add(timer, forMode: RunLoop.Mode.common)
}
}
private func startRetryConnectionTimer(timeInterval: TimeInterval) {
timer = Timer(timeInterval: timeInterval, target: self, selector: #selector(on(timer:)), userInfo: nil, repeats: true)
}
private func stopRetryConnectionTimer() {
timer = nil
}
func setBroadcastStatusForUserToError() {
if broadcastStatusForUser == .startTrying || broadcastStatusForUser == .startFailed{
broadcastStatusForUser = .startFailed
} else {
broadcastStatusForUser = .failed
}
}
func setBroadcastStatusForUserToFailed() {
if broadcastStatusForUser == .startTrying || broadcastStatusForUser == .startFailed{
broadcastStatusForUser = .startFailed
startRetryConnectionTimer(timeInterval: retryConnectInterval)
} else {
broadcastStatusForUser = .failed
}
}
func setBroadcastStatusForUserToFailedTimeout() {
if broadcastStatusForUser == .startTrying || broadcastStatusForUser == .startFailed {
broadcastStatusForUser = .startFailed
startRetryConnectionTimer(timeInterval: retryConnectInterval)
} else {
broadcastStatusForUser = .failedTimeout
startRetryConnectionTimer(timeInterval: retryConnectInterval)
}
}
func setBroadcastStatusForUserToClose() {
if isUserWantConnect == true {
broadcastStatusForUser = .failed
startRetryConnectionTimer(timeInterval: retryConnectInterval)
} else {
broadcastStatusForUser = .stop
}
}
func retryConnectionIfNeeded() {
guard isUserWantConnect == true else { return }
guard rtmpConnection.connected == false else { return }
guard rtmpStream.readyState == .closed || rtmpStream.readyState == .initialized else { return }
// If we try to start socket connection rapidly, problem occur. So we have disconnect properly before reconnect
if let interval = timer?.timeInterval {
unableTimeCount = unableTimeCount + interval
}
guard unableTimeCount < broadcastTimeout else {
unableTimeCount = 0
stopStreaming()
broadcastStatusForUser = .terminated
return
}
if broadcastStatusForUser == .startTrying || broadcastStatusForUser == .startFailed{
broadcastStatusForUser = .startTrying
} else {
broadcastStatusForUser = .failedRetying
}
startRTMPConnection(with: liveStreamAddress?.uri )
}
@objc private func on(timer: Timer) {
retryConnectionIfNeeded()
}
// MARK: Handler
@objc func rtmpIOErrorHandler(_ notification: Notification) {
// Socket timeout. when timed out, reconnection is not working
// Close stream for reconnect
stopRTMPConnection()
setBroadcastStatusForUserToFailedTimeout()
}
@objc func rtmpStatusHandler(_ notification: Notification) {
printLog("rtmpStatusHandler \(notification)")
let event: Event = Event.from(notification)
guard let data: ASObject = event.data as? ASObject, let code: String = data["code"] as? String else { return }
delegate?.broadcastStatusWith(code: code)
switch code {
case RTMPConnection.Code.connectSuccess.rawValue:
publishRTMPConnection(with: liveStreamAddress?.streamName, type: .live)
broadcastStatusForUser = .start
stopRetryConnectionTimer()
unableTimeCount = 0
break
case RTMPConnection.Code.connectNetworkChange.rawValue:
break
case RTMPConnection.Code.connectIdleTimeOut.rawValue:
setBroadcastStatusForUserToFailedTimeout()
break
case RTMPConnection.Code.connectRejected.rawValue:
// Server is not yet started or needs authentication
break
case RTMPConnection.Code.connectFailed.rawValue:
// If handshake is failed before deinitconnect, connectFailed call. Or connectClosed call
setBroadcastStatusForUserToFailed()
break
case RTMPConnection.Code.connectError.rawValue:
// If handshake is failed before deinitconnect, connectFailed call. Or connectClosed call
setBroadcastStatusForUserToError()
break
case RTMPConnection.Code.connectClosed.rawValue:
// Server is closing
setBroadcastStatusForUserToClose()
break
default:
break
}
}
}
| 35 | 156 | 0.634441 |
62fd3273ac2fd621d85af7e8ce8e26fc622a4829 | 9,591 | import Cocoa
public enum ControllerBackground {
case regular, dynamic
}
open class Controller: NSViewController, SpotsProtocol {
/// A closure that is called when the controller is reloaded with components
public static var spotsDidReloadComponents: ((Controller) -> Void)?
open static var configure: ((_ container: SpotsScrollView) -> Void)?
/// A collection of Spotable objects
open var spots: [Spotable] {
didSet {
spots.forEach { $0.delegate = delegate }
delegate?.didChange(spots: spots)
}
}
public var contentView: View {
return view
}
/// A convenience method for resolving the first spot
open var spot: Spotable? {
return spot(at: 0)
}
/// An array of refresh positions to avoid refreshing multiple times when using infinite scrolling
open var refreshPositions = [CGFloat]()
/// An optional StateCache used for view controller caching
open var stateCache: StateCache?
#if DEVMODE
/// A dispatch queue is a lightweight object to which your application submits blocks for subsequent execution.
public let fileQueue: DispatchQueue = DispatchQueue.global(qos: DispatchQoS.QoSClass.default)
/// An identifier for the type system object being monitored by a dispatch source.
public var source: DispatchSourceFileSystemObject?
#endif
/// A delegate for when an item is tapped within a Spot
weak public var delegate: SpotsDelegate? {
didSet {
spots.forEach {
$0.delegate = delegate
}
delegate?.didChange(spots: spots)
}
}
/// A custom scroll view that handles the scrolling for all internal scroll views
public var scrollView: SpotsScrollView = SpotsScrollView()
/// A scroll delegate for handling didReachBeginning and didReachEnd
weak open var scrollDelegate: ScrollDelegate?
/// A bool value to indicate if the Controller is refeshing
open var refreshing = false
fileprivate let backgroundType: ControllerBackground
/**
- parameter spots: An array of Spotable objects
- parameter backgroundType: The type of background that the Controller should use, .Regular or .Dynamic
*/
public required init(spots: [Spotable] = [], backgroundType: ControllerBackground = .regular) {
self.spots = spots
self.backgroundType = backgroundType
super.init(nibName: nil, bundle: nil)!
NotificationCenter.default.addObserver(self, selector: #selector(Controller.scrollViewDidScroll(_:)), name: NSNotification.Name.NSScrollViewDidLiveScroll, object: scrollView)
NotificationCenter.default.addObserver(self, selector: #selector(windowDidResize(_:)), name: NSNotification.Name.NSWindowDidResize, object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(windowDidEndLiveResize(_:)), name: NSNotification.Name.NSWindowDidEndLiveResize, object: nil)
}
/**
- parameter cacheKey: A key that will be used to identify the StateCache
*/
public convenience init(cacheKey: String) {
let stateCache = StateCache(key: cacheKey)
self.init(spots: Parser.parse(stateCache.load()))
self.stateCache = stateCache
}
/**
- parameter spot: A Spotable object
*/
public convenience init(spot: Spotable) {
self.init(spots: [spot])
}
/**
- parameter json: A JSON dictionary that gets parsed into UI elements
*/
public convenience init(_ json: [String : Any]) {
self.init(spots: Parser.parse(json))
}
/**
deinit
*/
deinit {
NotificationCenter.default.removeObserver(self)
spots.forEach { $0.delegate = nil }
delegate = nil
scrollDelegate = nil
}
/**
Returns an object initialized from data in a given unarchiver
- parameter coder: An unarchiver object.
*/
public required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
/// A generic look up method for resolving spots based on index
///
/// - parameter index: The index of the spot that you are trying to resolve.
/// - parameter type: The generic type for the spot you are trying to resolve.
///
/// - returns: An optional Spotable object of inferred type.
open func spot<T>(at index: Int = 0, ofType type: T.Type) -> T? {
return spots.filter({ $0.index == index }).first as? T
}
/// A look up method for resolving a spot at index as a Spotable object.
///
/// - parameter index: The index of the spot that you are trying to resolve.
///
/// - returns: An optional Spotable object.
open func spot(at index: Int = 0) -> Spotable? {
return spots.filter({ $0.index == index }).first
}
/**
A generic look up method for resolving spots using a closure
- parameter closure: A closure to perform actions on a spotable object
- returns: An optional Spotable object
*/
public func resolve(spot closure: (_ index: Int, _ spot: Spotable) -> Bool) -> Spotable? {
for (index, spot) in spots.enumerated()
where closure(index, spot) {
return spot
}
return nil
}
/**
Instantiates a view from a nib file and sets the value of the view property.
*/
open override func loadView() {
let view: NSView
switch backgroundType {
case .regular:
view = NSView()
case .dynamic:
let visualEffectView = NSVisualEffectView()
visualEffectView.blendingMode = .behindWindow
view = visualEffectView
}
view.autoresizingMask = .viewWidthSizable
view.autoresizesSubviews = true
self.view = view
}
/**
Called after the view controller’s view has been loaded into memory.
*/
open override func viewDidLoad() {
super.viewDidLoad()
view.addSubview(scrollView)
scrollView.hasVerticalScroller = true
scrollView.autoresizingMask = [.viewWidthSizable, .viewHeightSizable]
setupSpots()
Controller.configure?(scrollView)
}
open override func viewDidAppear() {
super.viewDidAppear()
for spot in spots {
spot.layout(scrollView.frame.size)
}
}
public func reloadSpots(spots: [Spotable], closure: (() -> Void)?) {
for spot in self.spots {
spot.delegate = nil
spot.render().removeFromSuperview()
}
self.spots = spots
delegate = nil
setupSpots()
closure?()
scrollView.layoutSubviews()
}
/**
- parameter animated: An optional animation closure that runs when a spot is being rendered
*/
public func setupSpots(animated: ((_ view: View) -> Void)? = nil) {
spots.enumerated().forEach { index, spot in
setupSpot(at: index, spot: spot)
animated?(spot.render())
}
}
public func setupSpot(at index: Int, spot: Spotable) {
if spot.render().superview == nil {
scrollView.spotsContentView.addSubview(spot.render())
}
spots[index].component.index = index
spot.registerAndPrepare()
var height = spot.computedHeight
if let componentSize = spot.component.size, componentSize.height > height {
height = componentSize.height
}
spot.setup(CGSize(width: view.frame.width, height: height))
spot.component.size = CGSize(
width: view.frame.width,
height: ceil(spot.render().frame.height))
(spot as? Gridable)?.layout(CGSize(width: view.frame.width, height: height))
}
open override func viewDidLayout() {
super.viewDidLayout()
for spot in spots {
spot.layout(CGSize(width: view.frame.width,
height: spot.computedHeight))
for compositeSpot in spot.compositeSpots {
compositeSpot.spot.setup(CGSize(width: view.frame.width,
height: compositeSpot.spot.computedHeight))
}
}
}
public func deselectAllExcept(selectedSpot: Spotable) {
for spot in spots {
if selectedSpot.render() != spot.render() {
spot.deselect()
}
}
}
public func windowDidResize(_ notification: Notification) {
for case let spot as Gridable in spots {
guard let layout = spot.component.layout, layout.span > 1 else {
continue
}
spot.layout.prepareForTransition(from: spot.layout)
spot.layout.invalidateLayout()
}
}
public func windowDidEndLiveResize(_ notification: Notification) {
for case let spot as Gridable in spots {
guard let layout = spot.component.layout, layout.span > 1 else {
continue
}
spot.layout.prepareForTransition(to: spot.layout)
spot.layout.invalidateLayout()
}
}
open func scrollViewDidScroll(_ notification: NSNotification) {
guard let scrollView = notification.object as? SpotsScrollView,
let delegate = scrollDelegate,
let _ = NSApplication.shared().mainWindow, !refreshing && scrollView.contentOffset.y > 0
else { return }
let offset = scrollView.contentOffset
let totalHeight = scrollView.documentView?.frame.size.height ?? 0
let multiplier: CGFloat = !refreshPositions.isEmpty
? CGFloat(1 + refreshPositions.count)
: 1.5
let currentOffset = offset.y + scrollView.frame.size.height
let shouldFetch = currentOffset > totalHeight - scrollView.frame.size.height * multiplier + scrollView.frame.origin.y &&
!refreshPositions.contains(currentOffset)
// Scroll did reach top
if scrollView.contentOffset.y < 0 &&
!refreshing {
refreshing = true
delegate.didReachBeginning(in: scrollView) {
self.refreshing = false
}
}
if shouldFetch {
// Infinite scrolling
refreshing = true
refreshPositions.append(currentOffset)
delegate.didReachEnd(in: scrollView) {
self.refreshing = false
}
}
}
}
| 29.878505 | 178 | 0.683453 |
bf3494fd2a88f9d9e6bccf060d9a2ddd98310ccd | 5,992 | //
// FSCityModel.swift
// fitsky
// 城市model
// Created by gouyz on 2019/7/22.
// Copyright © 2019 gyz. All rights reserved.
//
import UIKit
@objcMembers
class FSCityModel: LHSBaseModel,NSCoding {
/// 城市索引
var pinyinIndexArr : [String] = []
var cityListDic:[String:[FSCityListModel]] = [String:[FSCityListModel]]()
override func setValue(_ value: Any?, forKey key: String) {
if key == "list"{
guard let datas = value as? [String : Any] else { return }
for key in datas.keys {
guard let itemDatas = datas[key] as? [[String : Any]] else { continue }
var cityArr: [FSCityListModel] = [FSCityListModel]()
for item in itemDatas {
let model = FSCityListModel(dict: item)
cityArr.append(model)
}
cityListDic[key] = cityArr
}
}else if key == "first_pinyin"{
guard let datas = value as? [String] else { return }
for item in datas {
pinyinIndexArr.append(item)
}
}else {
super.setValue(value, forKey: key)
}
}
override init(dict: [String : Any]) {
super.init(dict: dict)
}
required init?(coder aDecoder: NSCoder) {
super.init()
pinyinIndexArr = aDecoder.decodeObject(forKey: "pinyinIndexArr") as? [String] ?? [String]()
cityListDic = aDecoder.decodeObject(forKey: "cityListDic") as? [String:[FSCityListModel]] ?? [String:[FSCityListModel]]()
}
func encode(with aCoder: NSCoder) {
aCoder.encode(pinyinIndexArr, forKey:"pinyinIndexArr")
aCoder.encode(cityListDic, forKey:"cityListDic")
}
}
@objcMembers
class FSCityListModel: LHSBaseModel,NSCoding {
/// 城市id
var id : String? = ""
/// 城市编号
var code : String? = ""
/// 城市名称
var name : String? = ""
/// 父id
var pid : String? = ""
/// 类型
var type : String? = ""
/// 城市拼音首字母
var first_pinyin : String? = ""
/// 城市拼音首字母缩写
var short_pinyin : String? = ""
/// 城市拼音全拼
var full_pinyin : String? = ""
/// 是否热门城市1是0否
var is_hot : String? = ""
var areaList:[FSCityListModel] = [FSCityListModel]()
override func setValue(_ value: Any?, forKey key: String) {
if key == "child"{
guard let datas = value as? [[String : Any]] else { return }
for dict in datas {
let model = FSCityListModel(dict: dict)
areaList.append(model)
}
}else {
super.setValue(value, forKey: key)
}
}
override init(dict: [String : Any]) {
super.init(dict: dict)
}
required init?(coder aDecoder: NSCoder) {
super.init()
id = aDecoder.decodeObject(forKey: "id") as? String ?? ""
code = aDecoder.decodeObject(forKey: "code") as? String ?? ""
name = aDecoder.decodeObject(forKey: "name") as? String ?? ""
pid = aDecoder.decodeObject(forKey: "pid") as? String ?? ""
type = aDecoder.decodeObject(forKey: "type") as? String ?? ""
first_pinyin = aDecoder.decodeObject(forKey: "first_pinyin") as? String ?? ""
short_pinyin = aDecoder.decodeObject(forKey: "short_pinyin") as? String ?? ""
full_pinyin = aDecoder.decodeObject(forKey: "full_pinyin") as? String ?? ""
is_hot = aDecoder.decodeObject(forKey: "is_hot") as? String ?? ""
areaList = aDecoder.decodeObject(forKey: "areaList") as? [FSCityListModel] ?? [FSCityListModel]()
}
func encode(with aCoder: NSCoder) {
aCoder.encode(id, forKey:"id")
aCoder.encode(code, forKey:"code")
aCoder.encode(name, forKey:"name")
aCoder.encode(pid, forKey:"pid")
aCoder.encode(type, forKey:"type")
aCoder.encode(first_pinyin, forKey:"first_pinyin")
aCoder.encode(short_pinyin, forKey:"short_pinyin")
aCoder.encode(full_pinyin, forKey:"full_pinyin")
aCoder.encode(is_hot, forKey:"is_hot")
aCoder.encode(areaList, forKey:"areaList")
}
}
/// 区域model
@objcMembers
class FSAreaModel: LHSBaseModel,NSCoding {
/// 用户id
var id : String? = ""
/// 城市编号
var code : String? = ""
/// 城市名称
var name : String? = ""
/// 父id
var pid : String? = ""
/// 类型
var type : String? = ""
/// 城市拼音首字母
var first_pinyin : String? = ""
/// 城市拼音首字母缩写
var short_pinyin : String? = ""
/// 城市拼音w全拼
var full_pinyin : String? = ""
/// 是否热门城市1是0否
var is_hot : String? = ""
override init(dict: [String : Any]) {
super.init(dict: dict)
}
required init?(coder aDecoder: NSCoder) {
super.init()
id = aDecoder.decodeObject(forKey: "id") as? String ?? ""
code = aDecoder.decodeObject(forKey: "code") as? String ?? ""
name = aDecoder.decodeObject(forKey: "name") as? String ?? ""
pid = aDecoder.decodeObject(forKey: "pid") as? String ?? ""
type = aDecoder.decodeObject(forKey: "type") as? String ?? ""
first_pinyin = aDecoder.decodeObject(forKey: "first_pinyin") as? String ?? ""
short_pinyin = aDecoder.decodeObject(forKey: "short_pinyin") as? String ?? ""
full_pinyin = aDecoder.decodeObject(forKey: "full_pinyin") as? String ?? ""
is_hot = aDecoder.decodeObject(forKey: "is_hot") as? String ?? ""
}
func encode(with aCoder: NSCoder) {
aCoder.encode(id, forKey:"id")
aCoder.encode(code, forKey:"code")
aCoder.encode(name, forKey:"name")
aCoder.encode(pid, forKey:"pid")
aCoder.encode(type, forKey:"type")
aCoder.encode(first_pinyin, forKey:"first_pinyin")
aCoder.encode(short_pinyin, forKey:"short_pinyin")
aCoder.encode(full_pinyin, forKey:"full_pinyin")
aCoder.encode(is_hot, forKey:"is_hot")
}
}
| 33.662921 | 129 | 0.572764 |
6169ed1c372d87cb9fd2cb9d9baa52fa13b69cff | 1,304 | import UIKit
func isValid(_ s: String) -> Bool {
var result: Bool = false
let stringLength = s.count
let inputStringArray = Array(s)
let allowedCharacters = CharacterSet(charactersIn: "(){}[]")
var stack: [Character] = []
func complementaryClosingBracket(_ bracket: Character) -> Character {
switch bracket {
case "{":
return "}"
case "}":
return "{"
case "[":
return "]"
case "]":
return "["
case "(":
return ")"
case ")":
return "("
default:
return "}"
}
}
if stringLength % 2 != 0 || s.rangeOfCharacter(from: allowedCharacters.inverted) != nil {
result = false
} else if stringLength == 0 {
result = true
} else {
for i in 0 ..< inputStringArray.count {
let stackCount = stack.count
if stackCount > 0,
inputStringArray[i] == complementaryClosingBracket(stack[stackCount - 1])
{
stack.remove(at: stackCount - 1)
} else {
stack.append(inputStringArray[i])
}
}
result = (stack.count == 0)
}
return result
}
print("is valid - \(isValid("[](){}"))")
| 25.568627 | 93 | 0.490031 |
620eb9a3b3e9f7307645869630457195023cfe89 | 382 | //
// Assembly.swift
// swiftBase
//
// Created by ios on 2022/2/17.
//
import Foundation
/*
汇编
1.寄存器：rbp栈指针 rsp栈顶指针 rax函数返回值 rdi、rsi函数默认传输寄存器
2.全局变量，静态变量通过rip相对索引进行访问
3.new出来的对象是在heap上；临时对象是在stack，用ebp索引
4.调用函数的地方call,后面的地址是函数地址
5.lea是用来传地址的指令
leaq 0xd(%rip) %rax
leaq是将rip + 0xd的地址值给rax
movq 0xd(%rip) %rax
movq是将rip + 0xd的地址取出8个字节给rax
*/
| 14.148148 | 54 | 0.685864 |
9b4e08bdac5612aac705c6013c53203b976c6512 | 51,477 | //
// This is a generated file, do not edit!
// Generated by R.swift, see https://github.com/mac-cain13/R.swift
//
import Foundation
import Rswift
import UIKit
/// This `R` struct is generated and contains references to static resources.
struct R: Rswift.Validatable {
fileprivate static let applicationLocale = hostingBundle.preferredLocalizations.first.flatMap(Locale.init) ?? Locale.current
fileprivate static let hostingBundle = Bundle(for: R.Class.self)
static func validate() throws {
try intern.validate()
}
/// This `R.file` struct is generated, and contains static references to 2 files.
struct file {
/// Resource file `EFOpenController.json`.
static let efOpenControllerJson = Rswift.FileResource(bundle: R.hostingBundle, name: "EFOpenController", pathExtension: "json")
/// Resource file `MJPhotoBrowser.bundle`.
static let mjPhotoBrowserBundle = Rswift.FileResource(bundle: R.hostingBundle, name: "MJPhotoBrowser", pathExtension: "bundle")
/// `bundle.url(forResource: "EFOpenController", withExtension: "json")`
static func efOpenControllerJson(_: Void = ()) -> Foundation.URL? {
let fileResource = R.file.efOpenControllerJson
return fileResource.bundle.url(forResource: fileResource)
}
/// `bundle.url(forResource: "MJPhotoBrowser", withExtension: "bundle")`
static func mjPhotoBrowserBundle(_: Void = ()) -> Foundation.URL? {
let fileResource = R.file.mjPhotoBrowserBundle
return fileResource.bundle.url(forResource: fileResource)
}
fileprivate init() {}
}
/// This `R.image` struct is generated, and contains static references to 23 images.
struct image {
/// Image `Launch`.
static let launch = Rswift.ImageResource(bundle: R.hostingBundle, name: "Launch")
/// Image `icon`.
static let icon = Rswift.ImageResource(bundle: R.hostingBundle, name: "icon")
/// Image `logo`.
static let logo = Rswift.ImageResource(bundle: R.hostingBundle, name: "logo")
/// Image `placeholder_default`.
static let placeholder_default = Rswift.ImageResource(bundle: R.hostingBundle, name: "placeholder_default")
/// Image `placeholder_transparent`.
static let placeholder_transparent = Rswift.ImageResource(bundle: R.hostingBundle, name: "placeholder_transparent")
/// Image `placeholder_user`.
static let placeholder_user = Rswift.ImageResource(bundle: R.hostingBundle, name: "placeholder_user")
/// Image `welcome_1`.
static let welcome_1 = Rswift.ImageResource(bundle: R.hostingBundle, name: "welcome_1")
/// Image `welcome_2`.
static let welcome_2 = Rswift.ImageResource(bundle: R.hostingBundle, name: "welcome_2")
/// Image `welcome_3`.
static let welcome_3 = Rswift.ImageResource(bundle: R.hostingBundle, name: "welcome_3")
/// Image `图标_ISO`.
static let 图标_ISO = Rswift.ImageResource(bundle: R.hostingBundle, name: "图标_ISO")
/// Image `图标_光圈`.
static let 图标_光圈 = Rswift.ImageResource(bundle: R.hostingBundle, name: "图标_光圈")
/// Image `图标_小人`.
static let 图标_小人 = Rswift.ImageResource(bundle: R.hostingBundle, name: "图标_小人")
/// Image `图标_小笔`.
static let 图标_小笔 = Rswift.ImageResource(bundle: R.hostingBundle, name: "图标_小笔")
/// Image `图标_选择_否`.
static let 图标_选择_否 = Rswift.ImageResource(bundle: R.hostingBundle, name: "图标_选择_否")
/// Image `图标_选择_是`.
static let 图标_选择_是 = Rswift.ImageResource(bundle: R.hostingBundle, name: "图标_选择_是")
/// Image `按钮_关闭`.
static let 按钮_关闭 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_关闭")
/// Image `按钮_新建`.
static let 按钮_新建 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_新建")
/// Image `按钮_更多_白`.
static let 按钮_更多_白 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_更多_白")
/// Image `按钮_更多_黑`.
static let 按钮_更多_黑 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_更多_黑")
/// Image `按钮_设置_白`.
static let 按钮_设置_白 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_设置_白")
/// Image `按钮_设置_黑`.
static let 按钮_设置_黑 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_设置_黑")
/// Image `按钮_返回_白`.
static let 按钮_返回_白 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_返回_白")
/// Image `按钮_返回_黑`.
static let 按钮_返回_黑 = Rswift.ImageResource(bundle: R.hostingBundle, name: "按钮_返回_黑")
/// `UIImage(named: "Launch", bundle: ..., traitCollection: ...)`
static func launch(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.launch, compatibleWith: traitCollection)
}
/// `UIImage(named: "icon", bundle: ..., traitCollection: ...)`
static func icon(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.icon, compatibleWith: traitCollection)
}
/// `UIImage(named: "logo", bundle: ..., traitCollection: ...)`
static func logo(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.logo, compatibleWith: traitCollection)
}
/// `UIImage(named: "placeholder_default", bundle: ..., traitCollection: ...)`
static func placeholder_default(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.placeholder_default, compatibleWith: traitCollection)
}
/// `UIImage(named: "placeholder_transparent", bundle: ..., traitCollection: ...)`
static func placeholder_transparent(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.placeholder_transparent, compatibleWith: traitCollection)
}
/// `UIImage(named: "placeholder_user", bundle: ..., traitCollection: ...)`
static func placeholder_user(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.placeholder_user, compatibleWith: traitCollection)
}
/// `UIImage(named: "welcome_1", bundle: ..., traitCollection: ...)`
static func welcome_1(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.welcome_1, compatibleWith: traitCollection)
}
/// `UIImage(named: "welcome_2", bundle: ..., traitCollection: ...)`
static func welcome_2(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.welcome_2, compatibleWith: traitCollection)
}
/// `UIImage(named: "welcome_3", bundle: ..., traitCollection: ...)`
static func welcome_3(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.welcome_3, compatibleWith: traitCollection)
}
/// `UIImage(named: "图标_ISO", bundle: ..., traitCollection: ...)`
static func 图标_ISO(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.图标_ISO, compatibleWith: traitCollection)
}
/// `UIImage(named: "图标_光圈", bundle: ..., traitCollection: ...)`
static func 图标_光圈(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.图标_光圈, compatibleWith: traitCollection)
}
/// `UIImage(named: "图标_小人", bundle: ..., traitCollection: ...)`
static func 图标_小人(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.图标_小人, compatibleWith: traitCollection)
}
/// `UIImage(named: "图标_小笔", bundle: ..., traitCollection: ...)`
static func 图标_小笔(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.图标_小笔, compatibleWith: traitCollection)
}
/// `UIImage(named: "图标_选择_否", bundle: ..., traitCollection: ...)`
static func 图标_选择_否(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.图标_选择_否, compatibleWith: traitCollection)
}
/// `UIImage(named: "图标_选择_是", bundle: ..., traitCollection: ...)`
static func 图标_选择_是(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.图标_选择_是, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_关闭", bundle: ..., traitCollection: ...)`
static func 按钮_关闭(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_关闭, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_新建", bundle: ..., traitCollection: ...)`
static func 按钮_新建(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_新建, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_更多_白", bundle: ..., traitCollection: ...)`
static func 按钮_更多_白(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_更多_白, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_更多_黑", bundle: ..., traitCollection: ...)`
static func 按钮_更多_黑(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_更多_黑, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_设置_白", bundle: ..., traitCollection: ...)`
static func 按钮_设置_白(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_设置_白, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_设置_黑", bundle: ..., traitCollection: ...)`
static func 按钮_设置_黑(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_设置_黑, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_返回_白", bundle: ..., traitCollection: ...)`
static func 按钮_返回_白(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_返回_白, compatibleWith: traitCollection)
}
/// `UIImage(named: "按钮_返回_黑", bundle: ..., traitCollection: ...)`
static func 按钮_返回_黑(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.按钮_返回_黑, compatibleWith: traitCollection)
}
fileprivate init() {}
}
/// This `R.storyboard` struct is generated, and contains static references to 2 storyboards.
struct storyboard {
/// Storyboard `LaunchScreen`.
static let launchScreen = _R.storyboard.launchScreen()
/// Storyboard `Main`.
static let main = _R.storyboard.main()
/// `UIStoryboard(name: "LaunchScreen", bundle: ...)`
static func launchScreen(_: Void = ()) -> UIKit.UIStoryboard {
return UIKit.UIStoryboard(resource: R.storyboard.launchScreen)
}
/// `UIStoryboard(name: "Main", bundle: ...)`
static func main(_: Void = ()) -> UIKit.UIStoryboard {
return UIKit.UIStoryboard(resource: R.storyboard.main)
}
fileprivate init() {}
}
/// This `R.string` struct is generated, and contains static references to 3 localization tables.
struct string {
/// This `R.string.launchScreen` struct is generated, and contains static references to 0 localization keys.
struct launchScreen {
fileprivate init() {}
}
/// This `R.string.localizable` struct is generated, and contains static references to 76 localization keys.
struct localizable {
/// zh-Hans translation: 同意
///
/// Locales: zh-Hans, zh-Hant, en
static let 同意 = Rswift.StringResource(key: " 同意", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 尚未注册？
///
/// Locales: zh-Hans, zh-Hant, en
static let 尚未注册 = Rswift.StringResource(key: " 尚未注册？", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 已有账号？
///
/// Locales: zh-Hans, zh-Hant, en
static let 已有账号 = Rswift.StringResource(key: " 已有账号？", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 上传失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 上传失败 = Rswift.StringResource(key: "上传失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 个人博客 or 个人网站
///
/// Locales: zh-Hans, zh-Hant, en
static let 个人博客Or个人网站 = Rswift.StringResource(key: "个人博客 or 个人网站", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 中英日数字_
///
/// Locales: zh-Hans, zh-Hant, en
static let 中英日数字_ = Rswift.StringResource(key: "中英日数字_", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 举报
///
/// Locales: zh-Hans, zh-Hant, en
static let 举报 = Rswift.StringResource(key: "举报", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 保存到相册
///
/// Locales: zh-Hans, zh-Hant, en
static let 保存到相册 = Rswift.StringResource(key: "保存到相册", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 保存失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 保存失败 = Rswift.StringResource(key: "保存失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 关于 VSCAM
///
/// Locales: zh-Hans, zh-Hant, en
static let 关于VSCAM = Rswift.StringResource(key: "关于 VSCAM", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 关于我的一句话自我介绍
///
/// Locales: zh-Hans, zh-Hant, en
static let 关于我的一句话自我介绍 = Rswift.StringResource(key: "关于我的一句话自我介绍", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 分享
///
/// Locales: zh-Hans, zh-Hant, en
static let 分享 = Rswift.StringResource(key: "分享", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 删除
///
/// Locales: zh-Hans, zh-Hant, en
static let 删除 = Rswift.StringResource(key: "删除", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 删除头像
///
/// Locales: zh-Hans, zh-Hant, en
static let 删除头像 = Rswift.StringResource(key: "删除头像", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 删除头像失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 删除头像失败 = Rswift.StringResource(key: "删除头像失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 删除头像成功
///
/// Locales: zh-Hans, zh-Hant, en
static let 删除头像成功 = Rswift.StringResource(key: "删除头像成功", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 剪贴板内容无法识别
///
/// Locales: zh-Hans, zh-Hant, en
static let 剪贴板内容无法识别 = Rswift.StringResource(key: "剪贴板内容无法识别", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 剪贴板没有内容
///
/// Locales: zh-Hans, zh-Hant, en
static let 剪贴板没有内容 = Rswift.StringResource(key: "剪贴板没有内容", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 加入
///
/// Locales: zh-Hans, zh-Hant, en
static let 加入 = Rswift.StringResource(key: "加入", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 去评分
///
/// Locales: zh-Hans, zh-Hant, en
static let 去评分 = Rswift.StringResource(key: "去评分", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 发布失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 发布失败 = Rswift.StringResource(key: "发布失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 取消
///
/// Locales: zh-Hans, zh-Hant, en
static let 取消 = Rswift.StringResource(key: "取消", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片举报失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片举报失败 = Rswift.StringResource(key: "图片举报失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片举报成功，感谢您的反馈！您将不会在列表中再次看到该图片，我们将会尽快对您的举报信息进行核实与处理，您将在 24 小时内收到我们的反馈邮件。
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片举报成功感谢您的反馈您将不会在列表中再次看到该图片我们将会尽快对您的举报信息进行核实与处理您将在24小时内收到我们的反馈邮件 = Rswift.StringResource(key: "图片举报成功，感谢您的反馈！您将不会在列表中再次看到该图片，我们将会尽快对您的举报信息进行核实与处理，您将在 24 小时内收到我们的反馈邮件。", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片列表刷新失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片列表刷新失败 = Rswift.StringResource(key: "图片列表刷新失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片列表加载失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片列表加载失败 = Rswift.StringResource(key: "图片列表加载失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片删除失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片删除失败 = Rswift.StringResource(key: "图片删除失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片描述不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片描述不能为空 = Rswift.StringResource(key: "图片描述不能为空", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片正在上传
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片正在上传 = Rswift.StringResource(key: "图片正在上传", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片编码失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片编码失败 = Rswift.StringResource(key: "图片编码失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片获取无效
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片获取无效 = Rswift.StringResource(key: "图片获取无效", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 图片详情页打开失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 图片详情页打开失败 = Rswift.StringResource(key: "图片详情页打开失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 密码不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static let 密码不能为空 = Rswift.StringResource(key: "密码不能为空", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 年
///
/// Locales: zh-Hans, zh-Hant, en
static let 年 = Rswift.StringResource(key: "年", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 成功保存到相册
///
/// Locales: zh-Hans, zh-Hant, en
static let 成功保存到相册 = Rswift.StringResource(key: "成功保存到相册", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 所选图片无效
///
/// Locales: zh-Hans, zh-Hant, en
static let 所选图片无效 = Rswift.StringResource(key: "所选图片无效", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 手机拍摄、胶片味、意识流
///
/// Locales: zh-Hans, zh-Hant, en
static let 手机拍摄胶片味意识流 = Rswift.StringResource(key: "手机拍摄、胶片味、意识流", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 描述信息
///
/// Locales: zh-Hans, zh-Hant, en
static let 描述信息 = Rswift.StringResource(key: "描述信息", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 提示
///
/// Locales: zh-Hans, zh-Hant, en
static let 提示 = Rswift.StringResource(key: "提示", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 操作失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 操作失败 = Rswift.StringResource(key: "操作失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 数据异常
///
/// Locales: zh-Hans, zh-Hant, en
static let 数据异常 = Rswift.StringResource(key: "数据异常", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 数据格式错误
///
/// Locales: zh-Hans, zh-Hant, en
static let 数据格式错误 = Rswift.StringResource(key: "数据格式错误", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 日
///
/// Locales: zh-Hans, zh-Hant, en
static let 日 = Rswift.StringResource(key: "日", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 昵称不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static let 昵称不能为空 = Rswift.StringResource(key: "昵称不能为空", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 更换
///
/// Locales: zh-Hans, zh-Hant, en
static let 更换 = Rswift.StringResource(key: "更换", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 更改个人信息成功
///
/// Locales: zh-Hans, zh-Hant, en
static let 更改个人信息成功 = Rswift.StringResource(key: "更改个人信息成功", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 更改失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 更改失败 = Rswift.StringResource(key: "更改失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 更改头像失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 更改头像失败 = Rswift.StringResource(key: "更改头像失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 更改头像成功
///
/// Locales: zh-Hans, zh-Hant, en
static let 更改头像成功 = Rswift.StringResource(key: "更改头像成功", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 月
///
/// Locales: zh-Hans, zh-Hant, en
static let 月 = Rswift.StringResource(key: "月", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 未知版本
///
/// Locales: zh-Hans, zh-Hant, en
static let 未知版本 = Rswift.StringResource(key: "未知版本", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 欢迎页面
///
/// Locales: zh-Hans, zh-Hant, en
static let 欢迎页面 = Rswift.StringResource(key: "欢迎页面", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 注册失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 注册失败 = Rswift.StringResource(key: "注册失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 清理缓存
///
/// Locales: zh-Hans, zh-Hant, en
static let 清理缓存 = Rswift.StringResource(key: "清理缓存", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 用户协议
///
/// Locales: zh-Hans, zh-Hant, en
static let 用户协议 = Rswift.StringResource(key: "用户协议", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 用户名不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static let 用户名不能为空 = Rswift.StringResource(key: "用户名不能为空", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 用户详情页打开失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 用户详情页打开失败 = Rswift.StringResource(key: "用户详情页打开失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 登录
///
/// Locales: zh-Hans, zh-Hant, en
static let 登录 = Rswift.StringResource(key: "登录", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 登录失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 登录失败 = Rswift.StringResource(key: "登录失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 确定
///
/// Locales: zh-Hans, zh-Hant, en
static let 确定 = Rswift.StringResource(key: "确定", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 确认更改
///
/// Locales: zh-Hans, zh-Hant, en
static let 确认更改 = Rswift.StringResource(key: "确认更改", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 缓存大小为
///
/// Locales: zh-Hans, zh-Hant, en
static let 缓存大小为 = Rswift.StringResource(key: "缓存大小为", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 网络不给力，图片下载失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 网络不给力图片下载失败 = Rswift.StringResource(key: "网络不给力，图片下载失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 获取图片失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 获取图片失败 = Rswift.StringResource(key: "获取图片失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 请先登录
///
/// Locales: zh-Hans, zh-Hant, en
static let 请先登录 = Rswift.StringResource(key: "请先登录", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 请填写您的举报描述信息以方便我们的查证与处理
///
/// Locales: zh-Hans, zh-Hant, en
static let 请填写您的举报描述信息以方便我们的查证与处理 = Rswift.StringResource(key: "请填写您的举报描述信息以方便我们的查证与处理", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 请查看并同意用户协议
///
/// Locales: zh-Hans, zh-Hant, en
static let 请查看并同意用户协议 = Rswift.StringResource(key: "请查看并同意用户协议", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 请求失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 请求失败 = Rswift.StringResource(key: "请求失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 请选择使用 iPhone 拍摄的照片或其它经过处理的图片
///
/// Locales: zh-Hans, zh-Hant, en
static let 请选择使用IPhone拍摄的照片或其它经过处理的图片 = Rswift.StringResource(key: "请选择使用 iPhone 拍摄的照片或其它经过处理的图片", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 输入一句话照片简介
///
/// Locales: zh-Hans, zh-Hant, en
static let 输入一句话照片简介 = Rswift.StringResource(key: "输入一句话照片简介", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 退出登录
///
/// Locales: zh-Hans, zh-Hant, en
static let 退出登录 = Rswift.StringResource(key: "退出登录", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 退出登录失败
///
/// Locales: zh-Hans, zh-Hant, en
static let 退出登录失败 = Rswift.StringResource(key: "退出登录失败", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 邮箱不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static let 邮箱不能为空 = Rswift.StringResource(key: "邮箱不能为空", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 邮箱格式错误
///
/// Locales: zh-Hans, zh-Hant, en
static let 邮箱格式错误 = Rswift.StringResource(key: "邮箱格式错误", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 隐私政策
///
/// Locales: zh-Hans, zh-Hant, en
static let 隐私政策 = Rswift.StringResource(key: "隐私政策", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: ，确定要清理缓存么？
///
/// Locales: zh-Hans, zh-Hant, en
static let 确定要清理缓存么 = Rswift.StringResource(key: "，确定要清理缓存么？", tableName: "Localizable", bundle: R.hostingBundle, locales: ["zh-Hans", "zh-Hant", "en"], comment: nil)
/// zh-Hans translation: 同意
///
/// Locales: zh-Hans, zh-Hant, en
static func 同意(_: Void = ()) -> String {
return NSLocalizedString(" 同意", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 尚未注册？
///
/// Locales: zh-Hans, zh-Hant, en
static func 尚未注册(_: Void = ()) -> String {
return NSLocalizedString(" 尚未注册？", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 已有账号？
///
/// Locales: zh-Hans, zh-Hant, en
static func 已有账号(_: Void = ()) -> String {
return NSLocalizedString(" 已有账号？", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 上传失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 上传失败(_: Void = ()) -> String {
return NSLocalizedString("上传失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 个人博客 or 个人网站
///
/// Locales: zh-Hans, zh-Hant, en
static func 个人博客Or个人网站(_: Void = ()) -> String {
return NSLocalizedString("个人博客 or 个人网站", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 中英日数字_
///
/// Locales: zh-Hans, zh-Hant, en
static func 中英日数字_(_: Void = ()) -> String {
return NSLocalizedString("中英日数字_", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 举报
///
/// Locales: zh-Hans, zh-Hant, en
static func 举报(_: Void = ()) -> String {
return NSLocalizedString("举报", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 保存到相册
///
/// Locales: zh-Hans, zh-Hant, en
static func 保存到相册(_: Void = ()) -> String {
return NSLocalizedString("保存到相册", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 保存失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 保存失败(_: Void = ()) -> String {
return NSLocalizedString("保存失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 关于 VSCAM
///
/// Locales: zh-Hans, zh-Hant, en
static func 关于VSCAM(_: Void = ()) -> String {
return NSLocalizedString("关于 VSCAM", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 关于我的一句话自我介绍
///
/// Locales: zh-Hans, zh-Hant, en
static func 关于我的一句话自我介绍(_: Void = ()) -> String {
return NSLocalizedString("关于我的一句话自我介绍", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 分享
///
/// Locales: zh-Hans, zh-Hant, en
static func 分享(_: Void = ()) -> String {
return NSLocalizedString("分享", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 删除
///
/// Locales: zh-Hans, zh-Hant, en
static func 删除(_: Void = ()) -> String {
return NSLocalizedString("删除", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 删除头像
///
/// Locales: zh-Hans, zh-Hant, en
static func 删除头像(_: Void = ()) -> String {
return NSLocalizedString("删除头像", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 删除头像失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 删除头像失败(_: Void = ()) -> String {
return NSLocalizedString("删除头像失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 删除头像成功
///
/// Locales: zh-Hans, zh-Hant, en
static func 删除头像成功(_: Void = ()) -> String {
return NSLocalizedString("删除头像成功", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 剪贴板内容无法识别
///
/// Locales: zh-Hans, zh-Hant, en
static func 剪贴板内容无法识别(_: Void = ()) -> String {
return NSLocalizedString("剪贴板内容无法识别", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 剪贴板没有内容
///
/// Locales: zh-Hans, zh-Hant, en
static func 剪贴板没有内容(_: Void = ()) -> String {
return NSLocalizedString("剪贴板没有内容", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 加入
///
/// Locales: zh-Hans, zh-Hant, en
static func 加入(_: Void = ()) -> String {
return NSLocalizedString("加入", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 去评分
///
/// Locales: zh-Hans, zh-Hant, en
static func 去评分(_: Void = ()) -> String {
return NSLocalizedString("去评分", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 发布失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 发布失败(_: Void = ()) -> String {
return NSLocalizedString("发布失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 取消
///
/// Locales: zh-Hans, zh-Hant, en
static func 取消(_: Void = ()) -> String {
return NSLocalizedString("取消", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片举报失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片举报失败(_: Void = ()) -> String {
return NSLocalizedString("图片举报失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片举报成功，感谢您的反馈！您将不会在列表中再次看到该图片，我们将会尽快对您的举报信息进行核实与处理，您将在 24 小时内收到我们的反馈邮件。
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片举报成功感谢您的反馈您将不会在列表中再次看到该图片我们将会尽快对您的举报信息进行核实与处理您将在24小时内收到我们的反馈邮件(_: Void = ()) -> String {
return NSLocalizedString("图片举报成功，感谢您的反馈！您将不会在列表中再次看到该图片，我们将会尽快对您的举报信息进行核实与处理，您将在 24 小时内收到我们的反馈邮件。", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片列表刷新失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片列表刷新失败(_: Void = ()) -> String {
return NSLocalizedString("图片列表刷新失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片列表加载失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片列表加载失败(_: Void = ()) -> String {
return NSLocalizedString("图片列表加载失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片删除失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片删除失败(_: Void = ()) -> String {
return NSLocalizedString("图片删除失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片描述不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片描述不能为空(_: Void = ()) -> String {
return NSLocalizedString("图片描述不能为空", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片正在上传
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片正在上传(_: Void = ()) -> String {
return NSLocalizedString("图片正在上传", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片编码失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片编码失败(_: Void = ()) -> String {
return NSLocalizedString("图片编码失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片获取无效
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片获取无效(_: Void = ()) -> String {
return NSLocalizedString("图片获取无效", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 图片详情页打开失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 图片详情页打开失败(_: Void = ()) -> String {
return NSLocalizedString("图片详情页打开失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 密码不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static func 密码不能为空(_: Void = ()) -> String {
return NSLocalizedString("密码不能为空", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 年
///
/// Locales: zh-Hans, zh-Hant, en
static func 年(_: Void = ()) -> String {
return NSLocalizedString("年", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 成功保存到相册
///
/// Locales: zh-Hans, zh-Hant, en
static func 成功保存到相册(_: Void = ()) -> String {
return NSLocalizedString("成功保存到相册", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 所选图片无效
///
/// Locales: zh-Hans, zh-Hant, en
static func 所选图片无效(_: Void = ()) -> String {
return NSLocalizedString("所选图片无效", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 手机拍摄、胶片味、意识流
///
/// Locales: zh-Hans, zh-Hant, en
static func 手机拍摄胶片味意识流(_: Void = ()) -> String {
return NSLocalizedString("手机拍摄、胶片味、意识流", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 描述信息
///
/// Locales: zh-Hans, zh-Hant, en
static func 描述信息(_: Void = ()) -> String {
return NSLocalizedString("描述信息", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 提示
///
/// Locales: zh-Hans, zh-Hant, en
static func 提示(_: Void = ()) -> String {
return NSLocalizedString("提示", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 操作失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 操作失败(_: Void = ()) -> String {
return NSLocalizedString("操作失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 数据异常
///
/// Locales: zh-Hans, zh-Hant, en
static func 数据异常(_: Void = ()) -> String {
return NSLocalizedString("数据异常", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 数据格式错误
///
/// Locales: zh-Hans, zh-Hant, en
static func 数据格式错误(_: Void = ()) -> String {
return NSLocalizedString("数据格式错误", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 日
///
/// Locales: zh-Hans, zh-Hant, en
static func 日(_: Void = ()) -> String {
return NSLocalizedString("日", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 昵称不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static func 昵称不能为空(_: Void = ()) -> String {
return NSLocalizedString("昵称不能为空", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 更换
///
/// Locales: zh-Hans, zh-Hant, en
static func 更换(_: Void = ()) -> String {
return NSLocalizedString("更换", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 更改个人信息成功
///
/// Locales: zh-Hans, zh-Hant, en
static func 更改个人信息成功(_: Void = ()) -> String {
return NSLocalizedString("更改个人信息成功", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 更改失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 更改失败(_: Void = ()) -> String {
return NSLocalizedString("更改失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 更改头像失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 更改头像失败(_: Void = ()) -> String {
return NSLocalizedString("更改头像失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 更改头像成功
///
/// Locales: zh-Hans, zh-Hant, en
static func 更改头像成功(_: Void = ()) -> String {
return NSLocalizedString("更改头像成功", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 月
///
/// Locales: zh-Hans, zh-Hant, en
static func 月(_: Void = ()) -> String {
return NSLocalizedString("月", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 未知版本
///
/// Locales: zh-Hans, zh-Hant, en
static func 未知版本(_: Void = ()) -> String {
return NSLocalizedString("未知版本", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 欢迎页面
///
/// Locales: zh-Hans, zh-Hant, en
static func 欢迎页面(_: Void = ()) -> String {
return NSLocalizedString("欢迎页面", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 注册失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 注册失败(_: Void = ()) -> String {
return NSLocalizedString("注册失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 清理缓存
///
/// Locales: zh-Hans, zh-Hant, en
static func 清理缓存(_: Void = ()) -> String {
return NSLocalizedString("清理缓存", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 用户协议
///
/// Locales: zh-Hans, zh-Hant, en
static func 用户协议(_: Void = ()) -> String {
return NSLocalizedString("用户协议", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 用户名不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static func 用户名不能为空(_: Void = ()) -> String {
return NSLocalizedString("用户名不能为空", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 用户详情页打开失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 用户详情页打开失败(_: Void = ()) -> String {
return NSLocalizedString("用户详情页打开失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 登录
///
/// Locales: zh-Hans, zh-Hant, en
static func 登录(_: Void = ()) -> String {
return NSLocalizedString("登录", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 登录失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 登录失败(_: Void = ()) -> String {
return NSLocalizedString("登录失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 确定
///
/// Locales: zh-Hans, zh-Hant, en
static func 确定(_: Void = ()) -> String {
return NSLocalizedString("确定", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 确认更改
///
/// Locales: zh-Hans, zh-Hant, en
static func 确认更改(_: Void = ()) -> String {
return NSLocalizedString("确认更改", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 缓存大小为
///
/// Locales: zh-Hans, zh-Hant, en
static func 缓存大小为(_: Void = ()) -> String {
return NSLocalizedString("缓存大小为", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 网络不给力，图片下载失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 网络不给力图片下载失败(_: Void = ()) -> String {
return NSLocalizedString("网络不给力，图片下载失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 获取图片失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 获取图片失败(_: Void = ()) -> String {
return NSLocalizedString("获取图片失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 请先登录
///
/// Locales: zh-Hans, zh-Hant, en
static func 请先登录(_: Void = ()) -> String {
return NSLocalizedString("请先登录", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 请填写您的举报描述信息以方便我们的查证与处理
///
/// Locales: zh-Hans, zh-Hant, en
static func 请填写您的举报描述信息以方便我们的查证与处理(_: Void = ()) -> String {
return NSLocalizedString("请填写您的举报描述信息以方便我们的查证与处理", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 请查看并同意用户协议
///
/// Locales: zh-Hans, zh-Hant, en
static func 请查看并同意用户协议(_: Void = ()) -> String {
return NSLocalizedString("请查看并同意用户协议", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 请求失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 请求失败(_: Void = ()) -> String {
return NSLocalizedString("请求失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 请选择使用 iPhone 拍摄的照片或其它经过处理的图片
///
/// Locales: zh-Hans, zh-Hant, en
static func 请选择使用IPhone拍摄的照片或其它经过处理的图片(_: Void = ()) -> String {
return NSLocalizedString("请选择使用 iPhone 拍摄的照片或其它经过处理的图片", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 输入一句话照片简介
///
/// Locales: zh-Hans, zh-Hant, en
static func 输入一句话照片简介(_: Void = ()) -> String {
return NSLocalizedString("输入一句话照片简介", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 退出登录
///
/// Locales: zh-Hans, zh-Hant, en
static func 退出登录(_: Void = ()) -> String {
return NSLocalizedString("退出登录", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 退出登录失败
///
/// Locales: zh-Hans, zh-Hant, en
static func 退出登录失败(_: Void = ()) -> String {
return NSLocalizedString("退出登录失败", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 邮箱不能为空
///
/// Locales: zh-Hans, zh-Hant, en
static func 邮箱不能为空(_: Void = ()) -> String {
return NSLocalizedString("邮箱不能为空", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 邮箱格式错误
///
/// Locales: zh-Hans, zh-Hant, en
static func 邮箱格式错误(_: Void = ()) -> String {
return NSLocalizedString("邮箱格式错误", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: 隐私政策
///
/// Locales: zh-Hans, zh-Hant, en
static func 隐私政策(_: Void = ()) -> String {
return NSLocalizedString("隐私政策", bundle: R.hostingBundle, comment: "")
}
/// zh-Hans translation: ，确定要清理缓存么？
///
/// Locales: zh-Hans, zh-Hant, en
static func 确定要清理缓存么(_: Void = ()) -> String {
return NSLocalizedString("，确定要清理缓存么？", bundle: R.hostingBundle, comment: "")
}
fileprivate init() {}
}
/// This `R.string.main` struct is generated, and contains static references to 0 localization keys.
struct main {
fileprivate init() {}
}
fileprivate init() {}
}
fileprivate struct intern: Rswift.Validatable {
fileprivate static func validate() throws {
try _R.validate()
}
fileprivate init() {}
}
fileprivate class Class {}
fileprivate init() {}
}
struct _R: Rswift.Validatable {
static func validate() throws {
try storyboard.validate()
}
struct storyboard: Rswift.Validatable {
static func validate() throws {
try launchScreen.validate()
try main.validate()
}
struct launchScreen: Rswift.StoryboardResourceWithInitialControllerType, Rswift.Validatable {
typealias InitialController = UIKit.UIViewController
let bundle = R.hostingBundle
let name = "LaunchScreen"
static func validate() throws {
if UIKit.UIImage(named: "Launch", in: R.hostingBundle, compatibleWith: nil) == nil { throw Rswift.ValidationError(description: "[R.swift] Image named 'Launch' is used in storyboard 'LaunchScreen', but couldn't be loaded.") }
if #available(iOS 11.0, *) {
}
}
fileprivate init() {}
}
struct main: Rswift.StoryboardResourceWithInitialControllerType, Rswift.Validatable {
typealias InitialController = MainNavigationController
let bundle = R.hostingBundle
let name = "Main"
static func validate() throws {
if #available(iOS 11.0, *) {
}
}
fileprivate init() {}
}
fileprivate init() {}
}
fileprivate init() {}
}
| 45.036745 | 289 | 0.609748 |
5b22fd5f5d5a3abb7f2ec43396fac5e6bd09090c | 1,215 | //
// PreworkTests.swift
// PreworkTests
//
// Created by Dmitri Lopez on 12/24/21.
//
import XCTest
@testable import Prework
class PreworkTests: XCTestCase {
override func setUpWithError() throws {
// Put setup code here. This method is called before the invocation of each test method in the class.
}
override func tearDownWithError() throws {
// Put teardown code here. This method is called after the invocation of each test method in the class.
}
func testExample() throws {
// This is an example of a functional test case.
// Use XCTAssert and related functions to verify your tests produce the correct results.
// Any test you write for XCTest can be annotated as throws and async.
// Mark your test throws to produce an unexpected failure when your test encounters an uncaught error.
// Mark your test async to allow awaiting for asynchronous code to complete. Check the results with assertions afterwards.
}
func testPerformanceExample() throws {
// This is an example of a performance test case.
self.measure {
// Put the code you want to measure the time of here.
}
}
}
| 32.837838 | 130 | 0.682305 |
8fb567f5c228ae46e0c1cd9b115fb6695fe3afdc | 1,744 |
import Foundation
import UIKit
// Протокол для обобщения разных подклассов презентеров
public protocol RouterProtocol:NSObjectProtocol {
var delegate:PresenterProtocol? { get set }
}
// Основной класс организации роутинга
public class MainRouter {
static let instance:MainRouter = MainRouter()
public static var TheInstance : MainRouter {
get { return instance }
}
private var storyboard = "Main"
public func setStoryboard(name:String!) {
self.storyboard = name
}
// Вся магия роутинга. Забирает из сториборда контроллер по ID и кастирует его по T из UIViewController
// Назначает контроллер делегатом presenter, и Презентер назначает свойству презентер контроллера
// Возвращает настроенный контроллер для использования в любом типе перехода
public func getController<T:UIViewController ,U:RouterProtocol>(type_ctr:T, presenter:inout U)->T where T:PresenterProtocol {
let controller = getController(type_ctr: type_ctr)
presenter.delegate = controller
controller.set_presenter(presenter_par: presenter)
return controller
}
public func getController<T:UIViewController>(type_ctr:T)->T where T:PresenterProtocol {
let story = UIStoryboard.init(name: self.storyboard, bundle: nil)
let controller = story.instantiateViewController(withIdentifier: type_ctr.get_storyboard_name()) as! T
return controller
}
public func getController<T:UIViewController>(type:String)->T {
let story = UIStoryboard.init(name: self.storyboard, bundle: nil)
let controller = story.instantiateViewController(withIdentifier: type) as! T
return controller
}
}
| 31.709091 | 129 | 0.713876 |
6a8f4c3334b3073e2b55de1c6e54ae7ec6cd95f1 | 2,936 | /*
* Copyright (C) 2012-2016. TomTom International BV (http://tomtom.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
public let log: Logger = Logger()
public class Logger {
public var customLogger: CustomLoggerInterface?
private init() {}
public func verbose(message: String, file: String = #file, function: String = #function, line: Int = #line) {
if let logger = customLogger {
logger.verbose(message, file: file, function: function, line: line)
}
else {
logMessage("VERBOSE", message: message, file: file, function: function, line: line)
}
}
public func debug(message: String, file: String = #file, function: String = #function, line: Int = #line) {
if let logger = customLogger {
logger.debug(message, file: file, function: function, line: line)
}
else {
logMessage("DEBUG", message: message, file: file, function: function, line: line)
}
}
public func info(message: String, file: String = #file, function: String = #function, line: Int = #line) {
if let logger = customLogger {
logger.info(message, file: file, function: function, line: line)
}
else {
logMessage("INFO", message: message, file: file, function: function, line: line)
}
}
public func warning(message: String, file: String = #file, function: String = #function, line: Int = #line) {
if let logger = customLogger {
logger.warning(message, file: file, function: function, line: line)
}
else {
logMessage("WARNING", message: message, file: file, function: function, line: line)
}
}
public func error(message: String, file: String = #file, function: String = #function, line: Int = #line) {
if let logger = customLogger {
logger.error(message, file: file, function: function, line: line)
}
else {
logMessage("ERROR", message: message, file: file, function: function, line: line)
}
}
private func logMessage(level: String, message: String, file: String, function: String, line: Int) {
let timestamp = NSDate().logFormatterString
let fileName = file.nsString.lastPathComponent
print("\(timestamp) \(level) \(fileName):\(line) \(function)\n\(message)\n")
}
}
| 38.12987 | 113 | 0.625341 |
8f4a6bee72b5012eeefc0a162434c84fcce5a056 | 1,208 | //
// ios_study_facebookUITests.swift
// ios-study-facebookUITests
//
// Created by Shinichiro Shimoda on 2018/12/02.
// Copyright © 2018 Shinichiro Shimoda. All rights reserved.
//
import XCTest
class ios_study_facebookUITests: XCTestCase {
override func setUp() {
// Put setup code here. This method is called before the invocation of each test method in the class.
// In UI tests it is usually best to stop immediately when a failure occurs.
continueAfterFailure = false
// UI tests must launch the application that they test. Doing this in setup will make sure it happens for each test method.
XCUIApplication().launch()
// In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this.
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class.
}
func testExample() {
// Use recording to get started writing UI tests.
// Use XCTAssert and related functions to verify your tests produce the correct results.
}
}
| 34.514286 | 182 | 0.700331 |
4a80d1eae9d60a179b0ae732ac365ff9192e05ad | 233 |
/// A struct defining the `CommunicationOption`s attribute.
public struct CommunicationOptionsAttribute {
/// Holds the `OptionSet` that contains the communication protocols.
var communicationOptions: CommunicationOptions
}
| 33.285714 | 72 | 0.793991 |
144d8d4b4abf55d19baded028cf0e52458f1437d | 362 | //
// ParraLoggerTests.swift
// ParraCoreTests
//
// Created by Mick MacCallum on 3/17/22.
//
import XCTest
@testable import ParraCore
class ParraLoggerTests: XCTestCase {
func testLogLevels() throws {
XCTAssert(ParraLogLevel.error > .warn)
XCTAssert(ParraLogLevel.warn > .info)
XCTAssert(ParraLogLevel.info > .verbose)
}
}
| 19.052632 | 48 | 0.68232 |
79bd6d67425e36a7c4e263ca852e8466e6ef2659 | 1,044 | //
// UserPostsViewModel.swift
// UsersApp
//
// Created by Tomer Ciucran on 07.12.18.
// Copyright © 2018 Tomer Ciucran. All rights reserved.
//
import Foundation
import RxSwift
class UserPostsViewModel {
private(set) var userPosts = Variable<[UserPostViewModel]>([])
private var disposeBag = DisposeBag()
let client: ClientProtocol
let userId: Int
init(userId: Int, client: ClientProtocol) {
self.client = client
self.userId = userId
fetchData()
}
private func fetchData() {
client.request(UsersAPI.getUserPosts(userId: userId)).subscribe(onSuccess: { [weak self] userPosts in
self?.userPosts.value = userPosts.map(UserPostViewModel.init)
}) { error in
print(error)
}.disposed(by: disposeBag)
}
}
class UserPostViewModel {
private(set) var title: String = ""
private(set) var body: String = ""
init(userPost: UserPost) {
self.title = userPost.title
self.body = userPost.body
}
}
| 24.27907 | 109 | 0.633142 |
50d47e7f0654e85fe41b4abc40343d95ca760ba3 | 1,025 | //
// ViewController.swift
// Homework_Genegics
//
// Created by Вика on 07/10/2019.
// Copyright © 2019 Vika Olegova. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
// MyStorage.saveValue(value: 10, key: "currentLevel")
// MyStorage.saveValue(value: "Some String", key: "currentLevelString")
let intValue: Result<Int, MyStorage.CustomError> = MyStorage.receiveValue(key: "currentLevel")
let wrongTypeValue: Result<String, MyStorage.CustomError> = MyStorage.receiveValue(key: "currentLevel")
let stringValue: Result<String, MyStorage.CustomError> = MyStorage.receiveValue(key: "currentLevelString")
let nilValue: Result<String, MyStorage.CustomError> = MyStorage.receiveValue(key: "alala")
print(intValue.description)
print(wrongTypeValue.description)
print(stringValue.description)
print(nilValue.description)
}
}
| 33.064516 | 114 | 0.687805 |
e96d7fc423e4e53514412fc8712e164a4d0ce949 | 2,510 | //
// NoDataView.swift
// SwiftBasics4
//
// Created by houwei on 2019/3/22.
// Copyright © 2019年 侯伟. All rights reserved.
//
import Foundation
class NoDataView: UIView {
var titleLabel: UILabel!
var imageView: UIImageView!
var imageYOffset: CGFloat = 168{
didSet{
if let _ = imageViewTopConstraint{
imageViewTopConstraint?.constant = imageYOffset
}
}
}
var contentSpace: CGFloat = 16
var refreshBlock:(() -> ())?
var title:String?{
didSet{
titleLabel.text = title
}
}
var image:UIImage?{
didSet{
imageView.image = image
}
}
var imageViewTopConstraint:NSLayoutConstraint?
override init(frame: CGRect) {
super.init(frame: frame)
imageView = UIImageView()
self.addSubview(imageView)
let centerX = NSLayoutConstraint.init(item: imageView, attribute: .centerX, relatedBy: .equal, toItem: self, attribute: .centerX, multiplier: 1.0, constant: 0);
imageView.addConstraint(centerX)
let top = NSLayoutConstraint.init(item: imageView, attribute: .top, relatedBy: .equal, toItem: self, attribute: .top, multiplier: 1.0, constant: imageYOffset);
imageView.addConstraint(top)
imageViewTopConstraint = top
titleLabel = UILabel()
titleLabel.textColor = lightGreyColor
titleLabel.font = font(13)
titleLabel.textAlignment = .center
self.addSubview(titleLabel)
let x = NSLayoutConstraint.init(item: titleLabel, attribute: .centerX, relatedBy: .equal, toItem: self, attribute: .centerX, multiplier: 1.0, constant: 0);
titleLabel.addConstraint(x)
let t = NSLayoutConstraint.init(item: titleLabel, attribute: .top, relatedBy: .equal, toItem: imageView, attribute: .bottom, multiplier: 1.0, constant: contentSpace);
titleLabel.addConstraint(t)
let btn = UIButton(type: .custom)
btn.frame = self.bounds
btn.addTarget(self, action: Selector.init(("clickRetry")), for: .touchUpInside)
self.addSubview(btn)
self.bringSubviewToFront(btn)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
fileprivate func clickRetry(_ sender: UIButton) {
if let block = refreshBlock{
block()
}
}
}
| 29.880952 | 174 | 0.610757 |
1a8aa82ab7d2d3f3d32a3d310e789af6a884459b | 804 | //
// TableViewCellViewModel.swift
// COVID19
//
// Created by Shiva Huang on 2020/5/28.
// Copyright © 2020 AI Labs. All rights reserved.
//
import CoreKit
import Foundation
protocol TableViewCellViewModel {
var title: String { get }
}
class TogglableCellViewModel: TableViewCellViewModel {
enum State {
case on
case off
case processing
}
let title: String
@Observed(queue: .main)
var state: State = .off
@Observed(queue: .main)
var isEnabled: Bool = true
init(title: String, state: State) {
self.title = title
self.state = state
}
func toggle() {
switch state {
case .off:
state = .on
default:
state = .off
}
}
}
| 17.478261 | 54 | 0.554726 |
6723e277d8489d8114a24cd83b0eff94bb7884dd | 13,004 | //
// ConfigurationTests.swift
// SwiftLint
//
// Created by JP Simard on 8/23/15.
// Copyright © 2015 Realm. All rights reserved.
//
import Foundation
import SourceKittenFramework
@testable import SwiftLintFramework
import XCTest
private let optInRules = masterRuleList.list.filter({ $0.1.init() is OptInRule }).map({ $0.0 })
extension Configuration {
fileprivate var disabledRules: [String] {
let configuredRuleIDs = rules.map({ type(of: $0).description.identifier })
let defaultRuleIDs = Set(masterRuleList.list.values.filter({
!($0.init() is OptInRule)
}).map({ $0.description.identifier }))
return defaultRuleIDs.subtracting(configuredRuleIDs).sorted(by: <)
}
}
class ConfigurationTests: XCTestCase {
func testInit() {
XCTAssert(Configuration(dict: [:]) != nil,
"initializing Configuration with empty Dictionary should succeed")
XCTAssert(Configuration(dict: ["a": 1, "b": 2]) != nil,
"initializing Configuration with valid Dictionary should succeed")
}
func testEmptyConfiguration() {
guard let config = Configuration(dict: [:]) else {
XCTFail("empty YAML string should yield non-nil Configuration")
return
}
XCTAssertEqual(config.disabledRules, [])
XCTAssertEqual(config.included, [])
XCTAssertEqual(config.excluded, [])
XCTAssertEqual(config.reporter, "xcode")
XCTAssertEqual(reporterFrom(identifier: config.reporter).identifier, "xcode")
}
func testWhitelistRules() {
let whitelist = ["nesting", "todo"]
let config = Configuration(dict: ["whitelist_rules": whitelist])!
let configuredIdentifiers = config.rules.map {
type(of: $0).description.identifier
}.sorted()
XCTAssertEqual(whitelist, configuredIdentifiers)
}
func testWarningThreshold_value() {
let config = Configuration(dict: ["warning_threshold": 5])!
XCTAssertEqual(config.warningThreshold, 5)
}
func testWarningThreshold_nil() {
let config = Configuration(dict: [:])!
XCTAssertEqual(config.warningThreshold, nil)
}
func testOtherRuleConfigurationsAlongsideWhitelistRules() {
let whitelist = ["nesting", "todo"]
let enabledRulesConfigDict = [
"opt_in_rules": ["line_length"],
"whitelist_rules": whitelist
]
let disabledRulesConfigDict = [
"disabled_rules": ["identifier_name"],
"whitelist_rules": whitelist
]
let combinedRulesConfigDict = enabledRulesConfigDict.reduce(disabledRulesConfigDict) {
var d = $0; d[$1.0] = $1.1; return d
}
var configuration = Configuration(dict: enabledRulesConfigDict)
XCTAssertNil(configuration)
configuration = Configuration(dict: disabledRulesConfigDict)
XCTAssertNil(configuration)
configuration = Configuration(dict: combinedRulesConfigDict)
XCTAssertNil(configuration)
}
func testDisabledRules() {
let disabledConfig = Configuration(dict: ["disabled_rules": ["nesting", "todo"]])!
XCTAssertEqual(disabledConfig.disabledRules,
["nesting", "todo"],
"initializing Configuration with valid rules in Dictionary should succeed")
let expectedIdentifiers = Set(masterRuleList.list.keys
.filter({ !(["nesting", "todo"] + optInRules).contains($0) }))
let configuredIdentifiers = Set(disabledConfig.rules.map {
type(of: $0).description.identifier
})
XCTAssertEqual(expectedIdentifiers, configuredIdentifiers)
// Duplicate
let duplicateConfig = Configuration(dict: ["disabled_rules": ["todo", "todo"]])
XCTAssert(duplicateConfig == nil, "initializing Configuration with duplicate rules in " +
"Dictionary should fail")
}
func testDisabledRulesWithUnknownRule() {
let validRule = "nesting"
let bogusRule = "no_sprites_with_elf_shoes"
let configuration = Configuration(dict: ["disabled_rules": [validRule, bogusRule]])!
XCTAssertEqual(configuration.disabledRules,
[validRule],
"initializing Configuration with valid rules in YAML string should succeed")
let expectedIdentifiers = Set(masterRuleList.list.keys
.filter({ !([validRule] + optInRules).contains($0) }))
let configuredIdentifiers = Set(configuration.rules.map {
type(of: $0).description.identifier
})
XCTAssertEqual(expectedIdentifiers, configuredIdentifiers)
}
private class TestFileManager: LintableFileManager {
func filesToLint(inPath path: String, rootDirectory: String? = nil) -> [String] {
switch path {
case "directory": return ["directory/File1.swift", "directory/File2.swift",
"directory/excluded/Excluded.swift",
"directory/ExcludedFile.swift"]
case "directory/excluded" : return ["directory/excluded/Excluded.swift"]
case "directory/ExcludedFile.swift" : return ["directory/ExcludedFile.swift"]
default: break
}
XCTFail("Should not be called with path \(path)")
return []
}
}
func testExcludedPaths() {
let configuration = Configuration(included: ["directory"],
excluded: ["directory/excluded",
"directory/ExcludedFile.swift"])!
let paths = configuration.lintablePaths(inPath: "", fileManager: TestFileManager())
XCTAssertEqual(["directory/File1.swift", "directory/File2.swift"], paths)
}
// MARK: - Testing Configuration Equality
fileprivate var projectMockConfig0: Configuration {
var configuration = Configuration(path: projectMockYAML0, optional: false, quiet: true)
configuration.rootPath = projectMockPathLevel0
return configuration
}
fileprivate var projectMockConfig2: Configuration {
return Configuration(path: projectMockYAML2, optional: false, quiet: true)
}
func testIsEqualTo() {
XCTAssertEqual(projectMockConfig0, projectMockConfig0)
}
func testIsNotEqualTo() {
XCTAssertNotEqual(projectMockConfig0, projectMockConfig2)
}
// MARK: - Testing Nested Configurations
func testMerge() {
XCTAssertEqual(projectMockConfig0.merge(with: projectMockConfig2), projectMockConfig2)
}
func testLevel0() {
XCTAssertEqual(projectMockConfig0.configuration(for: File(path: projectMockSwift0)!),
projectMockConfig0)
}
func testLevel1() {
XCTAssertEqual(projectMockConfig0.configuration(for: File(path: projectMockSwift1)!),
projectMockConfig0)
}
func testLevel2() {
XCTAssertEqual(projectMockConfig0.configuration(for: File(path: projectMockSwift2)!),
projectMockConfig0.merge(with: projectMockConfig2))
}
func testLevel3() {
XCTAssertEqual(projectMockConfig0.configuration(for: File(path: projectMockSwift3)!),
projectMockConfig0.merge(with: projectMockConfig2))
}
// MARK: - Testing Rules from config dictionary
let testRuleList = RuleList(rules: RuleWithLevelsMock.self)
func testConfiguresCorrectlyFromDict() throws {
let ruleConfiguration = [1, 2]
let config = [RuleWithLevelsMock.description.identifier: ruleConfiguration]
let rules = try testRuleList.configuredRules(with: config)
XCTAssertTrue(rules == [try RuleWithLevelsMock(configuration: ruleConfiguration)])
}
func testConfigureFallsBackCorrectly() throws {
let config = [RuleWithLevelsMock.description.identifier: ["a", "b"]]
let rules = try testRuleList.configuredRules(with: config)
XCTAssertTrue(rules == [RuleWithLevelsMock()])
}
// MARK: - Aliases
func testConfiguresCorrectlyFromDeprecatedAlias() throws {
let ruleConfiguration = [1, 2]
let config = ["mock": ruleConfiguration]
let rules = try testRuleList.configuredRules(with: config)
XCTAssertTrue(rules == [try RuleWithLevelsMock(configuration: ruleConfiguration)])
}
func testReturnsNilWithDuplicatedConfiguration() {
let dict = ["mock": [1, 2], "severity_level_mock": [1, 3]]
let configuration = Configuration(dict: dict, ruleList: testRuleList)
XCTAssertNil(configuration)
}
func testInitsFromDeprecatedAlias() {
let ruleConfiguration = [1, 2]
let configuration = Configuration(dict: ["mock": ruleConfiguration], ruleList: testRuleList)
XCTAssertNotNil(configuration)
}
func testWhitelistRulesFromDeprecatedAlias() {
let configuration = Configuration(dict: ["whitelist_rules": ["mock"]], ruleList: testRuleList)!
let configuredIdentifiers = configuration.rules.map {
type(of: $0).description.identifier
}
XCTAssertEqual(configuredIdentifiers, ["severity_level_mock"])
}
func testDisabledRulesFromDeprecatedAlias() {
let configuration = Configuration(dict: ["disabled_rules": ["mock"]], ruleList: testRuleList)!
XCTAssert(configuration.rules.isEmpty)
}
}
// MARK: - ProjectMock Paths
fileprivate extension String {
func stringByAppendingPathComponent(_ pathComponent: String) -> String {
return bridge().appendingPathComponent(pathComponent)
}
}
extension XCTestCase {
var bundlePath: String {
#if SWIFT_PACKAGE
return "Tests/SwiftLintFrameworkTests/Resources".bridge().absolutePathRepresentation()
#else
return Bundle(for: type(of: self)).resourcePath!
#endif
}
}
fileprivate extension XCTestCase {
var projectMockPathLevel0: String {
return bundlePath.stringByAppendingPathComponent("ProjectMock")
}
var projectMockPathLevel1: String {
return projectMockPathLevel0.stringByAppendingPathComponent("Level1")
}
var projectMockPathLevel2: String {
return projectMockPathLevel1.stringByAppendingPathComponent("Level2")
}
var projectMockPathLevel3: String {
return projectMockPathLevel2.stringByAppendingPathComponent("Level3")
}
var projectMockYAML0: String {
return projectMockPathLevel0.stringByAppendingPathComponent(Configuration.fileName)
}
var projectMockYAML2: String {
return projectMockPathLevel2.stringByAppendingPathComponent(Configuration.fileName)
}
var projectMockSwift0: String {
return projectMockPathLevel0.stringByAppendingPathComponent("Level0.swift")
}
var projectMockSwift1: String {
return projectMockPathLevel1.stringByAppendingPathComponent("Level1.swift")
}
var projectMockSwift2: String {
return projectMockPathLevel2.stringByAppendingPathComponent("Level2.swift")
}
var projectMockSwift3: String {
return projectMockPathLevel3.stringByAppendingPathComponent("Level3.swift")
}
}
extension ConfigurationTests {
static var allTests: [(String, (ConfigurationTests) -> () throws -> Void)] {
return [
("testInit", testInit),
("testEmptyConfiguration", testEmptyConfiguration),
("testWhitelistRules", testWhitelistRules),
("testWarningThreshold_value", testWarningThreshold_value),
("testWarningThreshold_nil", testWarningThreshold_nil),
("testOtherRuleConfigurationsAlongsideWhitelistRules",
testOtherRuleConfigurationsAlongsideWhitelistRules),
("testDisabledRules", testDisabledRules),
("testDisabledRulesWithUnknownRule", testDisabledRulesWithUnknownRule),
("testExcludedPaths", testExcludedPaths),
("testIsEqualTo", testIsEqualTo),
("testIsNotEqualTo", testIsNotEqualTo),
("testMerge", testMerge),
("testLevel0", testLevel0),
("testLevel1", testLevel1),
("testLevel2", testLevel2),
("testLevel3", testLevel3),
("testConfiguresCorrectlyFromDict", testConfiguresCorrectlyFromDict),
("testConfigureFallsBackCorrectly", testConfigureFallsBackCorrectly),
("testConfiguresCorrectlyFromDeprecatedAlias", testConfiguresCorrectlyFromDeprecatedAlias),
("testReturnsNilWithDuplicatedConfiguration", testReturnsNilWithDuplicatedConfiguration),
("testInitsFromDeprecatedAlias", testInitsFromDeprecatedAlias),
("testWhitelistRulesFromDeprecatedAlias", testWhitelistRulesFromDeprecatedAlias),
("testDisabledRulesFromDeprecatedAlias", testDisabledRulesFromDeprecatedAlias)
]
}
}
| 38.934132 | 103 | 0.665026 |
9b412360636425db974275ab3fd72c4ca8e3ede8 | 1,348 | //
// CounterView.swift
// CounterView
//
// Created by Albert Gil Escura on 25/5/21.
//
import SwiftUI
import ComposableArchitecture
public struct CounterView: View {
private let store: Store<CounterState, CounterAction>
public init(
store: Store<CounterState, CounterAction>
) {
self.store = store
}
public var body: some View {
WithViewStore(self.store) { viewStore in
HStack {
Text("Cheese")
Spacer()
HStack {
Button(
action: { viewStore.send(.decrementTapped) },
label: { Text("-") }
)
.buttonStyle(PlainButtonStyle())
Text("\(viewStore.counter)")
Button(
action: { viewStore.send(.incrementTapped) },
label: { Text("+") }
)
.buttonStyle(PlainButtonStyle())
}
}
}
}
}
struct CounterView_Previews: PreviewProvider {
static var previews: some View {
CounterView(
store: Store(
initialState: CounterState(),
reducer: reducerCounter,
environment: ()
)
)
}
}
| 24.509091 | 69 | 0.465134 |
7aa4545d3cefb149ee526e0e36213b7070b08479 | 362 | //
// AssignNotNil.swift
// Unsorted
//
// Created by José Manuel Sánchez Peñarroja on 12/5/16.
// Copyright © 2016 vitaminew. All rights reserved.
//
import Foundation
infix operator ?=: Additive
//infix operator ?= {
// associativity right
// precedence 90
// assignment
//}
public func ?= <T>(lhs: inout T, rhs: T?) {
lhs = rhs ?? lhs
}
| 15.73913 | 56 | 0.632597 |
d6adbaabdd4d338a3d72397ae2eabf7709939cfd | 3,032 | //
// BRTarTests.swift
// TosWallet
//
// Created by Samuel Sutch on 12/1/15.
// Copyright (c) 2016 breadwallet LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import XCTest
@testable import breadwallet
class BRTarTests: XCTestCase {
var fileUrl: URL?
override func setUp() {
// download a test tar file
let fm = FileManager.default
let url = URL(string: "https://s3.amazonaws.com/breadwallet-assets/bread-buy/7f5bc5c6cc005df224a6ea4567e508491acaffdc2e4769e5262a52f5b785e261.tar")!
let documentsUrl = fm.urls(for: .documentDirectory, in: .userDomainMask).first!
let destinationUrl = documentsUrl.appendingPathComponent(url.lastPathComponent)
if fm.fileExists(atPath: destinationUrl.path) {
print("file already exists [\(destinationUrl.path)]")
fileUrl = destinationUrl
} else if let dataFromURL = try? Data(contentsOf: url){
if (try? dataFromURL.write(to: destinationUrl, options: [.atomic])) != nil {
print("file saved [\(destinationUrl.path)]")
fileUrl = destinationUrl
} else {
XCTFail("error saving file")
}
} else {
XCTFail("error downloading file")
}
super.setUp()
}
override func tearDown() {
super.tearDown()
}
func testExtractTar() {
guard let fileUrl = fileUrl else { XCTFail("file url not defined"); return }
let fm = FileManager.default
let docsPath = fm.urls(for: .documentDirectory, in: .userDomainMask).first!
let destPath = docsPath.appendingPathComponent("extracted_files")
do {
try BRTar.createFilesAndDirectoriesAtPath(destPath.path, withTarPath: fileUrl.path)
} catch let e {
XCTFail("failed to extract tar file with \(e)")
}
}
// func testPerformanceExample() {
// self.measureBlock {
// }
// }
}
| 39.894737 | 156 | 0.664578 |
ab30164b91a827f05330dd80ca8f260d1ae968fc | 329 | //
// BaseViewController.swift
// FreePlayer
//
// Created by CXY on 2019/2/22.
// Copyright © 2019年 cxy. All rights reserved.
//
import UIKit
class BaseViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
}
deinit {
print("\(self) \(#function)")
}
}
| 14.304348 | 47 | 0.607903 |
fc0bd18b16e9cf5335ab61dc590f207a3fd8cd05 | 360 | //
// ViewController.swift
// Tip Calculator
//
// Created by Jining song on 2019/2/10.
// Copyright © 2019 Jining song. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
}
}
| 17.142857 | 80 | 0.669444 |
5d23b069c8676066e4f3338944750767c8e9d6cc | 15,542 | //
// UDDataLoader.swift
// Alien Adventure
//
// Created by Jarrod Parkes on 9/28/15.
// Copyright © 2015 Udacity. All rights reserved.
//
import SpriteKit
import Foundation
// MARK: - UDDataError
enum UDDataError: ErrorType {
case KeyError(String, String, String)
case UnknownError
}
// MARK: - UDDialogueKey
enum UDDialogueKey: String {
case StartingDialogue = "StartingDialogue"
case RequestingDialogue = "RequestingDialogue"
case TransitioningDialogue = "TransitioningDialogue"
case WinningDialogue = "WinningDialogue"
case LosingDialogue = "LosingDialogue"
}
// MARK: - UDDataLoader
class UDDataLoader {
// MARK: Hero Starting Items
static var items = [UDItem]()
// MARK: GameDataKeys
struct GameDataKeys {
static let Items = "Items"
static let ItemID = "ItemID"
static let ItemType = "ItemType"
static let ItemBaseValue = "BaseValue"
static let ItemInscription = "Inscription"
static let ItemRarity = "Rarity"
static let ItemHistoricalData = "HistoricalData"
static let ItemPlanetOfOrigin = "PlanetOfOrigin"
static let ItemCarbonAge = "CarbonAge"
static let Animations = "Animations"
static let Hero = "Hero"
static let Name = "Name"
static let Position = "Position"
static let Variant = "Variant"
static let Inventory = "Inventory"
static let Aliens = "Aliens"
static let Requests = "Requests"
static let Treasure = "Treasure"
static let InitialConversation = "InitialConversation"
static let PassConversation = "PassConversation"
static let FailConversation = "FailConversation"
static let RequestType = "RequestType"
static let HeroSpriteKey = "Hero"
static let AlienSpriteKey = "Alien"
static let TreasureSpriteKey = "Treasure"
static let LineText = "LineText"
static let LineSource = "LineSource"
static let Levels = "Levels"
static let ShowBadges = "ShowBadges"
}
struct KeyPostfixes {
static let AtlasFile = "AtlasFile"
static let Frames = "Frames"
static let TimePerFrame = "TPF"
}
// MARK: Load Level Data
class func LevelDictionaryFromGameDictionary(dictionary: [String: AnyObject], level: Int) throws -> [String:AnyObject] {
guard let levelArray = dictionary[GameDataKeys.Levels] as? [[String:AnyObject]] else {
throw UDDataError.KeyError("\(level)", "\(dictionary)", #function)
}
return levelArray[level]
}
// MARK: Load Items Index
class func ItemsIndexFromGameDictionary(dictionary: [String:AnyObject]) throws -> [String:UDItem] {
guard let itemsDictionaries = dictionary[GameDataKeys.Items] as? [String:AnyObject] else {
throw UDDataError.KeyError(GameDataKeys.Items, "\(dictionary)", #function)
}
var itemsIndex = [String:UDItem]()
for (itemKey, itemDictionary) in itemsDictionaries {
guard let itemDictionary = itemDictionary as? [String:AnyObject] else {
throw UDDataError.KeyError(GameDataKeys.Items, "\(itemsDictionaries)", #function)
}
do {
let item = try ItemFromDictionary(itemDictionary, name: itemKey)
itemsIndex[itemKey] = item
}
}
return itemsIndex
}
// MARK: Load Item
class func ItemFromDictionary(dictionary: [String:AnyObject], name: String) throws -> UDItem {
guard let itemID = dictionary[GameDataKeys.ItemID] as? Int else {
throw UDDataError.KeyError(GameDataKeys.ItemID, "\(dictionary)", #function)
}
guard let itemTypeInt = dictionary[GameDataKeys.ItemType] as? Int,
let itemType = UDItemType(rawValue: itemTypeInt) else {
throw UDDataError.KeyError(GameDataKeys.ItemType, "\(dictionary)", #function)
}
guard let baseValue = dictionary[GameDataKeys.ItemBaseValue] as? Int else {
throw UDDataError.KeyError(GameDataKeys.ItemBaseValue, "\(dictionary)", #function)
}
guard let rarityInt = dictionary[GameDataKeys.ItemRarity] as? Int,
let rarity = UDItemRarity(rawValue: rarityInt) else {
throw UDDataError.KeyError(GameDataKeys.ItemRarity, "\(dictionary)", #function)
}
guard let historicalData = dictionary[GameDataKeys.ItemHistoricalData] as? [String:AnyObject] else {
throw UDDataError.KeyError(GameDataKeys.ItemHistoricalData, "\(dictionary)", #function)
}
if let inscription = dictionary[GameDataKeys.ItemInscription] as? String {
return UDItem(itemID: itemID, itemType: itemType, name: name, baseValue: baseValue, inscription: inscription, rarity: rarity, historicalData: historicalData)
} else {
return UDItem(itemID: itemID, itemType: itemType, name: name, baseValue: baseValue, rarity: rarity, historicalData: historicalData)
}
}
// MARK: Load Animations
class func AnimationFromGameDictionary(dictionary: [String:AnyObject], spriteKey: String, animationKeyPrefix: String) throws -> UDAnimationData {
guard let animationsDictionary = dictionary[GameDataKeys.Animations] as? [String:AnyObject] else {
throw UDDataError.KeyError(GameDataKeys.Animations, "\(dictionary)", #function)
}
guard let spriteDictionary = animationsDictionary[spriteKey] as? [String:AnyObject] else {
throw UDDataError.KeyError("\(spriteKey)", "\(animationsDictionary)", #function)
}
let atlasfileKey = animationKeyPrefix + KeyPostfixes.AtlasFile
let framesKey = animationKeyPrefix + KeyPostfixes.Frames
let timePerFrameKey = animationKeyPrefix + KeyPostfixes.TimePerFrame
guard let atlasFile = spriteDictionary[atlasfileKey] as? String else {
throw UDDataError.KeyError("\(atlasfileKey)", "\(spriteDictionary)", #function)
}
guard let frameStrings = spriteDictionary[framesKey] as? [String] else {
throw UDDataError.KeyError("\(framesKey)", "\(spriteDictionary)", #function)
}
guard let timePerFrame = spriteDictionary[timePerFrameKey] as? Double else {
throw UDDataError.KeyError("\(timePerFrameKey)", "\(spriteDictionary)", #function)
}
let atlas = SKTextureAtlas(named: atlasFile)
var frames = [SKTexture]()
for frame in frameStrings {
frames.append(atlas.textureNamed(frame))
}
return UDAnimationData(atlasFile: atlasFile, frames: frames, timePerFrame: timePerFrame)
}
// MARK: Load Show Badges
class func ShowBadgesFromLevelDictionary(dictionary: [String:AnyObject]) throws -> Bool {
guard let showBadges = dictionary[GameDataKeys.ShowBadges] as? Bool else {
throw UDDataError.KeyError(GameDataKeys.ShowBadges, "\(dictionary)", #function)
}
return showBadges
}
// MARK: Load Dialogue String (Global)
class func DialogueStringFromLevelDictionary(dictionary: [String:AnyObject], key: UDDialogueKey) throws -> String {
guard let dialogueString = dictionary[key.rawValue] as? String else {
throw UDDataError.KeyError(key.rawValue, "\(dictionary)", #function)
}
return dialogueString
}
// MARK: Load Dialogue String (For Alien Request)
class func LineOfDialogueFromDialogueDictionary(dictionary: [String:AnyObject], npcName: String) throws -> UDLineOfDialogue {
guard let lineText = dictionary[GameDataKeys.LineText] as? String else {
throw UDDataError.KeyError(GameDataKeys.LineText, "\(dictionary)", #function)
}
guard let lineSource = dictionary[GameDataKeys.LineSource] as? Int else {
throw UDDataError.KeyError(GameDataKeys.LineSource, "\(dictionary)", #function)
}
return UDLineOfDialogue(lineText: (UDLineSource(rawValue: lineSource)! == .Hero) ? "\(GameDataKeys.Hero): " + lineText : "\(npcName): " + lineText, lineSource: UDLineSource(rawValue: lineSource)!)
}
// MARK: Load Conversation
class func ConversationFromDialogueDictionaries(dictionaries: [[String:AnyObject]], npcName: String) throws -> UDConversation {
var linesOfDialogue = [UDLineOfDialogue]()
for dialogueDictionary in dictionaries {
do {
let lineOfDialogue = try LineOfDialogueFromDialogueDictionary(dialogueDictionary, npcName: npcName)
linesOfDialogue.append(lineOfDialogue)
}
}
return UDConversation(linesOfDialogue: linesOfDialogue)
}
// MARK: Load Hero
class func HeroFromLevelDictionary(dictionary: [String:AnyObject]) throws -> Hero {
guard let heroDictionary = dictionary[GameDataKeys.Hero] as? [String:AnyObject] else {
throw UDDataError.KeyError(GameDataKeys.Hero, "\(dictionary)", #function)
}
guard let name = heroDictionary[GameDataKeys.Name] as? String else {
throw UDDataError.KeyError(GameDataKeys.Name, "\(dictionary)", #function)
}
guard let position = heroDictionary[GameDataKeys.Position] as? String else {
throw UDDataError.KeyError(GameDataKeys.Position, "\(dictionary)", #function)
}
guard let inventoryKeyArray = heroDictionary[GameDataKeys.Inventory] as? [String] else {
throw UDDataError.KeyError(GameDataKeys.Inventory, "\(dictionary)", #function)
}
for item in inventoryKeyArray {
if (UDItemIndex.items.indexForKey(item) != nil) {
items.append(UDItemIndex.items[item]!)
} else {
throw UDDataError.KeyError("\(item)", "\(UDItemIndex.items)", #function)
}
}
return Hero(name: name, position: CGPointFromString(position), items: items)
}
// MARK: Load Aliens
class func AliensFromLevelDictionary(dictionary: [String:AnyObject]) throws -> [Alien] {
guard let alienDictionaries = dictionary[GameDataKeys.Aliens] as? [[String:AnyObject]] else {
throw UDDataError.KeyError(GameDataKeys.Aliens, "\(dictionary)", #function)
}
var aliens = [Alien]()
for alienDictionary in alienDictionaries {
do {
let alien = try AlienFromAlienDictionary(alienDictionary)
aliens.append(alien)
}
}
return aliens
}
// MARK: Load Alien
class func AlienFromAlienDictionary(dictionary: [String:AnyObject]) throws -> Alien {
guard let name = dictionary[GameDataKeys.Name] as? String else {
throw UDDataError.KeyError(GameDataKeys.Name, "\(dictionary)", #function)
}
guard let position = dictionary[GameDataKeys.Position] as? String else {
throw UDDataError.KeyError(GameDataKeys.Position, "\(dictionary)", #function)
}
guard let variant = dictionary[GameDataKeys.Variant] as? String else {
throw UDDataError.KeyError(GameDataKeys.Variant, "\(dictionary)", #function)
}
guard let requestDictionaries = dictionary[GameDataKeys.Requests] as? [[String:AnyObject]] else {
throw UDDataError.KeyError(GameDataKeys.Requests, "\(dictionary)", #function)
}
var requests = [UDRequest]()
for requestDictionary in requestDictionaries {
do {
let request = try UDRequestFromUDRequestDictionary(requestDictionary, npcName: name)
requests.append(request)
}
}
return Alien(name: name, position: CGPointFromString(position), variant: AlienColor(rawValue: variant)!, requests: requests)
}
// MARK: Load Alien Request
class func UDRequestFromUDRequestDictionary(dictionary: [String:AnyObject], npcName: String) throws -> UDRequest {
guard let requestType = dictionary[GameDataKeys.RequestType] as? String else {
throw UDDataError.KeyError(GameDataKeys.RequestType, "\(dictionary)", #function)
}
guard let initialConversationData = dictionary[GameDataKeys.InitialConversation] as? [[String:AnyObject]] else {
throw UDDataError.KeyError(GameDataKeys.InitialConversation, "\(dictionary)", #function)
}
guard let passConversationData = dictionary[GameDataKeys.PassConversation] as? [[String:AnyObject]] else {
throw UDDataError.KeyError(GameDataKeys.PassConversation, "\(dictionary)", #function)
}
guard let failConversationData = dictionary[GameDataKeys.FailConversation] as? [[String:AnyObject]] else {
throw UDDataError.KeyError(GameDataKeys.FailConversation, "\(dictionary)", #function)
}
var initialConversation = UDConversation()
var passConversation = UDConversation()
var failConversation = UDConversation()
do {
initialConversation = try ConversationFromDialogueDictionaries(initialConversationData, npcName: npcName)
passConversation = try ConversationFromDialogueDictionaries(passConversationData, npcName: npcName)
failConversation = try ConversationFromDialogueDictionaries(failConversationData, npcName: npcName)
failConversation.addLine(UDLineOfDialogue(lineText: Settings.Dialogue.LosingDialogue, lineSource: .Hero))
}
return UDRequest(requestType: UDRequestType(rawValue: requestType)!, initialConversation: initialConversation, passConversation: passConversation, failConversation: failConversation)
}
// MARK: Load Treasure
class func TreasureFromLevelDictionary(dictionary: [String:AnyObject]) throws -> SKSpriteNode {
guard let treasureDictionary = dictionary[GameDataKeys.Treasure] as? [String:AnyObject] else {
throw UDDataError.KeyError(GameDataKeys.Treasure, "\(dictionary)", #function)
}
guard let name = treasureDictionary[GameDataKeys.Name] as? String else {
throw UDDataError.KeyError(GameDataKeys.Name, "\(dictionary)", #function)
}
guard let position = treasureDictionary[GameDataKeys.Position] as? String else {
throw UDDataError.KeyError(GameDataKeys.Position, "\(dictionary)", #function)
}
let treasure = SKSpriteNode(texture: UDAnimation.baseFrameForSprite[.Treasure])
treasure.size = CGSize(width: 145.5, height: 172)
treasure.name = name
treasure.position = CGPointFromString(position)
treasure.physicsBody = SKPhysicsBody(rectangleOfSize: CGSize(width: 650.0, height: 64))
if let treasurePhysicsBody = treasure.physicsBody {
UDCollision.setCollisionForPhysicsBody(treasurePhysicsBody, belongsToMask: .World, contactWithMask: .Player)
}
return treasure
}
} | 41.66756 | 204 | 0.643547 |
ef4cdb84244961bc35b1d45e1e078cec222749e3 | 286 | import Foundation
import GfxMath
public protocol Blob {
var id: UInt { get }
var type: BlobType { get }
var position: DVec2 { get set }
/// Mass. In MassUnits.
var mass: Double { get set }
var radius: Double { get set }
var consumed: Bool { get set }
} | 16.823529 | 35 | 0.611888 |
c1702ad91d6cc18132ea6cbd9e782cbfdf853f15 | 292 | import UIKit
@testable import VIPER_Demo
class TestablePersonDetailsWireFrame : PersonDetailsWireFrame {
var pushedViewController: UIViewController?
override func push(newViewController vc: UIViewController, onTo oldVC: UIViewController) {
pushedViewController = vc
}
} | 26.545455 | 94 | 0.784247 |
56920b874e07cfa86f1aa3ea7565a716554d8274 | 10,826 | //
// Primer.swift
// Quill
//
// Created by Cole, Eric (ETW) on 8/23/15.
// Copyright © 2015 Cole, Eric (ETW). All rights reserved.
//
import Foundation
struct ColumnDeclaration {
static let Boolean = "BOOLEAN" // BOOL
static let Integer = "INTEGER" // INT LONG NUMBER ...
static let Real = "REAL" // FLOAT DOUBLE NUMERIC
static let Text = "TEXT" // CHAR CLOB VARCHAR
static let Untyped = "BLOB" // NONE
static let CollateBinary = "BINARY"
static let CollateCaseInsensitive = "NOCASE"
static let CollateIgnoreTrailingSpace = "RTRIM"
enum Conflict : Int, CustomStringConvertible {
case Yes = 0, Rollback = 1, Abort = 2, Fail = 3, Ignore = 4, Replace = 5
var description:String { return ["default","rollback","abort","fail","ignore","replace"][rawValue] }
var sql:String { return ( .Yes != self ) ? " on conflict " + description : "" }
}
/// http://sqlite.org/syntax/column-constraint.html
let name:String
var type:String? // nil is NUMERIC
var primaryKey:Conflict?
var primaryDescending:Bool?
var primaryAutoincrement:Bool = false
var notNull:Conflict?
var unique:Conflict?
var check:String?
var defaults:String?
var collate:String?
var foreignKey:String?
var sql:String {
let tp = ( nil != type ) ? " " + type! : ""
let pk = ( nil != primaryKey ) ? " primary key" + ( nil != primaryDescending ? primaryDescending! ? " desc" : " asc" : "" ) + primaryKey!.sql + ( primaryAutoincrement ? " autoincrement" : "" ) : ""
let nn = ( nil != notNull ) ? " not null" + notNull!.sql : ""
let uq = ( nil != unique ) ? " unique" + unique!.sql : ""
let ck = ( nil != check ) ? " check ( " + check! + " )" : ""
let df = ( nil != defaults ) ? " default " + defaults! : ""
let cl = ( nil != collate ) ? " collate " + collate! : ""
let fk = ( nil != foreignKey ) ? " references " + foreignKey! : ""
return name + tp + pk + nn + uq + ck + df + cl + fk
}
init( name:String ) {
self.name = name
}
init( name:String, type:String?, defaults:String? = nil, notNull:Conflict? = nil, unique:Conflict? = nil, primaryKey:Conflict? = nil, primaryDescending:Bool? = nil, primaryAutoincrement:Bool = false, check:String? = nil, collate:String? = nil, foreignKey:String? = nil ) {
self.name = name
self.type = type
self.primaryKey = primaryKey
self.primaryDescending = primaryDescending
self.primaryAutoincrement = primaryAutoincrement
self.notNull = notNull
self.unique = unique
self.check = check
self.defaults = defaults
self.collate = collate
self.foreignKey = foreignKey
if nil == type && nil == defaults && nil != primaryKey && !( primaryDescending ?? false ) {
self.type = "INTEGER" // special integer primary key
}
}
static func boolean( name:String, defaults:Bool = false ) -> ColumnDeclaration {
return ColumnDeclaration( name:name, type:Boolean, defaults:( defaults ? "1" : "0" ), notNull:.Yes )
}
static func integer( name:String, defaults:Int? = 0, unique:Bool = false ) -> ColumnDeclaration {
return ColumnDeclaration( name:name, type:Integer, defaults:( nil == defaults ? nil : String(defaults!) ), notNull:( nil == defaults ? nil : .Yes ), unique:( unique ? .Yes : nil ) )
}
static func real( name:String, defaults:Double? = 0, unique:Bool = false ) -> ColumnDeclaration {
return ColumnDeclaration( name:name, type:Real, defaults:( nil == defaults ? nil : String(defaults!) ), notNull:( nil == defaults ? nil : .Yes ), unique:( unique ? .Yes : nil ) )
}
static func text( name:String, defaults:String? = "", unique:Bool = false, collate:String? ) -> ColumnDeclaration {
return ColumnDeclaration( name:name, type:Text, defaults:( nil == defaults ? nil : Connection.escape( defaults! ) ), notNull:( nil == defaults ? nil : .Yes ), unique:( unique ? .Yes : nil ), primaryKey:nil, primaryDescending:nil, primaryAutoincrement:false, check:nil, collate:collate )
}
static func data( name:String, unique:Bool = false ) -> ColumnDeclaration {
return ColumnDeclaration( name:name, type:Untyped, defaults:nil, notNull:nil, unique:( unique ? .Yes : nil ) )
}
static func primaryKey( name:String, type:String? = Integer, descending:Bool? = nil ) -> ColumnDeclaration {
return ColumnDeclaration( name:name, type:type, defaults:nil, notNull:.Yes, unique:nil, primaryKey:.Yes, primaryDescending:descending, primaryAutoincrement:false )
}
static func foriegnKey( name:String, foreignKey:String, notNull:Bool = false ) -> ColumnDeclaration {
return ColumnDeclaration( name:name, type:nil, defaults:nil, notNull:( notNull ? .Yes : nil ), unique:nil, primaryKey:nil, primaryDescending:nil, primaryAutoincrement:false, check:nil, collate:nil, foreignKey:foreignKey )
}
static func join( columns:[ColumnDeclaration] ) -> String {
var result = ""
var index = 0
for column in columns {
if index++ > 0 { result += ", " }
result += column.sql
}
return result
}
}
extension Connection {
// escape string literal as 'text' where all ' in text are doubled
// escape data literal as x'hexadecimal'
static func escape( string:String ) -> String {
return "'" + string.stringByReplacingOccurrencesOfString( "'", withString:"''" ) + "'"
}
/// http://sqlite.org/lang_select.html
/// http://sqlite.org/lang_insert.html
/// http://sqlite.org/lang_update.html
/// http://sqlite.org/lang_delete.html
/// http://sqlite.org/lang_with.html
/// http://sqlite.org/lang_transaction.html
enum TransactionType : Int { case Default = 0, Deferred = 1, Immediate = 2, Exclusive = 3 }
func beginTransaction( type:TransactionType = .Default ) throws -> Bool {
let modifier = [""," deferred"," immediate"," exclusive"][type.rawValue]
return try execute( "begin" + modifier + " transaction" )
}
/// http://sqlite.org/lang_transaction.html
func commit() throws -> Bool {
return try execute( "commit transaction" )
}
/// http://sqlite.org/lang_transaction.html
func rollback( savepoint:String? = nil ) throws -> Bool {
return try execute( "rollback transaction" + ( nil != savepoint ? " to savepoint " + savepoint! : "" ) )
}
/// http://sqlite.org/lang_savepoint.html
func makeSavepoint( savepoint:String ) throws -> Bool {
return try execute( "savepoint " + savepoint )
}
/// http://sqlite.org/lang_savepoint.html
func freeSavepoint( savepoint:String ) throws -> Bool {
return try execute( "release savepoint " + savepoint )
}
/// http://sqlite.org/lang_attach.html
public static let LocationMemory = "':memory:'"
public static let LocationTemporary = ""
func attachDatabase( name:String , location:String = LocationMemory ) throws -> Bool {
return try execute( "attach database " + location + " as " + name )
}
/// http://sqlite.org/lang_detach.html
func detachDatabase( name:String ) throws -> Bool {
return try execute( "detach database " + name )
}
/// http://sqlite.org/lang_reindex.html
func reindex( name:String ) throws -> Bool {
return try execute( "reindex " + name )
}
/// http://sqlite.org/lang_createindex.html
func createIndex( name:String, onTable:String, columnNames:String, unique:Bool = false, whereCondition:String? = nil ) throws -> Bool {
return try execute( "create" + ( unique ? " unique" : "" ) + " index" + ( " if not exists" ) + " " + name + " on " + onTable + " (" + columnNames + ")" + ( nil != whereCondition ? " where " + whereCondition! : "" ) )
}
/// http://sqlite.org/lang_dropindex.html
func dropIndex( name:String ) throws -> Bool {
return try execute( "drop index if exists " + name )
}
/// http://sqlite.org/lang_createtable.html
func createTable( name:String, columnDeclarations:String, temporary:Bool = false, strict:Bool = false, withRowIdentifiers:Bool = true ) throws -> Bool {
return try execute( "create" + ( temporary ? " temporary" : "" ) + " table" + ( strict ? "" : " if not exists" ) + " " + name + " (" + columnDeclarations + ")" + ( withRowIdentifiers ? "" : " without rowid" ) )
}
/// http://sqlite.org/lang_createtable.html
func createTableAs( name:String, select:String, temporary:Bool = false, strict:Bool = false ) throws -> Bool {
return try execute( "create" + ( temporary ? " temporary" : "" ) + " table" + ( strict ? "" : " if not exists" ) + " " + name + " as " + select )
}
/// http://sqlite.org/lang_altertable.html
func createTableColumn( name:String, columnDeclaration:String ) throws -> Bool {
return try execute( "alter table " + name + " add column " + columnDeclaration )
}
/// http://sqlite.org/lang_altertable.html
func renameTable( name:String, newName:String ) throws -> Bool {
return try execute( "alter table " + name + " rename to " + newName )
}
/// http://sqlite.org/lang_delete.html
func deleteAll( name:String ) throws -> Bool {
return try execute( "delete from " + name )
}
/// http://sqlite.org/lang_droptable.html
func dropTable( name:String ) throws -> Bool {
return try execute( "drop table if exists " + name )
}
/// http://sqlite.org/lang_createview.html
func createView( name:String, select:String, temporary:Bool = false, strict:Bool = false ) throws -> Bool {
return try execute( "create" + ( temporary ? " temporary" : "" ) + " view" + ( strict ? "" : " if not exists" ) + " " + name + " as " + select )
}
/// http://sqlite.org/lang_dropview.html
func dropView( name:String ) throws -> Bool {
return try execute( "drop view if exists " + name )
}
/// http://sqlite.org/lang_createtrigger.html
enum TriggerEvent { case Delete, Insert, Update, UpdateOf(columns:String) }
enum TriggerPhase : Int { case Default = 0, Before = 1, After = 2, Instead = 3 }
func createTrigger( name:String, table:String, event:TriggerEvent, statement:String, phase:TriggerPhase = .Default, when:String? = nil, temporary:Bool = false, strict:Bool = false ) throws -> Bool {
let tt = ( temporary ? " temporary" : "" )
let tx = ( strict ? "" : " if not exists" )
let te:String
let tp = [""," before"," after"," instead of"][phase.rawValue]
let tf = " for each row"
let tw = ( nil != when ? " when " + when! : "" )
switch ( event ) {
case .Delete: te = " delete"
case .Insert: te = " insert"
case .Update: te = " update"
case .UpdateOf(let columns): te = " update of " + columns
}
return try execute( "create" + tt + " trigger" + tx + " " + name + tp + te + " on " + table + tf + tw + " begin " + statement + "; end" )
}
/// http://sqlite.org/lang_droptrigger.html
func dropTrigger( name:String ) throws -> Bool {
return try execute( "drop trigger if exists " + name )
}
/// http://sqlite.org/lang_vacuum.html
func vacuum() throws -> Bool {
return try execute( "vacuum" )
}
/// http://sqlite.org/lang_analyze.html
func analyze( name:String ) throws -> Bool {
return try execute( "analyze " + name )
}
/// http://sqlite.org/lang_explain.html
}
| 40.85283 | 288 | 0.65823 |
edf9ca08b82d6127fad0d85371fc84ea88518bea | 545 | //
// ViewController.swift
// HmmToCProject
//
// Created by ZCC on 2021/3/2.
//
import UIKit
import CTMediator
import Common
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
self.view.backgroundColor = UIColor.lightGray
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
if let vc = CTMediator.sharedInstance().jumpToTest(["a": "b"]) {
self.present(vc, animated: true, completion: nil)
}
}
}
| 18.793103 | 79 | 0.629358 |
8fbc4fdc0e4a439038dc82615d4778b2076f94e6 | 1,194 | //
// LoginViewController.swift
// Hamburger
//
// Created by Kumawat, Diwakar on 4/22/17.
// Copyright © 2017 Kumawat, Diwakar. All rights reserved.
//
import UIKit
import BDBOAuth1Manager
class LoginViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
@IBAction func onLogin(_ sender: Any) {
TwitterClient.sharedInstance?.login(success: {
print("success logged in")
self.performSegue(withIdentifier: "segueToMenu", sender: nil)
}) { (error: Error) in
print(error)
}
}
/*
// MARK: - Navigation
// In a storyboard-based application, you will often want to do a little preparation before navigation
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
// Get the new view controller using segue.destinationViewController.
// Pass the selected object to the new view controller.
}
*/
}
| 25.404255 | 106 | 0.645729 |
567eddde30bba60cec54f314034756b68e6b4402 | 9,218 | //
// ChatViewController.swift
// FirebaseEvents
//
// Created by Mike Z on 11/14/19.
// Copyright © 2019 Electronic Armory. All rights reserved.
//
import UIKit
import FirebaseFirestore
class ChatViewController: UIViewController, UITableViewDelegate, UITableViewDataSource, UITextViewDelegate {
@IBOutlet weak var containerView: UIView!
@IBOutlet weak var tableView: UITableView!
@IBOutlet weak var remoteUserProfilePhoto: UIImageView!
@IBOutlet weak var messageTextView: UITextView!
@IBOutlet weak var sendButton: EAButton!
@IBOutlet weak var viewBottomConstraint: NSLayoutConstraint!
var originalBottomConstraintValue:CGFloat?
var remoteUser:EAUser? = nil
var chatMessages = [QueryDocumentSnapshot]()
var chatID:String?
let db = Firestore.firestore()
var keyboardIsVisible = false
let placeholderText:String = "Message or arrange a meeting."
override func viewDidLoad() {
super.viewDidLoad()
self.navigationController?.navigationBar.isHidden = true
if( (remoteUser?.uid)! < (AuthenticationController.user?.uid)!){
chatID = "\((remoteUser?.uid)!)==\((AuthenticationController.user?.uid)!)"
}
else{
chatID = "\((AuthenticationController.user?.uid)!)==\((remoteUser?.uid)!)"
}
messageTextView.text = placeholderText
messageTextView.textColor = UIColor.lightGray
messageTextView.selectedTextRange = messageTextView.textRange(from: messageTextView.beginningOfDocument, to: messageTextView.beginningOfDocument)
self.navigationItem.title = remoteUser?.displayName
remoteUserProfilePhoto.layer.cornerRadius = remoteUserProfilePhoto.frame.width/2
remoteUserProfilePhoto.layer.masksToBounds = true
remoteUserProfilePhoto.sd_setImage(with: remoteUser?.photoURL, placeholderImage: UIImage(named: "user-image-default"))
if( remoteUser != nil ){
db.collection("chats").document(self.chatID!).collection("messages").order(by: "timestamp", descending: false).addSnapshotListener({ (snapshot, error) in
guard let document = snapshot else {
print("Error fetching document: \(error!)")
return
}
self.chatMessages = document.documents
self.tableView.reloadData()
self.scrollTableViewToBottom()
})
}
originalBottomConstraintValue = viewBottomConstraint.constant
NotificationCenter.default.addObserver(self,
selector: #selector(keyboardWillShow),
name: UIResponder.keyboardWillShowNotification,
object: nil)
NotificationCenter.default.addObserver(self,
selector: #selector(keyboardWillHide),
name: UIResponder.keyboardWillHideNotification,
object: nil)
}
@IBAction func goBackTapped(_ sender: Any) {
self.navigationController?.popViewController(animated: true)
}
@objc
func keyboardWillShow(sender: NSNotification) {
if( keyboardIsVisible == false ){
keyboardIsVisible = true
let info = sender.userInfo!
let keyboardSize = (info[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue).cgRectValue.height
viewBottomConstraint.constant = keyboardSize - 50 /*- bottomLayoutGuide.length*/
let duration: TimeInterval = (info[UIResponder.keyboardAnimationDurationUserInfoKey] as! NSNumber).doubleValue
UIView.animate(withDuration: duration) { self.containerView.layoutIfNeeded() }
scrollTableViewToBottom()
}
}
@objc
func keyboardWillHide(sender: NSNotification) {
if( keyboardIsVisible == true ){
keyboardIsVisible = false
let info = sender.userInfo!
let duration: TimeInterval = (info[UIResponder.keyboardAnimationDurationUserInfoKey] as! NSNumber).doubleValue
viewBottomConstraint.constant = originalBottomConstraintValue!
UIView.animate(withDuration: duration) { self.containerView.layoutIfNeeded() }
}
}
func scrollTableViewToBottom(){
if( chatMessages.count > 0 ){
tableView.scrollToRow(at: IndexPath(row: chatMessages.count-1, section: 0), at: UITableView.ScrollPosition.bottom, animated: false)
}
}
func numberOfSections(in tableView: UITableView) -> Int {
return 1
}
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return chatMessages.count
}
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
tableView.deselectRow(at: indexPath, animated: false)
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let currentMessageSnapshot = chatMessages[indexPath.row]
let message:String = currentMessageSnapshot.data()["message"] as! String
let messageUID:String = "4MKh2TuxPDUvwOZ7TYwimEigXb93"
// currentMessageSnapshot.data()["uid"] as! String
// let messageTimestamp:Date = currentMessageSnapshot.data()["timestamp"] as! Date
var cell:MessageTableViewCell
// if( messageUID == AuthenticationController.user?.uid ){
// cell = tableView.dequeueReusableCell(withIdentifier: "ChatMessageCell") as! MessageTableViewCell
// }
// else{
cell = tableView.dequeueReusableCell(withIdentifier: "RemoteChatMessageCell") as! MessageTableViewCell
cell.profilePhoto?.sd_setImage(with: remoteUser?.photoURL, placeholderImage: UIImage(named: "user-image-default"))
// }
cell.messageLabel?.text = message
return cell
}
func textViewDidBeginEditing(_ textView: UITextView) {
if textView.textColor == UIColor.lightGray {
textView.text = ""
textView.textColor = UIColor.black
}
}
func textViewDidEndEditing(_ textView: UITextView) {
if textView.text.isEmpty {
textView.text = placeholderText
textView.textColor = UIColor.lightGray
}
}
func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
let currentText:String = textView.text
let updatedText = (currentText as NSString).replacingCharacters(in: range, with: text)
if updatedText.isEmpty {
textView.text = placeholderText
textView.textColor = UIColor.lightGray
textView.selectedTextRange = textView.textRange(from: textView.beginningOfDocument, to: textView.beginningOfDocument)
}
else if textView.textColor == UIColor.lightGray && !text.isEmpty {
textView.textColor = UIColor.black
textView.text = text
}
else {
return true
}
return false
}
func textViewDidChangeSelection(_ textView: UITextView) {
if self.view.window != nil {
if textView.textColor == UIColor.lightGray {
if textView.text != "" {
textView.selectedTextRange = textView.textRange(from: textView.beginningOfDocument, to: textView.beginningOfDocument)
}
}
}
}
@IBAction func sendMessageTapped(_ sender: Any) {
if messageTextView.text != placeholderText {
sendMessage()
}
}
func sendMessage(){
// TODO: Sanitize input text
let messageToAdd:[String : Any] = [
"uid": (AuthenticationController.user?.uid)!,
"message": messageTextView.text!,
"timestamp": Date()]
db.collection("chats").document(chatID!).collection("messages").addDocument(data: messageToAdd, completion: { (error) in
guard error == nil else {
print(error.debugDescription)
return
}
print("done sending message")
})
messageTextView.text = ""
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
/*
// MARK: - Navigation
// In a storyboard-based application, you will often want to do a little preparation before navigation
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
// Get the new view controller using segue.destinationViewController.
// Pass the selected object to the new view controller.
}
*/
}
| 36.007813 | 165 | 0.613691 |
76c5707e4243627e38946b1592cc820decb9b687 | 751 | import XCTest
import MarsSegmentBar
class Tests: XCTestCase {
override func setUp() {
super.setUp()
// Put setup code here. This method is called before the invocation of each test method in the class.
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class.
super.tearDown()
}
func testExample() {
// This is an example of a functional test case.
XCTAssert(true, "Pass")
}
func testPerformanceExample() {
// This is an example of a performance test case.
self.measure() {
// Put the code you want to measure the time of here.
}
}
}
| 25.896552 | 111 | 0.603196 |
e596f0d2ea946f43bf02449d809002cb2d8097ee | 449 | //
// NotValidator.swift
// AssignmentTwo
//
// Created by Sam Krishna on 2/16/22.
//
import Foundation
struct NotValidator<Value> : Validator {
let childValidator: AnyValidator<Value>
init<Child>(_ childValidator: Child) where Child : Validator, Child.Value == Value {
self.childValidator = AnyValidator(childValidator)
}
func validate(_ value: Value) -> Bool {
return !childValidator.validate(value)
}
}
| 21.380952 | 88 | 0.679287 |
61afc7b7bce18ede3f2808a3cebe449a4b20e3fe | 871 | //
// PageTabCollectionCell.swift
// Sakuin
//
// Created by svpcadmin on 11/11/16.
// Copyright © 2016 tamanyan. All rights reserved.
//
import UIKit
class PageTabCollectionCell: UICollectionViewCell {
static let cellIdentifier = "PageTabCollectionCell"
var titleLabel: UILabel = {
let label = UILabel()
label.textAlignment = .center
return label
}()
override init(frame: CGRect) {
super.init(frame: frame)
self.backgroundColor = .white
self.contentView.addSubview(self.titleLabel)
self.titleLabel.frame = CGRect(origin: CGPoint.zero, size: self.frame.size)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func prepareForReuse() {
super.prepareForReuse()
self.titleLabel.text = ""
}
}
| 24.194444 | 83 | 0.652124 |
9cbfa3bf5782ce1fdfb3af4d04312c18b96c11cf | 620 | //
// AppDelegate.swift
// Example-iOS
//
// Created by Kita, Maksim on 1/9/20.
// Copyright © 2020 Kita, Maksim. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
let window = UIWindow(frame: UIScreen.main.bounds)
window.rootViewController = SectionsViewController()
window.makeKeyAndVisible()
self.window = window
return true
}
}
| 23.846154 | 145 | 0.704839 |
2f4a7ea7823cc3039f32ebed3bb026a4195f7a24 | 95,522 | // RUN: %target-swift-frontend -disable-objc-attr-requires-foundation-module -typecheck -verify %s -swift-version 4 -enable-source-import -I %S/Inputs -enable-swift3-objc-inference
// RUN: %target-swift-ide-test -skip-deinit=false -print-ast-typechecked -source-filename %s -function-definitions=true -prefer-type-repr=false -print-implicit-attrs=true -explode-pattern-binding-decls=true -disable-objc-attr-requires-foundation-module -swift-version 4 -enable-source-import -I %S/Inputs -enable-swift3-objc-inference | %FileCheck %s
// RUN: not %target-swift-frontend -typecheck -dump-ast -disable-objc-attr-requires-foundation-module %s -swift-version 4 -enable-source-import -I %S/Inputs -enable-swift3-objc-inference > %t.ast
// RUN: %FileCheck -check-prefix CHECK-DUMP %s < %t.ast
// REQUIRES: objc_interop
import Foundation
class PlainClass {}
struct PlainStruct {}
enum PlainEnum {}
protocol PlainProtocol {} // expected-note {{protocol 'PlainProtocol' declared here}}
enum ErrorEnum : Error {
case failed
}
@objc class Class_ObjC1 {}
protocol Protocol_Class1 : class {} // expected-note {{protocol 'Protocol_Class1' declared here}}
protocol Protocol_Class2 : class {}
@objc protocol Protocol_ObjC1 {}
@objc protocol Protocol_ObjC2 {}
//===--- Subjects of @objc attribute.
@objc extension PlainStruct { } // expected-error{{'@objc' can only be applied to an extension of a class}}{{1-7=}}
class FáncyName {}
@objc (FancyName) extension FáncyName {}
@objc
var subject_globalVar: Int // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
var subject_getterSetter: Int {
@objc
get { // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
return 0
}
@objc
set { // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
}
}
var subject_global_observingAccessorsVar1: Int = 0 {
@objc
willSet { // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-9=}}
}
@objc
didSet { // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-9=}}
}
}
class subject_getterSetter1 {
var instanceVar1: Int {
@objc
get { // expected-error {{'@objc' getter for non-'@objc' property}}
return 0
}
}
var instanceVar2: Int {
get {
return 0
}
@objc
set { // expected-error {{'@objc' setter for non-'@objc' property}}
}
}
var instanceVar3: Int {
@objc
get { // expected-error {{'@objc' getter for non-'@objc' property}}
return 0
}
@objc
set { // expected-error {{'@objc' setter for non-'@objc' property}}
}
}
var observingAccessorsVar1: Int = 0 {
@objc
willSet { // expected-error {{observing accessors are not allowed to be marked @objc}} {{5-10=}}
}
@objc
didSet { // expected-error {{observing accessors are not allowed to be marked @objc}} {{5-10=}}
}
}
}
class subject_staticVar1 {
@objc
class var staticVar1: Int = 42 // expected-error {{class stored properties not supported}}
@objc
class var staticVar2: Int { return 42 }
}
@objc
func subject_freeFunc() { // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{1-6=}}
@objc
var subject_localVar: Int // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
@objc
func subject_nestedFreeFunc() { // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
}
}
@objc
func subject_genericFunc<T>(t: T) { // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{1-6=}}
@objc
var subject_localVar: Int // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
@objc
func subject_instanceFunc() {} // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
}
func subject_funcParam(a: @objc Int) { // expected-error {{attribute can only be applied to declarations, not types}} {{1-1=@objc }} {{27-33=}}
}
@objc // expected-error {{'@objc' attribute cannot be applied to this declaration}} {{1-7=}}
struct subject_struct {
@objc
var subject_instanceVar: Int // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
@objc
init() {} // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
@objc
func subject_instanceFunc() {} // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
}
@objc // expected-error {{'@objc' attribute cannot be applied to this declaration}} {{1-7=}}
struct subject_genericStruct<T> {
@objc
var subject_instanceVar: Int // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
@objc
init() {} // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
@objc
func subject_instanceFunc() {} // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
}
@objc
class subject_class1 { // no-error
@objc
var subject_instanceVar: Int // no-error
@objc
init() {} // no-error
@objc
func subject_instanceFunc() {} // no-error
}
@objc
class subject_class2 : Protocol_Class1, PlainProtocol { // no-error
}
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc' because they are not directly visible from Objective-C}} {{1-7=}}
class subject_genericClass<T> {
@objc
var subject_instanceVar: Int // no-error
@objc
init() {} // no-error
@objc
func subject_instanceFunc() {} // no_error
}
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc'}} {{1-7=}}
class subject_genericClass2<T> : Class_ObjC1 {
@objc
var subject_instanceVar: Int // no-error
@objc
init(foo: Int) {} // no-error
@objc
func subject_instanceFunc() {} // no_error
}
extension subject_genericClass where T : Hashable {
@objc var prop: Int { return 0 } // expected-error{{members of constrained extensions cannot be declared @objc}}
}
extension subject_genericClass {
@objc var extProp: Int { return 0 } // expected-error{{extensions of generic classes cannot contain '@objc' members}}
@objc func extFoo() {} // expected-error{{extensions of generic classes cannot contain '@objc' members}}
}
@objc
enum subject_enum: Int {
@objc // expected-error {{attribute has no effect; cases within an '@objc' enum are already exposed to Objective-C}} {{3-9=}}
case subject_enumElement1
@objc(subject_enumElement2)
case subject_enumElement2
@objc(subject_enumElement3)
case subject_enumElement3, subject_enumElement4 // expected-error {{'@objc' enum case declaration defines multiple enum cases with the same Objective-C name}}{{3-30=}}
@objc // expected-error {{attribute has no effect; cases within an '@objc' enum are already exposed to Objective-C}} {{3-9=}}
case subject_enumElement5, subject_enumElement6
@nonobjc // expected-error {{'@nonobjc' attribute cannot be applied to this declaration}}
case subject_enumElement7
@objc
init() {} // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-9=}}
@objc
func subject_instanceFunc() {} // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}} {{3-8=}}
}
enum subject_enum2 {
@objc(subject_enum2Element1)
case subject_enumElement1 // expected-error{{'@objc' enum case is not allowed outside of an '@objc' enum}}{{3-31=}}
}
@objc
protocol subject_protocol1 {
@objc
var subject_instanceVar: Int { get }
@objc
func subject_instanceFunc()
}
@objc protocol subject_protocol2 {} // no-error
// CHECK-LABEL: @objc protocol subject_protocol2 {
@objc protocol subject_protocol3 {} // no-error
// CHECK-LABEL: @objc protocol subject_protocol3 {
@objc
protocol subject_protocol4 : PlainProtocol {} // expected-error {{@objc protocol 'subject_protocol4' cannot refine non-@objc protocol 'PlainProtocol'}}
@objc
protocol subject_protocol5 : Protocol_Class1 {} // expected-error {{@objc protocol 'subject_protocol5' cannot refine non-@objc protocol 'Protocol_Class1'}}
@objc
protocol subject_protocol6 : Protocol_ObjC1 {}
protocol subject_containerProtocol1 {
@objc
var subject_instanceVar: Int { get } // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
@objc
func subject_instanceFunc() // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
@objc
static func subject_staticFunc() // expected-error {{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
}
@objc
protocol subject_containerObjCProtocol1 {
func func_FunctionReturn1() -> PlainStruct
// expected-error@-1 {{method cannot be a member of an @objc protocol because its result type cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
// expected-note@-3 {{inferring '@objc' because the declaration is a member of an '@objc' protocol}}
func func_FunctionParam1(a: PlainStruct)
// expected-error@-1 {{method cannot be a member of an @objc protocol because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
// expected-note@-3 {{inferring '@objc' because the declaration is a member of an '@objc' protocol}}
func func_Variadic(_: AnyObject...)
// expected-error @-1{{method cannot be a member of an @objc protocol because it has a variadic parameter}}
// expected-note @-2{{inferring '@objc' because the declaration is a member of an '@objc' protocol}}
subscript(a: PlainStruct) -> Int { get }
// expected-error@-1 {{subscript cannot be a member of an @objc protocol because its type cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
// expected-note@-3 {{inferring '@objc' because the declaration is a member of an '@objc' protocol}}
var varNonObjC1: PlainStruct { get }
// expected-error@-1 {{property cannot be a member of an @objc protocol because its type cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
// expected-note@-3 {{inferring '@objc' because the declaration is a member of an '@objc' protocol}}
}
@objc
protocol subject_containerObjCProtocol2 {
init(a: Int)
@objc init(a: Double)
func func1() -> Int
@objc func func1_() -> Int
var instanceVar1: Int { get set }
@objc var instanceVar1_: Int { get set }
subscript(i: Int) -> Int { get set }
@objc subscript(i: String) -> Int { get set}
}
protocol nonObjCProtocol {
@objc func objcRequirement() // expected-error{{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
}
func concreteContext1() {
@objc
class subject_inConcreteContext {}
}
class ConcreteContext2 {
@objc
class subject_inConcreteContext {}
}
class ConcreteContext3 {
func dynamicSelf1() -> Self { return self }
@objc func dynamicSelf1_() -> Self { return self }
@objc func genericParams<T: NSObject>() -> [T] { return [] }
// expected-error@-1{{method cannot be marked @objc because it has generic parameters}}
@objc func returnObjCProtocolMetatype() -> NSCoding.Protocol { return NSCoding.self }
// expected-error@-1{{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
typealias AnotherNSCoding = NSCoding
typealias MetaNSCoding1 = NSCoding.Protocol
typealias MetaNSCoding2 = AnotherNSCoding.Protocol
@objc func returnObjCAliasProtocolMetatype1() -> AnotherNSCoding.Protocol { return NSCoding.self }
// expected-error@-1{{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
@objc func returnObjCAliasProtocolMetatype2() -> MetaNSCoding1 { return NSCoding.self }
// expected-error@-1{{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
@objc func returnObjCAliasProtocolMetatype3() -> MetaNSCoding2 { return NSCoding.self }
// expected-error@-1{{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
typealias Composition = NSCopying & NSCoding
@objc func returnCompositionMetatype1() -> Composition.Protocol { return Composition.self }
// expected-error@-1{{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
@objc func returnCompositionMetatype2() -> (NSCopying & NSCoding).Protocol { return (NSCopying & NSCoding).self }
// expected-error@-1{{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
typealias NSCodingExistential = NSCoding.Type
@objc func inoutFunc(a: inout Int) {}
// expected-error@-1{{method cannot be marked @objc because inout parameters cannot be represented in Objective-C}}
@objc func metatypeOfExistentialMetatypePram1(a: NSCodingExistential.Protocol) {}
// expected-error@-1{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
@objc func metatypeOfExistentialMetatypePram2(a: NSCoding.Type.Protocol) {}
// expected-error@-1{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
}
func genericContext1<T>(_: T) {
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc' because they are not directly visible from Objective-C}} {{3-9=}}
class subject_inGenericContext {} // expected-error{{type 'subject_inGenericContext' cannot be nested in generic function 'genericContext1'}}
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc'}} {{3-9=}}
class subject_inGenericContext2 : Class_ObjC1 {} // expected-error{{type 'subject_inGenericContext2' cannot be nested in generic function 'genericContext1'}}
class subject_constructor_inGenericContext { // expected-error{{type 'subject_constructor_inGenericContext' cannot be nested in generic function 'genericContext1'}}
@objc
init() {} // no-error
}
class subject_var_inGenericContext { // expected-error{{type 'subject_var_inGenericContext' cannot be nested in generic function 'genericContext1'}}
@objc
var subject_instanceVar: Int = 0 // no-error
}
class subject_func_inGenericContext { // expected-error{{type 'subject_func_inGenericContext' cannot be nested in generic function 'genericContext1'}}
@objc
func f() {} // no-error
}
}
class GenericContext2<T> {
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc' because they are not directly visible from Objective-C}} {{3-9=}}
class subject_inGenericContext {}
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc'}} {{3-9=}}
class subject_inGenericContext2 : Class_ObjC1 {}
@objc
func f() {} // no-error
}
class GenericContext3<T> {
class MoreNested {
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc' because they are not directly visible from Objective-C}} {{5-11=}}
class subject_inGenericContext {}
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc'}} {{5-11=}}
class subject_inGenericContext2 : Class_ObjC1 {}
@objc
func f() {} // no-error
}
}
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc' because they are not directly visible from Objective-C}} {{1-7=}}
class ConcreteSubclassOfGeneric : GenericContext3<Int> {}
extension ConcreteSubclassOfGeneric {
@objc func foo() {} // okay
}
@objc // expected-error{{generic subclasses of '@objc' classes cannot have an explicit '@objc'}} {{1-7=}}
class ConcreteSubclassOfGeneric2 : subject_genericClass2<Int> {}
extension ConcreteSubclassOfGeneric2 {
@objc func foo() {} // okay
}
@objc(CustomNameForSubclassOfGeneric) // okay
class ConcreteSubclassOfGeneric3 : GenericContext3<Int> {}
extension ConcreteSubclassOfGeneric3 {
@objc func foo() {} // okay
}
class subject_subscriptIndexed1 {
@objc
subscript(a: Int) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptIndexed2 {
@objc
subscript(a: Int8) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptIndexed3 {
@objc
subscript(a: UInt8) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptKeyed1 {
@objc
subscript(a: String) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptKeyed2 {
@objc
subscript(a: Class_ObjC1) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptKeyed3 {
@objc
subscript(a: Class_ObjC1.Type) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptKeyed4 {
@objc
subscript(a: Protocol_ObjC1) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptKeyed5 {
@objc
subscript(a: Protocol_ObjC1.Type) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptKeyed6 {
@objc
subscript(a: Protocol_ObjC1 & Protocol_ObjC2) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptKeyed7 {
@objc
subscript(a: (Protocol_ObjC1 & Protocol_ObjC2).Type) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptBridgedFloat {
@objc
subscript(a: Float32) -> Int {
get { return 0 }
}
}
class subject_subscriptGeneric<T> {
@objc
subscript(a: Int) -> Int { // no-error
get { return 0 }
}
}
class subject_subscriptInvalid1 {
@objc class subscript(_ i: Int) -> AnyObject? {
// expected-error@-1 {{class subscript cannot be marked @objc}}
return nil
}
}
class subject_subscriptInvalid2 {
@objc
subscript(a: PlainClass) -> Int {
// expected-error@-1 {{subscript cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{classes not annotated with @objc cannot be represented in Objective-C}}
get { return 0 }
}
}
class subject_subscriptInvalid3 {
@objc
subscript(a: PlainClass.Type) -> Int { // expected-error {{subscript cannot be marked @objc because its type cannot be represented in Objective-C}}
get { return 0 }
}
}
class subject_subscriptInvalid4 {
@objc
subscript(a: PlainStruct) -> Int { // expected-error {{subscript cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-1{{Swift structs cannot be represented in Objective-C}}
get { return 0 }
}
}
class subject_subscriptInvalid5 {
@objc
subscript(a: PlainEnum) -> Int { // expected-error {{subscript cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-1{{enums cannot be represented in Objective-C}}
get { return 0 }
}
}
class subject_subscriptInvalid6 {
@objc
subscript(a: PlainProtocol) -> Int { // expected-error {{subscript cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-1{{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
get { return 0 }
}
}
class subject_subscriptInvalid7 {
@objc
subscript(a: Protocol_Class1) -> Int { // expected-error {{subscript cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-1{{protocol-constrained type containing protocol 'Protocol_Class1' cannot be represented in Objective-C}}
get { return 0 }
}
}
class subject_subscriptInvalid8 {
@objc
subscript(a: Protocol_Class1 & Protocol_Class2) -> Int { // expected-error {{subscript cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-1{{protocol-constrained type containing protocol 'Protocol_Class1' cannot be represented in Objective-C}}
get { return 0 }
}
}
class subject_propertyInvalid1 {
@objc
let plainStruct = PlainStruct() // expected-error {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-1{{Swift structs cannot be represented in Objective-C}}
}
//===--- Tests for @objc inference.
@objc
class infer_instanceFunc1 {
// CHECK-LABEL: @objc class infer_instanceFunc1 {
func func1() {}
// CHECK-LABEL: @objc func func1() {
@objc func func1_() {} // no-error
func func2(a: Int) {}
// CHECK-LABEL: @objc func func2(a: Int) {
@objc func func2_(a: Int) {} // no-error
func func3(a: Int) -> Int {}
// CHECK-LABEL: @objc func func3(a: Int) -> Int {
@objc func func3_(a: Int) -> Int {} // no-error
func func4(a: Int, b: Double) {}
// CHECK-LABEL: @objc func func4(a: Int, b: Double) {
@objc func func4_(a: Int, b: Double) {} // no-error
func func5(a: String) {}
// CHECK-LABEL: @objc func func5(a: String) {
@objc func func5_(a: String) {} // no-error
func func6() -> String {}
// CHECK-LABEL: @objc func func6() -> String {
@objc func func6_() -> String {} // no-error
func func7(a: PlainClass) {}
// CHECK-LABEL: {{^}} func func7(a: PlainClass) {
@objc func func7_(a: PlainClass) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{classes not annotated with @objc cannot be represented in Objective-C}}
func func7m(a: PlainClass.Type) {}
// CHECK-LABEL: {{^}} func func7m(a: PlainClass.Type) {
@objc func func7m_(a: PlainClass.Type) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
func func8() -> PlainClass {}
// CHECK-LABEL: {{^}} func func8() -> PlainClass {
@objc func func8_() -> PlainClass {}
// expected-error@-1 {{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
// expected-note@-2 {{classes not annotated with @objc cannot be represented in Objective-C}}
func func8m() -> PlainClass.Type {}
// CHECK-LABEL: {{^}} func func8m() -> PlainClass.Type {
@objc func func8m_() -> PlainClass.Type {}
// expected-error@-1 {{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
func func9(a: PlainStruct) {}
// CHECK-LABEL: {{^}} func func9(a: PlainStruct) {
@objc func func9_(a: PlainStruct) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
func func10() -> PlainStruct {}
// CHECK-LABEL: {{^}} func func10() -> PlainStruct {
@objc func func10_() -> PlainStruct {}
// expected-error@-1 {{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
func func11(a: PlainEnum) {}
// CHECK-LABEL: {{^}} func func11(a: PlainEnum) {
@objc func func11_(a: PlainEnum) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{non-'@objc' enums cannot be represented in Objective-C}}
func func12(a: PlainProtocol) {}
// CHECK-LABEL: {{^}} func func12(a: PlainProtocol) {
@objc func func12_(a: PlainProtocol) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
func func13(a: Class_ObjC1) {}
// CHECK-LABEL: @objc func func13(a: Class_ObjC1) {
@objc func func13_(a: Class_ObjC1) {} // no-error
func func14(a: Protocol_Class1) {}
// CHECK-LABEL: {{^}} func func14(a: Protocol_Class1) {
@objc func func14_(a: Protocol_Class1) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'Protocol_Class1' cannot be represented in Objective-C}}
func func15(a: Protocol_ObjC1) {}
// CHECK-LABEL: @objc func func15(a: Protocol_ObjC1) {
@objc func func15_(a: Protocol_ObjC1) {} // no-error
func func16(a: AnyObject) {}
// CHECK-LABEL: @objc func func16(a: AnyObject) {
@objc func func16_(a: AnyObject) {} // no-error
func func17(a: @escaping () -> ()) {}
// CHECK-LABEL: {{^}} @objc func func17(a: @escaping () -> ()) {
@objc func func17_(a: @escaping () -> ()) {}
func func18(a: @escaping (Int) -> (), b: Int) {}
// CHECK-LABEL: {{^}} @objc func func18(a: @escaping (Int) -> (), b: Int)
@objc func func18_(a: @escaping (Int) -> (), b: Int) {}
func func19(a: @escaping (String) -> (), b: Int) {}
// CHECK-LABEL: {{^}} @objc func func19(a: @escaping (String) -> (), b: Int) {
@objc func func19_(a: @escaping (String) -> (), b: Int) {}
func func_FunctionReturn1() -> () -> () {}
// CHECK-LABEL: {{^}} @objc func func_FunctionReturn1() -> () -> () {
@objc func func_FunctionReturn1_() -> () -> () {}
func func_FunctionReturn2() -> (Int) -> () {}
// CHECK-LABEL: {{^}} @objc func func_FunctionReturn2() -> (Int) -> () {
@objc func func_FunctionReturn2_() -> (Int) -> () {}
func func_FunctionReturn3() -> () -> Int {}
// CHECK-LABEL: {{^}} @objc func func_FunctionReturn3() -> () -> Int {
@objc func func_FunctionReturn3_() -> () -> Int {}
func func_FunctionReturn4() -> (String) -> () {}
// CHECK-LABEL: {{^}} @objc func func_FunctionReturn4() -> (String) -> () {
@objc func func_FunctionReturn4_() -> (String) -> () {}
func func_FunctionReturn5() -> () -> String {}
// CHECK-LABEL: {{^}} @objc func func_FunctionReturn5() -> () -> String {
@objc func func_FunctionReturn5_() -> () -> String {}
func func_ZeroParams1() {}
// CHECK-LABEL: @objc func func_ZeroParams1() {
@objc func func_ZeroParams1a() {} // no-error
func func_OneParam1(a: Int) {}
// CHECK-LABEL: @objc func func_OneParam1(a: Int) {
@objc func func_OneParam1a(a: Int) {} // no-error
func func_TupleStyle1(a: Int, b: Int) {}
// CHECK-LABEL: {{^}} @objc func func_TupleStyle1(a: Int, b: Int) {
@objc func func_TupleStyle1a(a: Int, b: Int) {}
func func_TupleStyle2(a: Int, b: Int, c: Int) {}
// CHECK-LABEL: {{^}} @objc func func_TupleStyle2(a: Int, b: Int, c: Int) {
@objc func func_TupleStyle2a(a: Int, b: Int, c: Int) {}
// Check that we produce diagnostics for every parameter and return type.
@objc func func_MultipleDiags(a: PlainStruct, b: PlainEnum) -> Any {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter 1 cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
// expected-error@-3 {{method cannot be marked @objc because the type of the parameter 2 cannot be represented in Objective-C}}
// expected-note@-4 {{non-'@objc' enums cannot be represented in Objective-C}}
@objc func func_UnnamedParam1(_: Int) {} // no-error
@objc func func_UnnamedParam2(_: PlainStruct) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
@objc func func_varParam1(a: AnyObject) {
var a = a
let b = a; a = b
}
func func_varParam2(a: AnyObject) {
var a = a
let b = a; a = b
}
// CHECK-LABEL: @objc func func_varParam2(a: AnyObject) {
}
@objc
class infer_constructor1 {
// CHECK-LABEL: @objc class infer_constructor1
init() {}
// CHECK: @objc init()
init(a: Int) {}
// CHECK: @objc init(a: Int)
init(a: PlainStruct) {}
// CHECK: {{^}} init(a: PlainStruct)
init(malice: ()) {}
// CHECK: @objc init(malice: ())
init(forMurder _: ()) {}
// CHECK: @objc init(forMurder _: ())
}
@objc
class infer_destructor1 {
// CHECK-LABEL: @objc class infer_destructor1
deinit {}
// CHECK: @objc deinit
}
// @!objc
class infer_destructor2 {
// CHECK-LABEL: {{^}}class infer_destructor2
deinit {}
// CHECK: @objc deinit
}
@objc
class infer_instanceVar1 {
// CHECK-LABEL: @objc class infer_instanceVar1 {
init() {}
var instanceVar1: Int
// CHECK: @objc var instanceVar1: Int
var (instanceVar2, instanceVar3): (Int, PlainProtocol)
// CHECK: @objc var instanceVar2: Int
// CHECK: {{^}} var instanceVar3: PlainProtocol
@objc var (instanceVar1_, instanceVar2_): (Int, PlainProtocol)
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
var intstanceVar4: Int {
// CHECK: @objc var intstanceVar4: Int {
get {}
// CHECK-NEXT: @objc get {}
}
var intstanceVar5: Int {
// CHECK: @objc var intstanceVar5: Int {
get {}
// CHECK-NEXT: @objc get {}
set {}
// CHECK-NEXT: @objc set {}
}
@objc var instanceVar5_: Int {
// CHECK: @objc var instanceVar5_: Int {
get {}
// CHECK-NEXT: @objc get {}
set {}
// CHECK-NEXT: @objc set {}
}
var observingAccessorsVar1: Int {
// CHECK: @objc @_hasStorage var observingAccessorsVar1: Int {
willSet {}
// CHECK-NEXT: {{^}} @objc get
didSet {}
// CHECK-NEXT: {{^}} @objc set
}
@objc var observingAccessorsVar1_: Int {
// CHECK: {{^}} @objc @_hasStorage var observingAccessorsVar1_: Int {
willSet {}
// CHECK-NEXT: {{^}} @objc get
didSet {}
// CHECK-NEXT: {{^}} @objc set
}
var var_Int: Int
// CHECK-LABEL: @objc var var_Int: Int
var var_Bool: Bool
// CHECK-LABEL: @objc var var_Bool: Bool
var var_CBool: CBool
// CHECK-LABEL: @objc var var_CBool: CBool
var var_String: String
// CHECK-LABEL: @objc var var_String: String
var var_Float: Float
var var_Double: Double
// CHECK-LABEL: @objc var var_Float: Float
// CHECK-LABEL: @objc var var_Double: Double
var var_Char: Unicode.Scalar
// CHECK-LABEL: @objc var var_Char: Unicode.Scalar
//===--- Tuples.
var var_tuple1: ()
// CHECK-LABEL: {{^}} @_hasInitialValue var var_tuple1: ()
@objc var var_tuple1_: ()
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{empty tuple type cannot be represented in Objective-C}}
var var_tuple2: Void
// CHECK-LABEL: {{^}} @_hasInitialValue var var_tuple2: Void
@objc var var_tuple2_: Void
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{empty tuple type cannot be represented in Objective-C}}
var var_tuple3: (Int)
// CHECK-LABEL: @objc var var_tuple3: (Int)
@objc var var_tuple3_: (Int) // no-error
var var_tuple4: (Int, Int)
// CHECK-LABEL: {{^}} var var_tuple4: (Int, Int)
@objc var var_tuple4_: (Int, Int)
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{tuples cannot be represented in Objective-C}}
//===--- Stdlib integer types.
var var_Int8: Int8
var var_Int16: Int16
var var_Int32: Int32
var var_Int64: Int64
// CHECK-LABEL: @objc var var_Int8: Int8
// CHECK-LABEL: @objc var var_Int16: Int16
// CHECK-LABEL: @objc var var_Int32: Int32
// CHECK-LABEL: @objc var var_Int64: Int64
var var_UInt8: UInt8
var var_UInt16: UInt16
var var_UInt32: UInt32
var var_UInt64: UInt64
// CHECK-LABEL: @objc var var_UInt8: UInt8
// CHECK-LABEL: @objc var var_UInt16: UInt16
// CHECK-LABEL: @objc var var_UInt32: UInt32
// CHECK-LABEL: @objc var var_UInt64: UInt64
var var_OpaquePointer: OpaquePointer
// CHECK-LABEL: @objc var var_OpaquePointer: OpaquePointer
var var_PlainClass: PlainClass
// CHECK-LABEL: {{^}} var var_PlainClass: PlainClass
@objc var var_PlainClass_: PlainClass
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{classes not annotated with @objc cannot be represented in Objective-C}}
var var_PlainStruct: PlainStruct
// CHECK-LABEL: {{^}} var var_PlainStruct: PlainStruct
@objc var var_PlainStruct_: PlainStruct
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
var var_PlainEnum: PlainEnum
// CHECK-LABEL: {{^}} var var_PlainEnum: PlainEnum
@objc var var_PlainEnum_: PlainEnum
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{non-'@objc' enums cannot be represented in Objective-C}}
var var_PlainProtocol: PlainProtocol
// CHECK-LABEL: {{^}} var var_PlainProtocol: PlainProtocol
@objc var var_PlainProtocol_: PlainProtocol
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
var var_ClassObjC: Class_ObjC1
// CHECK-LABEL: @objc var var_ClassObjC: Class_ObjC1
@objc var var_ClassObjC_: Class_ObjC1 // no-error
var var_ProtocolClass: Protocol_Class1
// CHECK-LABEL: {{^}} var var_ProtocolClass: Protocol_Class1
@objc var var_ProtocolClass_: Protocol_Class1
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'Protocol_Class1' cannot be represented in Objective-C}}
var var_ProtocolObjC: Protocol_ObjC1
// CHECK-LABEL: @objc var var_ProtocolObjC: Protocol_ObjC1
@objc var var_ProtocolObjC_: Protocol_ObjC1 // no-error
var var_PlainClassMetatype: PlainClass.Type
// CHECK-LABEL: {{^}} var var_PlainClassMetatype: PlainClass.Type
@objc var var_PlainClassMetatype_: PlainClass.Type
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_PlainStructMetatype: PlainStruct.Type
// CHECK-LABEL: {{^}} var var_PlainStructMetatype: PlainStruct.Type
@objc var var_PlainStructMetatype_: PlainStruct.Type
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_PlainEnumMetatype: PlainEnum.Type
// CHECK-LABEL: {{^}} var var_PlainEnumMetatype: PlainEnum.Type
@objc var var_PlainEnumMetatype_: PlainEnum.Type
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_PlainExistentialMetatype: PlainProtocol.Type
// CHECK-LABEL: {{^}} var var_PlainExistentialMetatype: PlainProtocol.Type
@objc var var_PlainExistentialMetatype_: PlainProtocol.Type
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ClassObjCMetatype: Class_ObjC1.Type
// CHECK-LABEL: @objc var var_ClassObjCMetatype: Class_ObjC1.Type
@objc var var_ClassObjCMetatype_: Class_ObjC1.Type // no-error
var var_ProtocolClassMetatype: Protocol_Class1.Type
// CHECK-LABEL: {{^}} var var_ProtocolClassMetatype: Protocol_Class1.Type
@objc var var_ProtocolClassMetatype_: Protocol_Class1.Type
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ProtocolObjCMetatype1: Protocol_ObjC1.Type
// CHECK-LABEL: @objc var var_ProtocolObjCMetatype1: Protocol_ObjC1.Type
@objc var var_ProtocolObjCMetatype1_: Protocol_ObjC1.Type // no-error
var var_ProtocolObjCMetatype2: Protocol_ObjC2.Type
// CHECK-LABEL: @objc var var_ProtocolObjCMetatype2: Protocol_ObjC2.Type
@objc var var_ProtocolObjCMetatype2_: Protocol_ObjC2.Type // no-error
var var_AnyObject1: AnyObject
var var_AnyObject2: AnyObject.Type
// CHECK-LABEL: @objc var var_AnyObject1: AnyObject
// CHECK-LABEL: @objc var var_AnyObject2: AnyObject.Type
var var_Existential0: Any
// CHECK-LABEL: @objc var var_Existential0: Any
@objc var var_Existential0_: Any
var var_Existential1: PlainProtocol
// CHECK-LABEL: {{^}} var var_Existential1: PlainProtocol
@objc var var_Existential1_: PlainProtocol
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
var var_Existential2: PlainProtocol & PlainProtocol
// CHECK-LABEL: {{^}} var var_Existential2: PlainProtocol
@objc var var_Existential2_: PlainProtocol & PlainProtocol
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
var var_Existential3: PlainProtocol & Protocol_Class1
// CHECK-LABEL: {{^}} var var_Existential3: PlainProtocol & Protocol_Class1
@objc var var_Existential3_: PlainProtocol & Protocol_Class1
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
var var_Existential4: PlainProtocol & Protocol_ObjC1
// CHECK-LABEL: {{^}} var var_Existential4: PlainProtocol & Protocol_ObjC1
@objc var var_Existential4_: PlainProtocol & Protocol_ObjC1
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'PlainProtocol' cannot be represented in Objective-C}}
var var_Existential5: Protocol_Class1
// CHECK-LABEL: {{^}} var var_Existential5: Protocol_Class1
@objc var var_Existential5_: Protocol_Class1
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'Protocol_Class1' cannot be represented in Objective-C}}
var var_Existential6: Protocol_Class1 & Protocol_Class2
// CHECK-LABEL: {{^}} var var_Existential6: Protocol_Class1 & Protocol_Class2
@objc var var_Existential6_: Protocol_Class1 & Protocol_Class2
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'Protocol_Class1' cannot be represented in Objective-C}}
var var_Existential7: Protocol_Class1 & Protocol_ObjC1
// CHECK-LABEL: {{^}} var var_Existential7: Protocol_Class1 & Protocol_ObjC1
@objc var var_Existential7_: Protocol_Class1 & Protocol_ObjC1
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{protocol-constrained type containing protocol 'Protocol_Class1' cannot be represented in Objective-C}}
var var_Existential8: Protocol_ObjC1
// CHECK-LABEL: @objc var var_Existential8: Protocol_ObjC1
@objc var var_Existential8_: Protocol_ObjC1 // no-error
var var_Existential9: Protocol_ObjC1 & Protocol_ObjC2
// CHECK-LABEL: @objc var var_Existential9: Protocol_ObjC1 & Protocol_ObjC2
@objc var var_Existential9_: Protocol_ObjC1 & Protocol_ObjC2 // no-error
var var_ExistentialMetatype0: Any.Type
var var_ExistentialMetatype1: PlainProtocol.Type
var var_ExistentialMetatype2: (PlainProtocol & PlainProtocol).Type
var var_ExistentialMetatype3: (PlainProtocol & Protocol_Class1).Type
var var_ExistentialMetatype4: (PlainProtocol & Protocol_ObjC1).Type
var var_ExistentialMetatype5: (Protocol_Class1).Type
var var_ExistentialMetatype6: (Protocol_Class1 & Protocol_Class2).Type
var var_ExistentialMetatype7: (Protocol_Class1 & Protocol_ObjC1).Type
var var_ExistentialMetatype8: Protocol_ObjC1.Type
var var_ExistentialMetatype9: (Protocol_ObjC1 & Protocol_ObjC2).Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype0: Any.Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype1: PlainProtocol.Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype2: (PlainProtocol).Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype3: (PlainProtocol & Protocol_Class1).Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype4: (PlainProtocol & Protocol_ObjC1).Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype5: (Protocol_Class1).Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype6: (Protocol_Class1 & Protocol_Class2).Type
// CHECK-LABEL: {{^}} var var_ExistentialMetatype7: (Protocol_Class1 & Protocol_ObjC1).Type
// CHECK-LABEL: @objc var var_ExistentialMetatype8: Protocol_ObjC1.Type
// CHECK-LABEL: @objc var var_ExistentialMetatype9: (Protocol_ObjC1 & Protocol_ObjC2).Type
var var_UnsafeMutablePointer1: UnsafeMutablePointer<Int>
var var_UnsafeMutablePointer2: UnsafeMutablePointer<Bool>
var var_UnsafeMutablePointer3: UnsafeMutablePointer<CBool>
var var_UnsafeMutablePointer4: UnsafeMutablePointer<String>
var var_UnsafeMutablePointer5: UnsafeMutablePointer<Float>
var var_UnsafeMutablePointer6: UnsafeMutablePointer<Double>
var var_UnsafeMutablePointer7: UnsafeMutablePointer<OpaquePointer>
var var_UnsafeMutablePointer8: UnsafeMutablePointer<PlainClass>
var var_UnsafeMutablePointer9: UnsafeMutablePointer<PlainStruct>
var var_UnsafeMutablePointer10: UnsafeMutablePointer<PlainEnum>
var var_UnsafeMutablePointer11: UnsafeMutablePointer<PlainProtocol>
var var_UnsafeMutablePointer12: UnsafeMutablePointer<AnyObject>
var var_UnsafeMutablePointer13: UnsafeMutablePointer<AnyObject.Type>
var var_UnsafeMutablePointer100: UnsafeMutableRawPointer
var var_UnsafeMutablePointer101: UnsafeMutableRawPointer
var var_UnsafeMutablePointer102: UnsafeMutablePointer<(Int, Int)>
// CHECK-LABEL: @objc var var_UnsafeMutablePointer1: UnsafeMutablePointer<Int>
// CHECK-LABEL: @objc var var_UnsafeMutablePointer2: UnsafeMutablePointer<Bool>
// CHECK-LABEL: @objc var var_UnsafeMutablePointer3: UnsafeMutablePointer<CBool>
// CHECK-LABEL: {{^}} var var_UnsafeMutablePointer4: UnsafeMutablePointer<String>
// CHECK-LABEL: @objc var var_UnsafeMutablePointer5: UnsafeMutablePointer<Float>
// CHECK-LABEL: @objc var var_UnsafeMutablePointer6: UnsafeMutablePointer<Double>
// CHECK-LABEL: @objc var var_UnsafeMutablePointer7: UnsafeMutablePointer<OpaquePointer>
// CHECK-LABEL: {{^}} var var_UnsafeMutablePointer8: UnsafeMutablePointer<PlainClass>
// CHECK-LABEL: {{^}} var var_UnsafeMutablePointer9: UnsafeMutablePointer<PlainStruct>
// CHECK-LABEL: {{^}} var var_UnsafeMutablePointer10: UnsafeMutablePointer<PlainEnum>
// CHECK-LABEL: {{^}} var var_UnsafeMutablePointer11: UnsafeMutablePointer<PlainProtocol>
// CHECK-LABEL: @objc var var_UnsafeMutablePointer12: UnsafeMutablePointer<AnyObject>
// CHECK-LABEL: var var_UnsafeMutablePointer13: UnsafeMutablePointer<AnyObject.Type>
// CHECK-LABEL: {{^}} @objc var var_UnsafeMutablePointer100: UnsafeMutableRawPointer
// CHECK-LABEL: {{^}} @objc var var_UnsafeMutablePointer101: UnsafeMutableRawPointer
// CHECK-LABEL: {{^}} var var_UnsafeMutablePointer102: UnsafeMutablePointer<(Int, Int)>
var var_Optional1: Class_ObjC1?
var var_Optional2: Protocol_ObjC1?
var var_Optional3: Class_ObjC1.Type?
var var_Optional4: Protocol_ObjC1.Type?
var var_Optional5: AnyObject?
var var_Optional6: AnyObject.Type?
var var_Optional7: String?
var var_Optional8: Protocol_ObjC1?
var var_Optional9: Protocol_ObjC1.Type?
var var_Optional10: (Protocol_ObjC1 & Protocol_ObjC2)?
var var_Optional11: (Protocol_ObjC1 & Protocol_ObjC2).Type?
var var_Optional12: OpaquePointer?
var var_Optional13: UnsafeMutablePointer<Int>?
var var_Optional14: UnsafeMutablePointer<Class_ObjC1>?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional1: Class_ObjC1?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional2: Protocol_ObjC1?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional3: Class_ObjC1.Type?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional4: Protocol_ObjC1.Type?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional5: AnyObject?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional6: AnyObject.Type?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional7: String?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional8: Protocol_ObjC1?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional9: Protocol_ObjC1.Type?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional10: (Protocol_ObjC1 & Protocol_ObjC2)?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional11: (Protocol_ObjC1 & Protocol_ObjC2).Type?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional12: OpaquePointer?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional13: UnsafeMutablePointer<Int>?
// CHECK-LABEL: @objc @_hasInitialValue var var_Optional14: UnsafeMutablePointer<Class_ObjC1>?
var var_ImplicitlyUnwrappedOptional1: Class_ObjC1!
var var_ImplicitlyUnwrappedOptional2: Protocol_ObjC1!
var var_ImplicitlyUnwrappedOptional3: Class_ObjC1.Type!
var var_ImplicitlyUnwrappedOptional4: Protocol_ObjC1.Type!
var var_ImplicitlyUnwrappedOptional5: AnyObject!
var var_ImplicitlyUnwrappedOptional6: AnyObject.Type!
var var_ImplicitlyUnwrappedOptional7: String!
var var_ImplicitlyUnwrappedOptional8: Protocol_ObjC1!
var var_ImplicitlyUnwrappedOptional9: (Protocol_ObjC1 & Protocol_ObjC2)!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional1: Class_ObjC1!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional2: Protocol_ObjC1!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional3: Class_ObjC1.Type!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional4: Protocol_ObjC1.Type!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional5: AnyObject!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional6: AnyObject.Type!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional7: String!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional8: Protocol_ObjC1!
// CHECK-LABEL: @objc @_hasInitialValue var var_ImplicitlyUnwrappedOptional9: (Protocol_ObjC1 & Protocol_ObjC2)!
var var_Optional_fail1: PlainClass?
var var_Optional_fail2: PlainClass.Type?
var var_Optional_fail3: PlainClass!
var var_Optional_fail4: PlainStruct?
var var_Optional_fail5: PlainStruct.Type?
var var_Optional_fail6: PlainEnum?
var var_Optional_fail7: PlainEnum.Type?
var var_Optional_fail8: PlainProtocol?
var var_Optional_fail10: PlainProtocol?
var var_Optional_fail11: (PlainProtocol & Protocol_ObjC1)?
var var_Optional_fail12: Int?
var var_Optional_fail13: Bool?
var var_Optional_fail14: CBool?
var var_Optional_fail20: AnyObject??
var var_Optional_fail21: AnyObject.Type??
var var_Optional_fail22: ComparisonResult? // a non-bridged imported value type
var var_Optional_fail23: NSRange? // a bridged struct imported from C
// CHECK-NOT: @objc{{.*}}Optional_fail
// CHECK-LABEL: @objc var var_CFunctionPointer_1: @convention(c) () -> ()
var var_CFunctionPointer_1: @convention(c) () -> ()
// CHECK-LABEL: @objc var var_CFunctionPointer_invalid_1: Int
var var_CFunctionPointer_invalid_1: @convention(c) Int // expected-error {{@convention attribute only applies to function types}}
// CHECK-LABEL: {{^}} var var_CFunctionPointer_invalid_2: @convention(c) (PlainStruct) -> Int
var var_CFunctionPointer_invalid_2: @convention(c) (PlainStruct) -> Int // expected-error {{'(PlainStruct) -> Int' is not representable in Objective-C, so it cannot be used with '@convention(c)'}}
// <rdar://problem/20918869> Confusing diagnostic for @convention(c) throws
var var_CFunctionPointer_invalid_3 : @convention(c) (Int) throws -> Int // expected-error {{'(Int) throws -> Int' is not representable in Objective-C, so it cannot be used with '@convention(c)'}}
weak var var_Weak1: Class_ObjC1?
weak var var_Weak2: Protocol_ObjC1?
// <rdar://problem/16473062> weak and unowned variables of metatypes are rejected
//weak var var_Weak3: Class_ObjC1.Type?
//weak var var_Weak4: Protocol_ObjC1.Type?
weak var var_Weak5: AnyObject?
//weak var var_Weak6: AnyObject.Type?
weak var var_Weak7: Protocol_ObjC1?
weak var var_Weak8: (Protocol_ObjC1 & Protocol_ObjC2)?
// CHECK-LABEL: @objc @_hasInitialValue weak var var_Weak1: @sil_weak Class_ObjC1
// CHECK-LABEL: @objc @_hasInitialValue weak var var_Weak2: @sil_weak Protocol_ObjC1
// CHECK-LABEL: @objc @_hasInitialValue weak var var_Weak5: @sil_weak AnyObject
// CHECK-LABEL: @objc @_hasInitialValue weak var var_Weak7: @sil_weak Protocol_ObjC1
// CHECK-LABEL: @objc @_hasInitialValue weak var var_Weak8: @sil_weak (Protocol_ObjC1 & Protocol_ObjC2)?
weak var var_Weak_fail1: PlainClass?
weak var var_Weak_bad2: PlainStruct?
// expected-error@-1 {{'weak' may only be applied to class and class-bound protocol types, not 'PlainStruct'}}
weak var var_Weak_bad3: PlainEnum?
// expected-error@-1 {{'weak' may only be applied to class and class-bound protocol types, not 'PlainEnum'}}
weak var var_Weak_bad4: String?
// expected-error@-1 {{'weak' may only be applied to class and class-bound protocol types, not 'String'}}
// CHECK-NOT: @objc{{.*}}Weak_fail
unowned var var_Unowned1: Class_ObjC1
unowned var var_Unowned2: Protocol_ObjC1
// <rdar://problem/16473062> weak and unowned variables of metatypes are rejected
//unowned var var_Unowned3: Class_ObjC1.Type
//unowned var var_Unowned4: Protocol_ObjC1.Type
unowned var var_Unowned5: AnyObject
//unowned var var_Unowned6: AnyObject.Type
unowned var var_Unowned7: Protocol_ObjC1
unowned var var_Unowned8: Protocol_ObjC1 & Protocol_ObjC2
// CHECK-LABEL: @objc unowned var var_Unowned1: @sil_unowned Class_ObjC1
// CHECK-LABEL: @objc unowned var var_Unowned2: @sil_unowned Protocol_ObjC1
// CHECK-LABEL: @objc unowned var var_Unowned5: @sil_unowned AnyObject
// CHECK-LABEL: @objc unowned var var_Unowned7: @sil_unowned Protocol_ObjC1
// CHECK-LABEL: @objc unowned var var_Unowned8: @sil_unowned Protocol_ObjC1 & Protocol_ObjC2
unowned var var_Unowned_fail1: PlainClass
unowned var var_Unowned_bad2: PlainStruct
// expected-error@-1 {{'unowned' may only be applied to class and class-bound protocol types, not 'PlainStruct'}}
unowned var var_Unowned_bad3: PlainEnum
// expected-error@-1 {{'unowned' may only be applied to class and class-bound protocol types, not 'PlainEnum'}}
unowned var var_Unowned_bad4: String
// expected-error@-1 {{'unowned' may only be applied to class and class-bound protocol types, not 'String'}}
// CHECK-NOT: @objc{{.*}}Unowned_fail
var var_FunctionType1: () -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType1: () -> ()
var var_FunctionType2: (Int) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType2: (Int) -> ()
var var_FunctionType3: (Int) -> Int
// CHECK-LABEL: {{^}} @objc var var_FunctionType3: (Int) -> Int
var var_FunctionType4: (Int, Double) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType4: (Int, Double) -> ()
var var_FunctionType5: (String) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType5: (String) -> ()
var var_FunctionType6: () -> String
// CHECK-LABEL: {{^}} @objc var var_FunctionType6: () -> String
var var_FunctionType7: (PlainClass) -> ()
// CHECK-NOT: @objc var var_FunctionType7: (PlainClass) -> ()
var var_FunctionType8: () -> PlainClass
// CHECK-NOT: @objc var var_FunctionType8: () -> PlainClass
var var_FunctionType9: (PlainStruct) -> ()
// CHECK-LABEL: {{^}} var var_FunctionType9: (PlainStruct) -> ()
var var_FunctionType10: () -> PlainStruct
// CHECK-LABEL: {{^}} var var_FunctionType10: () -> PlainStruct
var var_FunctionType11: (PlainEnum) -> ()
// CHECK-LABEL: {{^}} var var_FunctionType11: (PlainEnum) -> ()
var var_FunctionType12: (PlainProtocol) -> ()
// CHECK-LABEL: {{^}} var var_FunctionType12: (PlainProtocol) -> ()
var var_FunctionType13: (Class_ObjC1) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType13: (Class_ObjC1) -> ()
var var_FunctionType14: (Protocol_Class1) -> ()
// CHECK-LABEL: {{^}} var var_FunctionType14: (Protocol_Class1) -> ()
var var_FunctionType15: (Protocol_ObjC1) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType15: (Protocol_ObjC1) -> ()
var var_FunctionType16: (AnyObject) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType16: (AnyObject) -> ()
var var_FunctionType17: (() -> ()) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType17: (() -> ()) -> ()
var var_FunctionType18: ((Int) -> (), Int) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType18: ((Int) -> (), Int) -> ()
var var_FunctionType19: ((String) -> (), Int) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionType19: ((String) -> (), Int) -> ()
var var_FunctionTypeReturn1: () -> () -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionTypeReturn1: () -> () -> ()
@objc var var_FunctionTypeReturn1_: () -> () -> () // no-error
var var_FunctionTypeReturn2: () -> (Int) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionTypeReturn2: () -> (Int) -> ()
@objc var var_FunctionTypeReturn2_: () -> (Int) -> () // no-error
var var_FunctionTypeReturn3: () -> () -> Int
// CHECK-LABEL: {{^}} @objc var var_FunctionTypeReturn3: () -> () -> Int
@objc var var_FunctionTypeReturn3_: () -> () -> Int // no-error
var var_FunctionTypeReturn4: () -> (String) -> ()
// CHECK-LABEL: {{^}} @objc var var_FunctionTypeReturn4: () -> (String) -> ()
@objc var var_FunctionTypeReturn4_: () -> (String) -> () // no-error
var var_FunctionTypeReturn5: () -> () -> String
// CHECK-LABEL: {{^}} @objc var var_FunctionTypeReturn5: () -> () -> String
@objc var var_FunctionTypeReturn5_: () -> () -> String // no-error
var var_BlockFunctionType1: @convention(block) () -> ()
// CHECK-LABEL: @objc var var_BlockFunctionType1: @convention(block) () -> ()
@objc var var_BlockFunctionType1_: @convention(block) () -> () // no-error
var var_ArrayType1: [AnyObject]
// CHECK-LABEL: {{^}} @objc var var_ArrayType1: [AnyObject]
@objc var var_ArrayType1_: [AnyObject] // no-error
var var_ArrayType2: [@convention(block) (AnyObject) -> AnyObject] // no-error
// CHECK-LABEL: {{^}} @objc var var_ArrayType2: [@convention(block) (AnyObject) -> AnyObject]
@objc var var_ArrayType2_: [@convention(block) (AnyObject) -> AnyObject] // no-error
var var_ArrayType3: [PlainStruct]
// CHECK-LABEL: {{^}} var var_ArrayType3: [PlainStruct]
@objc var var_ArrayType3_: [PlainStruct]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ArrayType4: [(AnyObject) -> AnyObject] // no-error
// CHECK-LABEL: {{^}} var var_ArrayType4: [(AnyObject) -> AnyObject]
@objc var var_ArrayType4_: [(AnyObject) -> AnyObject]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ArrayType5: [Protocol_ObjC1]
// CHECK-LABEL: {{^}} @objc var var_ArrayType5: [Protocol_ObjC1]
@objc var var_ArrayType5_: [Protocol_ObjC1] // no-error
var var_ArrayType6: [Class_ObjC1]
// CHECK-LABEL: {{^}} @objc var var_ArrayType6: [Class_ObjC1]
@objc var var_ArrayType6_: [Class_ObjC1] // no-error
var var_ArrayType7: [PlainClass]
// CHECK-LABEL: {{^}} var var_ArrayType7: [PlainClass]
@objc var var_ArrayType7_: [PlainClass]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ArrayType8: [PlainProtocol]
// CHECK-LABEL: {{^}} var var_ArrayType8: [PlainProtocol]
@objc var var_ArrayType8_: [PlainProtocol]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ArrayType9: [Protocol_ObjC1 & PlainProtocol]
// CHECK-LABEL: {{^}} var var_ArrayType9: [PlainProtocol & Protocol_ObjC1]
@objc var var_ArrayType9_: [Protocol_ObjC1 & PlainProtocol]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ArrayType10: [Protocol_ObjC1 & Protocol_ObjC2]
// CHECK-LABEL: {{^}} @objc var var_ArrayType10: [Protocol_ObjC1 & Protocol_ObjC2]
@objc var var_ArrayType10_: [Protocol_ObjC1 & Protocol_ObjC2]
// no-error
var var_ArrayType11: [Any]
// CHECK-LABEL: @objc var var_ArrayType11: [Any]
@objc var var_ArrayType11_: [Any]
var var_ArrayType13: [Any?]
// CHECK-LABEL: {{^}} var var_ArrayType13: [Any?]
@objc var var_ArrayType13_: [Any?]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ArrayType15: [AnyObject?]
// CHECK-LABEL: {{^}} var var_ArrayType15: [AnyObject?]
@objc var var_ArrayType15_: [AnyObject?]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
var var_ArrayType16: [[@convention(block) (AnyObject) -> AnyObject]] // no-error
// CHECK-LABEL: {{^}} @objc var var_ArrayType16: {{\[}}[@convention(block) (AnyObject) -> AnyObject]]
@objc var var_ArrayType16_: [[@convention(block) (AnyObject) -> AnyObject]] // no-error
var var_ArrayType17: [[(AnyObject) -> AnyObject]] // no-error
// CHECK-LABEL: {{^}} var var_ArrayType17: {{\[}}[(AnyObject) -> AnyObject]]
@objc var var_ArrayType17_: [[(AnyObject) -> AnyObject]]
// expected-error @-1{{property cannot be marked @objc because its type cannot be represented in Objective-C}}
}
@objc
class ObjCBase {}
class infer_instanceVar2<
GP_Unconstrained,
GP_PlainClass : PlainClass,
GP_PlainProtocol : PlainProtocol,
GP_Class_ObjC : Class_ObjC1,
GP_Protocol_Class : Protocol_Class1,
GP_Protocol_ObjC : Protocol_ObjC1> : ObjCBase {
// CHECK-LABEL: class infer_instanceVar2<{{.*}}> : ObjCBase where {{.*}} {
override init() {}
var var_GP_Unconstrained: GP_Unconstrained
// CHECK-LABEL: {{^}} var var_GP_Unconstrained: GP_Unconstrained
@objc var var_GP_Unconstrained_: GP_Unconstrained
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
var var_GP_PlainClass: GP_PlainClass
// CHECK-LABEL: {{^}} var var_GP_PlainClass: GP_PlainClass
@objc var var_GP_PlainClass_: GP_PlainClass
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
var var_GP_PlainProtocol: GP_PlainProtocol
// CHECK-LABEL: {{^}} var var_GP_PlainProtocol: GP_PlainProtocol
@objc var var_GP_PlainProtocol_: GP_PlainProtocol
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
var var_GP_Class_ObjC: GP_Class_ObjC
// CHECK-LABEL: {{^}} var var_GP_Class_ObjC: GP_Class_ObjC
@objc var var_GP_Class_ObjC_: GP_Class_ObjC
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
var var_GP_Protocol_Class: GP_Protocol_Class
// CHECK-LABEL: {{^}} var var_GP_Protocol_Class: GP_Protocol_Class
@objc var var_GP_Protocol_Class_: GP_Protocol_Class
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
var var_GP_Protocol_ObjC: GP_Protocol_ObjC
// CHECK-LABEL: {{^}} var var_GP_Protocol_ObjC: GP_Protocol_ObjC
@objc var var_GP_Protocol_ObjCa: GP_Protocol_ObjC
// expected-error@-1 {{property cannot be marked @objc because its type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
func func_GP_Unconstrained(a: GP_Unconstrained) {}
// CHECK-LABEL: {{^}} func func_GP_Unconstrained(a: GP_Unconstrained) {
@objc func func_GP_Unconstrained_(a: GP_Unconstrained) {}
// expected-error@-1 {{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
@objc func func_GP_Unconstrained_() -> GP_Unconstrained {}
// expected-error@-1 {{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
@objc func func_GP_Class_ObjC__() -> GP_Class_ObjC {}
// expected-error@-1 {{method cannot be marked @objc because its result type cannot be represented in Objective-C}}
// expected-note@-2 {{generic type parameters cannot be represented in Objective-C}}
}
class infer_instanceVar3 : Class_ObjC1 {
// CHECK-LABEL: @objc class infer_instanceVar3 : Class_ObjC1 {
var v1: Int = 0
// CHECK-LABEL: @objc @_hasInitialValue var v1: Int
}
@objc
protocol infer_instanceVar4 {
// CHECK-LABEL: @objc protocol infer_instanceVar4 {
var v1: Int { get }
// CHECK-LABEL: @objc var v1: Int { get }
}
// @!objc
class infer_instanceVar5 {
// CHECK-LABEL: {{^}}class infer_instanceVar5 {
@objc
var intstanceVar1: Int {
// CHECK: @objc var intstanceVar1: Int
get {}
// CHECK: @objc get {}
set {}
// CHECK: @objc set {}
}
}
@objc
class infer_staticVar1 {
// CHECK-LABEL: @objc class infer_staticVar1 {
class var staticVar1: Int = 42 // expected-error {{class stored properties not supported}}
// CHECK: @objc @_hasInitialValue class var staticVar1: Int
}
// @!objc
class infer_subscript1 {
// CHECK-LABEL: class infer_subscript1
@objc
subscript(i: Int) -> Int {
// CHECK: @objc subscript(i: Int) -> Int
get {}
// CHECK: @objc get {}
set {}
// CHECK: @objc set {}
}
}
@objc
protocol infer_throughConformanceProto1 {
// CHECK-LABEL: @objc protocol infer_throughConformanceProto1 {
func funcObjC1()
var varObjC1: Int { get }
var varObjC2: Int { get set }
// CHECK: @objc func funcObjC1()
// CHECK: @objc var varObjC1: Int { get }
// CHECK: @objc var varObjC2: Int { get set }
}
class infer_class1 : PlainClass {}
// CHECK-LABEL: {{^}}class infer_class1 : PlainClass {
class infer_class2 : Class_ObjC1 {}
// CHECK-LABEL: @objc class infer_class2 : Class_ObjC1 {
class infer_class3 : infer_class2 {}
// CHECK-LABEL: @objc class infer_class3 : infer_class2 {
class infer_class4 : Protocol_Class1 {}
// CHECK-LABEL: {{^}}class infer_class4 : Protocol_Class1 {
class infer_class5 : Protocol_ObjC1 {}
// CHECK-LABEL: {{^}}class infer_class5 : Protocol_ObjC1 {
//
// If a protocol conforms to an @objc protocol, this does not infer @objc on
// the protocol itself, or on the newly introduced requirements. Only the
// inherited @objc requirements get @objc.
//
// Same rule applies to classes.
//
protocol infer_protocol1 {
// CHECK-LABEL: {{^}}protocol infer_protocol1 {
func nonObjC1()
// CHECK: {{^}} func nonObjC1()
}
protocol infer_protocol2 : Protocol_Class1 {
// CHECK-LABEL: {{^}}protocol infer_protocol2 : Protocol_Class1 {
func nonObjC1()
// CHECK: {{^}} func nonObjC1()
}
protocol infer_protocol3 : Protocol_ObjC1 {
// CHECK-LABEL: {{^}}protocol infer_protocol3 : Protocol_ObjC1 {
func nonObjC1()
// CHECK: {{^}} func nonObjC1()
}
protocol infer_protocol4 : Protocol_Class1, Protocol_ObjC1 {
// CHECK-LABEL: {{^}}protocol infer_protocol4 : Protocol_Class1, Protocol_ObjC1 {
func nonObjC1()
// CHECK: {{^}} func nonObjC1()
}
protocol infer_protocol5 : Protocol_ObjC1, Protocol_Class1 {
// CHECK-LABEL: {{^}}protocol infer_protocol5 : Protocol_Class1, Protocol_ObjC1 {
func nonObjC1()
// CHECK: {{^}} func nonObjC1()
}
class C {
// Don't crash.
@objc func foo(x: Undeclared) {} // expected-error {{use of undeclared type 'Undeclared'}}
@IBAction func myAction(sender: Undeclared) {} // expected-error {{use of undeclared type 'Undeclared'}}
}
//===---
//===--- @IBOutlet implies @objc
//===---
class HasIBOutlet {
// CHECK-LABEL: {{^}}class HasIBOutlet {
init() {}
@IBOutlet weak var goodOutlet: Class_ObjC1!
// CHECK-LABEL: {{^}} @objc @IBOutlet @_implicitly_unwrapped_optional @_hasInitialValue weak var goodOutlet: @sil_weak Class_ObjC1!
@IBOutlet var badOutlet: PlainStruct
// expected-error@-1 {{@IBOutlet property cannot have non-object type 'PlainStruct'}} {{3-13=}}
// expected-error@-2 {{@IBOutlet property has non-optional type 'PlainStruct'}}
// expected-note@-3 {{add '?' to form the optional type 'PlainStruct?'}}
// expected-note@-4 {{add '!' to form an implicitly unwrapped optional}}
// CHECK-LABEL: {{^}} @IBOutlet var badOutlet: PlainStruct
}
//===---
//===--- @IBAction implies @objc
//===---
// CHECK-LABEL: {{^}}class HasIBAction {
class HasIBAction {
@IBAction func goodAction(_ sender: AnyObject?) { }
// CHECK: {{^}} @objc @IBAction func goodAction(_ sender: AnyObject?) {
@IBAction func badAction(_ sender: PlainStruct?) { }
// expected-error@-1{{argument to @IBAction method cannot have non-object type 'PlainStruct?'}}
}
//===---
//===--- @IBInspectable implies @objc
//===---
// CHECK-LABEL: {{^}}class HasIBInspectable {
class HasIBInspectable {
@IBInspectable var goodProperty: AnyObject?
// CHECK: {{^}} @objc @IBInspectable @_hasInitialValue var goodProperty: AnyObject?
}
//===---
//===--- @GKInspectable implies @objc
//===---
// CHECK-LABEL: {{^}}class HasGKInspectable {
class HasGKInspectable {
@GKInspectable var goodProperty: AnyObject?
// CHECK: {{^}} @objc @GKInspectable @_hasInitialValue var goodProperty: AnyObject?
}
//===---
//===--- @NSManaged implies @objc
//===---
class HasNSManaged {
// CHECK-LABEL: {{^}}class HasNSManaged {
init() {}
@NSManaged
var goodManaged: Class_ObjC1
// CHECK-LABEL: {{^}} @objc @NSManaged dynamic var goodManaged: Class_ObjC1 {
// CHECK-NEXT: {{^}} @objc get
// CHECK-NEXT: {{^}} @objc set
// CHECK-NEXT: {{^}} }
@NSManaged
var badManaged: PlainStruct
// expected-error@-1 {{property cannot be marked @NSManaged because its type cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
// CHECK-LABEL: {{^}} @NSManaged dynamic var badManaged: PlainStruct {
// CHECK-NEXT: {{^}} get
// CHECK-NEXT: {{^}} set
// CHECK-NEXT: {{^}} }
}
//===---
//===--- Pointer argument types
//===---
@objc class TakesCPointers {
// CHECK-LABEL: {{^}}@objc class TakesCPointers {
func constUnsafeMutablePointer(p: UnsafePointer<Int>) {}
// CHECK-LABEL: @objc func constUnsafeMutablePointer(p: UnsafePointer<Int>) {
func constUnsafeMutablePointerToAnyObject(p: UnsafePointer<AnyObject>) {}
// CHECK-LABEL: @objc func constUnsafeMutablePointerToAnyObject(p: UnsafePointer<AnyObject>) {
func constUnsafeMutablePointerToClass(p: UnsafePointer<TakesCPointers>) {}
// CHECK-LABEL: @objc func constUnsafeMutablePointerToClass(p: UnsafePointer<TakesCPointers>) {
func mutableUnsafeMutablePointer(p: UnsafeMutablePointer<Int>) {}
// CHECK-LABEL: @objc func mutableUnsafeMutablePointer(p: UnsafeMutablePointer<Int>) {
func mutableStrongUnsafeMutablePointerToAnyObject(p: UnsafeMutablePointer<AnyObject>) {}
// CHECK-LABEL: {{^}} @objc func mutableStrongUnsafeMutablePointerToAnyObject(p: UnsafeMutablePointer<AnyObject>) {
func mutableAutoreleasingUnsafeMutablePointerToAnyObject(p: AutoreleasingUnsafeMutablePointer<AnyObject>) {}
// CHECK-LABEL: {{^}} @objc func mutableAutoreleasingUnsafeMutablePointerToAnyObject(p: AutoreleasingUnsafeMutablePointer<AnyObject>) {
}
// @objc with nullary names
@objc(NSObjC2)
class Class_ObjC2 {
// CHECK-LABEL: @objc(NSObjC2) class Class_ObjC2
@objc(initWithMalice)
init(foo: ()) { }
@objc(initWithIntent)
init(bar _: ()) { }
@objc(initForMurder)
init() { }
@objc(isFoo)
func foo() -> Bool {}
// CHECK-LABEL: @objc(isFoo) func foo() -> Bool {
}
@objc() // expected-error{{expected name within parentheses of @objc attribute}}
class Class_ObjC3 {
}
// @objc with selector names
extension PlainClass {
// CHECK-LABEL: @objc(setFoo:) dynamic func
@objc(setFoo:)
func foo(b: Bool) { }
// CHECK-LABEL: @objc(setWithRed:green:blue:alpha:) dynamic func set
@objc(setWithRed:green:blue:alpha:)
func set(_: Float, green: Float, blue: Float, alpha: Float) { }
// CHECK-LABEL: @objc(createWithRed:green:blue:alpha:) dynamic class func createWith
@objc(createWithRed:green blue:alpha)
class func createWithRed(_: Float, green: Float, blue: Float, alpha: Float) { }
// expected-error@-2{{missing ':' after selector piece in @objc attribute}}{{28-28=:}}
// expected-error@-3{{missing ':' after selector piece in @objc attribute}}{{39-39=:}}
// CHECK-LABEL: @objc(::) dynamic func badlyNamed
@objc(::)
func badlyNamed(_: Int, y: Int) {}
}
@objc(Class:) // expected-error{{'@objc' class must have a simple name}}{{12-13=}}
class BadClass1 { }
@objc(Protocol:) // expected-error{{'@objc' protocol must have a simple name}}{{15-16=}}
protocol BadProto1 { }
@objc(Enum:) // expected-error{{'@objc' enum must have a simple name}}{{11-12=}}
enum BadEnum1: Int { case X }
@objc
enum BadEnum2: Int {
@objc(X:) // expected-error{{'@objc' enum case must have a simple name}}{{10-11=}}
case X
}
class BadClass2 {
@objc(realDealloc) // expected-error{{'@objc' deinitializer cannot have a name}}
deinit { }
@objc(badprop:foo:wibble:) // expected-error{{'@objc' property must have a simple name}}{{16-28=}}
var badprop: Int = 5
@objc(foo) // expected-error{{'@objc' subscript cannot have a name; did you mean to put the name on the getter or setter?}}
subscript (i: Int) -> Int {
get {
return i
}
}
@objc(foo) // expected-error{{'@objc' method name provides names for 0 arguments, but method has one parameter}}
func noArgNamesOneParam(x: Int) { }
@objc(foo) // expected-error{{'@objc' method name provides names for 0 arguments, but method has one parameter}}
func noArgNamesOneParam2(_: Int) { }
@objc(foo) // expected-error{{'@objc' method name provides names for 0 arguments, but method has 2 parameters}}
func noArgNamesTwoParams(_: Int, y: Int) { }
@objc(foo:) // expected-error{{'@objc' method name provides one argument name, but method has 2 parameters}}
func oneArgNameTwoParams(_: Int, y: Int) { }
@objc(foo:) // expected-error{{'@objc' method name provides one argument name, but method has 0 parameters}}
func oneArgNameNoParams() { }
@objc(foo:) // expected-error{{'@objc' initializer name provides one argument name, but initializer has 0 parameters}}
init() { }
var _prop = 5
@objc var prop: Int {
@objc(property) get { return _prop }
@objc(setProperty:) set { _prop = newValue }
}
var prop2: Int {
@objc(property) get { return _prop } // expected-error{{'@objc' getter for non-'@objc' property}}
@objc(setProperty:) set { _prop = newValue } // expected-error{{'@objc' setter for non-'@objc' property}}
}
var prop3: Int {
@objc(setProperty:) didSet { } // expected-error{{observing accessors are not allowed to be marked @objc}} {{5-25=}}
}
@objc
subscript (c: Class_ObjC1) -> Class_ObjC1 {
@objc(getAtClass:) get {
return c
}
@objc(setAtClass:class:) set {
}
}
}
// Swift overrides that aren't also @objc overrides.
class Super {
@objc(renamedFoo)
var foo: Int { get { return 3 } } // expected-note 2{{overridden declaration is here}}
@objc func process(i: Int) -> Int { } // expected-note {{overriding '@objc' method 'process(i:)' here}}
}
class Sub1 : Super {
@objc(foo) // expected-error{{Objective-C property has a different name from the property it overrides ('foo' vs. 'renamedFoo')}}{{9-12=renamedFoo}}
override var foo: Int { get { return 5 } }
override func process(i: Int?) -> Int { } // expected-error{{method cannot be an @objc override because the type of the parameter cannot be represented in Objective-C}}
}
class Sub2 : Super {
@objc
override var foo: Int { get { return 5 } }
}
class Sub3 : Super {
override var foo: Int { get { return 5 } }
}
class Sub4 : Super {
@objc(renamedFoo)
override var foo: Int { get { return 5 } }
}
class Sub5 : Super {
@objc(wrongFoo) // expected-error{{Objective-C property has a different name from the property it overrides ('wrongFoo' vs. 'renamedFoo')}} {{9-17=renamedFoo}}
override var foo: Int { get { return 5 } }
}
enum NotObjCEnum { case X }
struct NotObjCStruct {}
// Closure arguments can only be @objc if their parameters and returns are.
// CHECK-LABEL: @objc class ClosureArguments
@objc class ClosureArguments {
// CHECK: @objc func foo
@objc func foo(f: (Int) -> ()) {}
// CHECK: @objc func bar
@objc func bar(f: (NotObjCEnum) -> NotObjCStruct) {} // expected-error{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}} expected-note{{function types cannot be represented in Objective-C unless their parameters and returns can be}}
// CHECK: @objc func bas
@objc func bas(f: (NotObjCEnum) -> ()) {} // expected-error{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}} expected-note{{function types cannot be represented in Objective-C unless their parameters and returns can be}}
// CHECK: @objc func zim
@objc func zim(f: () -> NotObjCStruct) {} // expected-error{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}} expected-note{{function types cannot be represented in Objective-C unless their parameters and returns can be}}
// CHECK: @objc func zang
@objc func zang(f: (NotObjCEnum, NotObjCStruct) -> ()) {} // expected-error{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}} expected-note{{function types cannot be represented in Objective-C unless their parameters and returns can be}}
@objc func zangZang(f: (Int...) -> ()) {} // expected-error{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}} expected-note{{function types cannot be represented in Objective-C unless their parameters and returns can be}}
// CHECK: @objc func fooImplicit
func fooImplicit(f: (Int) -> ()) {}
// CHECK: {{^}} func barImplicit
func barImplicit(f: (NotObjCEnum) -> NotObjCStruct) {}
// CHECK: {{^}} func basImplicit
func basImplicit(f: (NotObjCEnum) -> ()) {}
// CHECK: {{^}} func zimImplicit
func zimImplicit(f: () -> NotObjCStruct) {}
// CHECK: {{^}} func zangImplicit
func zangImplicit(f: (NotObjCEnum, NotObjCStruct) -> ()) {}
// CHECK: {{^}} func zangZangImplicit
func zangZangImplicit(f: (Int...) -> ()) {}
}
typealias GoodBlock = @convention(block) (Int) -> ()
typealias BadBlock = @convention(block) (NotObjCEnum) -> () // expected-error{{'(NotObjCEnum) -> ()' is not representable in Objective-C, so it cannot be used with '@convention(block)'}}
@objc class AccessControl {
// CHECK: @objc func foo
func foo() {}
// CHECK: {{^}} private func bar
private func bar() {}
// CHECK: @objc private func baz
@objc private func baz() {}
}
//===--- Ban @objc +load methods
class Load1 {
// Okay: not @objc
class func load() { }
class func alloc() {}
class func allocWithZone(_: Int) {}
class func initialize() {}
}
@objc class Load2 {
class func load() { } // expected-error{{method 'load()' defines Objective-C class method 'load', which is not permitted by Swift}}
class func alloc() {} // expected-error{{method 'alloc()' defines Objective-C class method 'alloc', which is not permitted by Swift}}
class func allocWithZone(_: Int) {} // expected-error{{method 'allocWithZone' defines Objective-C class method 'allocWithZone:', which is not permitted by Swift}}
class func initialize() {} // expected-error{{method 'initialize()' defines Objective-C class method 'initialize', which is not permitted by Swift}}
}
@objc class Load3 {
class var load: Load3 {
get { return Load3() } // expected-error{{getter for 'load' defines Objective-C class method 'load', which is not permitted by Swift}}
set { }
}
@objc(alloc) class var prop: Int { return 0 } // expected-error{{getter for 'prop' defines Objective-C class method 'alloc', which is not permitted by Swift}}
@objc(allocWithZone:) class func fooWithZone(_: Int) {} // expected-error{{method 'fooWithZone' defines Objective-C class method 'allocWithZone:', which is not permitted by Swift}}
@objc(initialize) class func barnitialize() {} // expected-error{{method 'barnitialize()' defines Objective-C class method 'initialize', which is not permitted by Swift}}
}
// Members of protocol extensions cannot be @objc
extension PlainProtocol {
@objc var property: Int { return 5 } // expected-error{{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
@objc subscript(x: Int) -> Class_ObjC1 { return Class_ObjC1() } // expected-error{{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
@objc func fun() { } // expected-error{{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
}
extension Protocol_ObjC1 {
@objc var property: Int { return 5 } // expected-error{{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
@objc subscript(x: Int) -> Class_ObjC1 { return Class_ObjC1() } // expected-error{{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
@objc func fun() { } // expected-error{{@objc can only be used with members of classes, @objc protocols, and concrete extensions of classes}}
}
extension Protocol_ObjC1 {
// Don't infer @objc for extensions of @objc protocols.
// CHECK: {{^}} var propertyOK: Int
var propertyOK: Int { return 5 }
}
//===---
//===--- Error handling
//===---
class ClassThrows1 {
// CHECK: @objc func methodReturnsVoid() throws
@objc func methodReturnsVoid() throws { }
// CHECK: @objc func methodReturnsObjCClass() throws -> Class_ObjC1
@objc func methodReturnsObjCClass() throws -> Class_ObjC1 {
return Class_ObjC1()
}
// CHECK: @objc func methodReturnsBridged() throws -> String
@objc func methodReturnsBridged() throws -> String { return String() }
// CHECK: @objc func methodReturnsArray() throws -> [String]
@objc func methodReturnsArray() throws -> [String] { return [String]() }
// CHECK: @objc init(degrees: Double) throws
@objc init(degrees: Double) throws { }
// Errors
@objc func methodReturnsOptionalObjCClass() throws -> Class_ObjC1? { return nil } // expected-error{{throwing method cannot be marked @objc because it returns a value of optional type 'Class_ObjC1?'; 'nil' indicates failure to Objective-C}}
@objc func methodReturnsOptionalArray() throws -> [String]? { return nil } // expected-error{{throwing method cannot be marked @objc because it returns a value of optional type '[String]?'; 'nil' indicates failure to Objective-C}}
@objc func methodReturnsInt() throws -> Int { return 0 } // expected-error{{throwing method cannot be marked @objc because it returns a value of type 'Int'; return 'Void' or a type that bridges to an Objective-C class}}
@objc func methodAcceptsThrowingFunc(fn: (String) throws -> Int) { }
// expected-error@-1{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2{{throwing function types cannot be represented in Objective-C}}
@objc init?(radians: Double) throws { } // expected-error{{a failable and throwing initializer cannot be marked @objc because 'nil' indicates failure to Objective-C}}
@objc init!(string: String) throws { } // expected-error{{a failable and throwing initializer cannot be marked @objc because 'nil' indicates failure to Objective-C}}
@objc func fooWithErrorEnum1(x: ErrorEnum) {}
// expected-error@-1{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2{{non-'@objc' enums cannot be represented in Objective-C}}
// CHECK: {{^}} func fooWithErrorEnum2(x: ErrorEnum)
func fooWithErrorEnum2(x: ErrorEnum) {}
@objc func fooWithErrorProtocolComposition1(x: Error & Protocol_ObjC1) { }
// expected-error@-1{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2{{protocol-constrained type containing 'Error' cannot be represented in Objective-C}}
// CHECK: {{^}} func fooWithErrorProtocolComposition2(x: Error & Protocol_ObjC1)
func fooWithErrorProtocolComposition2(x: Error & Protocol_ObjC1) { }
}
// CHECK-DUMP-LABEL: class_decl{{.*}}"ImplicitClassThrows1"
@objc class ImplicitClassThrows1 {
// CHECK: @objc func methodReturnsVoid() throws
// CHECK-DUMP: func_decl{{.*}}"methodReturnsVoid()"{{.*}}foreign_error=ZeroResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool
func methodReturnsVoid() throws { }
// CHECK: @objc func methodReturnsObjCClass() throws -> Class_ObjC1
// CHECK-DUMP: func_decl{{.*}}"methodReturnsObjCClass()" {{.*}}foreign_error=NilResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>
func methodReturnsObjCClass() throws -> Class_ObjC1 {
return Class_ObjC1()
}
// CHECK: @objc func methodReturnsBridged() throws -> String
func methodReturnsBridged() throws -> String { return String() }
// CHECK: @objc func methodReturnsArray() throws -> [String]
func methodReturnsArray() throws -> [String] { return [String]() }
// CHECK: {{^}} func methodReturnsOptionalObjCClass() throws -> Class_ObjC1?
func methodReturnsOptionalObjCClass() throws -> Class_ObjC1? { return nil }
// CHECK: @objc func methodWithTrailingClosures(_ s: String, fn1: @escaping ((Int) -> Int), fn2: @escaping (Int) -> Int, fn3: @escaping (Int) -> Int)
// CHECK-DUMP: func_decl{{.*}}"methodWithTrailingClosures(_:fn1:fn2:fn3:)"{{.*}}foreign_error=ZeroResult,unowned,param=1,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool
func methodWithTrailingClosures(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int, fn3: @escaping (Int) -> Int) throws { }
// CHECK: @objc init(degrees: Double) throws
// CHECK-DUMP: constructor_decl{{.*}}"init(degrees:)"{{.*}}foreign_error=NilResult,unowned,param=1,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>
init(degrees: Double) throws { }
// CHECK: {{^}} func methodReturnsBridgedValueType() throws -> NSRange
func methodReturnsBridgedValueType() throws -> NSRange { return NSRange() }
@objc func methodReturnsBridgedValueType2() throws -> NSRange {
return NSRange()
}
// expected-error@-3{{throwing method cannot be marked @objc because it returns a value of type 'NSRange' (aka '_NSRange'); return 'Void' or a type that bridges to an Objective-C class}}
// CHECK: {{^}} @objc func methodReturnsError() throws -> Error
func methodReturnsError() throws -> Error { return ErrorEnum.failed }
// CHECK: @objc func methodReturnStaticBridged() throws -> ((Int) -> (Int) -> Int)
func methodReturnStaticBridged() throws -> ((Int) -> (Int) -> Int) {
func add(x: Int) -> (Int) -> Int {
return { x + $0 }
}
}
}
// CHECK-DUMP-LABEL: class_decl{{.*}}"SubclassImplicitClassThrows1"
@objc class SubclassImplicitClassThrows1 : ImplicitClassThrows1 {
// CHECK: @objc override func methodWithTrailingClosures(_ s: String, fn1: @escaping ((Int) -> Int), fn2: @escaping ((Int) -> Int), fn3: @escaping ((Int) -> Int))
// CHECK-DUMP: func_decl{{.*}}"methodWithTrailingClosures(_:fn1:fn2:fn3:)"{{.*}}foreign_error=ZeroResult,unowned,param=1,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool
override func methodWithTrailingClosures(_ s: String, fn1: (@escaping (Int) -> Int), fn2: (@escaping (Int) -> Int), fn3: (@escaping (Int) -> Int)) throws { }
}
class ThrowsRedecl1 {
@objc func method1(_ x: Int, error: Class_ObjC1) { } // expected-note{{declared here}}
@objc func method1(_ x: Int) throws { } // expected-error{{with Objective-C selector 'method1:error:'}}
@objc func method2AndReturnError(_ x: Int) { } // expected-note{{declared here}}
@objc func method2() throws { } // expected-error{{with Objective-C selector 'method2AndReturnError:'}}
@objc func method3(_ x: Int, error: Int, closure: @escaping (Int) -> Int) { } // expected-note{{declared here}}
@objc func method3(_ x: Int, closure: (Int) -> Int) throws { } // expected-error{{with Objective-C selector 'method3:error:closure:'}}
@objc(initAndReturnError:) func initMethod1(error: Int) { } // expected-note{{declared here}}
@objc init() throws { } // expected-error{{with Objective-C selector 'initAndReturnError:'}}
@objc(initWithString:error:) func initMethod2(string: String, error: Int) { } // expected-note{{declared here}}
@objc init(string: String) throws { } // expected-error{{with Objective-C selector 'initWithString:error:'}}
@objc(initAndReturnError:fn:) func initMethod3(error: Int, fn: @escaping (Int) -> Int) { } // expected-note{{declared here}}
@objc init(fn: (Int) -> Int) throws { } // expected-error{{with Objective-C selector 'initAndReturnError:fn:'}}
}
class ThrowsObjCName {
@objc(method4:closure:error:) func method4(x: Int, closure: @escaping (Int) -> Int) throws { }
@objc(method5AndReturnError:x:closure:) func method5(x: Int, closure: @escaping (Int) -> Int) throws { }
@objc(method6) func method6() throws { } // expected-error{{@objc' method name provides names for 0 arguments, but method has one parameter (the error parameter)}}
@objc(method7) func method7(x: Int) throws { } // expected-error{{@objc' method name provides names for 0 arguments, but method has 2 parameters (including the error parameter)}}
// CHECK-DUMP: func_decl{{.*}}"method8(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=2,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool
@objc(method8:fn1:error:fn2:)
func method8(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
// CHECK-DUMP: func_decl{{.*}}"method9(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool
@objc(method9AndReturnError:s:fn1:fn2:)
func method9(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
}
class SubclassThrowsObjCName : ThrowsObjCName {
// CHECK-DUMP: func_decl{{.*}}"method8(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=2,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool
override func method8(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
// CHECK-DUMP: func_decl{{.*}}"method9(_:fn1:fn2:)"{{.*}}foreign_error=ZeroResult,unowned,param=0,paramtype=Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>,resulttype=ObjCBool
override func method9(_ s: String, fn1: (@escaping (Int) -> Int), fn2: @escaping (Int) -> Int) throws { }
}
@objc protocol ProtocolThrowsObjCName {
@objc optional func doThing(_ x: String) throws -> String // expected-note{{requirement 'doThing' declared here}}
}
class ConformsToProtocolThrowsObjCName1 : ProtocolThrowsObjCName {
@objc func doThing(_ x: String) throws -> String { return x } // okay
}
class ConformsToProtocolThrowsObjCName2 : ProtocolThrowsObjCName {
@objc func doThing(_ x: Int) throws -> String { return "" }
// expected-warning@-1{{instance method 'doThing' nearly matches optional requirement 'doThing' of protocol 'ProtocolThrowsObjCName'}}
// expected-note@-2{{move 'doThing' to an extension to silence this warning}}
// expected-note@-3{{make 'doThing' private to silence this warning}}{{9-9=private }}
// expected-note@-4{{candidate has non-matching type '(Int) throws -> String'}}
}
@objc class DictionaryTest {
// CHECK-LABEL: @objc func func_dictionary1a(x: Dictionary<ObjC_Class1, ObjC_Class1>)
func func_dictionary1a(x: Dictionary<ObjC_Class1, ObjC_Class1>) { }
// CHECK-LABEL: @objc func func_dictionary1b(x: Dictionary<ObjC_Class1, ObjC_Class1>)
@objc func func_dictionary1b(x: Dictionary<ObjC_Class1, ObjC_Class1>) { }
func func_dictionary2a(x: Dictionary<String, Int>) { }
@objc func func_dictionary2b(x: Dictionary<String, Int>) { }
}
@objc extension PlainClass {
// CHECK-LABEL: @objc final func objc_ext_objc_okay(_: Int) {
final func objc_ext_objc_okay(_: Int) { }
final func objc_ext_objc_not_okay(_: PlainStruct) { }
// expected-error@-1{{method cannot be in an @objc extension of a class (without @nonobjc) because the type of the parameter cannot be represented in Objective-C}}
// expected-note@-2 {{Swift structs cannot be represented in Objective-C}}
// CHECK-LABEL: {{^}} @nonobjc final func objc_ext_objc_explicit_nonobjc(_: PlainStruct) {
@nonobjc final func objc_ext_objc_explicit_nonobjc(_: PlainStruct) { }
}
@objc class ObjC_Class1 : Hashable {
func hash(into hasher: inout Hasher) {}
}
func ==(lhs: ObjC_Class1, rhs: ObjC_Class1) -> Bool {
return true
}
// CHECK-LABEL: @objc class OperatorInClass
@objc class OperatorInClass {
// CHECK: {{^}} static func == (lhs: OperatorInClass, rhs: OperatorInClass) -> Bool
static func ==(lhs: OperatorInClass, rhs: OperatorInClass) -> Bool {
return true
}
// CHECK: {{^}} @objc static func + (lhs: OperatorInClass, rhs: OperatorInClass) -> OperatorInClass
@objc static func +(lhs: OperatorInClass, rhs: OperatorInClass) -> OperatorInClass { // expected-error {{operator methods cannot be declared @objc}}
return lhs
}
} // CHECK: {{^}$}}
@objc protocol OperatorInProtocol {
static func +(lhs: Self, rhs: Self) -> Self // expected-error {{@objc protocols must not have operator requirements}}
}
class AdoptsOperatorInProtocol : OperatorInProtocol {
static func +(lhs: AdoptsOperatorInProtocol, rhs: AdoptsOperatorInProtocol) -> Self {}
// expected-error@-1 {{operator methods cannot be declared @objc}}
}
//===--- @objc inference for witnesses
@objc protocol InferFromProtocol {
@objc(inferFromProtoMethod1:)
optional func method1(value: Int)
}
// Infer when in the same declaration context.
// CHECK-LABEL: ClassInfersFromProtocol1
class ClassInfersFromProtocol1 : InferFromProtocol{
// CHECK: {{^}} @objc func method1(value: Int)
func method1(value: Int) { }
}
// Infer when in a different declaration context of the same class.
// CHECK-LABEL: ClassInfersFromProtocol2a
class ClassInfersFromProtocol2a {
// CHECK: {{^}} @objc func method1(value: Int)
func method1(value: Int) { }
}
extension ClassInfersFromProtocol2a : InferFromProtocol { }
// Infer when in a different declaration context of the same class.
class ClassInfersFromProtocol2b : InferFromProtocol { }
// CHECK-LABEL: ClassInfersFromProtocol2b
extension ClassInfersFromProtocol2b {
// CHECK: {{^}} @objc dynamic func method1(value: Int)
func method1(value: Int) { }
}
// Don't infer when there is a signature mismatch.
// CHECK-LABEL: ClassInfersFromProtocol3
class ClassInfersFromProtocol3 : InferFromProtocol {
}
extension ClassInfersFromProtocol3 {
// CHECK: {{^}} func method1(value: String)
func method1(value: String) { }
}
// Inference for subclasses.
class SuperclassImplementsProtocol : InferFromProtocol { }
class SubclassInfersFromProtocol1 : SuperclassImplementsProtocol {
// CHECK: {{^}} @objc func method1(value: Int)
func method1(value: Int) { }
}
class SubclassInfersFromProtocol2 : SuperclassImplementsProtocol {
}
extension SubclassInfersFromProtocol2 {
// CHECK: {{^}} @objc dynamic func method1(value: Int)
func method1(value: Int) { }
}
@objc class NeverReturningMethod {
@objc func doesNotReturn() -> Never {}
}
// SR-5025
class User: NSObject {
}
@objc extension User {
var name: String {
get {
return "No name"
}
set {
// Nothing
}
}
var other: String {
unsafeAddress { // expected-error{{addressors are not allowed to be marked @objc}}
}
}
}
// 'dynamic' methods cannot be @inlinable.
class BadClass {
@inlinable @objc dynamic func badMethod1() {}
// expected-error@-1 {{'@inlinable' attribute cannot be applied to 'dynamic' declarations}}
}
@objc
protocol ObjCProtocolWithWeakProperty {
weak var weakProp: AnyObject? { get set } // okay
}
@objc
protocol ObjCProtocolWithUnownedProperty {
unowned var unownedProp: AnyObject { get set } // okay
}
// rdar://problem/46699152: errors about read/modify accessors being implicitly
// marked @objc.
@objc class MyObjCClass: NSObject {}
@objc
extension MyObjCClass {
@objc
static var objCVarInObjCExtension: Bool {
get {
return true
}
set {}
}
// CHECK: {{^}} @objc private dynamic func stillExposedToObjCDespiteBeingPrivate()
private func stillExposedToObjCDespiteBeingPrivate() {}
}
@objc private extension MyObjCClass {
// CHECK: {{^}} @objc dynamic func alsoExposedToObjCDespiteBeingPrivate()
func alsoExposedToObjCDespiteBeingPrivate() {}
}
@objcMembers class VeryObjCClass: NSObject {
// CHECK: {{^}} private func notExposedToObjC()
private func notExposedToObjC() {}
}
// SR-9035
class SR_9035_C {}
@objc protocol SR_9035_P {
func throwingMethod1() throws -> Unmanaged<CFArray> // Ok
func throwingMethod2() throws -> Unmanaged<SR_9035_C> // expected-error {{method cannot be a member of an @objc protocol because its result type cannot be represented in Objective-C}}
// expected-note@-1 {{inferring '@objc' because the declaration is a member of an '@objc' protocol}}
}
| 40.509754 | 350 | 0.716421 |
71498c464458230545a964437398e1dc8c003e68 | 5,369 | //
// NSError+Ext.swift
// Beast
//
// Created by Kostiantyn Girych on 10/20/16.
// Copyright © 2016 hcyrig. All rights reserved.
//
import CFNetwork
import Foundation
public extension NSError {
public func errorDomainRepresentation() -> ErrorProtocol? {
switch domain {
case NSCocoaErrorDomain:
return CocoaDomainError(code: code)
case NSPOSIXErrorDomain:
return CocoaDomainError(code: code)
case NSOSStatusErrorDomain:
return CocoaDomainError(code: code)
case NSMachErrorDomain:
return CocoaDomainError(code: code)
case NSURLErrorDomain:
return URLDomainError(code: code)
default:
return nil
}
}
public func errorHTTPRepresentation(code:Int) -> ErrorProtocol? {
return ResponseCodeError(code: code)
}
// MARK: - return int type for http code from a response represantation
public func errorCodeHTTPURLResponseObjectKey() -> Int? {
if let response = self.userInfo[BError.HTTPURLResponseObjectKey.rawValue] {
return (response as AnyObject).statusCode
}
return nil
}
public func errorDescrioption() -> String? {
if let errorStr = userInfo[NSLocalizedFailureReasonErrorKey] {
return errorStr as? String
}
if let response = userInfo[BError.HTTPURLResponseObjectKey.rawValue] {
return "\(errorCodeHTTPURLResponseObjectKey())" + " " + HTTPURLResponse.localizedString(forStatusCode:(response as AnyObject).statusCode)
}
return localizedDescription
}
}
// MARK: - Parse error representation
public extension NSError {
public func isPoorConectionError() -> Bool {
let codes: Array = [ CFNetworkErrors.cfurlErrorCancelled.rawValue,
CFNetworkErrors.cfurlErrorTimedOut.rawValue,
CFNetworkErrors.cfurlErrorCancelled.rawValue,
CFNetworkErrors.cfurlErrorCannotFindHost.rawValue,
CFNetworkErrors.cfurlErrorCannotConnectToHost.rawValue,
CFNetworkErrors.cfurlErrorNetworkConnectionLost.rawValue,
CFNetworkErrors.cfurlErrorDNSLookupFailed.rawValue,
CFNetworkErrors.cfurlErrorResourceUnavailable.rawValue,
CFNetworkErrors.cfurlErrorNotConnectedToInternet.rawValue ]
if codes.contains(Int32(self.code)) {
return true
}
return false
}
}
// MARK: - Parse error JSON representation
public extension NSError {
public static func processResponseError(JSONObj:AnyObject) -> NSError? {
var error:NSError?
if let errorDict = JSONObj["error"] as? [String: AnyObject] {
let errorCode = errorDict["code"] as! NSNumber
let errorMessage = errorDict["message"] as! String
let errorDescription = "\(errorCode) \(errorMessage)"
error = NSError(domain: BError.Domain.rawValue,
code: -1,
userInfo: [NSLocalizedFailureReasonErrorKey: errorDescription])
}
else if let errorsDict = JSONObj["errors"] as? [String: AnyObject] {
var errorMessage: String?
if errorsDict["errors"] != nil &&
(errorsDict["errors"] as? NSArray) != nil {
errorMessage = errorsDict["errors"]?.firstObject as! String?
}
if errorMessage == nil {
errorMessage = NSLocalizedString("Unexpected error", comment: "")
}
error = NSError(domain: BError.Domain.rawValue,
code: -1,
userInfo: [NSLocalizedFailureReasonErrorKey: errorMessage!])
}
else if let errorsArray = JSONObj["errors"] as? [AnyObject] {
var errorMessage = ""
for string in errorsArray {
if let str = string as? NSString {
errorMessage += str as String
}
}
if errorMessage.characters.count == 0 {
errorMessage = NSLocalizedString("Unexpected error", comment: "")
}
error = NSError(domain: BError.Domain.rawValue,
code: -1,
userInfo: [NSLocalizedFailureReasonErrorKey: errorMessage])
}
else if let code = JSONObj["code"] as? NSNumber {
if code.intValue > 400 {
if let errorMessage = JSONObj["message"] {
error = NSError(domain: BError.Domain.rawValue,
code: code.intValue,
userInfo: [NSLocalizedFailureReasonErrorKey: "\(errorMessage)"])
}
}
else if let errorMessage = JSONObj["message"] as? NSString {
error = NSError(domain: BError.Domain.rawValue,
code: -1,
userInfo: [NSLocalizedFailureReasonErrorKey: errorMessage])
}
}
return error
}
}
| 36.52381 | 149 | 0.560067 |
291ef4fa2e728050d6f0e7ba9e63bb23b40045a0 | 235 | // Distributed under the terms of the MIT license
// Test case submitted to project by https://github.com/practicalswift (practicalswift)
// Test case found by fuzzing
if true{
class A{
enum B
struct B<T where B:a{
func j
}
protocol B | 21.363636 | 87 | 0.753191 |
878966f5dd65b07d57a2014319847271e7fb6d9a | 8,247 | //
// This is a generated file, do not edit!
// Generated by R.swift, see https://github.com/mac-cain13/R.swift
//
import Foundation
import Rswift
import UIKit
/// This `R` struct is generated and contains references to static resources.
struct R: Rswift.Validatable {
fileprivate static let applicationLocale = hostingBundle.preferredLocalizations.first.flatMap(Locale.init) ?? Locale.current
fileprivate static let hostingBundle = Bundle(for: R.Class.self)
static func validate() throws {
try intern.validate()
}
/// This `R.color` struct is generated, and contains static references to 0 colors.
struct color {
fileprivate init() {}
}
/// This `R.file` struct is generated, and contains static references to 1 files.
struct file {
/// Resource file `GoogleService-Info.plist`.
static let googleServiceInfoPlist = Rswift.FileResource(bundle: R.hostingBundle, name: "GoogleService-Info", pathExtension: "plist")
/// `bundle.url(forResource: "GoogleService-Info", withExtension: "plist")`
static func googleServiceInfoPlist(_: Void = ()) -> Foundation.URL? {
let fileResource = R.file.googleServiceInfoPlist
return fileResource.bundle.url(forResource: fileResource)
}
fileprivate init() {}
}
/// This `R.font` struct is generated, and contains static references to 0 fonts.
struct font {
fileprivate init() {}
}
/// This `R.image` struct is generated, and contains static references to 4 images.
struct image {
/// Image `icons8-gift-64`.
static let icons8Gift64 = Rswift.ImageResource(bundle: R.hostingBundle, name: "icons8-gift-64")
/// Image `icons8-herbal-medicine-64`.
static let icons8HerbalMedicine64 = Rswift.ImageResource(bundle: R.hostingBundle, name: "icons8-herbal-medicine-64")
/// Image `icons8-treatment-64`.
static let icons8Treatment64 = Rswift.ImageResource(bundle: R.hostingBundle, name: "icons8-treatment-64")
/// Image `storeSample`.
static let storeSample = Rswift.ImageResource(bundle: R.hostingBundle, name: "storeSample")
/// `UIImage(named: "icons8-gift-64", bundle: ..., traitCollection: ...)`
static func icons8Gift64(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.icons8Gift64, compatibleWith: traitCollection)
}
/// `UIImage(named: "icons8-herbal-medicine-64", bundle: ..., traitCollection: ...)`
static func icons8HerbalMedicine64(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.icons8HerbalMedicine64, compatibleWith: traitCollection)
}
/// `UIImage(named: "icons8-treatment-64", bundle: ..., traitCollection: ...)`
static func icons8Treatment64(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.icons8Treatment64, compatibleWith: traitCollection)
}
/// `UIImage(named: "storeSample", bundle: ..., traitCollection: ...)`
static func storeSample(compatibleWith traitCollection: UIKit.UITraitCollection? = nil) -> UIKit.UIImage? {
return UIKit.UIImage(resource: R.image.storeSample, compatibleWith: traitCollection)
}
fileprivate init() {}
}
/// This `R.nib` struct is generated, and contains static references to 0 nibs.
struct nib {
fileprivate init() {}
}
/// This `R.reuseIdentifier` struct is generated, and contains static references to 0 reuse identifiers.
struct reuseIdentifier {
fileprivate init() {}
}
/// This `R.segue` struct is generated, and contains static references to 1 view controllers.
struct segue {
/// This struct is generated for `UserViewController`, and contains static references to 1 segues.
struct userViewController {
/// Segue identifier `UserRegisterViewController`.
static let userRegisterViewController: Rswift.StoryboardSegueIdentifier<UIKit.UIStoryboardSegue, UserViewController, UserRegisterViewController> = Rswift.StoryboardSegueIdentifier(identifier: "UserRegisterViewController")
/// Optionally returns a typed version of segue `UserRegisterViewController`.
/// Returns nil if either the segue identifier, the source, destination, or segue types don't match.
/// For use inside `prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?)`.
static func userRegisterViewController(segue: UIKit.UIStoryboardSegue) -> Rswift.TypedStoryboardSegueInfo<UIKit.UIStoryboardSegue, UserViewController, UserRegisterViewController>? {
return Rswift.TypedStoryboardSegueInfo(segueIdentifier: R.segue.userViewController.userRegisterViewController, segue: segue)
}
fileprivate init() {}
}
fileprivate init() {}
}
/// This `R.storyboard` struct is generated, and contains static references to 2 storyboards.
struct storyboard {
/// Storyboard `LaunchScreen`.
static let launchScreen = _R.storyboard.launchScreen()
/// Storyboard `Main`.
static let main = _R.storyboard.main()
/// `UIStoryboard(name: "LaunchScreen", bundle: ...)`
static func launchScreen(_: Void = ()) -> UIKit.UIStoryboard {
return UIKit.UIStoryboard(resource: R.storyboard.launchScreen)
}
/// `UIStoryboard(name: "Main", bundle: ...)`
static func main(_: Void = ()) -> UIKit.UIStoryboard {
return UIKit.UIStoryboard(resource: R.storyboard.main)
}
fileprivate init() {}
}
/// This `R.string` struct is generated, and contains static references to 0 localization tables.
struct string {
fileprivate init() {}
}
fileprivate struct intern: Rswift.Validatable {
fileprivate static func validate() throws {
try _R.validate()
}
fileprivate init() {}
}
fileprivate class Class {}
fileprivate init() {}
}
struct _R: Rswift.Validatable {
static func validate() throws {
try storyboard.validate()
}
struct nib {
fileprivate init() {}
}
struct storyboard: Rswift.Validatable {
static func validate() throws {
try main.validate()
}
struct launchScreen: Rswift.StoryboardResourceWithInitialControllerType {
typealias InitialController = UIKit.UIViewController
let bundle = R.hostingBundle
let name = "LaunchScreen"
fileprivate init() {}
}
struct main: Rswift.StoryboardResourceWithInitialControllerType, Rswift.Validatable {
typealias InitialController = UIKit.UITabBarController
let bundle = R.hostingBundle
let name = "Main"
let userViewController = StoryboardViewControllerResource<UIKit.UINavigationController>(identifier: "UserViewController")
func userViewController(_: Void = ()) -> UIKit.UINavigationController? {
return UIKit.UIStoryboard(resource: self).instantiateViewController(withResource: userViewController)
}
static func validate() throws {
if UIKit.UIImage(named: "icons8-herbal-medicine-64") == nil { throw Rswift.ValidationError(description: "[R.swift] Image named 'icons8-herbal-medicine-64' is used in storyboard 'Main', but couldn't be loaded.") }
if UIKit.UIImage(named: "icons8-gift-64") == nil { throw Rswift.ValidationError(description: "[R.swift] Image named 'icons8-gift-64' is used in storyboard 'Main', but couldn't be loaded.") }
if UIKit.UIImage(named: "icons8-treatment-64") == nil { throw Rswift.ValidationError(description: "[R.swift] Image named 'icons8-treatment-64' is used in storyboard 'Main', but couldn't be loaded.") }
if UIKit.UIImage(named: "storeSample") == nil { throw Rswift.ValidationError(description: "[R.swift] Image named 'storeSample' is used in storyboard 'Main', but couldn't be loaded.") }
if _R.storyboard.main().userViewController() == nil { throw Rswift.ValidationError(description:"[R.swift] ViewController with identifier 'userViewController' could not be loaded from storyboard 'Main' as 'UIKit.UINavigationController'.") }
}
fileprivate init() {}
}
fileprivate init() {}
}
fileprivate init() {}
}
| 42.292308 | 247 | 0.701952 |
e8e4d697915164eecaf2087bc274fbab73edc7d5 | 966 | //
// InstagramTests.swift
// InstagramTests
//
// Created by XXY on 16/2/29.
// Copyright © 2016年 XXY. All rights reserved.
//
import XCTest
@testable import Instagram
class InstagramTests: XCTestCase {
override func setUp() {
super.setUp()
// Put setup code here. This method is called before the invocation of each test method in the class.
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class.
super.tearDown()
}
func testExample() {
// This is an example of a functional test case.
// Use XCTAssert and related functions to verify your tests produce the correct results.
}
func testPerformanceExample() {
// This is an example of a performance test case.
self.measureBlock {
// Put the code you want to measure the time of here.
}
}
}
| 26.108108 | 111 | 0.632505 |
180f33c99328a7f883526e39382400fe1e0d2d7e | 5,305 | //
// CallKitCenter.swift
// flutter_ios_voip_kit
//
// Created by 須藤将史 on 2020/07/02.
//
import Foundation
import CallKit
import UIKit
class CallKitCenter: NSObject {
private let controller = CXCallController()
private let iconName: String
private let localizedName: String
private let supportVideo: Bool
private let skipRecallScreen: Bool
private var provider: CXProvider?
private var uuid = UUID()
private(set) var uuidString: String?
private(set) var incomingCallerId: String?
private(set) var incomingCallerName: String?
private var isReceivedIncomingCall: Bool = false
private var isCallConnected: Bool = false
private var maximumCallGroups: Int = 1
var answerCallAction: CXAnswerCallAction?
var isCalleeBeforeAcceptIncomingCall: Bool {
return self.isReceivedIncomingCall && !self.isCallConnected
}
override init() {
if let path = Bundle.main.path(forResource: "Info", ofType: "plist") {
let plist = NSDictionary(contentsOfFile: path)
self.iconName = plist?["FIVKIconName"] as? String ?? "AppIcon-VoIPKit"
self.localizedName = plist?["FIVKLocalizedName"] as? String ?? "App Name"
self.supportVideo = plist?["FIVKSupportVideo"] as? Bool ?? false
self.skipRecallScreen = plist?["FIVKSkipRecallScreen"] as? Bool ?? false
self.maximumCallGroups = plist?["FIVKMaximumCallGroups"] as? Int ?? 1
} else {
self.iconName = "AppIcon-VoIPKit"
self.localizedName = "App Name"
self.supportVideo = false
self.skipRecallScreen = false
}
super.init()
}
func setup(delegate: CXProviderDelegate) {
let providerConfiguration = CXProviderConfiguration(localizedName: self.localizedName)
providerConfiguration.supportsVideo = self.supportVideo
providerConfiguration.maximumCallsPerCallGroup = 1
providerConfiguration.maximumCallGroups = maximumCallGroups
providerConfiguration.supportedHandleTypes = [.generic]
providerConfiguration.ringtoneSound = "ring.wav"
providerConfiguration.iconTemplateImageData = UIImage(named: self.iconName)?.pngData()
self.provider = CXProvider(configuration: providerConfiguration)
self.provider?.setDelegate(delegate, queue: nil)
}
func startCall(uuidString: String, targetName: String) {
self.uuid = UUID(uuidString: uuidString)!
let handle = CXHandle(type: .generic, value: targetName)
let startCallAction = CXStartCallAction(call: self.uuid, handle: handle)
startCallAction.isVideo = self.supportVideo
let transaction = CXTransaction(action: startCallAction)
self.controller.request(transaction) { error in
if let error = error {
print("❌ CXStartCallAction error: \(error.localizedDescription)")
}
}
}
func incomingCall(uuidString: String, callerId: String, callerName: String, completion: @escaping (Error?) -> Void) {
self.uuidString = uuidString
self.incomingCallerId = callerId
self.incomingCallerName = callerName
self.isReceivedIncomingCall = true
self.uuid = UUID(uuidString: uuidString)!
let update = CXCallUpdate()
update.remoteHandle = CXHandle(type: .generic, value: callerName)
update.hasVideo = self.supportVideo
update.supportsHolding = false
update.supportsGrouping = false
update.supportsUngrouping = true
self.provider?.reportNewIncomingCall(with: self.uuid, update: update, completion: { error in
if (error == nil) {
self.connectedOutgoingCall()
}
completion(error)
})
}
func acceptIncomingCall(alreadyEndCallerReason: CXCallEndedReason?) {
guard alreadyEndCallerReason == nil else {
self.skipRecallScreen ? self.answerCallAction?.fulfill() : self.answerCallAction?.fail()
self.answerCallAction = nil
return
}
self.answerCallAction?.fulfill()
self.answerCallAction = nil
}
func unansweredIncomingCall() {
self.disconnected(reason: .unanswered)
}
func endCall() {
let endCallAction = CXEndCallAction(call: self.uuid)
let transaction = CXTransaction(action: endCallAction)
self.controller.request(transaction) { error in
if let error = error {
print("❌ CXEndCallAction error: \(error.localizedDescription)")
}
}
}
func callConnected() {
self.isCallConnected = true
}
func connectingOutgoingCall() {
self.provider?.reportOutgoingCall(with: self.uuid, startedConnectingAt: nil)
}
private func connectedOutgoingCall() {
self.provider?.reportOutgoingCall(with: self.uuid, connectedAt: nil)
}
func disconnected(reason: CXCallEndedReason) {
self.uuidString = nil
self.incomingCallerId = nil
self.incomingCallerName = nil
self.answerCallAction = nil
self.isReceivedIncomingCall = false
self.isCallConnected = false
self.provider?.reportCall(with: self.uuid, endedAt: nil, reason: reason)
}
}
| 36.586207 | 121 | 0.663336 |
e0c1b08e53bccad6aa0a94212c7c2e300ffc0f1a | 13,243 | /*
This source file is part of the Swift.org open source project
Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See http://swift.org/LICENSE.txt for license information
See http://swift.org/CONTRIBUTORS.txt for Swift project authors
*/
import Foundation
import TSCBasic
import TSCUtility
/// When set to `false`,
/// `PackageIdentity` uses the canonical location of package dependencies as its identity.
/// Otherwise, only the last path component is used to identify package dependencies.
public var _useLegacyIdentities: Bool = true {
willSet {
PackageIdentity.provider = newValue ? LegacyPackageIdentity.self : CanonicalPackageIdentity.self
}
}
internal protocol PackageIdentityProvider: CustomStringConvertible {
init(_ string: String)
}
/// The canonical identifier for a package, based on its source location.
public struct PackageIdentity: Hashable, CustomStringConvertible {
/// The underlying type used to create package identities.
internal static var provider: PackageIdentityProvider.Type = LegacyPackageIdentity.self
/// A textual representation of this instance.
public let description: String
/// Creates a package identity from a string.
/// - Parameter string: A string used to identify a package.
init(_ string: String) {
self.description = Self.provider.init(string).description
}
/// Creates a package identity from a URL.
/// - Parameter url: The package's URL.
public init(url: String) { // TODO: Migrate to Foundation.URL
self.init(url)
}
/// Creates a package identity from a file path.
/// - Parameter path: An absolute path to the package.
public init(path: AbsolutePath) {
self.init(path.pathString)
}
}
extension PackageIdentity: Comparable {
public static func < (lhs: PackageIdentity, rhs: PackageIdentity) -> Bool {
return lhs.description < rhs.description
}
}
extension PackageIdentity: Codable {
public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
let description = try container.decode(String.self)
self.init(description)
}
public func encode(to encoder: Encoder) throws {
var container = encoder.singleValueContainer()
try container.encode(self.description)
}
}
extension PackageIdentity: JSONMappable, JSONSerializable {
public init(json: JSON) throws {
guard case .string(let string) = json else {
throw JSON.MapError.typeMismatch(key: "", expected: String.self, json: json)
}
self.init(string)
}
public func toJSON() -> JSON {
return .string(self.description)
}
}
// MARK: -
struct LegacyPackageIdentity: PackageIdentityProvider, Equatable {
/// A textual representation of this instance.
public let description: String
/// Instantiates an instance of the conforming type from a string representation.
public init(_ string: String) {
self.description = Self.computeDefaultName(fromURL: string).lowercased()
}
/// Compute the default name of a package given its URL.
public static func computeDefaultName(fromURL url: String) -> String {
#if os(Windows)
let isSeparator : (Character) -> Bool = { $0 == "/" || $0 == "\\" }
#else
let isSeparator : (Character) -> Bool = { $0 == "/" }
#endif
// Get the last path component of the URL.
// Drop the last character in case it's a trailing slash.
var endIndex = url.endIndex
if let lastCharacter = url.last, isSeparator(lastCharacter) {
endIndex = url.index(before: endIndex)
}
let separatorIndex = url[..<endIndex].lastIndex(where: isSeparator)
let startIndex = separatorIndex.map { url.index(after: $0) } ?? url.startIndex
var lastComponent = url[startIndex..<endIndex]
// Strip `.git` suffix if present.
if lastComponent.hasSuffix(".git") {
lastComponent = lastComponent.dropLast(4)
}
return String(lastComponent)
}
}
/// A canonicalized package identity.
///
/// A package may declare external packages as dependencies in its manifest.
/// Each external package is uniquely identified by the location of its source code.
///
/// An external package dependency may itself have one or more external package dependencies,
/// known as _transitive dependencies_.
/// When multiple packages have dependencies in common,
/// Swift Package Manager determines which version of that package should be used
/// (if any exist that satisfy all specified requirements)
/// in a process called package resolution.
///
/// External package dependencies are located by a URL
/// (which may be an implicit `file://` URL in the form of a file path).
/// For the purposes of package resolution,
/// package URLs are case-insensitive (mona ≍ MONA)
/// and normalization-insensitive (n + ◌̃ ≍ ñ).
/// Swift Package Manager takes additional steps to canonicalize URLs
/// to resolve insignificant differences between URLs.
/// For example,
/// the URLs `https://example.com/Mona/LinkedList` and `[email protected]:mona/linkedlist`
/// are equivalent, in that they both resolve to the same source code repository,
/// despite having different scheme, authority, and path components.
///
/// The `PackageIdentity` type canonicalizes package locations by
/// performing the following operations:
///
/// * Removing the scheme component, if present
/// ```
/// https://example.com/mona/LinkedList → example.com/mona/LinkedList
/// ```
/// * Removing the userinfo component (preceded by `@`), if present:
/// ```
/// [email protected]/mona/LinkedList → example.com/mona/LinkedList
/// ```
/// * Removing the port subcomponent, if present:
/// ```
/// example.com:443/mona/LinkedList → example.com/mona/LinkedList
/// ```
/// * Replacing the colon (`:`) preceding the path component in "`scp`-style" URLs:
/// ```
/// [email protected]:mona/LinkedList.git → example.com/mona/LinkedList
/// ```
/// * Expanding the tilde (`~`) to the provided user, if applicable:
/// ```
/// ssh://[email protected]/~/LinkedList.git → example.com/~mona/LinkedList
/// ```
/// * Removing percent-encoding from the path component, if applicable:
/// ```
/// example.com/mona/%F0%9F%94%97List → example.com/mona/🔗List
/// ```
/// * Removing the `.git` file extension from the path component, if present:
/// ```
/// example.com/mona/LinkedList.git → example.com/mona/LinkedList
/// ```
/// * Removing the trailing slash (`/`) in the path component, if present:
/// ```
/// example.com/mona/LinkedList/ → example.com/mona/LinkedList
/// ```
/// * Removing the fragment component (preceded by `#`), if present:
/// ```
/// example.com/mona/LinkedList#installation → example.com/mona/LinkedList
/// ```
/// * Removing the query component (preceded by `?`), if present:
/// ```
/// example.com/mona/LinkedList?utm_source=forums.swift.org → example.com/mona/LinkedList
/// ```
/// * Adding a leading slash (`/`) for `file://` URLs and absolute file paths:
/// ```
/// file:///Users/mona/LinkedList → /Users/mona/LinkedList
/// ```
struct CanonicalPackageIdentity: PackageIdentityProvider, Equatable {
/// A textual representation of this instance.
public let description: String
/// Instantiates an instance of the conforming type from a string representation.
public init(_ string: String) {
var description = string.precomposedStringWithCanonicalMapping.lowercased()
// Remove the scheme component, if present.
let detectedScheme = description.dropSchemeComponentPrefixIfPresent()
// Remove the userinfo subcomponent (user / password), if present.
if case (let user, _)? = description.dropUserinfoSubcomponentPrefixIfPresent() {
// If a user was provided, perform tilde expansion, if applicable.
description.replaceFirstOccurenceIfPresent(of: "/~/", with: "/~\(user)/")
}
// Remove the port subcomponent, if present.
description.removePortComponentIfPresent()
// Remove the fragment component, if present.
description.removeFragmentComponentIfPresent()
// Remove the query component, if present.
description.removeQueryComponentIfPresent()
// Accomodate "`scp`-style" SSH URLs
if detectedScheme == nil || detectedScheme == "ssh" {
description.replaceFirstOccurenceIfPresent(of: ":", before: description.firstIndex(of: "/"), with: "/")
}
// Split the remaining string into path components,
// filtering out empty path components and removing valid percent encodings.
var components = description.split(omittingEmptySubsequences: true, whereSeparator: isSeparator)
.compactMap { $0.removingPercentEncoding ?? String($0) }
// Remove the `.git` suffix from the last path component.
var lastPathComponent = components.popLast() ?? ""
lastPathComponent.removeSuffixIfPresent(".git")
components.append(lastPathComponent)
description = components.joined(separator: "/")
// Prepend a leading slash for file URLs and paths
if detectedScheme == "file" || string.first.flatMap(isSeparator) ?? false {
description.insert("/", at: description.startIndex)
}
self.description = description
}
}
#if os(Windows)
fileprivate let isSeparator: (Character) -> Bool = { $0 == "/" || $0 == "\\" }
#else
fileprivate let isSeparator: (Character) -> Bool = { $0 == "/" }
#endif
private extension Character {
var isDigit: Bool {
switch self {
case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9":
return true
default:
return false
}
}
var isAllowedInURLScheme: Bool {
return isLetter || self.isDigit || self == "+" || self == "-" || self == "."
}
}
private extension String {
@discardableResult
mutating func removePrefixIfPresent<T: StringProtocol>(_ prefix: T) -> Bool {
guard hasPrefix(prefix) else { return false }
removeFirst(prefix.count)
return true
}
@discardableResult
mutating func removeSuffixIfPresent<T: StringProtocol>(_ suffix: T) -> Bool {
guard hasSuffix(suffix) else { return false }
removeLast(suffix.count)
return true
}
@discardableResult
mutating func dropSchemeComponentPrefixIfPresent() -> String? {
if let rangeOfDelimiter = range(of: "://"),
self[startIndex].isLetter,
self[..<rangeOfDelimiter.lowerBound].allSatisfy({ $0.isAllowedInURLScheme })
{
defer { self.removeSubrange(..<rangeOfDelimiter.upperBound) }
return String(self[..<rangeOfDelimiter.lowerBound])
}
return nil
}
@discardableResult
mutating func dropUserinfoSubcomponentPrefixIfPresent() -> (user: String, password: String?)? {
if let indexOfAtSign = firstIndex(of: "@"),
let indexOfFirstPathComponent = firstIndex(where: isSeparator),
indexOfAtSign < indexOfFirstPathComponent
{
defer { self.removeSubrange(...indexOfAtSign) }
let userinfo = self[..<indexOfAtSign]
var components = userinfo.split(separator: ":", maxSplits: 2, omittingEmptySubsequences: false)
guard components.count > 0 else { return nil }
let user = String(components.removeFirst())
let password = components.last.map(String.init)
return (user, password)
}
return nil
}
@discardableResult
mutating func removePortComponentIfPresent() -> Bool {
if let indexOfFirstPathComponent = firstIndex(where: isSeparator),
let startIndexOfPort = firstIndex(of: ":"),
startIndexOfPort < endIndex,
let endIndexOfPort = self[index(after: startIndexOfPort)...].lastIndex(where: { $0.isDigit }),
endIndexOfPort <= indexOfFirstPathComponent
{
self.removeSubrange(startIndexOfPort ... endIndexOfPort)
return true
}
return false
}
@discardableResult
mutating func removeFragmentComponentIfPresent() -> Bool {
if let index = firstIndex(of: "#") {
self.removeSubrange(index...)
}
return false
}
@discardableResult
mutating func removeQueryComponentIfPresent() -> Bool {
if let index = firstIndex(of: "?") {
self.removeSubrange(index...)
}
return false
}
@discardableResult
mutating func replaceFirstOccurenceIfPresent<T: StringProtocol, U: StringProtocol>(
of string: T,
before index: Index? = nil,
with replacement: U
) -> Bool {
guard let range = range(of: string) else { return false }
if let index = index, range.lowerBound >= index {
return false
}
self.replaceSubrange(range, with: replacement)
return true
}
}
| 35.695418 | 115 | 0.656347 |
48df5be305c7bb45a263ee4911521eb51c6adc37 | 3,552 | //
// Copyright 2020 Swiftkube Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///
/// Generated by Swiftkube:ModelGen
/// Kubernetes v1.20.9
/// rbac.v1beta1.ClusterRoleBindingList
///
import Foundation
public extension rbac.v1beta1 {
///
/// ClusterRoleBindingList is a collection of ClusterRoleBindings. Deprecated in v1.17 in favor of rbac.authorization.k8s.io/v1 ClusterRoleBindingList, and will no longer be served in v1.22.
///
struct ClusterRoleBindingList: KubernetesResource, KubernetesResourceList {
///
/// KubernetesResourceList.Item associated type
///
public typealias Item = rbac.v1beta1.ClusterRoleBinding
///
/// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
///
public let apiVersion: String = "rbac.authorization.k8s.io/v1beta1"
///
/// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
///
public let kind: String = "ClusterRoleBindingList"
///
/// Standard object's metadata.
///
public var metadata: meta.v1.ListMeta?
///
/// Items is a list of ClusterRoleBindings
///
public var items: [rbac.v1beta1.ClusterRoleBinding]
///
/// Default memberwise initializer
///
public init(
metadata: meta.v1.ListMeta? = nil,
items: [rbac.v1beta1.ClusterRoleBinding]
) {
self.metadata = metadata
self.items = items
}
}
}
///
/// Codable conformance
///
public extension rbac.v1beta1.ClusterRoleBindingList {
private enum CodingKeys: String, CodingKey {
case apiVersion = "apiVersion"
case kind = "kind"
case metadata = "metadata"
case items = "items"
}
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
self.metadata = try container.decodeIfPresent(meta.v1.ListMeta.self, forKey: .metadata)
self.items = try container.decode([rbac.v1beta1.ClusterRoleBinding].self, forKey: .items)
}
func encode(to encoder: Encoder) throws {
var encodingContainer = encoder.container(keyedBy: CodingKeys.self)
try encodingContainer.encode(apiVersion, forKey: .apiVersion)
try encodingContainer.encode(kind, forKey: .kind)
try encodingContainer.encode(metadata, forKey: .metadata)
try encodingContainer.encode(items, forKey: .items)
}
}
// MARK: - rbac.v1beta1.ClusterRoleBindingList + Sequence
///
/// Sequence iterator for KubernetesResourceList items
///
extension rbac.v1beta1.ClusterRoleBindingList: Sequence {
public typealias Element = rbac.v1beta1.ClusterRoleBinding
public func makeIterator() -> AnyIterator<rbac.v1beta1.ClusterRoleBinding> {
AnyIterator(items.makeIterator())
}
}
| 33.509434 | 296 | 0.748874 |
08d93d8f017889401f3fbd6b1bd6cfe5d7a0dce7 | 49,583 | import Foundation
import PusherPlatform
public final class PCCurrentUser {
public let id: String
public let createdAt: String
public var updatedAt: String
public var name: String?
public var avatarURL: String?
public var customData: [String: Any]?
private let lock = DispatchSemaphore(value: 1)
let userStore: PCGlobalUserStore
let roomStore: PCRoomStore
let cursorStore: PCCursorStore
let typingIndicatorManager: PCTypingIndicatorManager
var delegate: PCChatManagerDelegate {
didSet {
userSubscription?.delegate = delegate
userPresenceSubscriptions.forEach { ($0.value).delegate = delegate }
}
}
// TODO: This should probably be [PCUser] instead, like the users property
// in PCRoom, or something even simpler
public var users: Set<PCUser> {
return self.userStore.users
}
public var rooms: [PCRoom] {
return self.roomStore.rooms.clone()
}
public let pathFriendlyID: String
public internal(set) var userSubscription: PCUserSubscription?
private var _presenceSubscription: PCPresenceSubscription?
public internal(set) var presenceSubscription: PCPresenceSubscription? {
get { return self.lock.synchronized { self._presenceSubscription } }
set(v) { self.lock.synchronized { self._presenceSubscription = v } }
}
public var createdAtDate: Date { return PCDateFormatter.shared.formatString(self.createdAt) }
public var updatedAtDate: Date { return PCDateFormatter.shared.formatString(self.updatedAt) }
private let chatkitBeamsTokenProviderInstance: Instance
let instance: Instance
let v6Instance: Instance
let filesInstance: Instance
let cursorsInstance: Instance
let presenceInstance: Instance
let connectionCoordinator: PCConnectionCoordinator
private lazy var readCursorDebouncerManager: PCReadCursorDebouncerManager = {
return PCReadCursorDebouncerManager(currentUser: self)
}()
public internal(set) var userPresenceSubscriptions = PCSynchronizedDictionary<String, PCUserPresenceSubscription>()
public init(
id: String,
pathFriendlyID: String,
createdAt: String,
updatedAt: String,
name: String?,
avatarURL: String?,
customData: [String: Any]?,
instance: Instance,
v6Instance: Instance,
chatkitBeamsTokenProviderInstance: Instance,
filesInstance: Instance,
cursorsInstance: Instance,
presenceInstance: Instance,
userStore: PCGlobalUserStore,
roomStore: PCRoomStore,
cursorStore: PCCursorStore,
connectionCoordinator: PCConnectionCoordinator,
delegate: PCChatManagerDelegate
) {
self.id = id
self.pathFriendlyID = pathFriendlyID
self.createdAt = createdAt
self.updatedAt = updatedAt
self.name = name
self.avatarURL = avatarURL
self.customData = customData
self.instance = instance
self.v6Instance = v6Instance
self.chatkitBeamsTokenProviderInstance = chatkitBeamsTokenProviderInstance
self.filesInstance = filesInstance
self.cursorsInstance = cursorsInstance
self.presenceInstance = presenceInstance
self.userStore = userStore
self.roomStore = roomStore
self.cursorStore = cursorStore
self.connectionCoordinator = connectionCoordinator
self.delegate = delegate
self.typingIndicatorManager = PCTypingIndicatorManager(instance: v6Instance)
self.userStore.onUserStoredHooks.append { [weak self] user in
guard let strongSelf = self else {
v6Instance.logger.log(
"PCCurrentUser (self) is nil when going to subscribe to user presence after storing user in store",
logLevel: .verbose
)
return
}
strongSelf.subscribeToUserPresence(user: user)
}
}
public func createRoom(
id: String? = nil,
name: String,
pushNotificationTitleOverride: String? = nil,
isPrivate: Bool = false,
addUserIDs userIDs: [String]? = nil,
customData: [String: Any]? = nil,
completionHandler: @escaping PCRoomCompletionHandler
) {
var roomObject: [String: Any] = [
"name": name,
"created_by_id": self.id,
"private": isPrivate,
]
if id != nil {
roomObject["id"] = id!
}
if pushNotificationTitleOverride != nil {
roomObject["push_notification_title_override"] = pushNotificationTitleOverride
}
if userIDs != nil && userIDs!.count > 0 {
roomObject["user_ids"] = userIDs
}
if customData != nil {
roomObject["custom_data"] = customData!
}
guard JSONSerialization.isValidJSONObject(roomObject) else {
completionHandler(nil, PCError.invalidJSONObjectAsData(roomObject))
return
}
guard let data = try? JSONSerialization.data(withJSONObject: roomObject, options: []) else {
completionHandler(nil, PCError.failedToJSONSerializeData(roomObject))
return
}
let path = "/rooms"
let generalRequest = PPRequestOptions(method: HTTPMethod.POST.rawValue, path: path, body: data)
self.v6Instance.requestWithRetry(
using: generalRequest,
onSuccess: { data in
guard let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) else {
completionHandler(nil, PCError.failedToDeserializeJSON(data))
return
}
guard let roomPayload = jsonObject as? [String: Any] else {
completionHandler(nil, PCError.failedToCastJSONObjectToDictionary(jsonObject))
return
}
do {
let room = self.roomStore.addOrMerge(try PCPayloadDeserializer.createRoomFromPayload(roomPayload))
self.populateRoomUserStore(room) { room in
completionHandler(room, nil)
}
} catch let err {
completionHandler(nil, err)
}
},
onError: { error in
completionHandler(nil, error)
}
)
}
// MARK: Room membership-related interactions
public func addUser(_ user: PCUser, to room: PCRoom, completionHandler: @escaping PCErrorCompletionHandler) {
self.addUsers([user], to: room, completionHandler: completionHandler)
}
public func addUser(id: String, to roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
self.addOrRemoveUsers(in: roomID, userIDs: [id], membershipChange: .add, completionHandler: completionHandler)
}
public func addUsers(_ users: [PCUser], to room: PCRoom, completionHandler: @escaping PCErrorCompletionHandler) {
let userIDs = users.map { $0.id }
self.addUsers(ids: userIDs, to: room.id, completionHandler: completionHandler)
}
public func addUsers(ids: [String], to roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
self.addOrRemoveUsers(in: roomID, userIDs: ids, membershipChange: .add, completionHandler: completionHandler)
}
public func removeUser(_ user: PCUser, from room: PCRoom, completionHandler: @escaping PCErrorCompletionHandler) {
self.removeUsers([user], from: room, completionHandler: completionHandler)
}
public func removeUser(id: String, from roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
self.removeUsers(ids: [id], from: roomID, completionHandler: completionHandler)
}
public func removeUsers(_ users: [PCUser], from room: PCRoom, completionHandler: @escaping PCErrorCompletionHandler) {
let userIDs = users.map { $0.id }
self.removeUsers(ids: userIDs, from: room.id, completionHandler: completionHandler)
}
public func removeUsers(ids: [String], from roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
self.addOrRemoveUsers(in: roomID, userIDs: ids, membershipChange: .remove, completionHandler: completionHandler)
}
public enum RoomPushNotificationTitle {
case Override(String)
case NoOverride
}
//MARK: Update Room
/**
* Update a room
*
* - parameter room: The room which should be updated.
* - parameter name: Name of the room.
* - parameter isPrivate: Indicates if a room should be private or public.
* - parameter customData: Optional custom data associated with a room.
* - parameter completionHandler: Invoked when request failed or completed.
*/
public func updateRoom(
_ room: PCRoom,
name: String? = nil,
pushNotificationTitleOverride: RoomPushNotificationTitle? = nil,
isPrivate: Bool? = nil,
customData: [String: Any]? = nil,
completionHandler: @escaping PCErrorCompletionHandler
) {
self.updateRoom(
roomID: room.id,
name: name,
pushNotificationTitleOverride: pushNotificationTitleOverride,
isPrivate: isPrivate,
customData: customData,
completionHandler: completionHandler
)
}
/**
* Update a room by providing the room id
*
* - parameter id: The id of the room which should be updated.
* - parameter name: Name of the room.
* - parameter isPrivate: Indicates if a room should be private or public.
* - parameter customData: Optional custom data associated with a room.
* - parameter completionHandler: Invoked when request failed or completed.
*/
public func updateRoom(
id: String,
name: String? = nil,
pushNotificationTitleOverride: RoomPushNotificationTitle? = nil,
isPrivate: Bool? = nil,
customData: [String: Any]? = nil,
completionHandler: @escaping PCErrorCompletionHandler
) {
self.updateRoom(
roomID: id,
name: name,
pushNotificationTitleOverride: pushNotificationTitleOverride,
isPrivate: isPrivate,
customData: customData,
completionHandler: completionHandler
)
}
fileprivate func updateRoom(
roomID: String,
name: String?,
pushNotificationTitleOverride: RoomPushNotificationTitle?,
isPrivate: Bool?,
customData: [String: Any]?,
completionHandler: @escaping PCErrorCompletionHandler
) {
guard name != nil || pushNotificationTitleOverride != nil || isPrivate != nil || customData != nil else {
completionHandler(nil)
return
}
var roomPayload: [String: Any] = [:]
roomPayload["name"] = name
if let pnTitleOverride = pushNotificationTitleOverride {
switch pnTitleOverride {
case .Override(let title):
roomPayload["push_notification_title_override"] = title
case .NoOverride:
roomPayload["push_notification_title_override"] = NSNull() // Forcing `null` to be serialized.
}
}
roomPayload["private"] = isPrivate
if customData != nil {
roomPayload["custom_data"] = customData
}
guard JSONSerialization.isValidJSONObject(roomPayload) else {
completionHandler(PCError.invalidJSONObjectAsData(roomPayload))
return
}
guard let data = try? JSONSerialization.data(withJSONObject: roomPayload, options: []) else {
completionHandler(PCError.failedToJSONSerializeData(roomPayload))
return
}
let path = "/rooms/\(roomID)"
let generalRequest = PPRequestOptions(method: HTTPMethod.PUT.rawValue, path: path, body: data)
self.v6Instance.requestWithRetry(
using: generalRequest,
onSuccess: { _ in
completionHandler(nil)
},
onError: { error in
completionHandler(error)
}
)
}
//MARK: Delete Room
/**
* Delete a room
*
* - parameter room: The room which should be deleted.
* - parameter completionHandler: Invoked when request failed or completed.
*/
public func deleteRoom(_ room: PCRoom, completionHandler: @escaping PCErrorCompletionHandler) {
self.deleteRoom(roomID: room.id, completionHandler: completionHandler)
}
/**
* Delete a room by providing the room id
*
* - parameter id: The id of the room which should be deleted.
* - parameter completionHandler: Invoked when request failed or completed.
*/
public func deleteRoom(id: String, completionHandler: @escaping PCErrorCompletionHandler) {
self.deleteRoom(roomID: id, completionHandler: completionHandler)
}
fileprivate func deleteRoom(roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
let path = "/rooms/\(roomID)"
let generalRequest = PPRequestOptions(method: HTTPMethod.DELETE.rawValue, path: path)
self.instance.requestWithRetry(
using: generalRequest,
onSuccess: { _ in
completionHandler(nil)
},
onError: { error in
completionHandler(error)
}
)
}
fileprivate func addOrRemoveUsers(
in roomID: String,
userIDs: [String],
membershipChange: PCUserMembershipChange,
completionHandler: @escaping PCErrorCompletionHandler
) {
let userPayload = ["user_ids": userIDs]
guard JSONSerialization.isValidJSONObject(userPayload) else {
completionHandler(PCError.invalidJSONObjectAsData(userPayload))
return
}
guard let data = try? JSONSerialization.data(withJSONObject: userPayload, options: []) else {
completionHandler(PCError.failedToJSONSerializeData(userPayload))
return
}
let path = "/rooms/\(roomID)/users/\(membershipChange.rawValue)"
let generalRequest = PPRequestOptions(method: HTTPMethod.PUT.rawValue, path: path, body: data)
self.v6Instance.requestWithRetry(
using: generalRequest,
onSuccess: { _ in
completionHandler(nil)
},
onError: { error in
completionHandler(error)
}
)
}
fileprivate enum PCUserMembershipChange: String {
case add
case remove
}
public func joinRoom(_ room: PCRoom, completionHandler: @escaping PCRoomCompletionHandler) {
self.joinRoom(roomID: room.id, completionHandler: completionHandler)
}
public func joinRoom(id: String, completionHandler: @escaping PCRoomCompletionHandler) {
self.joinRoom(roomID: id, completionHandler: completionHandler)
}
fileprivate func joinRoom(roomID: String, completionHandler: @escaping PCRoomCompletionHandler) {
if let room = self.rooms.first(where: { $0.id == roomID }) {
completionHandler(room, nil)
return
}
let path = "/users/\(self.pathFriendlyID)/rooms/\(roomID)/join"
let generalRequest = PPRequestOptions(method: HTTPMethod.POST.rawValue, path: path)
self.v6Instance.requestWithRetry(
using: generalRequest,
onSuccess: { data in
guard let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) else {
completionHandler(nil, PCError.failedToDeserializeJSON(data))
return
}
guard let roomPayload = jsonObject as? [String: Any] else {
completionHandler(nil, PCError.failedToCastJSONObjectToDictionary(jsonObject))
return
}
do {
let room = self.roomStore.addOrMerge(try PCPayloadDeserializer.createRoomFromPayload(roomPayload))
self.populateRoomUserStore(room) { room in
completionHandler(room, nil)
}
} catch let err {
self.v6Instance.logger.log(err.localizedDescription, logLevel: .debug)
completionHandler(nil, err)
return
}
},
onError: { error in
completionHandler(nil, error)
}
)
}
fileprivate func populateRoomUserStore(_ room: PCRoom, completionHandler: @escaping (PCRoom) -> Void) {
let roomUsersProgressCounter = PCProgressCounter(totalCount: room.userIDs.count, labelSuffix: "room-users")
// TODO: Use the soon-to-be-created new version of fetchUsersWithIDs from the
// userStore
room.userIDs.forEach { userID in
self.userStore.user(id: userID) { [weak self] user, err in
guard let strongSelf = self else {
print("self is nil when user store returns user during population of room user store")
return
}
guard let user = user, err == nil else {
strongSelf.v6Instance.logger.log(
"Unable to add user with id \(userID) to room \(room.name): \(err!.localizedDescription)",
logLevel: .debug
)
if roomUsersProgressCounter.incrementFailedAndCheckIfFinished() {
room.subscription?.delegate?.onUsersUpdated()
strongSelf.v6Instance.logger.log("Users updated in room \(room.name)", logLevel: .verbose)
completionHandler(room)
}
return
}
room.userStore.addOrMerge(user)
if roomUsersProgressCounter.incrementSuccessAndCheckIfFinished() {
room.subscription?.delegate?.onUsersUpdated()
strongSelf.v6Instance.logger.log("Users updated in room \(room.name)", logLevel: .verbose)
completionHandler(room)
}
}
}
}
public func leaveRoom(_ room: PCRoom, completionHandler: @escaping PCErrorCompletionHandler) {
self.leaveRoom(roomID: room.id, completionHandler: completionHandler)
}
public func leaveRoom(id roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
self.leaveRoom(roomID: roomID, completionHandler: completionHandler)
}
fileprivate func leaveRoom(roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
let path = "/users/\(self.pathFriendlyID)/rooms/\(roomID)/leave"
let generalRequest = PPRequestOptions(method: HTTPMethod.POST.rawValue, path: path)
self.v6Instance.requestWithRetry(
using: generalRequest,
onSuccess: { _ in
completionHandler(nil)
},
onError: { error in
completionHandler(error)
}
)
}
// MARK: Room fetching
public func getJoinableRooms(completionHandler: @escaping PCRoomsCompletionHandler) {
self.getUserRooms(onlyJoinable: true, completionHandler: completionHandler)
}
fileprivate func getUserRooms(onlyJoinable: Bool = false, completionHandler: @escaping PCRoomsCompletionHandler) {
let path = "/users/\(self.pathFriendlyID)/rooms"
let generalRequest = PPRequestOptions(method: HTTPMethod.GET.rawValue, path: path)
let joinableQueryItemValue = onlyJoinable ? "true" : "false"
generalRequest.addQueryItems([URLQueryItem(name: "joinable", value: joinableQueryItemValue)])
self.getRooms(request: generalRequest, completionHandler: completionHandler)
}
fileprivate func getRooms(request: PPRequestOptions, completionHandler: @escaping PCRoomsCompletionHandler) {
self.v6Instance.requestWithRetry(
using: request,
onSuccess: { data in
guard let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) else {
completionHandler(nil, PCError.failedToDeserializeJSON(data))
return
}
guard let roomsPayload = jsonObject as? [[String: Any]] else {
completionHandler(nil, PCError.failedToCastJSONObjectToDictionary(jsonObject))
return
}
let rooms = roomsPayload.compactMap { roomPayload -> PCRoom? in
do {
// TODO: Do we need to fetch users in the room here?
return try PCPayloadDeserializer.createRoomFromPayload(roomPayload)
} catch let err {
self.v6Instance.logger.log(err.localizedDescription, logLevel: .debug)
return nil
}
}
completionHandler(rooms, nil)
},
onError: { error in
completionHandler(nil, error)
}
)
}
// MARK: Typing-indicator-related interactions
public func typing(in roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
typingIndicatorManager.sendThrottledRequest(
roomID: roomID,
completionHandler: completionHandler
)
}
public func typing(in room: PCRoom, completionHandler: @escaping PCErrorCompletionHandler) {
typing(in: room.id, completionHandler: completionHandler)
}
// MARK: Message-related interactions
func sendMessage(instance: Instance, _ messageObject: [String: Any], roomID: String, completionHandler: @escaping (Int?, Error?) -> Void) {
guard JSONSerialization.isValidJSONObject(messageObject) else {
completionHandler(nil, PCError.invalidJSONObjectAsData(messageObject))
return
}
guard let data = try? JSONSerialization.data(withJSONObject: messageObject, options: []) else {
completionHandler(nil, PCError.failedToJSONSerializeData(messageObject))
return
}
let path = "/rooms/\(roomID)/messages"
let generalRequest = PPRequestOptions(method: HTTPMethod.POST.rawValue, path: path, body: data)
instance.requestWithRetry(
using: generalRequest,
onSuccess: { data in
guard let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) else {
completionHandler(nil, PCError.failedToDeserializeJSON(data))
return
}
guard let messageIDPayload = jsonObject as? [String: Int] else {
completionHandler(nil, PCError.failedToCastJSONObjectToDictionary(jsonObject))
return
}
guard let messageID = messageIDPayload["message_id"] else {
completionHandler(nil, PCMessageError.messageIDKeyMissingInMessageCreationResponse(messageIDPayload))
return
}
completionHandler(messageID, nil)
},
onError: { error in
completionHandler(nil, error)
}
)
}
func uploadAttachmentAndSendMessage(
_ messageObject: [String: Any],
attachment: PCAttachmentType,
roomID: String,
completionHandler: @escaping (Int?, Error?) -> Void,
progressHandler: ((Int64, Int64) -> Void)? = nil
) {
var multipartFormData: ((PPMultipartFormData) -> Void)
var reqOptions: PPRequestOptions
switch attachment {
case .fileData(let data, let name):
multipartFormData = { $0.append(data, withName: "file", fileName: name) }
let pathSafeName = pathFriendlyVersion(of: name)
reqOptions = PPRequestOptions(method: HTTPMethod.POST.rawValue, path: "/rooms/\(roomID)/users/\(pathFriendlyID)/files/\(pathSafeName)")
break
case .fileURL(let url, let name):
multipartFormData = { $0.append(url, withName: "file", fileName: name) }
let pathSafeName = pathFriendlyVersion(of: name)
reqOptions = PPRequestOptions(method: HTTPMethod.POST.rawValue, path: "/rooms/\(roomID)/users/\(pathFriendlyID)/files/\(pathSafeName)")
break
default:
sendMessage(instance: self.instance, messageObject, roomID: roomID, completionHandler: completionHandler)
return
}
self.filesInstance.upload(
using: reqOptions,
multipartFormData: multipartFormData,
onSuccess: { data in
guard let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) else {
completionHandler(nil, PCError.failedToDeserializeJSON(data))
return
}
guard let uploadPayload = jsonObject as? [String: Any] else {
completionHandler(nil, PCError.failedToCastJSONObjectToDictionary(jsonObject))
return
}
do {
let attachmentUploadResponse = try PCPayloadDeserializer.createAttachmentUploadResponseFromPayload(uploadPayload)
var mutableMessageObject = messageObject
mutableMessageObject["attachment"] = [
"resource_link": attachmentUploadResponse.link,
"type": attachmentUploadResponse.type
]
self.sendMessage(instance: self.instance, mutableMessageObject, roomID: roomID, completionHandler: completionHandler)
} catch let err {
completionHandler(nil, err)
self.instance.logger.log("Response from uploading attachment to room \(roomID) was invalid", logLevel: .verbose)
return
}
},
onError: { err in
completionHandler(nil, err)
self.instance.logger.log("Failed to upload attachment to room \(roomID)", logLevel: .verbose)
},
progressHandler: progressHandler
)
}
@available(*, deprecated, message: "Please use sendMultipartMessage")
public func sendMessage(
roomID: String,
text: String,
attachment: PCAttachmentType? = nil,
completionHandler: @escaping (Int?, Error?) -> Void
) {
var messageObject: [String: Any] = [
"user_id": self.id,
"text": text
]
guard let attachment = attachment else {
sendMessage(instance: self.instance, messageObject, roomID: roomID, completionHandler: completionHandler)
return
}
switch attachment {
case .fileData(_, _), .fileURL(_, _):
uploadAttachmentAndSendMessage(
messageObject,
attachment: attachment,
roomID: roomID,
completionHandler: completionHandler
)
break
case .link(let url, let type):
messageObject["attachment"] = [
"resource_link": url,
"type": type
]
sendMessage(instance: self.instance, messageObject, roomID: roomID, completionHandler: completionHandler)
break
}
}
public func sendSimpleMessage(roomID: String, text: String, completionHandler: @escaping (Int?, Error?) -> Void) {
let messageObject: [String: Any] = [
"parts": [
["content": text, "type": "text/plain"]
]
]
sendMessage(instance: self.v6Instance, messageObject, roomID: roomID, completionHandler: completionHandler)
}
public func sendMultipartMessage(
roomID: String,
parts: [PCPartRequest],
completionHandler: @escaping (Int?, Error?) -> Void
) {
var partObjects: [PartObjectWithIndex] = []
var uploadTasks: [PCMultipartAttachmentUploadTask] = []
var partIndex: Int = 0
for part in parts {
partIndex += 1
switch part.payload {
case .inline(let payload):
partObjects.append(PartObjectWithIndex(object: payload.toMap(), index: partIndex))
case .url(let payload):
partObjects.append(PartObjectWithIndex(object: payload.toMap(), index: partIndex))
case .attachment(let payload):
uploadTasks.append(
PCMultipartAttachmentUploadTask(
uploadRequest: PCMultipartAttachmentUploadRequest(
contentType: payload.type,
contentLength: payload.file.count,
name: payload.name,
customData: payload.customData
),
roomID: roomID,
file: payload.file,
partNumber: partIndex
)
)
}
}
let sendMessage: ([[String: Any]]) -> Void = { partsToSend in
self.sendMessage(
instance: self.v6Instance,
["parts": partsToSend],
roomID: roomID,
completionHandler: completionHandler
)
}
if uploadTasks.count > 0 {
let uploader = PCMultipartAttachmentUploader(instance: self.v6Instance, uploadTasks: uploadTasks)
uploader.upload() { results, errors in
guard errors == nil else {
completionHandler(nil, errors!.first!)
return
}
let uploadResultObjectsWithIndex = results!.map { PartObjectWithIndex(object: $0.payload, index: $0.partNumber)}
partObjects = (partObjects + uploadResultObjectsWithIndex).sorted(by: { $0.index < $1.index })
sendMessage(partObjects.map { $0.object })
}
} else {
sendMessage(partObjects.map { $0.object })
}
}
public func downloadAttachment(
_ link: String,
to destination: PCDownloadFileDestination? = nil,
onSuccess: ((URL) -> Void)? = nil,
onError: ((Error) -> Void)? = nil,
progressHandler: ((Int64, Int64) -> Void)? = nil
) {
let reqOptions = PPRequestOptions(
method: HTTPMethod.GET.rawValue,
destination: .absolute(link),
shouldFetchToken: false
)
self.instance.download(
using: reqOptions,
to: destination,
onSuccess: onSuccess,
onError: onError,
progressHandler: progressHandler
)
}
@available(*, deprecated, message: "Please use subscribeToRoomMultipart")
public func subscribeToRoom(
room: PCRoom,
roomDelegate: PCRoomDelegate,
messageLimit: Int = 20,
completionHandler: @escaping PCErrorCompletionHandler
) {
self.subscribeToRoom(
room,
delegate: roomDelegate,
messageLimit: messageLimit,
instance: self.instance,
version: "v2",
completionHandler: completionHandler
)
}
// TODO: Do we need a Last-Event-ID option here? Probably yes if we get to the point
// of supporting offline or caching, or someone wants to do that themselves, then
// offering this as a point to hook into would be an optimisation opportunity
@available(*, deprecated, message: "Please use subscribeToRoomMultipart")
public func subscribeToRoom(
id roomID: String,
roomDelegate: PCRoomDelegate,
messageLimit: Int = 20,
completionHandler: @escaping PCErrorCompletionHandler
) {
self.roomStore.room(id: roomID) { r, err in
guard err == nil, let room = r else {
self.instance.logger.log(
"Error getting room from room store as part of room subscription process \(err!.localizedDescription)",
logLevel: .error
)
completionHandler(err)
return
}
self.subscribeToRoom(
room,
delegate: roomDelegate,
messageLimit: messageLimit,
instance: self.instance,
version: "v2",
completionHandler: completionHandler
)
}
}
public func subscribeToRoomMultipart(
room: PCRoom,
roomDelegate: PCRoomDelegate,
messageLimit: Int = 20,
completionHandler: @escaping PCErrorCompletionHandler
) {
self.subscribeToRoom(
room,
delegate: roomDelegate,
messageLimit: messageLimit,
instance: self.v6Instance,
version: "v6",
completionHandler: completionHandler
)
}
public func subscribeToRoomMultipart(
id roomID: String,
roomDelegate: PCRoomDelegate,
messageLimit: Int = 20,
completionHandler: @escaping PCErrorCompletionHandler
) {
self.roomStore.room(id: roomID) { r, err in
guard err == nil, let room = r else {
self.v6Instance.logger.log(
"Error getting room from room store as part of multipart message subscription \(err!.localizedDescription)",
logLevel: .error
)
completionHandler(err)
return
}
self.subscribeToRoom(
room,
delegate: roomDelegate,
messageLimit: messageLimit,
instance: self.v6Instance,
version: "v6",
completionHandler: completionHandler
)
}
}
fileprivate func subscribeToRoom(
_ room: PCRoom,
delegate: PCRoomDelegate,
messageLimit: Int = 20,
instance: Instance,
version: String,
completionHandler: @escaping PCErrorCompletionHandler
) {
instance.logger.log(
"About to subscribe to room \(room.debugDescription)",
logLevel: .verbose
)
self.joinRoom(roomID: room.id) { innerRoom, err in
guard let roomToSubscribeTo = innerRoom, err == nil else {
instance.logger.log(
"Error joining room as part of room subscription process \(room.debugDescription)",
logLevel: .error
)
return
}
if room.subscription != nil {
room.subscription!.end()
room.subscription = nil
}
room.subscription = PCRoomSubscription(
room: roomToSubscribeTo,
messageLimit: messageLimit,
currentUserID: self.id,
roomDelegate: delegate,
chatManagerDelegate: self.delegate,
userStore: self.userStore,
roomStore: self.roomStore,
cursorStore: self.cursorStore,
typingIndicatorManager: self.typingIndicatorManager,
instance: instance,
cursorsInstance: self.cursorsInstance,
version: version,
logger: self.instance.logger,
completionHandler: completionHandler
)
}
}
@available(*, deprecated, message: "Please use fetchMultipartMessages")
public func fetchMessagesFromRoom(
_ room: PCRoom,
initialID: String? = nil,
limit: Int? = nil,
direction: PCRoomMessageFetchDirection = .older,
completionHandler: @escaping ([PCMessage]?, Error?) -> Void
) {
self.fetchEnrichedMessages(
room,
initialID: initialID,
limit: limit,
direction: direction,
instance: self.instance,
deserialise: PCPayloadDeserializer.createBasicMessageFromPayload,
messageFactory: { (basicMessage, room, user) in
return PCMessage(
id: basicMessage.id,
text: basicMessage.text,
createdAt: basicMessage.createdAt,
updatedAt: basicMessage.updatedAt,
deletedAt: basicMessage.deletedAt,
attachment: basicMessage.attachment,
sender: user,
room: room
)
},
completionHandler: completionHandler
)
}
public func fetchMultipartMessages(
_ room: PCRoom,
initialID: String? = nil,
limit: Int? = nil,
direction: PCRoomMessageFetchDirection = .older,
completionHandler: @escaping ([PCMultipartMessage]?, Error?) -> Void
) {
self.fetchEnrichedMessages(
room,
initialID: initialID,
limit: limit,
direction: direction,
instance: self.v6Instance,
deserialise: { rawPayload in
return try PCPayloadDeserializer.createMultipartMessageFromPayload(
rawPayload,
urlRefresher: PCMultipartAttachmentUrlRefresher(client: self.v6Instance)
)
},
messageFactory: { (basicMessage, room, user) in
return PCMultipartMessage(
id: basicMessage.id,
sender: user,
room: room,
parts: basicMessage.parts,
createdAt: basicMessage.createdAt,
updatedAt: basicMessage.updatedAt
)
},
completionHandler: completionHandler
)
}
fileprivate func fetchEnrichedMessages<A: PCCommonBasicMessage, B: PCEnrichedMessage>(
_ room: PCRoom,
initialID: String? = nil,
limit: Int? = nil,
direction: PCRoomMessageFetchDirection = .older,
instance: Instance,
deserialise: @escaping ([String: Any]) throws -> A,
messageFactory: @escaping (A, PCRoom, PCUser) -> B,
completionHandler: @escaping ([B]?, Error?) -> Void
) {
let path = "/rooms/\(room.id)/messages"
let generalRequest = PPRequestOptions(method: HTTPMethod.GET.rawValue, path: path)
if let initialID = initialID {
generalRequest.addQueryItems([URLQueryItem(name: "initial_id", value: initialID)])
}
if let limit = limit {
generalRequest.addQueryItems([URLQueryItem(name: "limit", value: String(limit))])
}
generalRequest.addQueryItems([URLQueryItem(name: "direction", value: direction.rawValue)])
instance.requestWithRetry(
using: generalRequest,
onSuccess: { data in
guard let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) else {
completionHandler(nil, PCError.failedToDeserializeJSON(data))
return
}
guard let messagesPayload = jsonObject as? [[String: Any]] else {
completionHandler(nil, PCError.failedToCastJSONObjectToDictionary(jsonObject))
return
}
guard messagesPayload.count > 0 else {
completionHandler([], nil)
return
}
let progressCounter = PCProgressCounter(totalCount: messagesPayload.count, labelSuffix: "message-enricher")
let messages = PCSynchronizedArray<B>()
var basicMessages: [A] = []
let messageUserIDs = messagesPayload.compactMap { messagePayload -> String? in
do {
let basicMessage = try deserialise(messagePayload)
basicMessages.append(basicMessage)
return basicMessage.senderID
} catch let err {
instance.logger.log(err.localizedDescription, logLevel: .debug)
return nil
}
}
let messageUserIDsSet = Set<String>(messageUserIDs)
self.userStore.fetchUsersWithIDs(messageUserIDsSet) { _, err in
if let err = err {
instance.logger.log(err.localizedDescription, logLevel: .debug)
}
let messageEnricher = PCBasicMessageEnricher<A, B>(
userStore: self.userStore,
room: room,
messageFactory: messageFactory,
logger: instance.logger
)
basicMessages.forEach { basicMessage in
messageEnricher.enrich(basicMessage) { message, err in
guard let message = message, err == nil else {
instance.logger.log(err!.localizedDescription, logLevel: .debug)
if progressCounter.incrementFailedAndCheckIfFinished() {
completionHandler(messages.clone().sorted(by: { $0.id > $1.id }), nil)
}
return
}
messages.append(message)
if progressCounter.incrementSuccessAndCheckIfFinished() {
completionHandler(
messages.clone().sorted(
by: { $0.id < $1.id }
),
nil
)
}
}
}
}
},
onError: { error in
completionHandler(nil, error)
}
)
}
public func readCursor(roomID: String, userID: String? = nil) throws -> PCCursor? {
guard let room = self.rooms.filter({ $0.id == roomID }).first else {
throw PCCurrentUserError.mustBeMemberOfRoom
}
let userIDToCheck = userID ?? self.id
if userIDToCheck != self.id && room.subscription == nil {
throw PCCurrentUserError.noSubscriptionToRoom(room)
}
return self.cursorStore.getSync(userID: userIDToCheck, roomID: roomID)
}
public func setReadCursor(position: Int, roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
readCursorDebouncerManager.set(cursorPosition: position, inRoomID: roomID, completionHandler: completionHandler)
}
func sendReadCursor(position: Int, roomID: String, completionHandler: @escaping PCErrorCompletionHandler) {
let cursorObject = ["position": position]
guard JSONSerialization.isValidJSONObject(cursorObject) else {
completionHandler(PCError.invalidJSONObjectAsData(cursorObject))
return
}
guard let data = try? JSONSerialization.data(withJSONObject: cursorObject, options: []) else {
completionHandler(PCError.failedToJSONSerializeData(cursorObject))
return
}
let path = "/cursors/\(PCCursorType.read.rawValue)/rooms/\(roomID)/users/\(self.pathFriendlyID)"
let cursorRequest = PPRequestOptions(method: HTTPMethod.PUT.rawValue, path: path, body: data)
self.cursorsInstance.request(
using: cursorRequest,
onSuccess: { data in
self.cursorsInstance.logger.log("Successfully set cursor in room \(roomID)", logLevel: .verbose)
completionHandler(nil)
},
onError: { err in
self.cursorsInstance.logger.log("Error setting cursor in room \(roomID): \(err.localizedDescription)", logLevel: .debug)
completionHandler(err)
}
)
}
fileprivate func subscribeToUserPresence(user: PCUser) {
guard user.id != self.id else {
return // don't subscribe to own presence
}
guard self.userPresenceSubscriptions[user.id] == nil else {
return // already subscribed to presence for user
}
let path = "/users/\(user.pathFriendlyID)"
let subscribeRequest = PPRequestOptions(
method: HTTPMethod.SUBSCRIBE.rawValue,
path: path
)
var resumableSub = PPResumableSubscription(
instance: self.presenceInstance,
requestOptions: subscribeRequest
)
let userPresenceSubscription = PCUserPresenceSubscription(
userID: user.id,
resumableSubscription: resumableSub,
userStore: self.userStore,
roomStore: self.roomStore,
logger: self.presenceInstance.logger,
delegate: delegate
)
self.userPresenceSubscriptions[user.id] = userPresenceSubscription
self.presenceInstance.subscribeWithResume(
with: &resumableSub,
using: subscribeRequest,
onEvent: { [unowned userPresenceSubscription] eventID, headers, data in
userPresenceSubscription.handleEvent(eventID: eventID, headers: headers, data: data)
},
onError: { err in
// TODO: What to do with an error? Just log?
self.cursorsInstance.logger.log(
"Error with user presence subscription for user with ID \(user.id): \(err.localizedDescription)",
logLevel: .error
)
}
)
}
}
struct PartObjectWithIndex {
let object: [String: Any]
let index: Int
}
func reconcileMemberships(
new: [PCUser],
old: [PCUser],
onUserJoinedHook: ((PCUser) -> Void)?,
onUserLeftHook: ((PCUser) -> Void)?
) {
let oldSet = Set(old)
let newSet = Set(new)
let newMembers = newSet.subtracting(oldSet)
let membersRemoved = oldSet.subtracting(newSet)
newMembers.forEach { onUserJoinedHook?($0) }
membersRemoved.forEach { m in
onUserLeftHook?(m)
}
}
public enum PCCurrentUserError: Error {
case noSubscriptionToRoom(PCRoom)
case mustBeMemberOfRoom
}
extension PCCurrentUser: PCUpdatable {
@discardableResult
func updateWithPropertiesOf(_ currentUser: PCCurrentUser) -> PCCurrentUser {
self.updatedAt = currentUser.updatedAt
self.name = currentUser.name
self.avatarURL = currentUser.avatarURL
self.customData = currentUser.customData
self.delegate = currentUser.delegate
return self
}
}
extension PCCurrentUserError: LocalizedError {
public var errorDescription: String? {
switch self {
case let .noSubscriptionToRoom(room):
return "You must be subscribed to room \(room.name) to get read cursors from it"
case .mustBeMemberOfRoom:
return "You must be a member of a room to get the read cursors for it"
}
}
}
public enum PCMessageError: Error {
case messageIDKeyMissingInMessageCreationResponse([String: Int])
}
extension PCMessageError: LocalizedError {
public var errorDescription: String? {
switch self {
case let .messageIDKeyMissingInMessageCreationResponse(payload):
return "\"message_id\" key missing from response after message creation: \(payload)"
}
}
}
public enum PCRoomMessageFetchDirection: String {
case older
case newer
}
public typealias PCErrorCompletionHandler = (Error?) -> Void
public typealias PCRoomCompletionHandler = (PCRoom?, Error?) -> Void
public typealias PCRoomsCompletionHandler = ([PCRoom]?, Error?) -> Void
// MARK: Beams
#if os(iOS) || os(macOS)
import PushNotifications
extension PCCurrentUser {
/**
Start PushNotifications service.
*/
public func enablePushNotifications() {
let beamsClient = PushNotifications(instanceId: self.v6Instance.id)
beamsClient.start()
let chatkitBeamsTokenProvider = ChatkitBeamsTokenProvider(instance: self.chatkitBeamsTokenProviderInstance)
beamsClient.setUserId(self.id, tokenProvider: chatkitBeamsTokenProvider) { error in
guard error == nil else {
return self.v6Instance.logger.log("Error occured while setting the user: \(error!)", logLevel: .error)
}
self.v6Instance.logger.log("Push Notifications service enabled 🎉", logLevel: .debug)
}
ChatManager.registerForRemoteNotifications()
}
}
#endif
| 37.878533 | 147 | 0.590384 |
1e16e12f05d2f88fc6fe2f440cfa2eb2386dd915 | 6,699 | // Generated using Sourcery 0.16.1 — https://github.com/krzysztofzablocki/Sourcery
// DO NOT EDIT
// Re-export various types from MongoSwift that are also used in the API for MongoSwiftSync. We start out with all of
// the types in MongoSwift, and then filter out types that are not public, that are explicitly annotated with
// "skipSyncExport" (this is used to mark types that are async-specific) and types whose definitions are nested within
// other types. We don't need to explicitly re-export nested types as re-exporting their parent types will make them
// available under their parents' namespaces, just as they are in the async module.
@_exported import struct MongoSwift.AggregateOptions
@_exported import struct MongoSwift.AuthenticationError
@_exported import enum MongoSwift.BSON
@_exported import struct MongoSwift.BSONCoderOptions
@_exported import class MongoSwift.BSONDecoder
@_exported import class MongoSwift.BSONEncoder
@_exported import enum MongoSwift.BSONType
@_exported import struct MongoSwift.Binary
@_exported import struct MongoSwift.BulkWriteError
@_exported import struct MongoSwift.BulkWriteFailure
@_exported import struct MongoSwift.BulkWriteOptions
@_exported import struct MongoSwift.BulkWriteResult
@_exported import struct MongoSwift.ChangeStreamEvent
@_exported import struct MongoSwift.ChangeStreamOptions
@_exported import struct MongoSwift.ClientOptions
@_exported import class MongoSwift.ClientSession
@_exported import struct MongoSwift.ClientSessionOptions
@_exported import struct MongoSwift.Code
@_exported import struct MongoSwift.CodeWithScope
@_exported import struct MongoSwift.CollectionOptions
@_exported import struct MongoSwift.CollectionSpecification
@_exported import struct MongoSwift.CollectionSpecificationInfo
@_exported import enum MongoSwift.CollectionType
@_exported import struct MongoSwift.CommandError
@_exported import struct MongoSwift.CommandFailedEvent
@_exported import struct MongoSwift.CommandStartedEvent
@_exported import struct MongoSwift.CommandSucceededEvent
@_exported import struct MongoSwift.CompatibilityError
@_exported import struct MongoSwift.ConnectionError
@_exported import struct MongoSwift.ConnectionId
@_exported import struct MongoSwift.CountDocumentsOptions
@_exported import struct MongoSwift.CreateCollectionOptions
@_exported import struct MongoSwift.CreateIndexOptions
@_exported import enum MongoSwift.CursorType
@_exported import struct MongoSwift.DBPointer
@_exported import enum MongoSwift.DataCodingStrategy
@_exported import struct MongoSwift.DatabaseOptions
@_exported import struct MongoSwift.DatabaseSpecification
@_exported import enum MongoSwift.DateCodingStrategy
@_exported import struct MongoSwift.Decimal128
@_exported import struct MongoSwift.DeleteModelOptions
@_exported import struct MongoSwift.DeleteOptions
@_exported import struct MongoSwift.DeleteResult
@_exported import struct MongoSwift.DistinctOptions
@_exported import struct MongoSwift.Document
@_exported import class MongoSwift.DocumentIterator
@_exported import class MongoSwift.DocumentStorage
@_exported import struct MongoSwift.DropCollectionOptions
@_exported import struct MongoSwift.DropDatabaseOptions
@_exported import struct MongoSwift.DropIndexOptions
@_exported import struct MongoSwift.EstimatedDocumentCountOptions
@_exported import struct MongoSwift.FindOneAndDeleteOptions
@_exported import struct MongoSwift.FindOneAndReplaceOptions
@_exported import struct MongoSwift.FindOneAndUpdateOptions
@_exported import struct MongoSwift.FindOneOptions
@_exported import struct MongoSwift.FindOptions
@_exported import enum MongoSwift.FullDocument
@_exported import enum MongoSwift.Hint
@_exported import struct MongoSwift.IndexModel
@_exported import struct MongoSwift.IndexOptions
@_exported import struct MongoSwift.InsertManyResult
@_exported import struct MongoSwift.InsertOneOptions
@_exported import struct MongoSwift.InsertOneResult
@_exported import struct MongoSwift.InternalError
@_exported import struct MongoSwift.InvalidArgumentError
@_exported import struct MongoSwift.ListCollectionsOptions
@_exported import struct MongoSwift.LogicError
@_exported import struct MongoSwift.MongoNamespace
@_exported import struct MongoSwift.ObjectId
@_exported import enum MongoSwift.OperationType
@_exported import struct MongoSwift.ReadConcern
@_exported import class MongoSwift.ReadPreference
@_exported import struct MongoSwift.RegularExpression
@_exported import struct MongoSwift.ReplaceOneModelOptions
@_exported import struct MongoSwift.ReplaceOptions
@_exported import struct MongoSwift.ResumeToken
@_exported import enum MongoSwift.ReturnDocument
@_exported import struct MongoSwift.RunCommandOptions
@_exported import struct MongoSwift.ServerClosedEvent
@_exported import struct MongoSwift.ServerDescription
@_exported import struct MongoSwift.ServerDescriptionChangedEvent
@_exported import struct MongoSwift.ServerHeartbeatFailedEvent
@_exported import struct MongoSwift.ServerHeartbeatStartedEvent
@_exported import struct MongoSwift.ServerHeartbeatSucceededEvent
@_exported import struct MongoSwift.ServerOpeningEvent
@_exported import struct MongoSwift.ServerSelectionError
@_exported import struct MongoSwift.Symbol
@_exported import struct MongoSwift.TLSOptions
@_exported import struct MongoSwift.Timestamp
@_exported import struct MongoSwift.TopologyClosedEvent
@_exported import struct MongoSwift.TopologyDescription
@_exported import struct MongoSwift.TopologyDescriptionChangedEvent
@_exported import struct MongoSwift.TopologyOpeningEvent
@_exported import enum MongoSwift.UUIDCodingStrategy
@_exported import struct MongoSwift.UpdateDescription
@_exported import struct MongoSwift.UpdateModelOptions
@_exported import struct MongoSwift.UpdateOptions
@_exported import struct MongoSwift.UpdateResult
@_exported import struct MongoSwift.WriteConcern
@_exported import struct MongoSwift.WriteConcernFailure
@_exported import struct MongoSwift.WriteError
@_exported import struct MongoSwift.WriteFailure
@_exported import enum MongoSwift.WriteModel
// Protocols are not included in the types list, so we list them separately here.
@_exported import protocol MongoSwift.CodingStrategyProvider
@_exported import protocol MongoSwift.LabeledError
@_exported import protocol MongoSwift.MongoCommandEvent
@_exported import protocol MongoSwift.MongoError
@_exported import protocol MongoSwift.MongoEvent
@_exported import protocol MongoSwift.RuntimeError
@_exported import protocol MongoSwift.ServerError
@_exported import protocol MongoSwift.UserError
// Manually add typealiases
@_exported import typealias MongoSwift.InsertManyOptions
@_exported import typealias MongoSwift.ServerErrorCode
| 52.335938 | 118 | 0.873265 |
c1ea0d04aa4854d6f00b34461a43efac0e89de15 | 1,752 | //
// Created by Pierluigi Cifani on 20/07/2018.
// Copyright © 2018 Dada. All rights reserved.
//
import UIKit
open class TransparentNavBarViewController: UIViewController {
open var shouldShowNavBarShadow: Bool = true
public var navBarBehaviour: NavBarTransparentBehavior?
public let scrollableStackView = ScrollableStackView()
override open func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = .white
let containerView = HostView()
view.addSubview(containerView)
containerView.pinToSuperview()
containerView.addSubview(scrollableStackView)
scrollableStackView.pinToSuperview()
}
override open func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
guard let navController = self.navigationController else {
fatalError()
}
navBarBehaviour = NavBarTransparentBehavior(navBar: navController.navigationBar, scrollView: scrollableStackView, shouldShowShadow: shouldShowNavBarShadow)
}
override open func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
navBarBehaviour?.setNavBar(toState: .regular)
navBarBehaviour = nil
}
}
extension TransparentNavBarViewController {
// This prevents UIKit to layout the
// subviews below the navBar
@objc(BSWTransparentNavBarViewHost)
private class HostView: UIView {
@available(iOS 11.0, *)
override var safeAreaInsets: UIEdgeInsets {
let superSafeArea = super.safeAreaInsets
return UIEdgeInsets(top: 0, left: superSafeArea.left, bottom: superSafeArea.bottom, right: superSafeArea.right)
}
}
}
| 31.854545 | 163 | 0.692922 |
d92ea3a100bc7f114471f5ee0ed02310f4119cb6 | 877 | //
// PresentTests.swift
// PresentTests
//
// Created on 14/2/21.
//
import XCTest
@testable import Present
class PresentTests: XCTestCase {
override func setUpWithError() throws {
// Put setup code here. This method is called before the invocation of each test method in the class.
}
override func tearDownWithError() throws {
// Put teardown code here. This method is called after the invocation of each test method in the class.
}
func testExample() throws {
// This is an example of a functional test case.
// Use XCTAssert and related functions to verify your tests produce the correct results.
}
func testPerformanceExample() throws {
// This is an example of a performance test case.
self.measure {
// Put the code you want to measure the time of here.
}
}
}
| 25.794118 | 111 | 0.659065 |
ef280e22bb1d6c4087917b74f51fd035cb052764 | 1,432 | /*:
# Swift之旅
这行代码是一个完整的程序。无需为输入/输出或字符串处理等功能导入单独的库、在全局范围编写的代码用作程序的入口点，不需要main()函数，也不需要在每个语句的末尾写分号。
*/
print("hello, world!")
/*:
## 简单的值
使用let声明一个常数，var声明一个变量。在编译时不需要知道常量的值，但必须为其分配一次值。这意味着您可以使用常量来命名您确定一次但在许多地方使用的值。
*/
var myVariable = 42
myVariable = 50
let myConstant = 42
//: 如果初始值未提供足够的信息（或者没有初始值），请通过在变量后面写入来指定类型，用冒号分隔。
let intCons: Int
let stringCons: Double = 5
//: 练习:
//: 创建一个Float类型值为4的常量
let exV: Float = 4
//: 值永远不会隐式转换为其他类型。如果需要将值转换为其他类型，请显式创建所需类型的实例。
let label = "宽度是"
let width = 8
var widthLabel = label + String(width)
//: 练习:
//: 尝试删除上面一行的String显式转换，看得到什么错误。
//: widthLabel = label + width//(Binary operator '+' cannot be applied to operands of type 'String' and 'Int')
//: 有一种简单的方法可以在字符串中包含值：在括号中写入值，并在括号前写入\。
let apples = 3
let oranges = 5
let appleSummary = "我有\(apples)个苹果"
let orangeSummary = "我有个\(oranges)橘子"
//: 对于占用多行的字符串，请使用三个双引号，每个引用行开头的缩进都会被删除，只要它与右引号的缩进相匹配即可(字符串必须另起一行，结束的三个引号也必须另起一行)
let quotation = """
我有\(apples)个苹果
我还有\(oranges)个橘子
"""
//: 使用方括号（[]）创建数组和字典，并通过在括号中写入索引或键来访问它们的元素。最后一个元素后面允许逗号。
var shoppingList = ["鱼", "狗", "人", "猪",]
shoppingList[0] = "草鱼"
var occupations = ["张三": "厨师", "李四": "iOS程序员", ]
occupations["lis"] = "前台"
//: 创建空数组或字典，请使用初始化程序语法。
let emptyArray = [String]()
let emptyDictionary = [String: Int]()
//: 如果可以推断类型信息，则可以将空数组写为[]空字典写为[:]
shoppingList = []
occupations = [:]
let emptyStringArray: [String] = []
let emptyStringDictionary: [String: String] = [:]
| 23.866667 | 110 | 0.712291 |
ac1150a32a8fd35231ac43213b31aac1cc10c66e | 599 | //
// HashableKeyPath.swift
// QBRepository
//
// Created by Stefan Kofler on 01.04.18.
//
import Foundation
public class HashableKeyPath<Model> {
private let _hashValue: (Model) -> Int
private let _string: () -> String
public init<T: Hashable>(_ keyPath: KeyPath<Model, T>) {
_hashValue = { obj in
return obj[keyPath: keyPath].hashValue
}
_string = {
return keyPath._kvcKeyPathString! as String
}
}
public func hashValue(obj: Model) -> Int {
return _hashValue(obj)
}
public func string() -> String {
return _string()
}
}
| 17.617647 | 58 | 0.626043 |
e208ee5fd22d486f0b34d67dfe05e938869e387f | 3,418 | //
// Strand.swift
// Strand
//
// Created by James Richard on 3/1/16.
//
#if os(Linux)
import Glibc
#else
import Darwin.C
#endif
#if !swift(>=3.0)
typealias Error = ErrorType
typealias OpaquePointer = COpaquePointer
#endif
public enum StrandError: Error {
case threadCreationFailed
case threadCancellationFailed(Int)
case threadJoinFailed(Int)
}
public class Strand {
#if swift(>=3.0)
#if os(Linux)
private var pthread: pthread_t = 0
#else
private var pthread: pthread_t
#endif
#else
#if os(Linux)
private var pthread: pthread_t = 0
#else
private var pthread: pthread_t = nil
#endif
#endif
public init(closure: () -> Void) throws {
let holder = Unmanaged.passRetained(StrandClosure(closure: closure))
#if swift(>=3.0)
let pointer = UnsafeMutablePointer<Void>(holder.toOpaque())
#if os(Linux)
guard pthread_create(&pthread, nil, runner, pointer) == 0 else {
holder.release()
throw StrandError.threadCreationFailed
}
#else
var pt: pthread_t?
guard pthread_create(&pt, nil, runner, pointer) == 0 && pt != nil else {
holder.release()
throw StrandError.threadCreationFailed
}
pthread = pt!
#endif
#else
let pointer = UnsafeMutablePointer<Void>(OpaquePointer(bitPattern: holder))
guard pthread_create(&pthread, nil, runner, pointer) == 0 else {
holder.release()
throw StrandError.threadCreationFailed
}
#endif
}
public func join() throws {
let status = pthread_join(pthread, nil)
if status != 0 {
throw StrandError.threadJoinFailed(Int(status))
}
}
public func cancel() throws {
let status = pthread_cancel(pthread)
if status != 0 {
throw StrandError.threadCancellationFailed(Int(status))
}
}
#if swift(>=3.0)
public class func exit(code: inout Int) {
pthread_exit(&code)
}
#else
public class func exit(inout code: Int) {
pthread_exit(&code)
}
#endif
deinit {
pthread_detach(pthread)
}
}
#if swift(>=3.0)
#if os(Linux)
private func runner(arg: UnsafeMutablePointer<Void>?) -> UnsafeMutablePointer<Void>? {
guard let arg = arg else { return nil }
let unmanaged = Unmanaged<StrandClosure>.fromOpaque(arg)
unmanaged.takeUnretainedValue().closure()
unmanaged.release()
return nil
}
#else
private func runner(arg: UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void>? {
let unmanaged = Unmanaged<StrandClosure>.fromOpaque(arg)
unmanaged.takeUnretainedValue().closure()
unmanaged.release()
return nil
}
#endif
#else
private func runner(arg: UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void> {
let unmanaged = Unmanaged<StrandClosure>.fromOpaque(OpaquePointer(arg))
unmanaged.takeUnretainedValue().closure()
unmanaged.release()
return nil
}
#endif
private class StrandClosure {
let closure: () -> Void
init(closure: () -> Void) {
self.closure = closure
}
}
| 26.496124 | 90 | 0.587478 |
1c10842cdaaddf47d4957c89e85f034a69a82f62 | 25,974 | //
// RtcEngineEvent.swift
// RCTAgora
//
// Created by LXH on 2020/4/13.
// Copyright (c) 2020 Syan. All rights reserved.
//
import AgoraRtcKit
import Foundation
class RtcEngineEvents {
static let Warning = "Warning"
static let Error = "Error"
static let ApiCallExecuted = "ApiCallExecuted"
static let JoinChannelSuccess = "JoinChannelSuccess"
static let RejoinChannelSuccess = "RejoinChannelSuccess"
static let LeaveChannel = "LeaveChannel"
static let LocalUserRegistered = "LocalUserRegistered"
static let UserInfoUpdated = "UserInfoUpdated"
static let ClientRoleChanged = "ClientRoleChanged"
static let UserJoined = "UserJoined"
static let UserOffline = "UserOffline"
static let ConnectionStateChanged = "ConnectionStateChanged"
static let NetworkTypeChanged = "NetworkTypeChanged"
static let ConnectionLost = "ConnectionLost"
static let TokenPrivilegeWillExpire = "TokenPrivilegeWillExpire"
static let RequestToken = "RequestToken"
static let AudioVolumeIndication = "AudioVolumeIndication"
static let ActiveSpeaker = "ActiveSpeaker"
static let FirstLocalAudioFrame = "FirstLocalAudioFrame"
static let FirstLocalVideoFrame = "FirstLocalVideoFrame"
static let UserMuteVideo = "UserMuteVideo"
static let VideoSizeChanged = "VideoSizeChanged"
static let RemoteVideoStateChanged = "RemoteVideoStateChanged"
static let LocalVideoStateChanged = "LocalVideoStateChanged"
static let RemoteAudioStateChanged = "RemoteAudioStateChanged"
static let LocalAudioStateChanged = "LocalAudioStateChanged"
static let LocalPublishFallbackToAudioOnly = "LocalPublishFallbackToAudioOnly"
static let RemoteSubscribeFallbackToAudioOnly = "RemoteSubscribeFallbackToAudioOnly"
static let AudioRouteChanged = "AudioRouteChanged"
static let CameraFocusAreaChanged = "CameraFocusAreaChanged"
static let CameraExposureAreaChanged = "CameraExposureAreaChanged"
static let FacePositionChanged = "FacePositionChanged"
static let RtcStats = "RtcStats"
static let LastmileQuality = "LastmileQuality"
static let NetworkQuality = "NetworkQuality"
static let LastmileProbeResult = "LastmileProbeResult"
static let LocalVideoStats = "LocalVideoStats"
static let LocalAudioStats = "LocalAudioStats"
static let RemoteVideoStats = "RemoteVideoStats"
static let RemoteAudioStats = "RemoteAudioStats"
static let AudioMixingFinished = "AudioMixingFinished"
static let AudioMixingStateChanged = "AudioMixingStateChanged"
static let AudioEffectFinished = "AudioEffectFinished"
static let RtmpStreamingStateChanged = "RtmpStreamingStateChanged"
static let TranscodingUpdated = "TranscodingUpdated"
static let StreamInjectedStatus = "StreamInjectedStatus"
static let StreamMessage = "StreamMessage"
static let StreamMessageError = "StreamMessageError"
static let MediaEngineLoadSuccess = "MediaEngineLoadSuccess"
static let MediaEngineStartCallSuccess = "MediaEngineStartCallSuccess"
static let ChannelMediaRelayStateChanged = "ChannelMediaRelayStateChanged"
static let ChannelMediaRelayEvent = "ChannelMediaRelayEvent"
static let FirstRemoteVideoFrame = "FirstRemoteVideoFrame"
static let FirstRemoteAudioFrame = "FirstRemoteAudioFrame"
static let FirstRemoteAudioDecoded = "FirstRemoteAudioDecoded"
static let UserMuteAudio = "UserMuteAudio"
static let StreamPublished = "StreamPublished"
static let StreamUnpublished = "StreamUnpublished"
static let RemoteAudioTransportStats = "RemoteAudioTransportStats"
static let RemoteVideoTransportStats = "RemoteVideoTransportStats"
static let UserEnableVideo = "UserEnableVideo"
static let UserEnableLocalVideo = "UserEnableLocalVideo"
static let FirstRemoteVideoDecoded = "FirstRemoteVideoDecoded"
static let MicrophoneEnabled = "MicrophoneEnabled"
static let ConnectionInterrupted = "ConnectionInterrupted"
static let ConnectionBanned = "ConnectionBanned"
static let AudioQuality = "AudioQuality"
static let CameraReady = "CameraReady"
static let VideoStopped = "VideoStopped"
static let MetadataReceived = "MetadataReceived"
static let FirstLocalAudioFramePublished = "FirstLocalAudioFramePublished"
static let FirstLocalVideoFramePublished = "FirstLocalVideoFramePublished"
static let AudioPublishStateChanged = "AudioPublishStateChanged"
static let VideoPublishStateChanged = "VideoPublishStateChanged"
static let AudioSubscribeStateChanged = "AudioSubscribeStateChanged"
static let VideoSubscribeStateChanged = "VideoSubscribeStateChanged"
static let RtmpStreamingEvent = "RtmpStreamingEvent"
static let UserSuperResolutionEnabled = "UserSuperResolutionEnabled"
static let UploadLogResult = "UploadLogResult"
static let AirPlayIsConnected = "AirPlayIsConnected"
static let VirtualBackgroundSourceEnabled = "VirtualBackgroundSourceEnabled"
static func toMap() -> [String: String] {
return [
"Warning": Warning,
"Error": Error,
"ApiCallExecuted": ApiCallExecuted,
"JoinChannelSuccess": JoinChannelSuccess,
"RejoinChannelSuccess": RejoinChannelSuccess,
"LeaveChannel": LeaveChannel,
"LocalUserRegistered": LocalUserRegistered,
"UserInfoUpdated": UserInfoUpdated,
"ClientRoleChanged": ClientRoleChanged,
"UserJoined": UserJoined,
"UserOffline": UserOffline,
"ConnectionStateChanged": ConnectionStateChanged,
"NetworkTypeChanged": NetworkTypeChanged,
"ConnectionLost": ConnectionLost,
"TokenPrivilegeWillExpire": TokenPrivilegeWillExpire,
"RequestToken": RequestToken,
"AudioVolumeIndication": AudioVolumeIndication,
"ActiveSpeaker": ActiveSpeaker,
"FirstLocalAudioFrame": FirstLocalAudioFrame,
"FirstLocalVideoFrame": FirstLocalVideoFrame,
"UserMuteVideo": UserMuteVideo,
"VideoSizeChanged": VideoSizeChanged,
"RemoteVideoStateChanged": RemoteVideoStateChanged,
"LocalVideoStateChanged": LocalVideoStateChanged,
"RemoteAudioStateChanged": RemoteAudioStateChanged,
"LocalAudioStateChanged": LocalAudioStateChanged,
"LocalPublishFallbackToAudioOnly": LocalPublishFallbackToAudioOnly,
"RemoteSubscribeFallbackToAudioOnly": RemoteSubscribeFallbackToAudioOnly,
"AudioRouteChanged": AudioRouteChanged,
"CameraFocusAreaChanged": CameraFocusAreaChanged,
"CameraExposureAreaChanged": CameraExposureAreaChanged,
"FacePositionChanged": FacePositionChanged,
"RtcStats": RtcStats,
"LastmileQuality": LastmileQuality,
"NetworkQuality": NetworkQuality,
"LastmileProbeResult": LastmileProbeResult,
"LocalVideoStats": LocalVideoStats,
"LocalAudioStats": LocalAudioStats,
"RemoteVideoStats": RemoteVideoStats,
"RemoteAudioStats": RemoteAudioStats,
"AudioMixingFinished": AudioMixingFinished,
"AudioMixingStateChanged": AudioMixingStateChanged,
"AudioEffectFinished": AudioEffectFinished,
"RtmpStreamingStateChanged": RtmpStreamingStateChanged,
"TranscodingUpdated": TranscodingUpdated,
"StreamInjectedStatus": StreamInjectedStatus,
"StreamMessage": StreamMessage,
"StreamMessageError": StreamMessageError,
"MediaEngineLoadSuccess": MediaEngineLoadSuccess,
"MediaEngineStartCallSuccess": MediaEngineStartCallSuccess,
"ChannelMediaRelayStateChanged": ChannelMediaRelayStateChanged,
"ChannelMediaRelayEvent": ChannelMediaRelayEvent,
"FirstRemoteVideoFrame": FirstRemoteVideoFrame,
"FirstRemoteAudioFrame": FirstRemoteAudioFrame,
"FirstRemoteAudioDecoded": FirstRemoteAudioDecoded,
"UserMuteAudio": UserMuteAudio,
"StreamPublished": StreamPublished,
"StreamUnpublished": StreamUnpublished,
"RemoteAudioTransportStats": RemoteAudioTransportStats,
"RemoteVideoTransportStats": RemoteVideoTransportStats,
"UserEnableVideo": UserEnableVideo,
"UserEnableLocalVideo": UserEnableLocalVideo,
"FirstRemoteVideoDecoded": FirstRemoteVideoDecoded,
"MicrophoneEnabled": MicrophoneEnabled,
"ConnectionInterrupted": ConnectionInterrupted,
"ConnectionBanned": ConnectionBanned,
"AudioQuality": AudioQuality,
"CameraReady": CameraReady,
"VideoStopped": VideoStopped,
"MetadataReceived": MetadataReceived,
"FirstLocalAudioFramePublished": FirstLocalAudioFramePublished,
"FirstLocalVideoFramePublished": FirstLocalVideoFramePublished,
"AudioPublishStateChanged": AudioPublishStateChanged,
"VideoPublishStateChanged": VideoPublishStateChanged,
"AudioSubscribeStateChanged": AudioSubscribeStateChanged,
"VideoSubscribeStateChanged": VideoSubscribeStateChanged,
"RtmpStreamingEvent": RtmpStreamingEvent,
"UserSuperResolutionEnabled": UserSuperResolutionEnabled,
"UploadLogResult": UploadLogResult,
"AirPlayIsConnected": AirPlayIsConnected,
"VirtualBackgroundSourceEnabled": VirtualBackgroundSourceEnabled,
]
}
}
class RtcEngineEventHandler: NSObject {
static let PREFIX = "io.agora.rtc."
var emitter: (_ methodName: String, _ data: [String: Any?]?) -> Void
init(emitter: @escaping (_ methodName: String, _ data: [String: Any?]?) -> Void) {
self.emitter = emitter
}
private func callback(_ methodName: String, _ data: Any?...) {
emitter(methodName, ["data": data])
}
}
extension RtcEngineEventHandler: AgoraRtcEngineDelegate {
public func rtcEngine(_: AgoraRtcEngineKit, didOccurWarning warningCode: AgoraWarningCode) {
callback(RtcEngineEvents.Warning, warningCode.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, didOccurError errorCode: AgoraErrorCode) {
callback(RtcEngineEvents.Error, errorCode.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, didApiCallExecute error: Int, api: String, result: String) {
callback(RtcEngineEvents.ApiCallExecuted, error, api, result)
}
public func rtcEngine(_: AgoraRtcEngineKit, didJoinChannel channel: String, withUid uid: UInt, elapsed: Int) {
callback(RtcEngineEvents.JoinChannelSuccess, channel, uid, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, didRejoinChannel channel: String, withUid uid: UInt, elapsed: Int) {
callback(RtcEngineEvents.RejoinChannelSuccess, channel, uid, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, didLeaveChannelWith stats: AgoraChannelStats) {
callback(RtcEngineEvents.LeaveChannel, stats.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, didRegisteredLocalUser userAccount: String, withUid uid: UInt) {
callback(RtcEngineEvents.LocalUserRegistered, uid, userAccount)
}
public func rtcEngine(_: AgoraRtcEngineKit, didUpdatedUserInfo userInfo: AgoraUserInfo, withUid uid: UInt) {
callback(RtcEngineEvents.UserInfoUpdated, uid, userInfo.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, didClientRoleChanged oldRole: AgoraClientRole, newRole: AgoraClientRole) {
callback(RtcEngineEvents.ClientRoleChanged, oldRole.rawValue, newRole.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, didJoinedOfUid uid: UInt, elapsed: Int) {
callback(RtcEngineEvents.UserJoined, uid, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, didOfflineOfUid uid: UInt, reason: AgoraUserOfflineReason) {
callback(RtcEngineEvents.UserOffline, uid, reason.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, connectionChangedTo state: AgoraConnectionStateType, reason: AgoraConnectionChangedReason) {
callback(RtcEngineEvents.ConnectionStateChanged, state.rawValue, reason.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, networkTypeChangedTo type: AgoraNetworkType) {
callback(RtcEngineEvents.NetworkTypeChanged, type.rawValue)
}
public func rtcEngineConnectionDidLost(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.ConnectionLost)
}
public func rtcEngine(_: AgoraRtcEngineKit, tokenPrivilegeWillExpire token: String) {
callback(RtcEngineEvents.TokenPrivilegeWillExpire, token)
}
public func rtcEngineRequestToken(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.RequestToken)
}
public func rtcEngine(_: AgoraRtcEngineKit, reportAudioVolumeIndicationOfSpeakers speakers: [AgoraRtcAudioVolumeInfo], totalVolume: Int) {
callback(RtcEngineEvents.AudioVolumeIndication, speakers.toMapList(), totalVolume)
}
public func rtcEngine(_: AgoraRtcEngineKit, activeSpeaker speakerUid: UInt) {
callback(RtcEngineEvents.ActiveSpeaker, speakerUid)
}
public func rtcEngine(_: AgoraRtcEngineKit, firstLocalAudioFrame elapsed: Int) {
callback(RtcEngineEvents.FirstLocalAudioFrame, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, firstLocalVideoFrameWith size: CGSize, elapsed: Int) {
callback(RtcEngineEvents.FirstLocalVideoFrame, Int(size.width), Int(size.height), elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, didVideoMuted muted: Bool, byUid uid: UInt) {
callback(RtcEngineEvents.UserMuteVideo, uid, muted)
}
public func rtcEngine(_: AgoraRtcEngineKit, videoSizeChangedOfUid uid: UInt, size: CGSize, rotation: Int) {
callback(RtcEngineEvents.VideoSizeChanged, uid, Int(size.width), Int(size.height), rotation)
}
public func rtcEngine(_: AgoraRtcEngineKit, remoteVideoStateChangedOfUid uid: UInt, state: AgoraVideoRemoteState, reason: AgoraVideoRemoteStateReason, elapsed: Int) {
callback(RtcEngineEvents.RemoteVideoStateChanged, uid, state.rawValue, reason.rawValue, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, localVideoStateChange state: AgoraLocalVideoStreamState, error: AgoraLocalVideoStreamError) {
callback(RtcEngineEvents.LocalVideoStateChanged, state.rawValue, error.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, remoteAudioStateChangedOfUid uid: UInt, state: AgoraAudioRemoteState, reason: AgoraAudioRemoteStateReason, elapsed: Int) {
callback(RtcEngineEvents.RemoteAudioStateChanged, uid, state.rawValue, reason.rawValue, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, localAudioStateChange state: AgoraAudioLocalState, error: AgoraAudioLocalError) {
callback(RtcEngineEvents.LocalAudioStateChanged, state.rawValue, error.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, didLocalPublishFallbackToAudioOnly isFallbackOrRecover: Bool) {
callback(RtcEngineEvents.LocalPublishFallbackToAudioOnly, isFallbackOrRecover)
}
public func rtcEngine(_: AgoraRtcEngineKit, didRemoteSubscribeFallbackToAudioOnly isFallbackOrRecover: Bool, byUid uid: UInt) {
callback(RtcEngineEvents.RemoteSubscribeFallbackToAudioOnly, uid, isFallbackOrRecover)
}
public func rtcEngine(_: AgoraRtcEngineKit, didAudioRouteChanged routing: AgoraAudioOutputRouting) {
callback(RtcEngineEvents.AudioRouteChanged, routing.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, cameraFocusDidChangedTo rect: CGRect) {
callback(RtcEngineEvents.CameraFocusAreaChanged, rect.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, cameraExposureDidChangedTo rect: CGRect) {
callback(RtcEngineEvents.CameraExposureAreaChanged, rect.toMap())
}
func rtcEngine(_: AgoraRtcEngineKit, facePositionDidChangeWidth width: Int32, previewHeight height: Int32, faces: [AgoraFacePositionInfo]?) {
callback(RtcEngineEvents.FacePositionChanged, width, height, faces?.toMapList())
}
public func rtcEngine(_: AgoraRtcEngineKit, reportRtcStats stats: AgoraChannelStats) {
callback(RtcEngineEvents.RtcStats, stats.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, lastmileQuality quality: AgoraNetworkQuality) {
callback(RtcEngineEvents.LastmileQuality, quality.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, networkQuality uid: UInt, txQuality: AgoraNetworkQuality, rxQuality: AgoraNetworkQuality) {
callback(RtcEngineEvents.NetworkQuality, uid, txQuality.rawValue, rxQuality.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, lastmileProbeTest result: AgoraLastmileProbeResult) {
callback(RtcEngineEvents.LastmileProbeResult, result.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, localVideoStats stats: AgoraRtcLocalVideoStats) {
callback(RtcEngineEvents.LocalVideoStats, stats.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, localAudioStats stats: AgoraRtcLocalAudioStats) {
callback(RtcEngineEvents.LocalAudioStats, stats.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, remoteVideoStats stats: AgoraRtcRemoteVideoStats) {
callback(RtcEngineEvents.RemoteVideoStats, stats.toMap())
}
public func rtcEngine(_: AgoraRtcEngineKit, remoteAudioStats stats: AgoraRtcRemoteAudioStats) {
callback(RtcEngineEvents.RemoteAudioStats, stats.toMap())
}
public func rtcEngineLocalAudioMixingDidFinish(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.AudioMixingFinished)
}
func rtcEngine(_: AgoraRtcEngineKit, localAudioMixingStateDidChanged state: AgoraAudioMixingStateCode, reason: AgoraAudioMixingReasonCode) {
callback(RtcEngineEvents.AudioMixingStateChanged, state.rawValue, reason.rawValue)
}
public func rtcEngineRemoteAudioMixingDidStart(_: AgoraRtcEngineKit) {
// TODO: Not in Android
}
public func rtcEngineRemoteAudioMixingDidFinish(_: AgoraRtcEngineKit) {
// TODO: Not in Android
}
public func rtcEngineDidAudioEffectFinish(_: AgoraRtcEngineKit, soundId: Int) {
callback(RtcEngineEvents.AudioEffectFinished, soundId)
}
public func rtcEngine(_: AgoraRtcEngineKit, rtmpStreamingChangedToState url: String, state: AgoraRtmpStreamingState, errorCode: AgoraRtmpStreamingErrorCode) {
callback(RtcEngineEvents.RtmpStreamingStateChanged, url, state.rawValue, errorCode.rawValue)
}
public func rtcEngineTranscodingUpdated(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.TranscodingUpdated)
}
public func rtcEngine(_: AgoraRtcEngineKit, streamInjectedStatusOfUrl url: String, uid: UInt, status: AgoraInjectStreamStatus) {
callback(RtcEngineEvents.StreamInjectedStatus, url, uid, status.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, receiveStreamMessageFromUid uid: UInt, streamId: Int, data: Data) {
callback(RtcEngineEvents.StreamMessage, uid, streamId, String(data: data, encoding: .utf8))
}
public func rtcEngine(_: AgoraRtcEngineKit, didOccurStreamMessageErrorFromUid uid: UInt, streamId: Int, error: Int, missed: Int, cached: Int) {
callback(RtcEngineEvents.StreamMessageError, uid, streamId, error, missed, cached)
}
public func rtcEngineMediaEngineDidLoaded(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.MediaEngineLoadSuccess)
}
public func rtcEngineMediaEngineDidStartCall(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.MediaEngineStartCallSuccess)
}
public func rtcEngine(_: AgoraRtcEngineKit, channelMediaRelayStateDidChange state: AgoraChannelMediaRelayState, error: AgoraChannelMediaRelayError) {
callback(RtcEngineEvents.ChannelMediaRelayStateChanged, state.rawValue, error.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, didReceive event: AgoraChannelMediaRelayEvent) {
callback(RtcEngineEvents.ChannelMediaRelayEvent, event.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, firstRemoteVideoFrameOfUid uid: UInt, size: CGSize, elapsed: Int) {
callback(RtcEngineEvents.FirstRemoteVideoFrame, uid, Int(size.width), Int(size.height), elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, firstRemoteAudioFrameOfUid uid: UInt, elapsed: Int) {
callback(RtcEngineEvents.FirstRemoteAudioFrame, uid, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, firstRemoteAudioFrameDecodedOfUid uid: UInt, elapsed: Int) {
callback(RtcEngineEvents.FirstRemoteAudioDecoded, uid, elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, didAudioMuted muted: Bool, byUid uid: UInt) {
callback(RtcEngineEvents.UserMuteAudio, uid, muted)
}
public func rtcEngine(_: AgoraRtcEngineKit, streamPublishedWithUrl url: String, errorCode: AgoraErrorCode) {
callback(RtcEngineEvents.StreamPublished, url, errorCode.rawValue)
}
public func rtcEngine(_: AgoraRtcEngineKit, streamUnpublishedWithUrl url: String) {
callback(RtcEngineEvents.StreamUnpublished, url)
}
public func rtcEngine(_: AgoraRtcEngineKit, audioTransportStatsOfUid uid: UInt, delay: UInt, lost: UInt, rxKBitRate: UInt) {
callback(RtcEngineEvents.RemoteAudioTransportStats, uid, delay, lost, rxKBitRate)
}
public func rtcEngine(_: AgoraRtcEngineKit, videoTransportStatsOfUid uid: UInt, delay: UInt, lost: UInt, rxKBitRate: UInt) {
callback(RtcEngineEvents.RemoteVideoTransportStats, uid, delay, lost, rxKBitRate)
}
public func rtcEngine(_: AgoraRtcEngineKit, didVideoEnabled enabled: Bool, byUid uid: UInt) {
callback(RtcEngineEvents.UserEnableVideo, uid, enabled)
}
public func rtcEngine(_: AgoraRtcEngineKit, didLocalVideoEnabled enabled: Bool, byUid uid: UInt) {
callback(RtcEngineEvents.UserEnableLocalVideo, uid, enabled)
}
public func rtcEngine(_: AgoraRtcEngineKit, firstRemoteVideoDecodedOfUid uid: UInt, size: CGSize, elapsed: Int) {
callback(RtcEngineEvents.FirstRemoteVideoDecoded, uid, Int(size.width), Int(size.height), elapsed)
}
public func rtcEngine(_: AgoraRtcEngineKit, didMicrophoneEnabled enabled: Bool) {
callback(RtcEngineEvents.MicrophoneEnabled, enabled)
}
public func rtcEngineConnectionDidInterrupted(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.ConnectionInterrupted)
}
public func rtcEngineConnectionDidBanned(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.ConnectionBanned)
}
public func rtcEngine(_: AgoraRtcEngineKit, audioQualityOfUid uid: UInt, quality: AgoraNetworkQuality, delay: UInt, lost: UInt) {
callback(RtcEngineEvents.AudioQuality, uid, quality.rawValue, delay, lost)
}
public func rtcEngineCameraDidReady(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.CameraReady)
}
public func rtcEngineVideoDidStop(_: AgoraRtcEngineKit) {
callback(RtcEngineEvents.VideoStopped)
}
func rtcEngine(_: AgoraRtcEngineKit, firstLocalAudioFramePublished elapsed: Int) {
callback(RtcEngineEvents.FirstLocalAudioFramePublished, elapsed)
}
func rtcEngine(_: AgoraRtcEngineKit, firstLocalVideoFramePublished elapsed: Int) {
callback(RtcEngineEvents.FirstLocalVideoFramePublished, elapsed)
}
func rtcEngine(_: AgoraRtcEngineKit, didAudioPublishStateChange channel: String, oldState: AgoraStreamPublishState, newState: AgoraStreamPublishState, elapseSinceLastState: Int) {
callback(RtcEngineEvents.AudioPublishStateChanged, channel, oldState.rawValue, newState.rawValue, elapseSinceLastState)
}
func rtcEngine(_: AgoraRtcEngineKit, didVideoPublishStateChange channel: String, oldState: AgoraStreamPublishState, newState: AgoraStreamPublishState, elapseSinceLastState: Int) {
callback(RtcEngineEvents.VideoPublishStateChanged, channel, oldState.rawValue, newState.rawValue, elapseSinceLastState)
}
func rtcEngine(_: AgoraRtcEngineKit, didAudioSubscribeStateChange channel: String, withUid uid: UInt, oldState: AgoraStreamSubscribeState, newState: AgoraStreamSubscribeState, elapseSinceLastState: Int) {
callback(RtcEngineEvents.AudioSubscribeStateChanged, channel, uid, oldState.rawValue, newState.rawValue, elapseSinceLastState)
}
func rtcEngine(_: AgoraRtcEngineKit, didVideoSubscribeStateChange channel: String, withUid uid: UInt, oldState: AgoraStreamSubscribeState, newState: AgoraStreamSubscribeState, elapseSinceLastState: Int) {
callback(RtcEngineEvents.VideoSubscribeStateChanged, channel, uid, oldState.rawValue, newState.rawValue, elapseSinceLastState)
}
func rtcEngine(_: AgoraRtcEngineKit, rtmpStreamingEventWithUrl url: String, eventCode: AgoraRtmpStreamingEvent) {
callback(RtcEngineEvents.RtmpStreamingEvent, url, eventCode.rawValue)
}
func rtcEngine(_: AgoraRtcEngineKit, superResolutionEnabledOfUid uid: UInt, enabled: Bool, reason: AgoraSuperResolutionStateReason) {
callback(RtcEngineEvents.UserSuperResolutionEnabled, uid, enabled, reason.rawValue)
}
func rtcEngine(_: AgoraRtcEngineKit, uploadLogResultRequestId requestId: String, success: Bool, reason: AgoraUploadErrorReason) {
callback(RtcEngineEvents.UploadLogResult, requestId, success, reason.rawValue)
}
func rtcEngineAirPlayIsConnected(_ engine: AgoraRtcEngineKit) {
callback(RtcEngineEvents.AirPlayIsConnected)
}
func rtcEngine(_ engine: AgoraRtcEngineKit, virtualBackgroundSourceEnabled enabled: Bool, reason: AgoraVirtualBackgroundSourceStateReason) {
callback(RtcEngineEvents.VirtualBackgroundSourceEnabled, enabled, reason.rawValue)
}
}
| 49.474286 | 208 | 0.752637 |
0eec75f162e4782be5fc881094ab0e32475cbcde | 1,068 | // swift-tools-version:4.0
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "EasyCamery",
products: [
// Products define the executables and libraries produced by a package, and make them visible to other packages.
.library(
name: "EasyCamery",
targets: ["EasyCamery"]),
],
dependencies: [
// Dependencies declare other packages that this package depends on.
.package(url: "https://github.com/koher/EasyImagy.git", from: "0.5.0-alpha"),
],
targets: [
// Targets are the basic building blocks of a package. A target can define a module or a test suite.
// Targets can depend on other targets in this package, and on products in packages which this package depends on.
.target(
name: "EasyCamery",
dependencies: ["EasyImagy"]),
.testTarget(
name: "EasyCameryTests",
dependencies: ["EasyCamery"]),
]
)
| 36.827586 | 122 | 0.633895 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.