repo_name
stringlengths 6
91
| path
stringlengths 8
968
| copies
stringclasses 210
values | size
stringlengths 2
7
| content
stringlengths 61
1.01M
| license
stringclasses 15
values | hash
stringlengths 32
32
| line_mean
float64 6
99.8
| line_max
int64 12
1k
| alpha_frac
float64 0.3
0.91
| ratio
float64 2
9.89
| autogenerated
bool 1
class | config_or_test
bool 2
classes | has_no_keywords
bool 2
classes | has_few_assignments
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
linebounce/HLT-Challenge
|
HLTChallenge/FlickrCommentTableViewCell.swift
|
1
|
5891
|
//
// FlickrCommentTableViewCell.swift
// HLTChallenge
//
// Created by Key Hoffman on 10/10/16.
// Copyright © 2016 Key Hoffman. All rights reserved.
//
import UIKit
// MARK: - FlickrCommentTableViewCell
final class FlickrCommentTableViewCell: UITableViewCell, PreparedConfigurable {
private let authorLabel = FlickrCommentTableViewCellStyleSheet.Label.author.label
private let contentLabel = FlickrCommentTableViewCellStyleSheet.Label.content.label
let mainStackView = FlickrCommentTableViewCellStyleSheet.StackView.main.stackView
// MARK: - Initialization
override init(style: UITableViewCellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
defer { prepare() }
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
// MARK: - Preparable Conformance
func prepare() {
defer { FlickrCommentTableViewCellStyleSheet.prepare(self) }
mainStackView.addArrangedSubviews <| [authorLabel, contentLabel]
addSubview(mainStackView)
}
// MARK: - Configurable Conformance
func configure(_ comment: FlickrPhotoComment) {
defer { prepare() }
authorLabel.text = comment.ownerName
contentLabel.text = comment.content
}
}
// MARK: - FlickrCommentTableViewCellStyleSheet
fileprivate struct FlickrCommentTableViewCellStyleSheet: ViewPreparer {
fileprivate static func prepare(_ commentCell: FlickrCommentTableViewCell) {
commentCell.backgroundColor = .clear
defer { commentCell.layoutIfNeeded() }
let stackViewTop = ¿NSLayoutConstraint.init <| commentCell.mainStackView <| .top <| .equal <| commentCell <| .top <| 1 <| 0
let stackViewBottom = ¿NSLayoutConstraint.init <| commentCell.mainStackView <| .bottom <| .equal <| commentCell <| .bottom <| 1 <| 0
let stackViewLeading = ¿NSLayoutConstraint.init <| commentCell.mainStackView <| .leading <| .equal <| commentCell <| .leading <| 1 <| 0
let stackViewTrailing = ¿NSLayoutConstraint.init <| commentCell.mainStackView <| .trailing <| .equal <| commentCell <| .trailing <| 1 <| 0
let stackViewConstraints = [stackViewTop, stackViewBottom, stackViewLeading, stackViewTrailing]
NSLayoutConstraint.activate <| stackViewConstraints
}
// MARK: - StackView
fileprivate enum StackView: Int {
case main = 1
fileprivate var stackView: UIStackView {
let sv = UIStackView()
sv.tag = rawValue
sv.axis = axis
sv.distribution = distribution
sv.alignment = alignment
sv.spacing = spacing
sv.translatesAutoresizingMaskIntoConstraints = translatesAutoresizingMaskIntoConstraints
return sv
}
private var axis: UILayoutConstraintAxis {
switch self {
case .main: return .vertical
}
}
private var distribution: UIStackViewDistribution {
switch self {
case .main: return .fillProportionally
}
}
private var alignment: UIStackViewAlignment {
switch self {
case .main: return .leading
}
}
private var spacing: CGFloat {
switch self {
case .main: return 5
}
}
private var translatesAutoresizingMaskIntoConstraints: Bool {
switch self {
case .main: return false
}
}
}
// MARK: - Label
fileprivate enum Label: Int {
case content = 1, author = 2
fileprivate var label: UILabel {
let l = UILabel()
l.tag = rawValue
l.backgroundColor = backgroundColor
l.textColor = textColor
l.textAlignment = textAlignment
l.numberOfLines = numberOfLines
l.adjustsFontSizeToFitWidth = adjustsFontSizeToFitWidth
l.translatesAutoresizingMaskIntoConstraints = translatesAutoresizingMaskIntoConstraints
return l
}
private var backgroundColor: UIColor {
switch self {
case .content: return .clear
case .author: return .red
}
}
private var textColor: UIColor {
switch self {
case .content: return .white
case .author: return .white
}
}
private var textAlignment: NSTextAlignment {
switch self {
case .content: return .left
case .author: return .left
}
}
private var numberOfLines: Int {
switch self {
case .content: return 0
case .author: return 1
}
}
private var adjustsFontSizeToFitWidth: Bool {
switch self {
case .content: return true
case .author: return false
}
}
private var translatesAutoresizingMaskIntoConstraints: Bool {
switch self {
case .content: return false
case .author: return false
}
}
}
}
|
mit
|
6d502f37dee9ff4fb83099eb1a3eb220
| 32.443182 | 146 | 0.542474 | 6.261702 | false | false | false | false |
davidkuchar/codepath-04-twitterredux
|
Twitter/ComposeTweetViewController.swift
|
1
|
2341
|
//
// ComposeTweetViewController.swift
// Twitter
//
// Created by David Kuchar on 5/24/15.
// Copyright (c) 2015 David Kuchar. All rights reserved.
//
import UIKit
class ComposeTweetViewController: UIViewController {
@IBOutlet weak var userImageButton: UIButton!
@IBOutlet weak var userNameLabel: UILabel!
@IBOutlet weak var usernameButton: UIButton!
@IBOutlet weak var tweetMessageTextView: UITextView!
var replyToTweet: Tweet?
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
userImageButton.setBackgroundImageForState(.Normal, withURL: NSURL(string: User.currentUser!.profileImageUrl!))
userImageButton.layer.cornerRadius = 3
userImageButton.clipsToBounds = true
userNameLabel.text = User.currentUser!.name
if let userTwitterHandle = User.currentUser!.screenname {
usernameButton.setTitle("@\(userTwitterHandle)", forState: UIControlState.Normal)
}
if let replyToTwitterHandle = replyToTweet?.user?.screenname {
tweetMessageTextView.text = "@\(replyToTwitterHandle) "
}
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
@IBAction func onCancel(sender: AnyObject) {
navigationController?.popViewControllerAnimated(true)
}
@IBAction func onTweet(sender: AnyObject) {
// send the tweet first!
println(tweetMessageTextView.text)
Tweet.sendTweet(tweetMessageTextView.text)
navigationController?.popViewControllerAnimated(true)
}
// 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.
if segue.identifier == "onOpenProfile" {
if let profileViewContoller = segue.destinationViewController as? ProfileViewController {
profileViewContoller.user = User.currentUser!
}
}
}
}
|
mit
|
7b646d289199a046fca15c20e1f21e1c
| 32.927536 | 119 | 0.677915 | 5.381609 | false | false | false | false |
martinjakubik/war
|
batanimal/lib/GamePlay.swift
|
1
|
14485
|
//
// GamePlay.swift
// batanimal
//
// Created by Marcin Jakubik on 22/02/18.
// Copyright © 2018 martin jakubik. All rights reserved.
//
import SpriteKit
import os.log
class GamePlay {
var gamePlayDelegate:GamePlayProtocol!
var numPlayers:Int = 0
let maxNumPlayers:Int = 2
var cards:[Card] = []
var shuffledCards:[Card] = []
var playerControllers:[PlayerController] = []
var restOfCards:[Card] = []
var topView:SKView
var scene:SKScene
var statusText:String
let restartButtonTop:CGFloat = 60
let restartButtonWidth:CGFloat = 80
let statusTop:CGFloat = 100
let statusWidth:CGFloat = 80
let gameBottom:CGFloat
let gameLeft:CGFloat = 20
let playerHeight:CGFloat = 160
let tableWidth:CGFloat = 120
let handSpace:CGFloat = 20
let cardSpace:CGFloat = 0
// width:height ratio is 0.644
let cardHeight:CGFloat = 86
let cardWidth:CGFloat = 55
var numMoves = 0
enum GameState {
case waitingToGatherCards
case waitingToFillTable
case waitingForFaceDownWarCard
case gameOver
}
var gameState:GameState
let wigglePath:CGPath = Tools.makeWigglePath()
let wiggleAction:SKAction
var statusLabel:SKLabelNode
var restartButton:ButtonNode
let control_layer_z_position:CGFloat = 50.0
let log:OSLog
init(topView:SKView, scene:SKScene, numPlayers:Int, cards:[Card], log:OSLog) {
self.topView = topView
self.scene = scene
self.numPlayers = numPlayers
self.cards = cards
self.gameState = GameState.waitingToFillTable
self.statusText = ""
self.wiggleAction = SKAction.follow(wigglePath, asOffset: true, orientToPath: false, speed: 600)
self.gameBottom = (self.topView.frame.size.height - playerHeight) / 2.0
let buttonPosition = CGPoint(
x: self.scene.size.width / 2,
y: self.restartButtonTop
)
self.statusLabel = SKLabelNode(text: "")
self.statusLabel.zPosition = control_layer_z_position
self.restartButton = ButtonNode(withText: "Restart", position: buttonPosition)
self.log = log
}
/*
* updates the game when player wants to play a card, based on current state
*/
func handlePlayerWantsToPlayACard(playerController:PlayerController) {
handleLocalPlayerWantsToPlayACard(for: playerController)
updateGameState()
}
/*
* updates the game when local player wants to play a card, based on current state
*/
func handleLocalPlayerWantsToPlayACard(for playerController:PlayerController) {
switch self.gameState {
case .waitingToFillTable:
os_log("game state: %@", log:self.log, type:.debug, "waiting to fill table")
// checks if the player already has a face-up card on the table
if (playerController.doesPlayerHaveCardOnTableFaceUp()) {
// wiggles card
wiggleCardInHand(for: playerController)
} else {
// puts card on table
playerController.putCardOnTable()
}
break
case .waitingForFaceDownWarCard:
os_log("game state: %@", log:self.log, type:.debug, "waiting for face down war card")
// checks if player only has a face-up card on table
if (playerController.doesPlayerHaveCardOnTableFaceUp()) {
playerController.putCardOnTable()
} else {
wiggleCardInHand(for: playerController)
}
break
case .waitingToGatherCards:
os_log("game state: %@", log:self.log, type:.debug, "waiting to gather cards")
gatherCards()
self.numMoves = self.numMoves + 1
break
default:
break
}
}
/*
* Moves the table cards to the hand of the player that won the turn.
* Or waits for more cards on the table in case of a tie.
*/
func gatherCards() {
var winningPlayerNumber:Int = -1
// decides what to do if all players have played
if (doAllPlayersHaveSameNumberOfCardsOnTable() && self.gameState == .waitingToGatherCards) {
winningPlayerNumber = self.gamePlayDelegate.whoseCardWins()
// every five moves, randomly switches order of the gathered cards
if (numMoves % 5 == 0 && Int.random(in: 0..<10) < 5) {
// moves everyone's cards to the winner's hand, player 1 first
self.playerControllers[winningPlayerNumber].moveTableCardsToHand(fromPlayer: self.playerControllers[1])
self.playerControllers[winningPlayerNumber].moveTableCardsToHand(fromPlayer: self.playerControllers[0])
} else {
// moves everyone's cards to the winner's hand, player 0 first
self.playerControllers[winningPlayerNumber].moveTableCardsToHand(fromPlayer: self.playerControllers[0])
self.playerControllers[winningPlayerNumber].moveTableCardsToHand(fromPlayer: self.playerControllers[1])
}
self.gameState = .waitingToFillTable
}
}
/*
* Checks table to see if it's a war, or if it's time to gather cards.
*/
func updateGameState() {
// checks if the players have the same number of cards on the table
if (doAllPlayersHaveSameNumberOfCardsOnTable()) {
if (playerControllers[0].doesPlayerHaveCardOnTableFaceDown()) {
// assumes both players need to play another card
self.gameState = .waitingToFillTable
} else if (playerControllers[0].doesPlayerHaveCardOnTableFaceUp()
&& doPlayersHaveSameCardOnTable()) {
// assumes both players have the same face-up card (starts war)
playWarSound()
self.gameState = .waitingForFaceDownWarCard
} else {
// assumes one player has a winning card
self.gameState = .waitingToGatherCards
// checks if the game is finished
if (isGameOver()) {
endGame()
}
}
} else if (playerControllers.count > 1 // TODO: protect this array access using swift style
&& playerControllers[0].getTable().count == 0
&& playerControllers[1].getTable().count == 0) {
// assumes the players have no cards on the table
self.gameState = .waitingToFillTable
}
}
/*
* if there is more than one player, returns true if all have same number of cards on the table; otherwise false
*/
func doAllPlayersHaveSameNumberOfCardsOnTable() -> Bool {
var doAllPlayersHaveSameNumberOfCardsOnTable:Bool = false
if (playerControllers.count > 1) {
let player0TableCount = playerControllers[0].getTable().count
let player1TableCount = playerControllers[1].getTable().count
doAllPlayersHaveSameNumberOfCardsOnTable = (player0TableCount == player1TableCount)
}
return doAllPlayersHaveSameNumberOfCardsOnTable
}
/*
* returns true if players 0 and 1 have the same value of card on the table
*/
func doPlayersHaveSameCardOnTable() -> Bool {
var doPlayersHaveSameCardOnTable:Bool = false
if let player0Card = playerControllers[0].getTopCardOnTable() {
if let player1Card = playerControllers[1].getTopCardOnTable() {
doPlayersHaveSameCardOnTable = (player0Card.value == player1Card.value)
}
}
return doPlayersHaveSameCardOnTable
}
/*
* wiggles a card
*/
func wiggleCardInHand(for playerController:PlayerController) {
if playerController.getHand().count > 0 {
let topCard = playerController.getHand()[0]
let cardNode = playerController.gameNode.childNode(withName: topCard.getId())
if let existingCardNode:CardNode = cardNode as? CardNode {
existingCardNode.run(wiggleAction)
}
}
}
/*
* checks if a player won the game
*/
func isGameOver() -> Bool {
var isGameOver:Bool = false
var winningPlayerNumber:Int
if (self.playerControllers.count < 2) {
return isGameOver
}
if (self.playerControllers[0].doesPlayerHaveCardOnTable() && self.playerControllers[1].doesPlayerHaveCardOnTable()) {
winningPlayerNumber = self.gamePlayDelegate.whoseCardWins()
// checks if the other player's hand is empty
for i in 0 ... self.playerControllers.count - 1 {
if (i != winningPlayerNumber) {
if (self.playerControllers[i].getHand().count == 0) {
isGameOver = true
self.gameState = GameState.gameOver
self.statusText = self.playerControllers[winningPlayerNumber].getName() + " wins"
}
}
}
}
return isGameOver
}
/*
* ends the game
*/
func endGame() {
self.statusText = "someone won"
}
func setUpGameSlot () {
makePlayer0()
makePlayer1()
}
/*
* makes a model, view and controller for player 0;
*/
func makePlayer0 () {
// makes player 0 view and controller
gamePlayDelegate.makePlayerViewAndController(initializedPlayer: nil, playerNumber: 0, playerTop: self.gameBottom + self.playerHeight, playerName: "Fox")
// distributes cards to player 0
distributeCardsToAvailablePlayers()
// renders player O's cards
self.playerControllers[0].renderHand()
}
/*
* makes a view and controller for player 1;
* does nothing if there is no player 0 model yet
*/
func makePlayer1 () {
os_log("player 0 top: %f, player 1 top: %f", log:self.log, type:.debug, "string parameter", self.gameBottom + self.playerHeight, self.gameBottom)
// makes player 1 view and controller
// TODO: what if we have a remote player1 model already here?
gamePlayDelegate.makePlayerViewAndController(initializedPlayer: nil, playerNumber: 1, playerTop: self.gameBottom, playerName: "Turkey")
self.playerControllers[1].setHand(hand: self.restOfCards)
// renders player 1's cards
self.playerControllers[1].renderHand()
}
/*
* hides the Restart button
*/
func hideRestartMessage () {
os_log("removing restart button", log:self.log, type:.debug)
self.scene.removeChildren(in: [self.restartButton, self.statusLabel])
}
/*
* plays a war sound
*/
func playWarSound () {
var soundFileName = "tiger-growl.wav"
if let card:Card = playerControllers[0].getTopCardOnTable() {
switch card.value {
case 1:
soundFileName = "hamster-wheel.wav"
case 2:
soundFileName = "rabbit-crunch.wav"
case 3:
soundFileName = "cat-meow.wav"
case 4:
soundFileName = "dog-bark.wav"
case 5:
soundFileName = "tiger-growl.wav"
case 6:
soundFileName = "elephant.wav"
default:
soundFileName = "tiger-growl.wav"
}
SKAction.playSoundFileNamed(soundFileName, waitForCompletion: false)
}
}
/*
* distributes cards from the given array into the given number of mutliple arrays
*/
func distribute (cards:[Card], numPlayersAmongWhichToDistribute:Int) -> [[Card]] {
var i:Int = 0;
var distributedCards:[[Card]] = []
for card in cards {
for j in 0...numPlayersAmongWhichToDistribute {
if (i % numPlayersAmongWhichToDistribute == j) {
if (distributedCards.count < j + 1) {
distributedCards.append([])
}
distributedCards[j].append(card)
break
}
}
i = i + 1
}
return distributedCards
}
/*
* distributes cards to all players that have joined the game
* (those that have player controllers);
* keeps the rest in restOfCards
*/
func distributeCardsToAvailablePlayers () {
// distributes the cards to the local players
let numPlayersAmongWhichToDistributeCards = self.numPlayers > 1 ? self.numPlayers : 2;
let distributedCards = distribute(cards: self.shuffledCards, numPlayersAmongWhichToDistribute: numPlayersAmongWhichToDistributeCards)
var i:Int = 0
for playerController in self.playerControllers {
playerController.setHand(hand: distributedCards[i])
i = i + 1
}
if (distributedCards.count > i - 1) {
self.restOfCards = distributedCards[i]
}
}
/*
* makes and shows the scene
*/
func makeScene() {
// makes a background sprite
let backgroundFileName = "background.png"
let backgroundTexture = SKTexture(imageNamed: backgroundFileName)
let backgroundNode = SKSpriteNode(
texture: backgroundTexture,
size: self.scene.size
)
backgroundNode.position = CGPoint(
x: self.scene.size.width / 2,
y: self.scene.size.height / 2
)
self.scene.addChild(backgroundNode)
// shows the status box
self.scene.addChild(self.statusLabel)
self.statusLabel.text = "Waiting for player 2"
// shows the dont wait button
self.restartButton.controller = self
self.scene.addChild(self.restartButton)
// shows the scene
self.topView.presentScene(self.scene)
}
/*
* starts the game
*/
func startGame (shuffleCards:Bool) {
if shuffleCards {
self.shuffledCards = Tools.shuffle(things: self.cards)
} else {
self.shuffledCards = self.cards
}
setUpGameSlot()
makeScene()
}
}
|
apache-2.0
|
7ea161023be79739029c1fea58356751
| 25.05036 | 160 | 0.598453 | 4.541863 | false | false | false | false |
benjaminsnorris/FirebaseReSwift
|
FirebaseReSwift/Subscribing.swift
|
1
|
6936
|
/*
| _ ____ ____ _
| | |‾| ⚈ |-| ⚈ |‾| |
| | | ‾‾‾‾| |‾‾‾‾ | |
| ‾ ‾ ‾
*/
import Foundation
import Marshal
import ReSwift
import Firebase
/// A protocol to be adopted by sub states that hold a flag indicating whether an object
/// has been subscribed to in Firebase or not.
public protocol SubscribingState: StateType {
var subscribed: Bool { get }
associatedtype SubscribingObject: Unmarshaling, EndpointNaming
}
/// Protocol for objects which have an associated endpoint name
public protocol EndpointNaming {
static var endpointName: String { get }
}
/**
An error that occurred parsing data from a Firebase event.
- `NoData`: The snapshot for the event contained no data
- `MalformedData`: The data in the snapshot could not be parsed as JSON
*/
public enum FirebaseSubscriptionError: Error {
case noData(path: String)
case malformedData(path: String)
}
extension FirebaseSubscriptionError: Equatable { }
public func ==(lhs: FirebaseSubscriptionError, rhs: FirebaseSubscriptionError) -> Bool {
switch (lhs, rhs) {
case (.noData(_), .noData(_)):
return true
case (.malformedData(_), .malformedData(_)):
return true
default:
return false
}
}
/**
This protocol is adopted by a state object in order to receive updates of a specific
data object from Firebase.
- Note: The object must also adopt `Unmarshaling` in order to parse JSON into an object
of that type.
*/
public extension SubscribingState {
typealias ObjectType = Self.SubscribingObject
/**
Calling this function results in the dispatching actions to the store for the following
events that occur in Firebase matching the given query. The actions are generic actions
scoped to the data object on which the function is called.
- Note: The `ObjectErrored` action can be called on any of those events if the resulting
data does not exist, or cannot be parsed from JSON into the data object. It is likewise a
generic action scoped to the data object.
- `ChildAdded` event: `ObjectAdded` action
- `ChildChanged` event: `ObjectChanged` action
- `ChildRemoved` event: `ObjectRemoved` action
- Parameters:
- query: The Firebase database query to which to subscribe. This is usually
constructed from the base `ref` using `childByAppendingPath(_)` or other
`FQuery` functions.
- returns: An `ActionCreator` (`(state: StateType, store: StoreType) -> Action?`) whose
type matches the state type associated with the store on which it is dispatched.
*/
public func subscribeToObjects<T: StateType>(_ query: DatabaseQuery) -> (_ state: T, _ store: Store<T>) -> Action? {
return { state, store in
if !self.subscribed {
let idKey = "id"
let refKey = "ref"
// Additions
query.observe(.childAdded, with: { snapshot in
guard snapshot.exists() && !(snapshot.value is NSNull) else {
store.dispatch(ObjectErrored<ObjectType>(error: FirebaseSubscriptionError.noData(path: query.ref.description())))
return
}
guard var json = snapshot.value as? JSONObject else {
store.dispatch(ObjectErrored<ObjectType>(error: FirebaseSubscriptionError.malformedData(path: query.ref.description())))
return
}
json[idKey] = snapshot.key
json[refKey] = snapshot.ref.description()
do {
let object = try ObjectType(object: json)
store.dispatch(ObjectAdded(object: object))
} catch {
store.dispatch(ObjectErrored<ObjectType>(error: error))
}
})
// Changes
query.observe(.childChanged, with: { snapshot in
guard snapshot.exists() && !(snapshot.value is NSNull) else {
store.dispatch(ObjectErrored<ObjectType>(error: FirebaseSubscriptionError.noData(path: query.ref.description())))
return
}
guard var json = snapshot.value as? JSONObject else {
store.dispatch(ObjectErrored<ObjectType>(error: FirebaseSubscriptionError.malformedData(path: query.ref.description())))
return
}
json[idKey] = snapshot.key
json[refKey] = snapshot.ref.description()
do {
let object = try ObjectType(object: json)
store.dispatch(ObjectChanged(object: object))
} catch {
store.dispatch(ObjectErrored<ObjectType>(error: error))
}
})
// Removals
query.observe(.childRemoved, with: { snapshot in
guard snapshot.exists() && !(snapshot.value is NSNull) else {
store.dispatch(ObjectErrored<ObjectType>(error: FirebaseSubscriptionError.noData(path: query.ref.description())))
return
}
guard var json = snapshot.value as? JSONObject else {
store.dispatch(ObjectErrored<ObjectType>(error: FirebaseSubscriptionError.malformedData(path: query.ref.description())))
return
}
json[idKey] = snapshot.key
json[refKey] = snapshot.ref.description()
do {
let object = try ObjectType(object: json)
store.dispatch(ObjectRemoved(object: object))
} catch {
store.dispatch(ObjectErrored<ObjectType>(error: error))
}
})
return ObjectSubscribed(subscribed: true, state: self)
}
return nil
}
}
/**
Removes all observers on a `FIRDatabaseQuery`.
- Note: This is often used when signing out, or switching Firebase apps.
- Parameter query: The query that was originally used to subscribe to events.
*/
public func removeSubscriptions<T: StateType>(_ query: DatabaseQuery) -> (_ state: T, _ store: Store<T>) -> Action? {
return { state, store in
if self.subscribed {
query.removeAllObservers()
return ObjectSubscribed(subscribed: false, state: self)
}
return nil
}
}
}
|
mit
|
e2c4cce0eb16a176e5fcb684ba03e2c6
| 39.151163 | 144 | 0.562409 | 5.208145 | false | false | false | false |
qianqian2/ocStudy1
|
ImageViewText/ImageViewText/detailViewController.swift
|
1
|
2841
|
//
// detailViewController.swift
// ImageViewText
//
// Created by arang on 16/12/19.
// Copyright © 2016年 arang. All rights reserved.
//
import UIKit
class detailViewController: UIViewController {
fileprivate lazy var guestVM :GuestViewModel = GuestViewModel()
@IBOutlet weak var back: UIBarButtonItem!
//@IBOutlet weak var tableView: UITableView!
@IBOutlet weak var tableView: UITableView!
var btnActionCallback: (()->())!
//let textArray = ["text1","text2","text3","text4"]
override func viewDidLoad() {
super.viewDidLoad()
self.tableView.register(UITableViewCell.self, forCellReuseIdentifier: "cell1")
loadData()
}
@IBAction func backBtn(_ sender: Any) {
self.presentingViewController!.dismiss(animated: true, completion: nil)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
//MARK: - loadGuestDate
extension detailViewController{
fileprivate func loadData(){
guestVM.loadAllGuestList {
//1.展示数据
self.tableView.reloadData()
// 2. 数据请求完成
}
}
}
extension detailViewController : UITableViewDelegate,UITableViewDataSource {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int{
return guestVM.guestList.count
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell
{
let identify:String = "cell1"
let cell = tableView.dequeueReusableCell(withIdentifier: identify, for: indexPath) as UITableViewCell
cell.accessoryType = .disclosureIndicator
cell.textLabel?.text = guestVM.guestList[indexPath.row].subject
print(guestVM.guestList[indexPath.item])
return cell
}
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
self.tableView.deselectRow(at: indexPath, animated: true)
let itemString = self.guestVM.guestList[indexPath.row].subject
self.performSegue(withIdentifier: "ShowDetailView", sender: itemString)
}
//在此方法中给新页面传递参数
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
if segue.identifier == "ShowDetailView"{
let controller = segue.destination as! thirdViewControll
controller.itemString = sender as? String
}
}
}
|
apache-2.0
|
c913d0bf8865ac496d5ee2b88630ee1a
| 20.8125 | 109 | 0.598854 | 5.369231 | false | false | false | false |
LYM-mg/GoodBookDemo
|
GoodBookDemo/GoodBookDemo/AppDelegate.swift
|
1
|
7885
|
//
// AppDelegate.swift
// GoodBookDemo
//
// Created by ming on 16/5/6.
// Copyright © 2016年 ming. All rights reserved.
//
import UIKit
import CoreData
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
/**
设置LeanCloud
*/
AVOSCloud.setApplicationId("i40Bw8oWkFemep2Rn2k9e5WX", clientKey: "MpeDsXwLTcQuuhplDjN1Hs8l")
self.window = UIWindow(frame: CGRectMake(0, 0, MGScreen_Width, MGScreen_Height))
let tabBarVC = UITabBarController()
let rankController = UINavigationController(rootViewController: MGRankViewController())
let searchController = UINavigationController(rootViewController:MGSearchViewController())
let pushController = UINavigationController(rootViewController:MGPushViewController())
let circleController = UINavigationController(rootViewController:MGCircleViewController())
let moreController = UINavigationController(rootViewController:MGMoreViewController())
tabBarVC.viewControllers = [rankController,searchController,pushController,circleController,moreController]
rankController.tabBarItem = UITabBarItem(title: "排行榜", image: UIImage(named: "bio"), selectedImage: UIImage(named: "bio_red"))
searchController.tabBarItem = UITabBarItem(title: "发现", image: UIImage(named: "timer 2"), selectedImage: UIImage(named: "timer 2"))
pushController.tabBarItem = UITabBarItem(title: "", image: UIImage(named: "pencil"), selectedImage: UIImage(named: "pencil_red"))
circleController.tabBarItem = UITabBarItem(title: "圈子", image: UIImage(named: "users two-2"), selectedImage: UIImage(named: "users two-2_red"))
moreController.tabBarItem = UITabBarItem(title: "更多", image: UIImage(named: "users two-2"), selectedImage: UIImage(named: "users two-2_red"))
rankController.tabBarController?.tabBar.tintColor = MAIN_Color
window?.rootViewController = tabBarVC
window?.makeKeyAndVisible()
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:.
// Saves changes in the application's managed object context before the application terminates.
self.saveContext()
}
// MARK: - Core Data stack
lazy var applicationDocumentsDirectory: NSURL = {
// The directory the application uses to store the Core Data store file. This code uses a directory named "com.ming.GoodBookDemo" in the application's documents Application Support directory.
let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
return urls[urls.count-1]
}()
lazy var managedObjectModel: NSManagedObjectModel = {
// The managed object model for the application. This property is not optional. It is a fatal error for the application not to be able to find and load its model.
let modelURL = NSBundle.mainBundle().URLForResource("GoodBookDemo", withExtension: "momd")!
return NSManagedObjectModel(contentsOfURL: modelURL)!
}()
lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator = {
// The persistent store coordinator for the application. This implementation creates and returns a coordinator, having added the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail.
// Create the coordinator and store
let coordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent("SingleViewCoreData.sqlite")
var failureReason = "There was an error creating or loading the application's saved data."
do {
try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil)
} catch {
// Report any error we got.
var dict = [String: AnyObject]()
dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"
dict[NSLocalizedFailureReasonErrorKey] = failureReason
dict[NSUnderlyingErrorKey] = error as NSError
let wrappedError = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
// Replace this with code to handle the error appropriately.
// abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
abort()
}
return coordinator
}()
lazy var managedObjectContext: NSManagedObjectContext = {
// Returns the managed object context for the application (which is already bound to the persistent store coordinator for the application.) This property is optional since there are legitimate error conditions that could cause the creation of the context to fail.
let coordinator = self.persistentStoreCoordinator
var managedObjectContext = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
managedObjectContext.persistentStoreCoordinator = coordinator
return managedObjectContext
}()
// MARK: - Core Data Saving support
func saveContext () {
if managedObjectContext.hasChanges {
do {
try managedObjectContext.save()
} catch {
// Replace this implementation with code to handle the error appropriately.
// abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
let nserror = error as NSError
NSLog("Unresolved error \(nserror), \(nserror.userInfo)")
abort()
}
}
}
}
|
mit
|
e725c448ce369eb0e08202c23e403cae
| 54.352113 | 291 | 0.714504 | 5.630372 | false | false | false | false |
Pencroff/ai-hackathon-2017
|
IOS APP/FoodAI/ViewController.swift
|
1
|
3586
|
//
// ViewController.swift
// FoodAI
//
// Created by Pablo on 2/18/17.
// Copyright © 2017 Pablo Carvalho. All rights reserved.
//
import UIKit
import SwiftSpinner
class ViewController: UIViewController, UINavigationControllerDelegate, UIImagePickerControllerDelegate, FoodAIDelegate {
@IBOutlet weak var imageView: UIImageView!
private var image : UIImage? {
didSet {
imageView.image = image
}
}
private var nutrients = [Nutrient]()
private var foodName : String?
private var hasLaunchedCamera = false
private let segueName = "showNutrients"
private lazy var imagePicker : UIImagePickerController! = {
[unowned self] in
let imagePicker = UIImagePickerController()
imagePicker.delegate = self
imagePicker.sourceType = .camera
return imagePicker
}()
private lazy var foodAI : FoodAI! = {
let foodAI = FoodAI(cloudStorageCloudName: Settings.cloudName,
cloudStorageApiKey: Settings.apiKey,
cloudStorageApiSecret: Settings.apiSecret)
foodAI.delegate = self
foodAI.uploadingProgress = { progress in
SwiftSpinner.show(progress: progress, title: "Uploading \(Int(progress * 100))%")
}
foodAI.finishedUploading = { url in
SwiftSpinner.show("Processing", animated: true)
}
foodAI.onError = { error in
SwiftSpinner.show(duration: 2, title: "Error. Please try again")
}
return foodAI
}()
override func viewDidLoad() {
let gesture = UITapGestureRecognizer(target: self, action: #selector(ViewController.tap))
view.addGestureRecognizer(gesture)
}
override func viewDidAppear(_ animated: Bool) {
if hasLaunchedCamera == false {
takePicture()
}
}
func showNutrients() {
self.performSegue(withIdentifier: segueName, sender: self)
}
func tap() {
if image == nil {
takePicture()
return
}
if nutrients.count > 0 {
showNutrients()
}
}
func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [String : Any]) {
imagePicker.dismiss(animated: true, completion: nil)
let image = info[UIImagePickerControllerOriginalImage] as? UIImage
self.image = image
if let image = image {
foodAI.getNutritionFacts(forImage: image)
}
}
@IBAction func takePicture() {
present(imagePicker, animated: true, completion: nil)
hasLaunchedCamera = true
}
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
if segue.identifier == segueName {
let vc = segue.destination as! NutritionFactsViewController
vc.nutrients = nutrients
vc.image = image
vc.foodName = foodName
}
}
func foodAI(_ foodAI: FoodAI, didRecognizeFood food: String) {
SwiftSpinner.show(food, animated: true)
}
func foodAI(_ foodAI: FoodAI, didGetNutrionFacts nutritionFacts: [Nutrient], forFood food: String) {
self.nutrients = nutritionFacts
self.foodName = food
if nutritionFacts.count > 0 {
SwiftSpinner.hide()
showNutrients()
} else {
SwiftSpinner.show(duration: 3, title: "Please try again", animated: true)
}
}
}
|
mit
|
f067c5c834a1506d522483700343e7ae
| 28.628099 | 121 | 0.604463 | 4.938017 | false | false | false | false |
yankodimitrov/SignalKit
|
SignalKit/Extensions/UIKit/Keyboard.swift
|
1
|
3318
|
//
// Keyboard.swift
// SignalKit
//
// Created by Yanko Dimitrov on 3/6/16.
// Copyright © 2016 Yanko Dimitrov. All rights reserved.
//
import UIKit
public struct Keyboard {
public struct Event {}
/// Returns the available Keyboard events
public static func observe() -> SignalEvent<Keyboard.Event> {
return SignalEvent(sender: Keyboard.Event())
}
}
// MARK: - Keyboard State
public struct KeyboardState {
public var beginFrame: CGRect {
guard let frame = info[UIKeyboardFrameBeginUserInfoKey] as? NSValue else {
return CGRectZero
}
return frame.CGRectValue()
}
public var endFrame: CGRect {
guard let frame = info[UIKeyboardFrameEndUserInfoKey] as? NSValue else {
return CGRectZero
}
return frame.CGRectValue()
}
public var animationCurve: UIViewAnimationCurve? {
guard let curve = info[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber else {
return nil
}
return UIViewAnimationCurve(rawValue: curve.integerValue)
}
public var animationDuration: Double {
guard let duration = info[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber else {
return 0
}
return duration.doubleValue
}
private let info: [NSObject: AnyObject]
public init(notification: NSNotification) {
info = notification.userInfo ?? [NSObject: AnyObject]()
}
}
// MARK: - Keyboard Events
public extension SignalEventType where Sender == Keyboard.Event {
private func keyboardSignalFor(notificationName: String) -> Signal<KeyboardState> {
let signal = Signal<KeyboardState>()
let center = NSNotificationCenter.defaultCenter()
let observer = NotificationObserver(center: center, name: notificationName)
observer.notificationCallback = { [weak signal] in
signal?.sendNext(KeyboardState(notification: $0))
}
signal.disposableSource = observer
return signal
}
/// Observe for keyboard will show event
var willShow: Signal<KeyboardState> {
return keyboardSignalFor(UIKeyboardWillShowNotification)
}
/// Observe for keyboard did show event
var didShow: Signal<KeyboardState> {
return keyboardSignalFor(UIKeyboardDidShowNotification)
}
/// Observe for keyboard will hide event
var willHide: Signal<KeyboardState> {
return keyboardSignalFor(UIKeyboardWillHideNotification)
}
/// Observe for keyboard did hide event
var didHide: Signal<KeyboardState> {
return keyboardSignalFor(UIKeyboardDidHideNotification)
}
/// Observe for keyboard will change frame event
var willChangeFrame: Signal<KeyboardState> {
return keyboardSignalFor(UIKeyboardWillChangeFrameNotification)
}
/// Observe for keyboard did change frame event
var didChangeFrame: Signal<KeyboardState> {
return keyboardSignalFor(UIKeyboardDidChangeFrameNotification)
}
}
|
mit
|
8a1ff420a6ad3019d4c39ff39e43e6c0
| 24.128788 | 93 | 0.623756 | 5.809107 | false | false | false | false |
niunaruto/DeDaoAppSwift
|
testSwift/Pods/RxSwift/RxSwift/Traits/Completable+AndThen.swift
|
20
|
5071
|
//
// Completable+AndThen.swift
// RxSwift
//
// Created by Krunoslav Zaher on 7/2/17.
// Copyright © 2017 Krunoslav Zaher. All rights reserved.
//
extension PrimitiveSequenceType where Trait == CompletableTrait, Element == Never {
/**
Concatenates the second observable sequence to `self` upon successful termination of `self`.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- parameter second: Second observable sequence.
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
*/
public func andThen<Element>(_ second: Single<Element>) -> Single<Element> {
let completable = self.primitiveSequence.asObservable()
return Single(raw: ConcatCompletable(completable: completable, second: second.asObservable()))
}
/**
Concatenates the second observable sequence to `self` upon successful termination of `self`.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- parameter second: Second observable sequence.
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
*/
public func andThen<Element>(_ second: Maybe<Element>) -> Maybe<Element> {
let completable = self.primitiveSequence.asObservable()
return Maybe(raw: ConcatCompletable(completable: completable, second: second.asObservable()))
}
/**
Concatenates the second observable sequence to `self` upon successful termination of `self`.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- parameter second: Second observable sequence.
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
*/
public func andThen(_ second: Completable) -> Completable {
let completable = self.primitiveSequence.asObservable()
return Completable(raw: ConcatCompletable(completable: completable, second: second.asObservable()))
}
/**
Concatenates the second observable sequence to `self` upon successful termination of `self`.
- seealso: [concat operator on reactivex.io](http://reactivex.io/documentation/operators/concat.html)
- parameter second: Second observable sequence.
- returns: An observable sequence that contains the elements of `self`, followed by those of the second sequence.
*/
public func andThen<Element>(_ second: Observable<Element>) -> Observable<Element> {
let completable = self.primitiveSequence.asObservable()
return ConcatCompletable(completable: completable, second: second.asObservable())
}
}
final private class ConcatCompletable<Element>: Producer<Element> {
fileprivate let _completable: Observable<Never>
fileprivate let _second: Observable<Element>
init(completable: Observable<Never>, second: Observable<Element>) {
self._completable = completable
self._second = second
}
override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
let sink = ConcatCompletableSink(parent: self, observer: observer, cancel: cancel)
let subscription = sink.run()
return (sink: sink, subscription: subscription)
}
}
final private class ConcatCompletableSink<Observer: ObserverType>
: Sink<Observer>
, ObserverType {
typealias Element = Never
typealias Parent = ConcatCompletable<Observer.Element>
private let _parent: Parent
private let _subscription = SerialDisposable()
init(parent: Parent, observer: Observer, cancel: Cancelable) {
self._parent = parent
super.init(observer: observer, cancel: cancel)
}
func on(_ event: Event<Element>) {
switch event {
case .error(let error):
self.forwardOn(.error(error))
self.dispose()
case .next:
break
case .completed:
let otherSink = ConcatCompletableSinkOther(parent: self)
self._subscription.disposable = self._parent._second.subscribe(otherSink)
}
}
func run() -> Disposable {
let subscription = SingleAssignmentDisposable()
self._subscription.disposable = subscription
subscription.setDisposable(self._parent._completable.subscribe(self))
return self._subscription
}
}
final private class ConcatCompletableSinkOther<Observer: ObserverType>
: ObserverType {
typealias Element = Observer.Element
typealias Parent = ConcatCompletableSink<Observer>
private let _parent: Parent
init(parent: Parent) {
self._parent = parent
}
func on(_ event: Event<Observer.Element>) {
self._parent.forwardOn(event)
if event.isStopEvent {
self._parent.dispose()
}
}
}
|
mit
|
34386f207960ee56fd1d8923039cd9de
| 37.409091 | 171 | 0.693097 | 4.96572 | false | false | false | false |
hooman/swift
|
test/Concurrency/Runtime/async_initializer.swift
|
2
|
3956
|
// RUN: %target-run-simple-swift(-parse-as-library -Xfrontend -disable-availability-checking %import-libdispatch) | %FileCheck %s
// REQUIRES: executable_test
// REQUIRES: concurrency
// REQUIRES: libdispatch
// rdar://76038845
// UNSUPPORTED: use_os_stdlib
// UNSUPPORTED: back_deployment_runtime
@available(SwiftStdlib 5.5, *)
actor NameGenerator {
private var counter = 0
private var prefix : String
init(_ title: String) { self.prefix = title }
func getName() -> String {
counter += 1
return "\(prefix) \(counter)"
}
}
@available(SwiftStdlib 5.5, *)
protocol Person {
init() async
var name : String { get set }
}
@available(SwiftStdlib 5.5, *)
class EarthPerson : Person {
private static let oracle = NameGenerator("Earthling")
var name : String
required init() async {
self.name = await EarthPerson.oracle.getName()
}
init(name: String) async {
self.name = await (detach { name }).get()
}
}
@available(SwiftStdlib 5.5, *)
class NorthAmericaPerson : EarthPerson {
private static let oracle = NameGenerator("NorthAmerican")
required init() async {
await super.init()
self.name = await NorthAmericaPerson.oracle.getName()
}
override init(name: String) async {
await super.init(name: name)
}
}
@available(SwiftStdlib 5.5, *)
class PrecariousClass {
init?(nilIt : Int) async {
let _ : Optional<Int> = await (detach { nil }).get()
return nil
}
init(throwIt : Double) async throws {
if await (detach { 0 }).get() != 1 {
throw Something.bogus
}
}
init?(nilOrThrowIt shouldThrow: Bool) async throws {
let flag = await (detach { shouldThrow }).get()
if flag {
throw Something.bogus
}
return nil
}
init!(crashOrThrowIt shouldThrow: Bool) async throws {
let flag = await (detach { shouldThrow }).get()
if flag {
throw Something.bogus
}
return nil
}
}
enum Something : Error {
case bogus
}
@available(SwiftStdlib 5.5, *)
struct PrecariousStruct {
init?(nilIt : Int) async {
let _ : Optional<Int> = await (detach { nil }).get()
return nil
}
init(throwIt : Double) async throws {
if await (detach { 0 }).get() != 1 {
throw Something.bogus
}
}
}
// CHECK: Earthling 1
// CHECK-NEXT: Alice
// CHECK-NEXT: Earthling 2
// CHECK-NEXT: Bob
// CHECK-NEXT: Earthling 3
// CHECK-NEXT: Alex
// CHECK-NEXT: NorthAmerican 1
// CHECK-NEXT: NorthAmerican 2
// CHECK-NEXT: Earthling 6
// CHECK-NEXT: class was nil
// CHECK-NEXT: class threw
// CHECK-NEXT: nilOrThrowIt init was nil
// CHECK-NEXT: nilOrThrowIt init threw
// CHECK-NEXT: crashOrThrowIt init threw
// CHECK-NEXT: struct was nil
// CHECK-NEXT: struct threw
// CHECK: done
@available(SwiftStdlib 5.5, *)
@main struct RunIt {
static func main() async {
let people : [Person] = [
await EarthPerson(),
await NorthAmericaPerson(name: "Alice"),
await EarthPerson(),
await NorthAmericaPerson(name: "Bob"),
await EarthPerson(),
await NorthAmericaPerson(name: "Alex"),
await NorthAmericaPerson(),
await NorthAmericaPerson(),
await EarthPerson()
]
for p in people {
print(p.name)
}
// ----
if await PrecariousClass(nilIt: 0) == nil {
print("class was nil")
}
do { let _ = try await PrecariousClass(throwIt: 0.0) } catch {
print("class threw")
}
if try! await PrecariousClass(nilOrThrowIt: false) == nil {
print("nilOrThrowIt init was nil")
}
do { let _ = try await PrecariousClass(nilOrThrowIt: true) } catch {
print("nilOrThrowIt init threw")
}
do { let _ = try await PrecariousClass(crashOrThrowIt: true) } catch {
print("crashOrThrowIt init threw")
}
if await PrecariousStruct(nilIt: 0) == nil {
print("struct was nil")
}
do { let _ = try await PrecariousStruct(throwIt: 0.0) } catch {
print("struct threw")
}
print("done")
}
}
|
apache-2.0
|
bb2568705597c0ff86fe2f53930faa30
| 21.477273 | 130 | 0.639282 | 3.920714 | false | false | false | false |
lorentey/swift
|
test/SILGen/function_conversion_objc.swift
|
25
|
6364
|
// RUN: %target-swift-emit-silgen -module-name function_conversion_objc -sdk %S/Inputs %s -I %S/Inputs -enable-source-import -enable-objc-interop -verify | %FileCheck %s
import Foundation
// ==== Metatype to object conversions
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc20convMetatypeToObjectyySo8NSObjectCmADcF
func convMetatypeToObject(_ f: @escaping (NSObject) -> NSObject.Type) {
// CHECK: function_ref @$sSo8NSObjectCABXMTIeggd_AByXlIeggo_TR
// CHECK: partial_apply
let _: (NSObject) -> AnyObject = f
}
// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] [ossa] @$sSo8NSObjectCABXMTIeggd_AByXlIeggo_TR : $@convention(thin) (@guaranteed NSObject, @guaranteed @callee_guaranteed (@guaranteed NSObject) -> @thick NSObject.Type) -> @owned AnyObject {
// CHECK: apply %1(%0)
// CHECK: thick_to_objc_metatype {{.*}} : $@thick NSObject.Type to $@objc_metatype NSObject.Type
// CHECK: objc_metatype_to_object {{.*}} : $@objc_metatype NSObject.Type to $AnyObject
// CHECK: return
@objc protocol NSBurrito {}
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc31convExistentialMetatypeToObjectyyAA9NSBurrito_pXpAaC_pcF
func convExistentialMetatypeToObject(_ f: @escaping (NSBurrito) -> NSBurrito.Type) {
// CHECK: function_ref @$s24function_conversion_objc9NSBurrito_pAaB_pXmTIeggd_AaB_pyXlIeggo_TR
// CHECK: partial_apply
let _: (NSBurrito) -> AnyObject = f
}
// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] [ossa] @$s24function_conversion_objc9NSBurrito_pAaB_pXmTIeggd_AaB_pyXlIeggo_TR : $@convention(thin) (@guaranteed NSBurrito, @guaranteed @callee_guaranteed (@guaranteed NSBurrito) -> @thick NSBurrito.Type) -> @owned AnyObject
// CHECK: apply %1(%0)
// CHECK: thick_to_objc_metatype {{.*}} : $@thick NSBurrito.Type to $@objc_metatype NSBurrito.Type
// CHECK: objc_existential_metatype_to_object {{.*}} : $@objc_metatype NSBurrito.Type to $AnyObject
// CHECK: return
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc28convProtocolMetatypeToObjectyyAA9NSBurrito_pmycF
func convProtocolMetatypeToObject(_ f: @escaping () -> NSBurrito.Protocol) {
// CHECK: function_ref @$s24function_conversion_objc9NSBurrito_pXMtIegd_So8ProtocolCIego_TR
// CHECK: partial_apply
let _: () -> Protocol = f
}
// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] [ossa] @$s24function_conversion_objc9NSBurrito_pXMtIegd_So8ProtocolCIego_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @thin NSBurrito.Protocol) -> @owned Protocol
// CHECK: apply %0() : $@callee_guaranteed () -> @thin NSBurrito.Protocol
// CHECK: objc_protocol #NSBurrito : $Protocol
// CHECK: copy_value
// CHECK: return
// ==== Representation conversions
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc11funcToBlockyyyXByycF : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @owned @convention(block) () -> ()
// CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage
// CHECK: [[BLOCK:%.*]] = init_block_storage_header [[BLOCK_STORAGE]]
// CHECK: [[COPY:%.*]] = copy_block [[BLOCK]] : $@convention(block) () -> ()
// CHECK: return [[COPY]]
func funcToBlock(_ x: @escaping () -> ()) -> @convention(block) () -> () {
return x
}
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc11blockToFuncyyycyyXBF : $@convention(thin) (@guaranteed @convention(block) () -> ()) -> @owned @callee_guaranteed () -> ()
// CHECK: bb0([[ARG:%.*]] : @guaranteed $@convention(block) () -> ()):
// CHECK: [[COPIED:%.*]] = copy_block [[ARG]]
// CHECK: [[BORROWED_COPIED:%.*]] = begin_borrow [[COPIED]]
// CHECK: [[COPIED_2:%.*]] = copy_value [[BORROWED_COPIED]]
// CHECK: [[THUNK:%.*]] = function_ref @$sIeyB_Ieg_TR
// CHECK: [[FUNC:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[COPIED_2]])
// CHECK: end_borrow [[BORROWED_COPIED]]
// CHECK: destroy_value [[COPIED]]
// CHECK-NOT: destroy_value [[ARG]]
// CHECK: return [[FUNC]]
func blockToFunc(_ x: @escaping @convention(block) () -> ()) -> () -> () {
return x
}
// ==== Representation change + function type conversion
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc22blockToFuncExistentialyypycSiyXBF : $@convention(thin) (@guaranteed @convention(block) () -> Int) -> @owned @callee_guaranteed () -> @out Any
// CHECK: function_ref @$sSiIeyBd_SiIegd_TR
// CHECK: partial_apply
// CHECK: function_ref @$sSiIegd_ypIegr_TR
// CHECK: partial_apply
// CHECK: return
func blockToFuncExistential(_ x: @escaping @convention(block) () -> Int) -> () -> Any {
return x
}
// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] [ossa] @$sSiIeyBd_SiIegd_TR : $@convention(thin) (@guaranteed @convention(block) () -> Int) -> Int
// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] [ossa] @$sSiIegd_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> Int) -> @out Any
// C function pointer conversions
class A : NSObject {}
class B : A {}
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc18cFuncPtrConversionyyAA1BCXCyAA1ACXCF
func cFuncPtrConversion(_ x: @escaping @convention(c) (A) -> ()) -> @convention(c) (B) -> () {
// CHECK: convert_function %0 : $@convention(c) (A) -> () to $@convention(c) (B) -> ()
// CHECK: return
return x
}
func cFuncPtr(_ a: A) {}
// CHECK-LABEL: sil hidden [ossa] @$s24function_conversion_objc19cFuncDeclConversionyAA1BCXCyF
func cFuncDeclConversion() -> @convention(c) (B) -> () {
// CHECK: function_ref @$s24function_conversion_objc8cFuncPtryyAA1ACFTo : $@convention(c) (A) -> ()
// CHECK: convert_function %0 : $@convention(c) (A) -> () to $@convention(c) (B) -> ()
// CHECK: return
return cFuncPtr
}
func cFuncPtrConversionUnsupported(_ x: @escaping @convention(c) (@convention(block) () -> ()) -> ())
-> @convention(c) (@convention(c) () -> ()) -> () {
return x // expected-error{{C function pointer signature '@convention(c) (@convention(block) () -> ()) -> ()' is not compatible with expected type '@convention(c) (@convention(c) () -> ()) -> ()'}}
}
|
apache-2.0
|
4b43286c47ccb808007898330a7d0c19
| 54.33913 | 302 | 0.660119 | 3.553322 | false | false | false | false |
robbajorek/ModalOverlayIOS
|
ModalOverlayIOS-Swift/ModalOverlayIOS-Swift/ViewController.swift
|
1
|
3796
|
//
// ViewController.swift
// ModalOverlayIOS-Swift
//
// Created by Rob Bajorek on 12/22/18.
// Copyright © 2018 Rob Bajorek. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
/// The text field that responds to a double-tap.
@IBOutlet private weak var firstField: UITextField!
/// A simple label that shows we received a message back from the overlay.
@IBOutlet private weak var label: UILabel!
/// The window that will appear over our existing one.
private var overlayWindow: UIWindow?
/// The window that contains the keyboard.
/// This assumes that there _is_ a window with a keyboard.
private var keyboardWindow: UIWindow? {
// The window containing the keyboard always seems to be the last one.
return UIApplication.shared.windows.last
}
override func viewDidLoad() {
super.viewDidLoad()
// Set up gesture recognizer
let doubleTapRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleDoubleTap))
doubleTapRecognizer.numberOfTapsRequired = 2
doubleTapRecognizer.delegate = self
firstField.addGestureRecognizer(doubleTapRecognizer)
firstField.becomeFirstResponder()
}
@objc func handleDoubleTap() {
print("Text field double tapped")
// Prepare the overlay window
guard let overlayFrame = view?.window?.frame else { return }
overlayWindow = UIWindow(frame: overlayFrame)
overlayWindow?.windowLevel = .alert
let overlayVC = OverlayViewController.init(nibName: "OverlayViewController", bundle: nil)
overlayWindow?.rootViewController = overlayVC
overlayVC.delegate = self
showOverlayWindow()
}
private func showMainWindow() {
keyboardWindow?.isHidden = false
UIWindow.animate(withDuration: 0.3,
animations: { [weak self] in
self?.overlayWindow?.alpha = 0.0
self?.keyboardWindow?.alpha = 1.0
},
completion: { [weak self] _ in
self?.overlayWindow = nil
})
}
private func showOverlayWindow() {
overlayWindow?.alpha = 0.0
overlayWindow?.isHidden = false
UIWindow.animate(withDuration: 0.3,
animations: { [weak self] in
self?.overlayWindow?.alpha = 1.0
self?.keyboardWindow?.alpha = 0.0
},
completion: { [weak self] _ in
self?.keyboardWindow?.isHidden = true
})
}
}
extension ViewController: OverlayViewControllerDelegate {
func optionOneChosen() {
let text = "Option 1 chosen"
print(text)
label.text = text
showMainWindow()
}
func optionTwoChosen() {
let text = "Option 2 chosen"
print(text)
label.text = text
showMainWindow()
}
}
extension ViewController: UIGestureRecognizerDelegate {
// Our gesture recognizer clashes with UITextField's. Need to allow both
// to work simultaneously.
func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer,
shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
return true
}
}
extension ViewController: UITextFieldDelegate {
override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
// Disables the select/copy/etc. menu when tapping text
DispatchQueue.main.async {
UIMenuController.shared.isMenuVisible = false
}
return super.canPerformAction(action, withSender: sender)
}
}
|
mit
|
69824c7b42681280add17cdf3b291275
| 33.5 | 115 | 0.624242 | 5.300279 | false | false | false | false |
IvanKalaica/GitHubSearch
|
GitHubSearch/GitHubSearch/App/ViewControllers.swift
|
1
|
1499
|
//
// ViewControllers.swift
// GitHubSearch
//
// Created by Ivan Kalaica on 21/09/2017.
// Copyright © 2017 Kalaica. All rights reserved.
//
import Foundation
import UIKit
enum Screen {
case repositorySearch
case repository(RepositoryViewModel)
case user(UserViewModel)
case myProfile
}
protocol ViewControllers {
func get(_ screen: Screen) -> UIViewController
}
struct DefaultViewControllers: ViewControllers {
private let viewModels: ViewModels
init(viewModels: ViewModels) {
self.viewModels = viewModels
}
func get(_ screen: Screen) -> UIViewController {
switch screen {
case .repositorySearch:
let vc = RepositorySearchViewController(toolbox: Toolbox(viewControllers: self), viewModel: self.viewModels.repositorySearchViewModel)
vc.title = NSLocalizedString("Repositories", comment: "Main screen \"Repositories\" section nav and tab bar title")
return vc
case .repository(let viewModel):
return RepositoryViewController(toolbox: Toolbox(viewControllers: self), viewModel: viewModel)
case .user(let viewModel):
return UserViewController(viewModel: viewModel)
case .myProfile:
let vc = MyProfileViewController(viewModel: self.viewModels.myProfileViewModel)
vc.title = NSLocalizedString("My Profile", comment: "Main screen \"My Profile\" section nav and tab bar title")
return vc
}
}
}
|
mit
|
1d10b6f8f7e7b5066b33d4293ac7e41d
| 31.565217 | 146 | 0.683578 | 4.976744 | false | false | false | false |
lyft/SwiftLint
|
Source/SwiftLintFramework/Models/YamlParser.swift
|
1
|
2020
|
import Foundation
import Yams
// MARK: - YamlParsingError
internal enum YamlParserError: Error, Equatable {
case yamlParsing(String)
}
internal func == (lhs: YamlParserError, rhs: YamlParserError) -> Bool {
switch (lhs, rhs) {
case let (.yamlParsing(lhs), .yamlParsing(rhs)):
return lhs == rhs
}
}
// MARK: - YamlParser
public struct YamlParser {
public static func parse(_ yaml: String,
env: [String: String] = ProcessInfo.processInfo.environment) throws -> [String: Any] {
do {
return try Yams.load(yaml: yaml, .default,
.swiftlintContructor(env: env)) as? [String: Any] ?? [:]
} catch {
throw YamlParserError.yamlParsing("\(error)")
}
}
}
private extension Constructor {
static func swiftlintContructor(env: [String: String]) -> Constructor {
return Constructor(customScalarMap(env: env))
}
static func customScalarMap(env: [String: String]) -> ScalarMap {
var map = defaultScalarMap
map[.str] = String.constructExpandingEnvVars(env: env)
map[.bool] = Bool.constructUsingOnlyTrueAndFalse
return map
}
}
private extension String {
static func constructExpandingEnvVars(env: [String: String]) -> (_ scalar: Node.Scalar) -> String? {
return { (scalar: Node.Scalar) -> String? in
return scalar.string.expandingEnvVars(env: env)
}
}
func expandingEnvVars(env: [String: String]) -> String {
var result = self
for (key, value) in env {
result = result.replacingOccurrences(of: "${\(key)}", with: value)
}
return result
}
}
private extension Bool {
static func constructUsingOnlyTrueAndFalse(from scalar: Node.Scalar) -> Bool? {
switch scalar.string.lowercased() {
case "true":
return true
case "false":
return false
default:
return nil
}
}
}
|
mit
|
228b092964d7cc83623c83a7f0a76fa0
| 26.671233 | 115 | 0.59505 | 4.225941 | false | false | false | false |
KrishMunot/swift
|
test/attr/attr_noescape.swift
|
2
|
14636
|
// RUN: %target-parse-verify-swift
@noescape var fn : () -> Int = { 4 } // expected-error {{@noescape may only be used on 'parameter' declarations}} {{1-11=}}
func doesEscape(_ fn : () -> Int) {}
func takesGenericClosure<T>(_ a : Int, @noescape _ fn : () -> T) {}
func takesNoEscapeClosure(@noescape _ fn : () -> Int) {
takesNoEscapeClosure { 4 } // ok
fn() // ok
var x = fn // expected-error {{@noescape parameter 'fn' may only be called}}
// This is ok, because the closure itself is noescape.
takesNoEscapeClosure { fn() }
// This is not ok, because it escapes the 'fn' closure.
doesEscape { fn() } // expected-error {{closure use of @noescape parameter 'fn' may allow it to escape}}
// This is not ok, because it escapes the 'fn' closure.
func nested_function() {
fn() // expected-error {{declaration closing over @noescape parameter 'fn' may allow it to escape}}
}
takesNoEscapeClosure(fn) // ok
doesEscape(fn) // expected-error {{invalid conversion from non-escaping function of type '@noescape () -> Int' to potentially escaping function type '() -> Int'}}
takesGenericClosure(4, fn) // ok
takesGenericClosure(4) { fn() } // ok.
}
class SomeClass {
final var x = 42
func test() {
// This should require "self."
doesEscape { x } // expected-error {{reference to property 'x' in closure requires explicit 'self.' to make capture semantics explicit}} {{18-18=self.}}
// Since 'takesNoEscapeClosure' doesn't escape its closure, it doesn't
// require "self." qualification of member references.
takesNoEscapeClosure { x }
}
func foo() -> Int {
foo()
func plain() { foo() }
let plain2 = { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
func multi() -> Int { foo(); return 0 }
let mulit2: () -> Int = { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{31-31=self.}}
doesEscape { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{18-18=self.}}
takesNoEscapeClosure { foo() } // okay
doesEscape { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{18-18=self.}}
takesNoEscapeClosure { foo(); return 0 } // okay
func outer() {
func inner() { foo() }
let inner2 = { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
func multi() -> Int { foo(); return 0 }
let _: () -> Int = { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{28-28=self.}}
doesEscape { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo() }
doesEscape { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo(); return 0 }
}
let outer2: () -> Void = {
func inner() { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
let inner2 = { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
func multi() -> Int { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{29-29=self.}}
let mulit2: () -> Int = { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{33-33=self.}}
doesEscape { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{30-30=self.}}
doesEscape { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{30-30=self.}}
}
doesEscape {
func inner() { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
let inner2 = { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
func multi() -> Int { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{29-29=self.}}
let mulit2: () -> Int = { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{33-33=self.}}
doesEscape { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{30-30=self.}}
doesEscape { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{30-30=self.}}
return 0
}
takesNoEscapeClosure {
func inner() { foo() }
let inner2 = { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
func multi() -> Int { foo(); return 0 }
let mulit2: () -> Int = { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{33-33=self.}}
doesEscape { foo() } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo() } // okay
doesEscape { foo(); return 0 } // expected-error {{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{20-20=self.}}
takesNoEscapeClosure { foo(); return 0 } // okay
return 0
}
struct Outer {
func bar() -> Int {
bar()
func plain() { bar() }
let plain2 = { bar() } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{24-24=self.}}
func multi() -> Int { bar(); return 0 }
let _: () -> Int = { bar(); return 0 } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{30-30=self.}}
doesEscape { bar() } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
takesNoEscapeClosure { bar() } // okay
doesEscape { bar(); return 0 } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{22-22=self.}}
takesNoEscapeClosure { bar(); return 0 } // okay
return 0
}
}
func structOuter() {
struct Inner {
func bar() -> Int {
bar() // no-warning
func plain() { bar() }
let plain2 = { bar() } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{26-26=self.}}
func multi() -> Int { bar(); return 0 }
let _: () -> Int = { bar(); return 0 } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{32-32=self.}}
doesEscape { bar() } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{24-24=self.}}
takesNoEscapeClosure { bar() } // okay
doesEscape { bar(); return 0 } // expected-error {{call to method 'bar' in closure requires explicit 'self.' to make capture semantics explicit}} {{24-24=self.}}
takesNoEscapeClosure { bar(); return 0 } // okay
return 0
}
}
}
return 0
}
}
// Implicit conversions (in this case to @convention(block)) are ok.
@_silgen_name("whatever")
func takeNoEscapeAsObjCBlock(@noescape _: @convention(block) () -> Void)
func takeNoEscapeTest2(@noescape _ fn : () -> ()) {
takeNoEscapeAsObjCBlock(fn)
}
// Autoclosure implies noescape, but produce nice diagnostics so people know
// why noescape problems happen.
func testAutoclosure(@autoclosure _ a : () -> Int) { // expected-note{{parameter 'a' is implicitly @noescape because it was declared @autoclosure}}
doesEscape { a() } // expected-error {{closure use of @noescape parameter 'a' may allow it to escape}}
}
// <rdar://problem/19470858> QoI: @autoclosure implies @noescape, so you shouldn't be allowed to specify both
func redundant(@noescape // expected-error {{@noescape is implied by @autoclosure and should not be redundantly specified}} {{16-25=}}
@autoclosure _ fn : () -> Int) {
}
protocol P1 {
associatedtype Element
}
protocol P2 : P1 {
associatedtype Element
}
func overloadedEach<O: P1, T>(_ source: O, _ transform: O.Element -> (), _: T) {}
func overloadedEach<P: P2, T>(_ source: P, _ transform: P.Element -> (), _: T) {}
struct S : P2 {
typealias Element = Int
func each(@noescape _ transform: Int -> ()) {
overloadedEach(self, // expected-error {{cannot invoke 'overloadedEach' with an argument list of type '(S, @noescape Int -> (), Int)'}}
transform, 1)
// expected-note @-2 {{overloads for 'overloadedEach' exist with these partially matching parameter lists: (O, O.Element -> (), T), (P, P.Element -> (), T)}}
}
}
// rdar://19763676 - False positive in @noescape analysis triggered by parameter label
func r19763676Callee(@noescape _ f: (param: Int) -> Int) {}
func r19763676Caller(@noescape _ g: (Int) -> Int) {
r19763676Callee({ _ in g(1) })
}
// <rdar://problem/19763732> False positive in @noescape analysis triggered by default arguments
func calleeWithDefaultParameters(@noescape _ f: () -> (), x : Int = 1) {} // expected-warning {{closure parameter prior to parameters with default arguments will not be treated as a trailing closure}}
func callerOfDefaultParams(@noescape _ g: () -> ()) {
calleeWithDefaultParameters(g)
}
// <rdar://problem/19773562> Closures executed immediately { like this }() are not automatically @noescape
class NoEscapeImmediatelyApplied {
func f() {
// Shouldn't require "self.", the closure is obviously @noescape.
_ = { return ivar }()
}
final var ivar = 42
}
// Reduced example from XCTest overlay, involves a TupleShuffleExpr
public func XCTAssertTrue(@autoclosure _ expression: () -> Boolean, _ message: String = "", file: StaticString = #file, line: UInt = #line) -> Void {
}
public func XCTAssert( @autoclosure _ expression: () -> Boolean, _ message: String = "", file: StaticString = #file, line: UInt = #line) -> Void {
XCTAssertTrue(expression, message, file: file, line: line);
}
/// SR-770 - Currying and `noescape`/`rethrows` don't work together anymore
func curriedFlatMap<A, B>(_ x: [A]) -> (@noescape (A) -> [B]) -> [B] {
return { f in
x.flatMap(f)
}
}
func curriedFlatMap2<A, B>(_ x: [A]) -> (@noescape (A) -> [B]) -> [B] {
return { (f : @noescape (A) -> [B]) in
x.flatMap(f)
}
}
func bad(_ a : (Int)-> Int) -> Int { return 42 }
func escapeNoEscapeResult(_ x: [Int]) -> (@noescape (Int) -> Int) -> Int {
return { f in
bad(f) // expected-error {{invalid conversion from non-escaping function of type '@noescape (Int) -> Int' to potentially escaping function type '(Int) -> Int'}}
}
}
// SR-824 - @noescape for Type Aliased Closures
//
typealias CompletionHandlerNE = @noescape (success: Bool) -> ()
typealias CompletionHandler = (success: Bool) -> ()
var escape : CompletionHandlerNE
func doThing1(@noescape _ completion: CompletionHandler) {
// expected-error @+2 {{@noescape value 'escape' may only be called}}
// expected-error @+1 {{@noescape parameter 'completion' may only be called}}
escape = completion
}
func doThing2(_ completion: CompletionHandlerNE) {
// expected-error @+2 {{@noescape value 'escape' may only be called}}
// expected-error @+1 {{@noescape parameter 'completion' may only be called}}
escape = completion
}
// <rdar://problem/19997680> @noescape doesn't work on parameters of function type
func apply<T, U>(@noescape _ f: T -> U, @noescape g: (@noescape T -> U) -> U) -> U {
return g(f)
}
// <rdar://problem/19997577> @noescape cannot be applied to locals, leading to duplication of code
enum r19997577Type {
case Unit
case Function(() -> r19997577Type, () -> r19997577Type)
case Sum(() -> r19997577Type, () -> r19997577Type)
func reduce<Result>(_ initial: Result, @noescape _ combine: (Result, r19997577Type) -> Result) -> Result {
let binary: @noescape (r19997577Type, r19997577Type) -> Result = { combine(combine(combine(initial, self), $0), $1) }
switch self {
case Unit:
return combine(initial, self)
case let Function(t1, t2):
return binary(t1(), t2())
case let Sum(t1, t2):
return binary(t1(), t2())
}
}
}
// type attribute and decl attribute
func noescapeD(@noescape f: () -> Bool) {} // ok
func noescapeT(f: @noescape () -> Bool) {} // ok
func autoclosureD(@autoclosure f: () -> Bool) {} // ok
func autoclosureT(f: @autoclosure () -> Bool) {} // expected-error {{attribute can only be applied to declarations, not types}} {{1-1=@autoclosure }} {{22-35=}}
func noescapeD_noescapeT(@noescape f: @noescape () -> Bool) {} // ok
func autoclosureD_noescapeT(@autoclosure f: @noescape () -> Bool) {} // ok
|
apache-2.0
|
927e4aeeda529f5abd242b7db740e820
| 47.463576 | 201 | 0.646215 | 4.008765 | false | false | false | false |
suzuki-0000/SKPhotoBrowser
|
SKPhotoBrowserExample/SKPhotoBrowserExample/FromLocalViewController.swift
|
1
|
7073
|
//
// ViewController.swift
// SKPhotoBrowserExample
//
// Created by suzuki_keishi on 2015/10/06.
// Copyright © 2015 suzuki_keishi. All rights reserved.
//
import UIKit
import SKPhotoBrowser
class FromLocalViewController: UIViewController, UICollectionViewDataSource, UICollectionViewDelegate, SKPhotoBrowserDelegate {
@IBOutlet weak var collectionView: UICollectionView!
var images = [SKPhotoProtocol]()
override func viewDidLoad() {
super.viewDidLoad()
// Static setup
SKPhotoBrowserOptions.displayAction = true
SKPhotoBrowserOptions.displayStatusbar = true
SKPhotoBrowserOptions.displayCounterLabel = true
SKPhotoBrowserOptions.displayBackAndForwardButton = true
setupTestData()
setupCollectionView()
}
override var prefersStatusBarHidden: Bool {
return false
}
override var preferredStatusBarStyle: UIStatusBarStyle {
return .lightContent
}
}
// MARK: - UICollectionViewDataSource
extension FromLocalViewController {
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return images.count
}
@objc(collectionView:cellForItemAtIndexPath:) func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "exampleCollectionViewCell", for: indexPath) as? ExampleCollectionViewCell else {
return UICollectionViewCell()
}
cell.exampleImageView.image = UIImage(named: "image\((indexPath as NSIndexPath).row % 10).jpg")
return cell
}
}
// MARK: - UICollectionViewDelegate
extension FromLocalViewController {
@objc(collectionView:didSelectItemAtIndexPath:) func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
let browser = SKPhotoBrowser(photos: images, initialPageIndex: indexPath.row)
browser.delegate = self
present(browser, animated: true, completion: {})
}
func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAtIndexPath indexPath: IndexPath) -> CGSize {
if UIDevice.current.userInterfaceIdiom == .pad {
return CGSize(width: UIScreen.main.bounds.size.width / 2 - 5, height: 300)
} else {
return CGSize(width: UIScreen.main.bounds.size.width / 2 - 5, height: 200)
}
}
}
// MARK: - SKPhotoBrowserDelegate
extension FromLocalViewController {
func didShowPhotoAtIndex(_ index: Int) {
collectionView.visibleCells.forEach({$0.isHidden = false})
collectionView.cellForItem(at: IndexPath(item: index, section: 0))?.isHidden = true
}
func willDismissAtPageIndex(_ index: Int) {
collectionView.visibleCells.forEach({$0.isHidden = false})
collectionView.cellForItem(at: IndexPath(item: index, section: 0))?.isHidden = true
}
func willShowActionSheet(_ photoIndex: Int) {
// do some handle if you need
}
func didDismissAtPageIndex(_ index: Int) {
collectionView.cellForItem(at: IndexPath(item: index, section: 0))?.isHidden = false
}
func didDismissActionSheetWithButtonIndex(_ buttonIndex: Int, photoIndex: Int) {
// handle dismissing custom actions
}
func removePhoto(_ browser: SKPhotoBrowser, index: Int, reload: @escaping (() -> Void)) {
reload()
}
func viewForPhoto(_ browser: SKPhotoBrowser, index: Int) -> UIView? {
return collectionView.cellForItem(at: IndexPath(item: index, section: 0))
}
func captionViewForPhotoAtIndex(index: Int) -> SKCaptionView? {
return nil
}
}
// MARK: - private
private extension FromLocalViewController {
func setupTestData() {
images = createLocalPhotos()
}
func setupCollectionView() {
collectionView.delegate = self
collectionView.dataSource = self
}
func createLocalPhotos() -> [SKPhotoProtocol] {
return (0..<10).map { (i: Int) -> SKPhotoProtocol in
let photo = SKPhoto.photoWithImage(UIImage(named: "image\(i%10).jpg")!)
photo.caption = caption[i%10]
return photo
}
}
}
class ExampleCollectionViewCell: UICollectionViewCell {
@IBOutlet weak var exampleImageView: UIImageView!
override func awakeFromNib() {
super.awakeFromNib()
exampleImageView.image = nil
// layer.cornerRadius = 25.0
layer.masksToBounds = true
}
override func prepareForReuse() {
exampleImageView.image = nil
}
}
var caption = ["Lorem Ipsum is simply dummy text of the printing and typesetting industry.",
"Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book",
"It has survived not only five centuries, but also the leap into electronic typesetting",
"remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.",
"Lorem Ipsum is simply dummy text of the printing and typesetting industry.",
"Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.",
"It has survived not only five centuries, but also the leap into electronic typesetting",
"remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.",
"Lorem Ipsum is simply dummy text of the printing and typesetting industry.",
"Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.",
"It has survived not only five centuries, but also the leap into electronic typesetting",
"remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum."
]
|
mit
|
550c4e923ca0c8fd5e55fdc25a1c3242
| 43.2 | 528 | 0.700792 | 5.102453 | false | false | false | false |
mortenjust/androidtool-mac
|
PreferencesWindowController.swift
|
1
|
1573
|
//
// PreferencesWindowController.swift
// AndroidTool
//
// Created by Morten Just Petersen on 5/1/15.
// Copyright (c) 2015 Morten Just Petersen. All rights reserved.
//
import Cocoa
class PreferencesWindowController: NSWindowController {
@IBAction func screenshotFolderClicked(_ sender: AnyObject) {
selectFolder("Screenshots", message: "Save screenshots in this folder", defaultsPath: "screenshotsFolder")
}
@IBAction func screenRecordingFolderClicked(_ sender: AnyObject) {
selectFolder("Screen recordings", message: "Save recordings in this folder", defaultsPath: "screenRecordingsFolder")
}
override func windowDidLoad() {
super.windowDidLoad()
// all bindings are belong to IB
}
func selectFolder(_ title:String, message:String, defaultsPath:String){
let openPanel = NSOpenPanel();
openPanel.title = title
openPanel.message = message
openPanel.showsResizeIndicator=true;
openPanel.canChooseDirectories = true;
openPanel.canChooseFiles = false;
openPanel.allowsMultipleSelection = false;
openPanel.canCreateDirectories = true;
openPanel.begin { (result) -> Void in
if(result == NSFileHandlingPanelOKButton){
let path = openPanel.url!.path
print("selected folder is \(path), saving to \(defaultsPath)");
let ud = UserDefaults.standard
ud.setValue(path, forKey: defaultsPath)
}
}
}
}
|
apache-2.0
|
b2e7e00510cdc195a9bd680c399b2ee2
| 30.46 | 124 | 0.643357 | 5.243333 | false | false | false | false |
ngageoint/fog-machine
|
Demo/FogViewshed/FogViewshed/Models/Viewshed/FogMachine/ViewshedTool.swift
|
1
|
4935
|
import Foundation
import FogMachine
import SwiftEventBus
public class ViewshedTool : FMTool {
public var createWorkViewshedObserver:Observer?
public var createWorkViewshedAlgorithmName:ViewshedAlgorithmName?
public override init() {
super.init()
}
public override func id() -> UInt32 {
return 4230345579
}
public override func name() -> String {
return "Viewshed Tool with " + createWorkViewshedAlgorithmName!.rawValue + " algorithm for observer at (\(createWorkViewshedObserver!.position.latitude), \(createWorkViewshedObserver!.position.longitude))"
}
public override func createWork(node:FMNode, nodeNumber:UInt, numberOfNodes:UInt) -> ViewshedWork {
return ViewshedWork(sectorCount: Int(numberOfNodes), sectorNumber: Int(nodeNumber), observer: createWorkViewshedObserver!, viewshedAlgorithmName: createWorkViewshedAlgorithmName!)
}
public override func processWork(node:FMNode, fromNode:FMNode, work: FMWork) -> ViewshedResult {
let viewshedWork = work as! ViewshedWork
// draw the pin if it doesn't exist
SwiftEventBus.post(ViewshedEventBusEvents.addObserverPin, sender:viewshedWork.observer)
// make the sector
let angleSize:Double = (2*M_PI)/Double(viewshedWork.sectorCount)
let startAngle:Double = angleSize*Double(viewshedWork.sectorNumber)
let endAngle:Double = angleSize*Double(viewshedWork.sectorNumber + 1)
let sector:Sector = Sector(center: viewshedWork.observer.position, startAngleInRadans: startAngle, endAngleInRadans: endAngle, radiusInMeters: viewshedWork.observer.radiusInMeters)
var axisOrientedBoundingBox:AxisOrientedBoundingBox
var perimeter:Perimeter
// get bounding box for sector
if(viewshedWork.sectorCount == 1) {
// special case for no peers
axisOrientedBoundingBox = BoundingBoxUtility.getBoundingBox(viewshedWork.observer.position, radiusInMeters: viewshedWork.observer.radiusInMeters)
} else {
axisOrientedBoundingBox = sector.getBoundingBox()
}
// read elevation data
viewshedLog("Start reading in elevation data")
let dataReadTimer:FMTimer = FMTimer()
dataReadTimer.start()
let elevationDataGrid:DataGrid = HGTManager.getElevationGrid(axisOrientedBoundingBox, resolution: Srtm.SRTM3_RESOLUTION)
viewshedLog("Read elevation data in " + String(format: "%.3f", dataReadTimer.stop()) + " seconds")
if(viewshedWork.sectorCount == 1) {
perimeter = RectangularPerimeter(dataGrid: elevationDataGrid)
} else {
perimeter = SectorPerimeter(dataGrid: elevationDataGrid, sector: sector)
}
// run viewshed on data
viewshedLog("Start running viewshed")
let viewshedTimer:FMTimer = FMTimer()
viewshedTimer.start()
var viewsehdAlgorithm:ViewsehdAlgorithm
if(viewshedWork.viewshedAlgorithmName == ViewshedAlgorithmName.VanKreveld) {
viewsehdAlgorithm = VanKreveldViewshed(elevationDataGrid: elevationDataGrid, observer: viewshedWork.observer)
} else {
viewsehdAlgorithm = FranklinRayViewshed(elevationDataGrid: elevationDataGrid, perimeter: perimeter, observer: viewshedWork.observer)
}
let viewshedDataGrid:DataGrid = viewsehdAlgorithm.runViewshed()
viewshedLog("Ran viewshed in " + String(format: "%.3f", viewshedTimer.stop()) + " seconds")
SwiftEventBus.post(ViewshedEventBusEvents.drawGridOverlay, sender:ImageUtility.generateViewshedOverlay(viewshedDataGrid))
return ViewshedResult(dataGrid: viewshedDataGrid)
}
public override func mergeResults(node:FMNode, nodeToResult: [FMNode:FMResult]) -> Void {
for (n, result) in nodeToResult {
// if this is not me
if(node != n) {
let viewshedResult = result as! ViewshedResult
NSLog("Received result from node " + n.description)
SwiftEventBus.post(ViewshedEventBusEvents.drawGridOverlay, sender:ImageUtility.generateViewshedOverlay(viewshedResult.dataGrid))
}
}
SwiftEventBus.post(ViewshedEventBusEvents.viewshedComplete)
}
public override func onPeerConnect(myNode:FMNode, connectedNode:FMNode) {
SwiftEventBus.post(FogMachineEventBusEvents.onPeerConnect)
}
public override func onPeerDisconnect(myNode:FMNode, disconnectedNode:FMNode) {
SwiftEventBus.post(FogMachineEventBusEvents.onPeerDisconnect)
}
public func viewshedLog(format:String) {
NSLog(format)
self.onLog(format)
}
public override func onLog(format:String) {
SwiftEventBus.post(ViewshedEventBusEvents.onLog, sender:format)
}
}
|
mit
|
8c8ba0937def270dfa887cb5cc2e3256
| 43.872727 | 213 | 0.692401 | 4.445946 | false | false | false | false |
rajagp/iOS-UIAutomationExample
|
LSUITestExample-UIAutomation/LSUITestExample-UIAutomation/LSAddTaskViewController.swift
|
1
|
3633
|
//
// LSAddTaskViewController.swift
// LSUITestExample-UIAutomation
//
// Created by Priya Rajagopal on 6/14/15.
// Copyright (c) 2015 lunaria. All rights reserved.
//
import Foundation
import UIKit
class LSAddTaskViewController :UITableViewController, UIPickerViewDelegate, UITextViewDelegate
{
let ROW_HEIGHT:CGFloat = 45.0
let ROW_INDEX_TASKDETAILS = 0
let SECTION_INDEX_DATEPICKER = 1
var datePickerCellHeight:CGFloat = 45.0
@IBOutlet var dueDate: UILabel!
@IBOutlet var saveButton: UIBarButtonItem!
@IBOutlet var taskDetailsTextView: UITextView!
@IBOutlet var datePickerView: UIView!
@IBOutlet var datePickerZeroHeightConstraint: NSLayoutConstraint!
@IBOutlet var datePicker: UIDatePicker!
var dataManager:LSTaskDataManager {
get{
return LSTaskDataManager.sharedInstance()
}
};
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
self.tableView.estimatedRowHeight = ROW_HEIGHT
self.tableView.rowHeight = UITableViewAutomaticDimension
self.datePickerView.hidden = true
self.datePickerView.addConstraint(datePickerZeroHeightConstraint)
let dateVal = NSDateFormatter.localizedStringFromDate(self.datePicker.date, dateStyle:.ShortStyle, timeStyle:.ShortStyle)
self.dueDate.text = dateVal;
self.datePicker.minimumDate = NSDate()
}
// MARK - UITableViewDataSOurce
override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
var height = ROW_HEIGHT
if indexPath.section == SECTION_INDEX_DATEPICKER {
return self.datePickerCellHeight
}
return height
}
// MARK - UITableViewDelegate
override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
if indexPath.section == 1 {
var cell:UITableViewCell = tableView.cellForRowAtIndexPath(indexPath)!
self.datePickerView.hidden = !self.datePickerView.hidden
if self.datePickerView.hidden {
self.datePicker.hidden = true
self.datePickerView.addConstraint(datePickerZeroHeightConstraint)
}
else {
self.datePicker.hidden = false
self.datePickerView.removeConstraint(datePickerZeroHeightConstraint)
}
let dateVal = NSDateFormatter.localizedStringFromDate(self.datePicker.date, dateStyle:.ShortStyle, timeStyle:.ShortStyle)
self.dueDate.text = dateVal;
cell.setNeedsUpdateConstraints()
cell.setNeedsLayout()
self.datePickerCellHeight = cell.contentView.systemLayoutSizeFittingSize(CGSizeMake(self.tableView.bounds.size.width, 0), withHorizontalFittingPriority: 1000.0, verticalFittingPriority: 749.0).height
tableView.beginUpdates()
tableView.endUpdates()
}
}
// MARK - UITextViewDelegate
func textViewDidChange(textView: UITextView) {
self.saveButton.enabled = count(textView.text.utf16) > 0
}
// MARK - IBActions
@IBAction func onSaveTapped(sender: UIBarButtonItem) {
let task:LSTask = LSTask(detail:self.taskDetailsTextView.text, andDueDate: self.datePicker.date)
self.dataManager.addTask(task)
self.performSegueWithIdentifier("unwind", sender: self)
}
}
|
mit
|
9834ac396792e0e247262e7938168772
| 34.281553 | 211 | 0.666942 | 5.390208 | false | false | false | false |
Desgard/Calendouer-iOS
|
Calendouer/Calendouer/App/Controller/setting/AboutOpenSourceViewController.swift
|
1
|
4716
|
//
// AboutOpenSourceViewController.swift
// Calendouer
//
// Created by 段昊宇 on 2017/4/27.
// Copyright © 2017年 Desgard_Duan. All rights reserved.
//
import UIKit
class AboutOpenSourceViewController: UIViewController {
var tableView: UITableView!
let repoDatas: [String] = [
"SDWebImage",
"SnapKit",
"Alamofire",
"SwiftyJSON",
"lottie-ios",
"TKSwitcherCollection",
"Agrume",
]
let urlDatas: [String] = [
"https://github.com/rs/SDWebImage",
"https://github.com/SnapKit/SnapKit",
"https://github.com/Alamofire/Alamofire",
"https://github.com/SwiftyJSON/SwiftyJSON",
"https://github.com/airbnb/lottie-ios",
"https://github.com/TBXark/TKSwitcherCollection",
"https://github.com/JanGorman/Agrume",
]
override func viewDidLoad() {
super.viewDidLoad()
initialDatas()
initialViews()
addViews()
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
self.navigationController?.navigationBar.titleTextAttributes = [
NSFontAttributeName: UIFont(name: "Ubuntu-Light", size: 17) ?? UIFont.systemFont(ofSize: 17),
NSForegroundColorAttributeName: UIColor.white,
]
self.tabBarController?.tabBar.isHidden = true
}
private func initialDatas() {
}
private func initialViews() {
view.backgroundColor = DouBackGray
title = "开源协议"
tableView = UITableView(frame: view.bounds, style: UITableViewStyle.grouped)
tableView.backgroundColor = DouBackGray
tableView.separatorColor = .clear
tableView.estimatedRowHeight = 30
tableView.rowHeight = UITableViewAutomaticDimension
tableView.dataSource = self
tableView.delegate = self
tableView.register(UINib(nibName: LogoTableViewCellId, bundle: nil), forCellReuseIdentifier: LogoTableViewCellId)
tableView.register(UINib(nibName: TitleSettingTableViewCellId, bundle: nil), forCellReuseIdentifier: TitleSettingTableViewCellId)
tableView.register(UINib(nibName: TextSettingTableViewCellId, bundle: nil), forCellReuseIdentifier: TextSettingTableViewCellId)
}
private func addViews() {
view.addSubview(tableView)
}
}
extension AboutOpenSourceViewController: UITableViewDelegate {
@available(iOS 2.0, *)
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return 2 + self.repoDatas.count
}
func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
return 0.1
}
func tableView(_ tableView: UITableView, heightForFooterInSection section: Int) -> CGFloat {
return 0.1
}
func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
return nil
}
func tableView(_ tableView: UITableView, viewForFooterInSection section: Int) -> UIView? {
return nil
}
}
extension AboutOpenSourceViewController: UITableViewDataSource {
@available(iOS 2.0, *)
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
if indexPath.row == 0 {
let cell: LogoTableViewCell = tableView.dequeueReusableCell(withIdentifier: LogoTableViewCellId, for: indexPath) as! LogoTableViewCell
cell.selectionStyle = .none
return cell
}
else if indexPath.row == 1 {
let cell: TitleSettingTableViewCell = tableView.dequeueReusableCell(withIdentifier: TitleSettingTableViewCellId, for: indexPath) as! TitleSettingTableViewCell
cell.initialCell(title: "感谢以下开源项目提供的帮助")
cell.backgroundColor = .clear
cell.selectionStyle = .none
return cell
}
else {
let cell: TextSettingTableViewCell = tableView.dequeueReusableCell(withIdentifier: TextSettingTableViewCellId, for: indexPath) as! TextSettingTableViewCell
cell.initialCell(title: self.repoDatas[indexPath.row - 2], target: "")
return cell
}
}
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
tableView.deselectRow(at: indexPath, animated: true)
if indexPath.row == 0 || indexPath.row == 1 {
return
}
else {
let url = self.urlDatas[indexPath.row - 2]
UIApplication.shared.open(URL.init(string: url)!, options: [:], completionHandler: { (finished) in })
}
}
}
|
mit
|
269e7f19528dad4bf72d23dccf58fde0
| 35.507813 | 170 | 0.65397 | 4.913775 | false | false | false | false |
petrpavlik/AsyncChat
|
Chat/Classes/ImageMessageCell.swift
|
1
|
2495
|
//
// ImageMessageCell.swift
// Chat
//
// Created by Petr Pavlik on 25/10/15.
// Copyright © 2015 Petr Pavlik. All rights reserved.
//
import UIKit
import AsyncDisplayKit
import Toucan
public class ImageMessageCell: MessageCell, ASNetworkImageNodeDelegate {
private let imageNode = ASNetworkImageNode()
//FIXME: This is probably called on multiple threads.
private var requiredImageSize = CGSizeZero
public init(imageURL: NSURL, isIncomming: Bool) {
super.init()
self.isIncomingMessage = isIncomming
addSubnode(imageNode)
imageNode.delegate = self
imageNode.imageModificationBlock = { (image) in
var toucanImage = Toucan(image: image).resize(CGSizeMake(200, 200/4*3))
toucanImage = toucanImage.maskWithPath(path: UIBezierPath(roundedRect: CGRectMake(0, 0, toucanImage.image.size.width, toucanImage.image.size.height), cornerRadius: 18))
return toucanImage.image
}
imageNode.setURL(imageURL, resetToDefault: true)
isIncomingMessage = isIncomming
if isIncomming == true {
bubbleNode.tintColor = incomingMessageColorNormal
} else {
bubbleNode.tintColor = outgoingMessageColorNormal
}
}
override func layoutSpecForBubbneNode(bubbleNode: ASDisplayNode) -> ASLayoutSpec {
imageNode.sizeRange = ASRelativeSizeRangeMakeWithExactCGSize(CGSizeMake(200, 200/4*3))
let imageSizeSpec = ASStaticLayoutSpec(children: [imageNode])
return ASBackgroundLayoutSpec(child: imageSizeSpec, background: bubbleNode)
}
/*func layoutSpecForMessageBubble() -> ASLayoutSpec {
let sizeLayout = ASStackLayoutSpec(direction: .Horizontal, spacing: 0, justifyContent: .Start, alignItems: .Start, children: [bubbleNode])
sizeLayout.sizeRange = ASRelativeSizeRangeMake(
ASRelativeSizeMake(ASRelativeDimensionMakeWithPoints(100), ASRelativeDimensionMakeWithPoints(0)),
ASRelativeSizeMake(ASRelativeDimensionMakeWithPoints(100), ASRelativeDimensionMakeWithPoints(100))
)
let aspectLayout = ASRatioLayoutSpec(ratio: 4/3, child: bubbleNode)
return ASStaticLayoutSpec(children: [sizeLayout, aspectLayout])
}*/
public func imageNode(imageNode: ASNetworkImageNode!, didLoadImage image: UIImage!) {
}
}
|
mit
|
7918b4bfba02fc77c687e356ee9c69a0
| 34.126761 | 180 | 0.672414 | 4.890196 | false | false | false | false |
audrl1010/EasyMakePhotoPicker
|
Example/EasyMakePhotoPicker/FacebookPermissionVC.swift
|
1
|
5889
|
//
// FacebookPermissionVC.swift
// EasyMakePhotoPicker
//
// Created by myung gi son on 2017. 7. 7..
// Copyright © 2017년 CocoaPods. All rights reserved.
//
import UIKit
import RxSwift
import RxCocoa
class FacebookPermissionVC: BaseVC {
struct Constant {
static let titleLabelText = "Please Allow Photo Access"
static let contentLabelText = "This allows you to share photos from your library and save photos to your camera roll."
static let enumerationOneLabelText = "1. Tap Privacy"
static let enumerationSecondLabelText = "2. Switch Photos On"
static let allowAccessButtonText = "Allow Access"
}
struct Color {
static let containerViewBGColor = UIColor.white
static let titleLabelColor = UIColor(
red: 114/255,
green: 116/255,
blue: 130/255,
alpha: 1.0)
static let contentLabelColor = UIColor(
red: 114/255,
green: 116/255,
blue: 130/255,
alpha: 1.0)
static let enumerationOneLabelColor = UIColor(
red: 114/255,
green: 116/255,
blue: 130/255,
alpha: 1.0)
static let enumerationSecondLabelColor = UIColor(
red: 114/255,
green: 116/255,
blue: 130/255,
alpha: 1.0)
}
struct Font {
static let titleLabelFont = UIFont.boldSystemFont(ofSize: 18)
static let contentLabelFont = UIFont.systemFont(ofSize: 14)
static let enumerationOneLabelFont = UIFont.boldSystemFont(ofSize: 16)
static let enumerationSecondLabelFont = UIFont.boldSystemFont(ofSize: 16)
static let allowAccessButtonFont = UIFont.boldSystemFont(ofSize: 16)
}
struct Metric {
static let containerViewLeft = CGFloat(25)
static let containerViewTop = CGFloat(100)
static let containerViewRight = CGFloat(-25)
static let containerViewBottom = CGFloat(50)
static let titleLabelTop = CGFloat(5)
static let contentLabelTop = CGFloat(10)
static let enumerationOneLabelLabelTop = CGFloat(20)
static let enumerationSecondLabelTop = CGFloat(10)
static let allowAccessButtonTop = CGFloat(35)
}
var containerView = UIView().then {
$0.backgroundColor = Color.containerViewBGColor
}
var titleLabel = UILabel().then {
$0.textColor = Color.titleLabelColor
$0.font = Font.titleLabelFont
$0.textAlignment = .center
$0.text = Constant.titleLabelText
}
var contentLabel = UILabel().then {
$0.textColor = Color.contentLabelColor
$0.font = Font.contentLabelFont
$0.text = Constant.contentLabelText
$0.textAlignment = .center
$0.numberOfLines = 0
}
var enumerationOneLabel = UILabel().then {
$0.textColor = Color.enumerationOneLabelColor
$0.font = Font.enumerationOneLabelFont
$0.text = Constant.enumerationOneLabelText
}
var enumerationSecondLabel = UILabel().then {
$0.textColor = Color.enumerationSecondLabelColor
$0.font = Font.enumerationSecondLabelFont
$0.text = Constant.enumerationSecondLabelText
}
var allowAccessButton = UIButton(type: .system).then {
$0.setTitle(Constant.allowAccessButtonText, for: .normal)
$0.titleLabel?.font = Font.allowAccessButtonFont
}
var doneButton = UIBarButtonItem(
barButtonSystemItem: .done,
target: nil,
action: nil)
var disposeBag = DisposeBag()
override func setupViews() {
navigationItem.rightBarButtonItem = doneButton
view.backgroundColor = .white
view.addSubview(containerView)
containerView.addSubview(titleLabel)
containerView.addSubview(contentLabel)
containerView.addSubview(enumerationOneLabel)
containerView.addSubview(enumerationSecondLabel)
containerView.addSubview(allowAccessButton)
bind()
}
override func setupConstraints() {
containerView
.fs_leftAnchor(
equalTo: view.leftAnchor,
constant: Metric.containerViewLeft)
.fs_topAnchor(
equalTo: topLayoutGuide.bottomAnchor,
constant: Metric.containerViewTop)
.fs_rightAnchor(
equalTo: view.rightAnchor,
constant: Metric.containerViewRight)
.fs_bottomAnchor(
equalTo: view.bottomAnchor,
constant: Metric.containerViewBottom)
.fs_endSetup()
titleLabel
.fs_topAnchor(
equalTo: containerView.topAnchor,
constant: Metric.titleLabelTop)
.fs_centerXAnchor(equalTo: containerView.centerXAnchor)
.fs_endSetup()
contentLabel
.fs_topAnchor(
equalTo: titleLabel.bottomAnchor,
constant: Metric.contentLabelTop)
.fs_leftAnchor(equalTo: containerView.leftAnchor)
.fs_rightAnchor(equalTo: containerView.rightAnchor)
.fs_endSetup()
enumerationOneLabel
.fs_topAnchor(
equalTo: contentLabel.bottomAnchor,
constant: Metric.enumerationOneLabelLabelTop)
.fs_centerXAnchor(equalTo: containerView.centerXAnchor)
.fs_endSetup()
enumerationSecondLabel
.fs_topAnchor(
equalTo: enumerationOneLabel.bottomAnchor,
constant: Metric.enumerationSecondLabelTop)
.fs_centerXAnchor(equalTo: containerView.centerXAnchor)
.fs_endSetup()
allowAccessButton
.fs_topAnchor(
equalTo: enumerationSecondLabel.bottomAnchor,
constant: Metric.allowAccessButtonTop)
.fs_centerXAnchor(equalTo: containerView.centerXAnchor)
.fs_endSetup()
}
func bind() {
doneButton.rx.tap
.observeOn(MainScheduler.instance)
.subscribe(onNext: { [weak self] _ in
guard let `self` = self else { return }
self.dismiss(animated: true, completion: nil)
})
.disposed(by: disposeBag)
allowAccessButton.rx.controlEvent(.touchUpInside)
.subscribe(onNext: {
UIApplication.shared
.openURL(URL(string: UIApplication.openSettingsURLString)!)
})
.disposed(by: disposeBag)
}
}
|
mit
|
d1257793a2b93226cc8e3c4641be0abb
| 29.184615 | 122 | 0.687903 | 4.510345 | false | false | false | false |
duliodenis/HackingWithSwift
|
project-14/Whack-a-Penguin/Whack-a-Penguin/WhackSlot.swift
|
1
|
2062
|
//
// WhackSlot.swift
// Whack-a-Penguin
//
// Created by Dulio Denis on 2/15/15.
// Copyright (c) 2015 ddApps. All rights reserved.
//
import UIKit
import SpriteKit
class WhackSlot: SKNode {
var charNode: SKSpriteNode!
var isVisible = false
var isHit = false
func configureAtPosition(pos: CGPoint) {
position = pos
let sprite = SKSpriteNode(imageNamed: "whackHole")
addChild(sprite)
let cropNode = SKCropNode()
cropNode.position = CGPoint(x: 0, y: 15)
cropNode.zPosition = 1
cropNode.maskNode = SKSpriteNode(imageNamed: "whackMask")
charNode = SKSpriteNode(imageNamed: "penguinGood")
charNode.position = CGPoint(x: 0, y: -90)
charNode.name = "character"
cropNode.addChild(charNode)
addChild(cropNode)
}
func show(#hideTime: Double) {
if isVisible { return }
charNode.runAction(SKAction.moveByX(0, y: 80, duration: 0.05))
isVisible = true
isHit = false
if RandomInt(min: 0, max: 2) == 0 {
charNode.texture = SKTexture(imageNamed: "penguinGood")
charNode.name = "charFriend"
} else {
charNode.texture = SKTexture(imageNamed: "penguinEvil")
charNode.name = "charEnemy"
}
charNode.xScale = 1
charNode.yScale = 1
runAfterDelay(hideTime * 3.5) { [unowned self] in
self.hide()
}
}
func hide() {
if !isVisible { return }
charNode.runAction(SKAction.moveByX(0, y: -80, duration: 0.05))
isVisible = false
}
func hit() {
isHit = true
let delay = SKAction.waitForDuration(0.25)
let hide = SKAction.moveByX(0, y: -80, duration: 0.5)
let notVisible = SKAction.runBlock { [unowned self] in self.isVisible = false }
let sequence = SKAction.sequence([delay, hide, notVisible])
charNode.runAction(sequence)
}
}
|
mit
|
ec1f7c409569529be7437eb384c3ff5e
| 26.493333 | 87 | 0.56935 | 4.140562 | false | false | false | false |
dclelland/AudioKit
|
AudioKit/Common/Nodes/Generators/Physical Models/Plucked String/AKPluckedString.swift
|
1
|
5511
|
//
// AKPluckedString.swift
// AudioKit
//
// Created by Aurelius Prochazka, revision history on Github.
// Copyright (c) 2016 Aurelius Prochazka. All rights reserved.
//
import AVFoundation
/// Karplus-Strong plucked string instrument.
///
/// - parameter frequency: Variable frequency. Values less than the initial frequency will be doubled until it is greater than that.
/// - parameter amplitude: Amplitude
/// - parameter lowestFrequency: This frequency is used to allocate all the buffers needed for the delay. This should be the lowest frequency you plan on using.
///
public class AKPluckedString: AKVoice {
// MARK: - Properties
internal var internalAU: AKPluckedStringAudioUnit?
internal var token: AUParameterObserverToken?
private var frequencyParameter: AUParameter?
private var amplitudeParameter: AUParameter?
private var lowestFrequency: Double
/// Ramp Time represents the speed at which parameters are allowed to change
public var rampTime: Double = AKSettings.rampTime {
willSet {
if rampTime != newValue {
internalAU?.rampTime = newValue
internalAU?.setUpParameterRamp()
}
}
}
/// Variable frequency. Values less than the initial frequency will be doubled until it is greater than that.
public var frequency: Double = 110 {
willSet {
if frequency != newValue {
frequencyParameter?.setValue(Float(newValue), originator: token!)
}
}
}
/// Amplitude
public var amplitude: Double = 0.5 {
willSet {
if amplitude != newValue {
amplitudeParameter?.setValue(Float(newValue), originator: token!)
}
}
}
/// Tells whether the node is processing (ie. started, playing, or active)
override public var isStarted: Bool {
return internalAU!.isPlaying()
}
// MARK: - Initialization
/// Initialize the pluck with defaults
override convenience init() {
self.init(frequency: 110)
}
/// Initialize this pluck node
///
/// - parameter frequency: Variable frequency. Values less than the initial frequency will be doubled until it is greater than that.
/// - parameter amplitude: Amplitude
/// - parameter lowestFrequency: This frequency is used to allocate all the buffers needed for the delay. This should be the lowest frequency you plan on using.
///
public init(
frequency: Double,
amplitude: Double = 0.5,
lowestFrequency: Double = 110) {
self.frequency = frequency
self.amplitude = amplitude
self.lowestFrequency = lowestFrequency
var description = AudioComponentDescription()
description.componentType = kAudioUnitType_Generator
description.componentSubType = 0x706c756b /*'pluk'*/
description.componentManufacturer = 0x41754b74 /*'AuKt'*/
description.componentFlags = 0
description.componentFlagsMask = 0
AUAudioUnit.registerSubclass(
AKPluckedStringAudioUnit.self,
asComponentDescription: description,
name: "Local AKPluckedString",
version: UInt32.max)
super.init()
AVAudioUnit.instantiateWithComponentDescription(description, options: []) {
avAudioUnit, error in
guard let avAudioUnitGenerator = avAudioUnit else { return }
self.avAudioNode = avAudioUnitGenerator
self.internalAU = avAudioUnitGenerator.AUAudioUnit as? AKPluckedStringAudioUnit
AudioKit.engine.attachNode(self.avAudioNode)
}
guard let tree = internalAU?.parameterTree else { return }
frequencyParameter = tree.valueForKey("frequency") as? AUParameter
amplitudeParameter = tree.valueForKey("amplitude") as? AUParameter
token = tree.tokenByAddingParameterObserver {
address, value in
dispatch_async(dispatch_get_main_queue()) {
if address == self.frequencyParameter!.address {
self.frequency = Double(value)
} else if address == self.amplitudeParameter!.address {
self.amplitude = Double(value)
}
}
}
internalAU?.frequency = Float(frequency)
internalAU?.amplitude = Float(amplitude)
}
/// Function create an identical new node for use in creating polyphonic instruments
override public func duplicate() -> AKVoice {
let copy = AKPluckedString(frequency: self.frequency, amplitude: self.amplitude, lowestFrequency: self.lowestFrequency)
return copy
}
/// Trigger the sound with an optional set of parameters
/// - parameter frequency: Frequency in Hz
/// - amplitude amplitude: Volume
///
public func trigger(frequency frequency: Double, amplitude: Double = 1) {
self.frequency = frequency
self.amplitude = amplitude
self.internalAU!.start()
self.internalAU!.triggerFrequency(Float(frequency), amplitude: Float(amplitude))
}
/// Function to start, play, or activate the node, all do the same thing
override public func start() {
self.internalAU!.start()
}
/// Function to stop or bypass the node, both are equivalent
override public func stop() {
self.internalAU!.stop()
}
}
|
mit
|
448c0f8feedf34a7ff4e03b330fd433d
| 34.326923 | 164 | 0.644711 | 5.424213 | false | false | false | false |
turingcorp/gattaca
|
gattaca/View/LocationDenied/VLocationDeniedIcon.swift
|
1
|
1249
|
import UIKit
class VLocationDeniedIcon:
View<VLocationDenied, MLocationDenied, CLocationDenied>
{
required init(controller:CLocationDenied)
{
super.init(controller:controller)
isUserInteractionEnabled = false
let background:UIImageView = UIImageView()
background.isUserInteractionEnabled = false
background.translatesAutoresizingMaskIntoConstraints = false
background.clipsToBounds = true
background.contentMode = UIViewContentMode.center
background.image = #imageLiteral(resourceName: "assetGenericCircle")
let icon:UIImageView = UIImageView()
icon.isUserInteractionEnabled = false
icon.translatesAutoresizingMaskIntoConstraints = false
icon.clipsToBounds = true
icon.contentMode = UIViewContentMode.center
icon.image = #imageLiteral(resourceName: "assetGenericLocation")
addSubview(background)
addSubview(icon)
NSLayoutConstraint.equals(
view:background,
toView:self)
NSLayoutConstraint.equals(
view:icon,
toView:self)
}
required init?(coder:NSCoder)
{
return nil
}
}
|
mit
|
b3715030bc3401c55ddf000b1cd38144
| 29.463415 | 76 | 0.654924 | 6.004808 | false | false | false | false |
TeamProxima/predictive-fault-tracker
|
mobile/SieHack/Pods/Charts/Source/Charts/Utils/Platform.swift
|
21
|
16449
|
import Foundation
/** This file provides a thin abstraction layer atop of UIKit (iOS, tvOS) and Cocoa (OS X). The two APIs are very much
alike, and for the chart library's usage of the APIs it is often sufficient to typealias one to the other. The NSUI*
types are aliased to either their UI* implementation (on iOS) or their NS* implementation (on OS X). */
#if os(iOS) || os(tvOS)
import UIKit
public typealias NSUIFont = UIFont
public typealias NSUIColor = UIColor
public typealias NSUIEvent = UIEvent
public typealias NSUITouch = UITouch
public typealias NSUIImage = UIImage
public typealias NSUIScrollView = UIScrollView
public typealias NSUIGestureRecognizer = UIGestureRecognizer
public typealias NSUIGestureRecognizerState = UIGestureRecognizerState
public typealias NSUIGestureRecognizerDelegate = UIGestureRecognizerDelegate
public typealias NSUITapGestureRecognizer = UITapGestureRecognizer
public typealias NSUIPanGestureRecognizer = UIPanGestureRecognizer
#if !os(tvOS)
public typealias NSUIPinchGestureRecognizer = UIPinchGestureRecognizer
public typealias NSUIRotationGestureRecognizer = UIRotationGestureRecognizer
#endif
public typealias NSUIScreen = UIScreen
public typealias NSUIDisplayLink = CADisplayLink
extension NSUITapGestureRecognizer
{
final func nsuiNumberOfTouches() -> Int
{
return numberOfTouches
}
final var nsuiNumberOfTapsRequired: Int
{
get
{
return self.numberOfTapsRequired
}
set
{
self.numberOfTapsRequired = newValue
}
}
}
extension NSUIPanGestureRecognizer
{
final func nsuiNumberOfTouches() -> Int
{
return numberOfTouches
}
final func nsuiLocationOfTouch(_ touch: Int, inView: UIView?) -> CGPoint
{
return super.location(ofTouch: touch, in: inView)
}
}
#if !os(tvOS)
extension NSUIRotationGestureRecognizer
{
final var nsuiRotation: CGFloat
{
get { return rotation }
set { rotation = newValue }
}
}
#endif
#if !os(tvOS)
extension NSUIPinchGestureRecognizer
{
final var nsuiScale: CGFloat
{
get
{
return scale
}
set
{
scale = newValue
}
}
final func nsuiLocationOfTouch(_ touch: Int, inView: UIView?) -> CGPoint
{
return super.location(ofTouch: touch, in: inView)
}
}
#endif
open class NSUIView: UIView
{
public final override func touchesBegan(_ touches: Set<NSUITouch>, with event: NSUIEvent?)
{
self.nsuiTouchesBegan(touches, withEvent: event)
}
public final override func touchesMoved(_ touches: Set<NSUITouch>, with event: NSUIEvent?)
{
self.nsuiTouchesMoved(touches, withEvent: event)
}
public final override func touchesEnded(_ touches: Set<NSUITouch>, with event: NSUIEvent?)
{
self.nsuiTouchesEnded(touches, withEvent: event)
}
public final override func touchesCancelled(_ touches: Set<NSUITouch>, with event: NSUIEvent?)
{
self.nsuiTouchesCancelled(touches, withEvent: event)
}
open func nsuiTouchesBegan(_ touches: Set<NSUITouch>, withEvent event: NSUIEvent?)
{
super.touchesBegan(touches, with: event!)
}
open func nsuiTouchesMoved(_ touches: Set<NSUITouch>, withEvent event: NSUIEvent?)
{
super.touchesMoved(touches, with: event!)
}
open func nsuiTouchesEnded(_ touches: Set<NSUITouch>, withEvent event: NSUIEvent?)
{
super.touchesEnded(touches, with: event!)
}
open func nsuiTouchesCancelled(_ touches: Set<NSUITouch>?, withEvent event: NSUIEvent?)
{
super.touchesCancelled(touches!, with: event!)
}
var nsuiLayer: CALayer?
{
return self.layer
}
}
extension UIView
{
final var nsuiGestureRecognizers: [NSUIGestureRecognizer]?
{
return self.gestureRecognizers
}
}
extension UIScrollView
{
var nsuiIsScrollEnabled: Bool
{
get { return isScrollEnabled }
set { isScrollEnabled = newValue }
}
}
extension UIScreen
{
final var nsuiScale: CGFloat
{
return self.scale
}
}
func NSUIGraphicsGetCurrentContext() -> CGContext?
{
return UIGraphicsGetCurrentContext()
}
func NSUIGraphicsGetImageFromCurrentImageContext() -> NSUIImage!
{
return UIGraphicsGetImageFromCurrentImageContext()
}
func NSUIGraphicsPushContext(_ context: CGContext)
{
UIGraphicsPushContext(context)
}
func NSUIGraphicsPopContext()
{
UIGraphicsPopContext()
}
func NSUIGraphicsEndImageContext()
{
UIGraphicsEndImageContext()
}
func NSUIImagePNGRepresentation(_ image: NSUIImage) -> Data?
{
return UIImagePNGRepresentation(image)
}
func NSUIImageJPEGRepresentation(_ image: NSUIImage, _ quality: CGFloat = 0.8) -> Data?
{
return UIImageJPEGRepresentation(image, quality)
}
func NSUIMainScreen() -> NSUIScreen?
{
return NSUIScreen.main
}
func NSUIGraphicsBeginImageContextWithOptions(_ size: CGSize, _ opaque: Bool, _ scale: CGFloat)
{
UIGraphicsBeginImageContextWithOptions(size, opaque, scale)
}
#endif
#if os(OSX)
import Cocoa
import Quartz
public typealias NSUIFont = NSFont
public typealias NSUIColor = NSColor
public typealias NSUIEvent = NSEvent
public typealias NSUITouch = NSTouch
public typealias NSUIImage = NSImage
public typealias NSUIScrollView = NSScrollView
public typealias NSUIGestureRecognizer = NSGestureRecognizer
public typealias NSUIGestureRecognizerState = NSGestureRecognizerState
public typealias NSUIGestureRecognizerDelegate = NSGestureRecognizerDelegate
public typealias NSUITapGestureRecognizer = NSClickGestureRecognizer
public typealias NSUIPanGestureRecognizer = NSPanGestureRecognizer
public typealias NSUIPinchGestureRecognizer = NSMagnificationGestureRecognizer
public typealias NSUIRotationGestureRecognizer = NSRotationGestureRecognizer
public typealias NSUIScreen = NSScreen
/** On OS X there is no CADisplayLink. Use a 60 fps timer to render the animations. */
public class NSUIDisplayLink
{
private var timer: Timer?
private var displayLink: CVDisplayLink?
private var _timestamp: CFTimeInterval = 0.0
private weak var _target: AnyObject?
private var _selector: Selector
public var timestamp: CFTimeInterval
{
return _timestamp
}
init(target: AnyObject, selector: Selector)
{
_target = target
_selector = selector
if CVDisplayLinkCreateWithActiveCGDisplays(&displayLink) == kCVReturnSuccess
{
CVDisplayLinkSetOutputCallback(displayLink!, { (displayLink, inNow, inOutputTime, flagsIn, flagsOut, userData) -> CVReturn in
let _self = unsafeBitCast(userData, to: NSUIDisplayLink.self)
_self._timestamp = CFAbsoluteTimeGetCurrent()
_self._target?.performSelector(onMainThread: _self._selector, with: _self, waitUntilDone: false)
return kCVReturnSuccess
}, Unmanaged.passUnretained(self).toOpaque())
}
else
{
timer = Timer(timeInterval: 1.0 / 60.0, target: target, selector: selector, userInfo: nil, repeats: true)
}
}
deinit
{
stop()
}
open func add(to runloop: RunLoop, forMode mode: RunLoopMode)
{
if displayLink != nil
{
CVDisplayLinkStart(displayLink!)
}
else if timer != nil
{
runloop.add(timer!, forMode: mode)
}
}
open func remove(from: RunLoop, forMode: RunLoopMode)
{
stop()
}
private func stop()
{
if displayLink != nil
{
CVDisplayLinkStop(displayLink!)
}
if timer != nil
{
timer?.invalidate()
}
}
}
/** The 'tap' gesture is mapped to clicks. */
extension NSUITapGestureRecognizer
{
final func nsuiNumberOfTouches() -> Int
{
return 1
}
final var nsuiNumberOfTapsRequired: Int
{
get
{
return self.numberOfClicksRequired
}
set
{
self.numberOfClicksRequired = newValue
}
}
}
extension NSUIPanGestureRecognizer
{
final func nsuiNumberOfTouches() -> Int
{
return 1
}
/// FIXME: Currently there are no more than 1 touch in OSX gestures, and not way to create custom touch gestures.
final func nsuiLocationOfTouch(_ touch: Int, inView: NSView?) -> NSPoint
{
return super.location(in: inView)
}
}
extension NSUIRotationGestureRecognizer
{
/// FIXME: Currently there are no velocities in OSX gestures, and not way to create custom touch gestures.
final var velocity: CGFloat
{
return 0.1
}
final var nsuiRotation: CGFloat
{
get { return -rotation }
set { rotation = -newValue }
}
}
extension NSUIPinchGestureRecognizer
{
final var nsuiScale: CGFloat
{
get
{
return magnification + 1.0
}
set
{
magnification = newValue - 1.0
}
}
/// FIXME: Currently there are no more than 1 touch in OSX gestures, and not way to create custom touch gestures.
final func nsuiLocationOfTouch(_ touch: Int, inView view: NSView?) -> NSPoint
{
return super.location(in: view)
}
}
extension NSView
{
final var nsuiGestureRecognizers: [NSGestureRecognizer]?
{
return self.gestureRecognizers
}
}
extension NSScrollView
{
var nsuiIsScrollEnabled: Bool
{
get { return scrollEnabled }
set { scrollEnabled = newValue }
}
}
open class NSUIView: NSView
{
public final override var isFlipped: Bool
{
return true
}
func setNeedsDisplay()
{
self.setNeedsDisplay(self.bounds)
}
public final override func touchesBegan(with event: NSEvent)
{
self.nsuiTouchesBegan(event.touches(matching: .any, in: self), withEvent: event)
}
public final override func touchesEnded(with event: NSEvent)
{
self.nsuiTouchesEnded(event.touches(matching: .any, in: self), withEvent: event)
}
public final override func touchesMoved(with event: NSEvent)
{
self.nsuiTouchesMoved(event.touches(matching: .any, in: self), withEvent: event)
}
open override func touchesCancelled(with event: NSEvent)
{
self.nsuiTouchesCancelled(event.touches(matching: .any, in: self), withEvent: event)
}
open func nsuiTouchesBegan(_ touches: Set<NSUITouch>, withEvent event: NSUIEvent?)
{
super.touchesBegan(with: event!)
}
open func nsuiTouchesMoved(_ touches: Set<NSUITouch>, withEvent event: NSUIEvent?)
{
super.touchesMoved(with: event!)
}
open func nsuiTouchesEnded(_ touches: Set<NSUITouch>, withEvent event: NSUIEvent?)
{
super.touchesEnded(with: event!)
}
open func nsuiTouchesCancelled(_ touches: Set<NSUITouch>?, withEvent event: NSUIEvent?)
{
super.touchesCancelled(with: event!)
}
var backgroundColor: NSUIColor?
{
get
{
return self.layer?.backgroundColor == nil
? nil
: NSColor(cgColor: self.layer!.backgroundColor!)
}
set
{
self.layer?.backgroundColor = newValue == nil ? nil : newValue!.cgColor
}
}
final var nsuiLayer: CALayer?
{
return self.layer
}
}
extension NSFont
{
var lineHeight: CGFloat
{
// Not sure if this is right, but it looks okay
return self.boundingRectForFont.size.height
}
}
extension NSScreen
{
final var nsuiScale: CGFloat
{
return self.backingScaleFactor
}
}
extension NSImage
{
var cgImage: CGImage?
{
return self.cgImage(forProposedRect: nil, context: nil, hints: nil)
}
}
extension NSTouch
{
/** Touch locations on OS X are relative to the trackpad, whereas on iOS they are actually *on* the view. */
func locationInView(view: NSView) -> NSPoint
{
let n = self.normalizedPosition
let b = view.bounds
return NSPoint(x: b.origin.x + b.size.width * n.x, y: b.origin.y + b.size.height * n.y)
}
}
extension NSScrollView
{
var scrollEnabled: Bool
{
get
{
return true
}
set
{
// FIXME: We can't disable scrolling it on OSX
}
}
}
extension NSString
{
// iOS: size(attributes: ...), OSX: size(withAttributes: ...)
// Both are translated into sizeWithAttributes: on ObjC. So conflict...
@nonobjc
func size(attributes attrs: [String : Any]? = nil) -> NSSize
{
return size(withAttributes: attrs)
}
}
func NSUIGraphicsGetCurrentContext() -> CGContext?
{
return NSGraphicsContext.current()?.cgContext
}
func NSUIGraphicsPushContext(_ context: CGContext)
{
let cx = NSGraphicsContext(cgContext: context, flipped: true)
NSGraphicsContext.saveGraphicsState()
NSGraphicsContext.setCurrent(cx)
}
func NSUIGraphicsPopContext()
{
NSGraphicsContext.restoreGraphicsState()
}
func NSUIImagePNGRepresentation(_ image: NSUIImage) -> Data?
{
image.lockFocus()
let rep = NSBitmapImageRep(focusedViewRect: NSMakeRect(0, 0, image.size.width, image.size.height))
image.unlockFocus()
return rep?.representation(using: NSPNGFileType, properties: [:])
}
func NSUIImageJPEGRepresentation(_ image: NSUIImage, _ quality: CGFloat = 0.9) -> Data?
{
image.lockFocus()
let rep = NSBitmapImageRep(focusedViewRect: NSMakeRect(0, 0, image.size.width, image.size.height))
image.unlockFocus()
return rep?.representation(using: NSJPEGFileType, properties: [NSImageCompressionFactor: quality])
}
private var imageContextStack: [CGFloat] = []
func NSUIGraphicsBeginImageContextWithOptions(_ size: CGSize, _ opaque: Bool, _ scale: CGFloat)
{
var scale = scale
if scale == 0.0
{
scale = NSScreen.main()?.backingScaleFactor ?? 1.0
}
let width = Int(size.width * scale)
let height = Int(size.height * scale)
if width > 0 && height > 0
{
imageContextStack.append(scale)
let colorSpace = CGColorSpaceCreateDeviceRGB()
guard let ctx = CGContext(data: nil, width: width, height: height, bitsPerComponent: 8, bytesPerRow: 4*width, space: colorSpace, bitmapInfo: (opaque ? CGImageAlphaInfo.noneSkipFirst.rawValue : CGImageAlphaInfo.premultipliedFirst.rawValue))
else { return }
ctx.concatenate(CGAffineTransform(a: 1, b: 0, c: 0, d: -1, tx: 0, ty: CGFloat(height)))
ctx.scaleBy(x: scale, y: scale)
NSUIGraphicsPushContext(ctx)
}
}
func NSUIGraphicsGetImageFromCurrentImageContext() -> NSUIImage?
{
if !imageContextStack.isEmpty
{
guard let ctx = NSUIGraphicsGetCurrentContext()
else { return nil }
let scale = imageContextStack.last!
if let theCGImage = ctx.makeImage()
{
let size = CGSize(width: CGFloat(ctx.width) / scale, height: CGFloat(ctx.height) / scale)
let image = NSImage(cgImage: theCGImage, size: size)
return image
}
}
return nil
}
func NSUIGraphicsEndImageContext()
{
if imageContextStack.last != nil
{
imageContextStack.removeLast()
NSUIGraphicsPopContext()
}
}
func NSUIMainScreen() -> NSUIScreen?
{
return NSUIScreen.main()
}
#endif
|
mit
|
9245d15a2a99501b45be741494d946de
| 25.402889 | 243 | 0.625509 | 4.749928 | false | false | false | false |
huonw/swift
|
benchmark/single-source/Array2D.swift
|
6
|
1002
|
//===--- Array2D.swift ----------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
import TestsUtils
public let Array2D = BenchmarkInfo(
name: "Array2D",
runFunction: run_Array2D,
tags: [.validation, .api, .Array])
@inline(never)
public func run_Array2D(_ N: Int) {
var A: [[Int]] = []
for _ in 0 ..< 1024 {
var B: [Int] = []
for y in 0 ..< 1024 {
B.append(y)
}
A.append(B)
}
for _ in 0..<N {
for i in 0 ..< 1024 {
for y in 0 ..< 1024 {
A[i][y] = A[i][y] + 1
A[i][y] = A[i][y] - 1
}
}
}
}
|
apache-2.0
|
4a40ba8b9ac470768d1f970e830fb0a6
| 25.368421 | 80 | 0.50499 | 3.604317 | false | false | false | false |
iOSWizards/AwesomeMedia
|
Example/Pods/AwesomeCore/AwesomeCore/Classes/AwesomeData/Extensions.swift
|
1
|
5743
|
//
// Extensions.swift
// AwesomeData
//
// Created by Evandro Harrison Hoffmann on 16/08/2016.
// Copyright © 2016 It's Day Off. All rights reserved.
//
import UIKit
extension Data {
public var attributedStringAC: NSAttributedString? {
do {
return try NSAttributedString(data: self, options:[
NSAttributedString.DocumentReadingOptionKey.documentType:NSAttributedString.DocumentType.html,
NSAttributedString.DocumentReadingOptionKey.characterEncoding: String.Encoding.utf8.rawValue
], documentAttributes: nil)
} catch let error as NSError {
print(error.localizedDescription)
}
return nil
}
}
extension String {
public var utf8DataAC: Data? {
return data(using: String.Encoding.utf8)
}
public var stripHTMLAC: String? {
return replacingOccurrences(of: "<[^>]+>", with: "", options: .regularExpression, range: nil)
}
var cleanHTMLAC: String{
var allHTMLText = self
allHTMLText = allHTMLText.replacingOccurrences(of: " ", with: "")
allHTMLText = allHTMLText.replacingOccurrences(of: "<br></li>", with: "</li>")
allHTMLText = allHTMLText.replacingOccurrences(of: "<br></p>", with: "</p>")
allHTMLText = allHTMLText.replacingOccurrences(of: "\n", with: "")
allHTMLText = allHTMLText.replacingOccurrences(of: "\r", with: "")
allHTMLText = allHTMLText.replacingOccurrences(of: "<p></p>", with: "")
allHTMLText = allHTMLText.replacingOccurrences(of: "<ul></ul>", with: "")
allHTMLText = allHTMLText.replacingOccurrences(of: "</ol>", with: "</ol><br>")
allHTMLText = allHTMLText.replacingOccurrences(of: "</ul>", with: "</ul><br>")
allHTMLText = allHTMLText.replacingOccurrences(of: "</h2><p>", with: "</h2><br><p>")
return allHTMLText
}
var localized: String {
return NSLocalizedString(self, tableName: nil, bundle: Bundle.main, value: "", comment: "")
}
}
extension Int {
public var secondsToTimeString: String {
if self <= 0 {
return ""
}
let hours = Int(self / 3600)
let minutes = Int((self / 60) % 60)
if hours > 0 {
return String(format: "%1d \("hr".localized) \(minutes > 9 ? "%2d" : "%1d") \("min".localized)", hours, minutes)
}
if minutes > 0 {
return String(format: "%0.2d " + "minutes".localized, minutes)
}
let seconds = self % 60
return String(format: "%0.2d " + "seconds".localized, seconds)
}
}
extension Float {
func roundTo(places: Int) -> Float {
let divisor = pow(10.0, Float(places))
return (self * divisor).rounded() / divisor
}
}
extension Double {
var timeString: String {
let ti = NSInteger(self)
let seconds = ti % 60
let minutes = (ti / 60) % 60
let hours = (ti / 3600)
if hours > 0 {
return String(format: "%d \("hours".localized) %d \("minutes".localized)", hours, minutes)
} else if minutes > 0 {
return String(format: "%d \("min".localized)", minutes)
}
return String(format: "%d \("seconds".localized)", seconds)
}
}
extension NSAttributedString {
func heightWithConstrainedWidthAC(_ width: CGFloat) -> CGFloat {
let constraintRect = CGSize(width: width, height: CGFloat.greatestFiniteMagnitude)
let boundingBox = self.boundingRect(with: constraintRect, options: NSStringDrawingOptions.usesLineFragmentOrigin, context: nil)
return ceil(boundingBox.height)
}
func widthWithConstrainedHeightAC(_ height: CGFloat) -> CGFloat {
let constraintRect = CGSize(width: CGFloat.greatestFiniteMagnitude, height: height)
let boundingBox = self.boundingRect(with: constraintRect, options: NSStringDrawingOptions.usesLineFragmentOrigin, context: nil)
return ceil(boundingBox.width)
}
}
extension TimeInterval {
var days: String {
return String(format:"%02d", Int((self/86400)))
}
}
extension Date {
//get date from milliseconds
init(milliseconds:Int) {
self = Date(timeIntervalSince1970: TimeInterval(milliseconds) / 1000)
}
func days(from date: Date) -> Int {
return Calendar.current.dateComponents([.day], from: date, to: self).day ?? 0
}
func days(toDate date: Date) -> Int {
// Replace the hour (time) of both dates with 00:00
let date1 = Calendar.current.startOfDay(for: self)
let date2 = Calendar.current.startOfDay(for: date)
let components = Calendar.current.dateComponents([Calendar.Component.day], from: date1, to: date2)
if let days = components.day {
return days
}
return 0
}
func toString(format: String) -> String {
let dateFormatter = DateFormatter()
dateFormatter.dateFormat = format
return dateFormatter.string(from: self)
}
}
extension String {
var date: Date? {
return date()
}
func date(_ callback:@escaping (Date?) -> Void) {
DispatchQueue.main.async {
callback(self.date())
}
}
func date(withFormat format: String? = nil) -> Date? {
let date = self.replacingOccurrences(of: ".000000Z", with: "Z")
let dateFormatter = DateFormatter()
dateFormatter.dateFormat = format ?? "yyyy-MM-dd'T'HH:mm:ssZ"
return dateFormatter.date(from: date)
}
}
|
mit
|
bc58f1b62514669a0173730350350b39
| 30.377049 | 135 | 0.59387 | 4.510605 | false | false | false | false |
voyages-sncf-technologies/Collor
|
Example/Collor/RealTimeSample/RealTimeViewController.swift
|
1
|
2000
|
//
// RealTimeViewController.swift
// Collor
//
// Created by Guihal Gwenn on 04/09/2017.
// Copyright © 2017 CocoaPods. All rights reserved.
//
import UIKit
import Collor
class RealTimeViewController: UIViewController {
@IBOutlet weak var collectionView: UICollectionView!
fileprivate(set) lazy var collectionViewDelegate: CollectionDelegate = CollectionDelegate(delegate: self)
fileprivate(set) lazy var collectionViewDatasource: CollectionDataSource = CollectionDataSource(delegate: self)
private let realTimeService = RealTimeService()
let collectionData = RealTimeCollectionData()
var timer:Timer?
override func viewDidLoad() {
super.viewDidLoad()
title = "Real Time"
bind(collectionView: collectionView, with: collectionData, and: collectionViewDelegate, and: collectionViewDatasource)
collectionView.collectionViewLayout = RealTimeLayout(datas: collectionData)
timer = Timer.scheduledTimer(timeInterval: 2, target: self, selector: #selector(RealTimeViewController.fetch), userInfo: nil, repeats: true)
timer!.fire()
}
@objc func fetch() {
realTimeService.getRecentTweets { [weak self] response in
switch response {
case .success(let data):
self?.collectionData.update(model: data)
let result = self?.collectionData.update { updater in
updater.diff()
}
if let result = result {
self?.collectionView.performUpdates(with: result)
}
case .error(let error):
print(error)
}
}
}
}
extension RealTimeViewController : CollectionDidSelectCellDelegate {
func didSelect(_ cellDescriptor: CollectionCellDescribable, sectionDescriptor: CollectionSectionDescribable, indexPath: IndexPath) {}
}
extension RealTimeViewController : CollectionUserEventDelegate {
}
|
bsd-3-clause
|
e98fdec53bbf29183aa429463f97372a
| 32.316667 | 148 | 0.667834 | 5.330667 | false | false | false | false |
dvor/TextWiki
|
TextWikiTests/Modules/Application/Interactor/ApplicationInteractorTests.swift
|
1
|
883
|
//
// ApplicationInteractorTests.swift
// TextWiki
//
// Created by Dmytro Vorobiov on 23/05/2017.
// Copyright © 2017 Dmytro Vorobiov. All rights reserved.
//
import XCTest
class ApplicationInteractorTests: XCTestCase {
var interactor: ApplicationInteractor!
var output: ApplicationInteractorOutput!
override func setUp() {
super.setUp()
// Put setup code here. This method is called before the invocation of each test method in the class.
interactor = ApplicationInteractor()
output = MockPresenter()
interactor.output = output
}
override func tearDown() {
interactor = nil
output = nil
// Put teardown code here. This method is called after the invocation of each test method in the class.
super.tearDown()
}
class MockPresenter: ApplicationInteractorOutput {
}
}
|
mit
|
574af81861d68405d3e22322f61e0e8d
| 24.941176 | 111 | 0.678005 | 4.983051 | false | true | false | false |
Ben21hao/edx-app-ios-enterprise-new
|
Source/UserCourseEnrollment.swift
|
3
|
1678
|
//
// UserCourseEnrollment.swift
// edX
//
// Created by Michael Katz on 11/12/15.
// Copyright © 2015 edX. All rights reserved.
//
import Foundation
import edXCore
//TODO: remove NSObject when done with @objc
public class UserCourseEnrollment : NSObject {
let created: String?
let mode: String?
let isActive: Bool
let course: OEXCourse
/** Url if the user has completed a certificate */
let certificateUrl: String?
init?(dictionary: [String: AnyObject]) {
created = dictionary["created"] as? String
mode = dictionary["mode"] as? String
isActive = (dictionary["is_active"] as? NSNumber)?.boolValue ?? false
if let certificatesInfo = dictionary["certificate"] as? [NSObject: AnyObject] {
certificateUrl = certificatesInfo["url"] as? String
} else {
certificateUrl = nil
}
if let dictCourse = dictionary["course"] as? [NSObject: AnyObject] {
course = OEXCourse(dictionary:dictCourse)
} else {
course = OEXCourse()
super.init()
return nil
}
super.init()
}
init(course: OEXCourse, created: String? = nil, mode: String? = nil, isActive: Bool = true, certificateURL: String? = nil) {
self.created = created
self.mode = mode
self.course = course
self.isActive = isActive
self.certificateUrl = certificateURL
}
convenience init?(json: JSON) {
guard let dict = json.dictionaryObject else {
self.init(dictionary:[:])
return nil
}
self.init(dictionary: dict)
}
}
|
apache-2.0
|
eb36875094a8ca0a81a6fa65ff053d59
| 26.966667 | 128 | 0.593918 | 4.569482 | false | false | false | false |
CherishSmile/ZYBase
|
ZYBase/Tools/ZYNetModel/ZYRootModel.swift
|
1
|
1855
|
//
// ZYRootModel.swift
// ZYBase
//
// Created by Mzywx on 2016/12/29.
// Copyright © 2016年 Mzywx. All rights reserved.
//
open class ZYRootModel: NSObject {
public var data : Any!
public var map : Any!
public var message : String!
public var status : String!
public var statusCode : String!
public init(fromJson json:JSON,dataClass:ZYDataModel.Type?,mapClass:ZYMapModel.Type?) {
if json.isEmpty {
return
}
let dataArrJson = json["list"].arrayValue
if !dataArrJson.isEmpty {
var dicArr : Array<ZYDataModel> = []
for dataDic in dataArrJson {
let dataModel = dataClass?.init(fromJson: dataDic)
dicArr.append(dataModel!)
}
data = dicArr
}
let dataDicJson = json["list"].dictionaryValue
if !dataDicJson.isEmpty{
let dataDic = json["list"]
data = dataClass?.init(fromJson: dataDic)
}
let mapArrJosn = json["map"].arrayValue
if !mapArrJosn.isEmpty {
var dicArr : Array<ZYMapModel> = []
for dataDic in mapArrJosn {
let mapModel = mapClass?.init(fromJson: dataDic)
dicArr.append(mapModel!)
}
map = dicArr
}
let mapDicJosn = json["map"].dictionaryValue
if !mapDicJosn.isEmpty {
let mapDic = json["map"]
map = mapClass?.init(fromJson: mapDic)
}
message = json["message"].stringValue
status = json["status"].stringValue
statusCode = json["statusCode"].stringValue
}
}
open class ZYDataModel: NSObject {
required public init(fromJson json:JSON) {
}
}
open class ZYMapModel: NSObject {
required public init(fromJson json:JSON) {
}
}
|
mit
|
ad89094e17e6694dc65906c92dd68596
| 27.9375 | 91 | 0.568575 | 4.267281 | false | false | false | false |
fahlout/FilterView
|
Classes/NFFilterView.swift
|
1
|
9645
|
//
// NFFilterView.swift
//
// Created by Niklas Fahl on 1/15/16.
// Copyright © 2016 Niklas Fahl. All rights reserved.
//
import UIKit
class NFFilterView: UITableViewController {
var filterObjects: [AnyObject] = []
var filteredObjects: [AnyObject] = []
var filterProperties: [String] = []
// Dictionaries holding data to make selection and displaying possible
// Key: sectionIndex+propertyName+filterByName
// Value: (filterByName, amountOfObjects)
var selectedFilters: [String: (String, Int)] = [:]
var filters: [String: (String, Int)] = [:]
required init(objects: [AnyObject], properties: [String]) {
super.init(style: .Grouped)
filterObjects = objects
filteredObjects = objects
filterProperties = properties
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
}
override func viewDidLoad() {
super.viewDidLoad()
configure()
// Generate defaults
generateDefaultSelections()
generateFilters(filterObjects)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
}
// MARK: - UI Setup
func configure() {
self.title = "Filter"
addBarButtons()
configureTableView()
}
// Table View
func configureTableView() {
tableView.registerClass(NFFilterViewTableViewCell.self, forCellReuseIdentifier: "NFFilterViewTableViewCell")
}
// Bar buttons
func addBarButtons() {
addResetBarButton()
addDoneBarButton()
}
func addDoneBarButton() {
let doneButton = UIBarButtonItem(title: "Done", style: UIBarButtonItemStyle.Plain, target: self, action: "closeFilterController")
self.navigationItem.rightBarButtonItem = doneButton
}
func addResetBarButton() {
let resetButton = UIBarButtonItem(title: "Reset", style: UIBarButtonItemStyle.Plain, target: self, action: "resetFilters")
self.navigationItem.leftBarButtonItem = resetButton
}
// NSNotification for filtered object changes
func sendNotificationForUpdates() {
NSNotificationCenter.defaultCenter().postNotificationName("filteredObjectsDidUpdate", object: self, userInfo: ["filteredObjects": filteredObjects])
}
// MARK: - Close/Reset Filter Controller
func closeFilterController() {
// Remember selection
self.dismissViewControllerAnimated(true, completion: nil)
}
func resetFilters() {
selectedFilters = [:]
filteredObjects = filterObjects.map() { $0 }
generateDefaultSelections()
generateFilters(filterObjects)
tableView.reloadData()
}
// MARK: - Show Filter Controller
func show(presentingViewController: UIViewController) {
let navigationController: UINavigationController = UINavigationController(rootViewController: self)
presentingViewController.presentViewController(navigationController, animated: true, completion: nil)
}
// MARK: - Generate selections
func generateDefaultSelections() {
var sectionIndex = 0
for propertyName in filterProperties {
let filterKey = "1+\(sectionIndex)+\(propertyName)+All"
selectedFilters[filterKey] = ("All", filterObjects.count)
sectionIndex++
}
}
// MARK: - Generate Filters
func generateFilters(objects: [AnyObject]) {
filters = [:]
var sectionIndex = 0
for object in objects {
for propertyName in filterProperties {
let filterByName = convertToString(object.valueForKey(propertyName))
if filterByName != "" {
let filterKey = "2+\(sectionIndex)+\(propertyName)+\(filterByName)"
if filters[filterKey] == nil {
filters[filterKey] = (filterByName, 1)
} else {
filters[filterKey] = (filterByName, filters[filterKey]!.1 + 1)
}
}
sectionIndex++
}
sectionIndex = 0
}
for propertyName in filterProperties {
let filterKey = "1+\(sectionIndex)+\(propertyName)+All"
// Calculate "All" count
let propertyNameInSection = filterProperties[sectionIndex]
let allKeys = Array(filters.keys).sort()
let keys = allKeys.filter() { $0.rangeOfString(propertyNameInSection) != nil }
var allAmount = 0
for key in keys {
allAmount += filters[key]!.1
}
filters[filterKey] = ("All", allAmount)
sectionIndex++
}
}
// MARK: - Test filtering with predicate
func filterBySelections() {
filteredObjects = filterObjects.map() { $0 }
for selectionKey in selectedFilters.keys {
let selectionParts = selectionKey.componentsSeparatedByString("+")
let selectionFilterByName = selectionParts[3]
if selectionFilterByName != "All" {
let selectionProperty = selectionParts[2]
filteredObjects = filterObjects.filter() { convertToString($0.valueForKey(selectionProperty)) == selectionFilterByName}
}
}
}
func convertToString(value: AnyObject?) -> String {
if value == nil {
return ""
} else {
return "\(value!)"
}
}
// MARK: - Table view data source
override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
return filterProperties.count
}
override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
let propertyNameInSection = filterProperties[section]
let keys = Array(filters.keys)
let propertyInSectionCount = (keys.filter() { $0.rangeOfString(propertyNameInSection) != nil }).count
return propertyInSectionCount
}
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier("NFFilterViewTableViewCell", forIndexPath: indexPath) as! NFFilterViewTableViewCell
// Get values to configure cell
let propertyNameInSection = filterProperties[indexPath.section]
let allKeys = Array(filters.keys).sort()
let keys = allKeys.filter() { $0.rangeOfString(propertyNameInSection) != nil }
cell.filterKey = keys[indexPath.row]
cell.filterValue = filters[cell.filterKey]!.0
cell.textLabel?.text = cell.filterValue + " (\(filters[cell.filterKey]!.1))"
if selectedFilters[cell.filterKey] != nil {
cell.accessoryType = .Checkmark
} else {
cell.accessoryType = .None
}
return cell
}
override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
let cell: NFFilterViewTableViewCell = tableView.cellForRowAtIndexPath(indexPath) as! NFFilterViewTableViewCell
// Make sure user cannot deselect "All" only select it when it's appropriate
if indexPath.row > 0 {
let filterByName = cell.filterValue
let propertyName = filterProperties[indexPath.section]
if cell.accessoryType == .None {
cell.accessoryType = .Checkmark
let allKey = "1+\(indexPath.section)+\(filterProperties[indexPath.section])+All"
selectedFilters.removeValueForKey(allKey)
selectedFilters[cell.filterKey] = filters[cell.filterKey]
// Filter by new selection
filteredObjects = filteredObjects.filter() { convertToString($0.valueForKey(propertyName)) == filterByName}
} else {
cell.accessoryType = .None
selectedFilters.removeValueForKey(cell.filterKey)
// Filter by current selections after deselection
filterBySelections()
}
// Generate filters with new selections
generateFilters(filteredObjects)
tableView.reloadData()
} else {
if cell.accessoryType == .None {
cell.accessoryType = .Checkmark
let allKey = "1+\(indexPath.section)+\(filterProperties[indexPath.section])+All"
selectedFilters.removeValueForKey(allKey)
selectedFilters[cell.filterKey] = filters[cell.filterKey]
let allKeys = Array(selectedFilters.keys).sort()
let filterString = "2+\(indexPath.section)+\(filterProperties[indexPath.section])"
let keys = allKeys.filter() { $0.rangeOfString(filterString) != nil }
for key in keys {
selectedFilters.removeValueForKey(key)
}
filterBySelections()
generateFilters(filteredObjects)
tableView.reloadData()
}
}
sendNotificationForUpdates()
}
override func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
return filterProperties[section]
}
}
|
mit
|
a953f960ba02e7274a3d36d4af13c231
| 34.985075 | 155 | 0.601203 | 5.571346 | false | false | false | false |
TimothyG/SyndicationKit
|
Source/Models/RSS/RSSEnclosure.swift
|
1
|
2100
|
//
// RSSEnclosure.swift
// SyndicationKit
//
// Created by Timothy Gonzales on 10/17/16.
// Copyright © 2016 Tim Gonzales. All rights reserved.
//
import Foundation
/// Describes a media object that is attached to the item.
@objc(SYKRSSEnclosure)
final public class RSSEnclosure: NSObject, NSCoding {
fileprivate struct SerializationKeys {
static let attributes = "attributes"
}
/// The underlying attributes for the `RSSEnclosure` objects.
private var attributes: [String: String]
/// An HTTP URL where the enclosure is located.
public var href: URL? {
return URL(string: attributes["url"] ?? "")
}
/// The length (in bytes) for the enclosure.
public var length: Int? {
if let length = attributes["length"] {
return Int(length)
}
return nil
}
/// The MIME type of the enclosure.
public var type: String? {
return attributes["type"]
}
// MARK: Initializers
/**
Initializes and returns a new `RSSEnclosure` object.
- parameter attributes: The attributes associated with the `RSSEnclosure` object.
- returns: An initialized `RSSEnclosure` object.
*/
public init(attributes: [String: String]) {
self.attributes = [:]
for (key, value) in attributes {
self.attributes.updateValue(value, forKey: key.lowercased())
}
}
// MARK: NSCoding
/// :nodoc:
public required init?(coder aDecoder: NSCoder) {
self.attributes = aDecoder.decodeObject(forKey: SerializationKeys.attributes) as! [String: String]
}
/// :nodoc:
public func encode(with aCoder: NSCoder) {
aCoder.encode(attributes, forKey: SerializationKeys.attributes)
}
// MARK: Equality
/// :nodoc:
public override func isEqual(_ object: Any?) -> Bool {
if let enclosure = object as? RSSEnclosure {
return attributes == enclosure.attributes
}
return false
}
}
|
mit
|
6b3d77e0ef6fbd250ac21aae273ed171
| 25.2375 | 106 | 0.599809 | 4.533477 | false | false | false | false |
Shivam0911/IOS-Training-Projects
|
SirUI with DEMOPIC NOedit/SirUI/signUpVC.swift
|
1
|
4787
|
//
// signUpVC.swift
// SirUI
//
// Created by MAC on 06/02/17.
// Copyright © 2017 Appinventiv. All rights reserved.
//
import UIKit
class signUpVC: UIViewController , UITableViewDataSource, UITableViewDelegate{
// cell.carNameLabel.text = cars[indexPath.row]["carName"] as? String ?? ""
let details : [[String:Any]] =
[
["label1" : "FullName", "label2" : "Shivam Gaur"],
["label1" : "Email", "label2" : "[email protected]"],
["label1" : "Password", "label2" : "**************"],
["label1" : "BirthDay", "label2" : "9-Nov-1995"],
["label1" : "Gender", "label2" : "Male"],
["label1" : "Height", "label2" : "5'7''"],
["label1" : "Weight", "label2" : "62"]
]
@IBOutlet weak var mainTableView: UITableView!
@IBOutlet weak var saveChangesButton: UIButton!
override func viewDidLoad() {
super.viewDidLoad()
self.title = "Profile Settings"
self.mainTableView.dataSource = self
self.mainTableView.delegate = self
self.mainTableView.backgroundColor = UIColor.clear //sets backgroundColor to Clear
}
/*
This func clearBackGround( _ cell1 : UITableViewCell) is used to clear the backgroundColor of contentView,
CellView,
*/
func clearBackGround( _ cell1 : UITableViewCell) {
cell1.contentView.backgroundColor = UIColor.clear
cell1.backgroundColor = UIColor.clear
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
}
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return details.count + 1 //return no of rows
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
print(#function,indexPath)
return returnCell(tableView,indexPath)
}
/*
func returnCell(_ tableView: UITableView,_ indexPath: IndexPath) ->UITableViewCell is used to return respective cell according to the Row Number Specified
*/
func returnCell(_ tableView: UITableView,_ indexPath: IndexPath) ->UITableViewCell{
if indexPath.row == 0{
let cell = tableView.dequeueReusableCell(withIdentifier: "ImageCellID", for: indexPath) as! ImageCell
clearBackGround(cell)
return cell
}
else if indexPath.row < details.count{
let cell2 = tableView.dequeueReusableCell(withIdentifier: "DetailsID", for: indexPath) as! Details
cell2.labelOne.text = details[indexPath.row-1]["label1"] as? String ?? ""
cell2.labelTwo.text = details[indexPath.row-1]["label2"] as? String ?? ""
return cell2
}
else{
let cell3 = tableView.dequeueReusableCell(withIdentifier: "SaveButtonID", for: indexPath) as! SaveButtonCell
print("cell3")
return cell3
}
}
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
if indexPath.row == 0 {
return 150
}
else {
return 60
}
}
}
//class imageCell is linked with the image inside the cell and the AddButton
class ImageCell: UITableViewCell {
@IBOutlet weak var imageView1: UIImageView!
@IBOutlet weak var AddButton: UIButton!
override func awakeFromNib() { // In this method implementaion to convert sqaure image into round image is done
super.awakeFromNib()
self.imageView1.clipsToBounds = true
self.AddButton.layer.cornerRadius = self.AddButton.layer.bounds.width/2
self.imageView1.layer.cornerRadius = self.imageView1.layer.bounds.width/2
}
override func prepareForReuse() {
super.prepareForReuse()
}
}
// class Details is linked to the two labels and the DetailCell
class Details: UITableViewCell {
@IBOutlet weak var labelOne: UILabel!
@IBOutlet weak var labelTwo: UILabel!
override func awakeFromNib() {
super.awakeFromNib()
}
//Use func prepareForReuse() to set the values of cell to be reused to Null or prepare them befrore reusing them
override func prepareForReuse() {
super.prepareForReuse()
self.labelOne.text = ""
self.labelTwo.text = ""
}
}
class SaveButtonCell : UITableViewCell{
@IBOutlet weak var addBtn: UIButton!
override func awakeFromNib() {
super.awakeFromNib()
self.addBtn.layer.cornerRadius = self.addBtn.layer.bounds.height/2 // sets the cornerRadius of SaveButton
}
}
|
mit
|
9624f39a6c5fd65e1ba64dcc0a5336cc
| 30.906667 | 162 | 0.616799 | 4.687561 | false | false | false | false |
uasys/swift
|
test/decl/protocol/special/coding/class_codable_simple_extension.swift
|
16
|
1623
|
// RUN: %target-typecheck-verify-swift
// Simple classes where Codable conformance is added in extensions should not
// derive conformance yet.
class SimpleClass { // expected-note {{did you mean 'init'?}}
var x: Int = 1
var y: Double = .pi
static var z: String = "foo"
func foo() {
// They should not get a CodingKeys type.
let _ = SimpleClass.CodingKeys.self // expected-error {{type 'SimpleClass' has no member 'CodingKeys'}}
let _ = SimpleClass.CodingKeys.x // expected-error {{type 'SimpleClass' has no member 'CodingKeys'}}
let _ = SimpleClass.CodingKeys.y // expected-error {{type 'SimpleClass' has no member 'CodingKeys'}}
let _ = SimpleClass.CodingKeys.z // expected-error {{type 'SimpleClass' has no member 'CodingKeys'}}
}
}
extension SimpleClass : Codable {} // expected-error {{implementation of 'Decodable' cannot be automatically synthesized in an extension}}
// expected-error@-1 {{implementation of 'Decodable' cannot be automatically synthesized in an extension}}
// expected-error@-2 {{implementation of 'Encodable' cannot be automatically synthesized in an extension}}
// expected-error@-3 {{implementation of 'Encodable' cannot be automatically synthesized in an extension}}
// They should not receive Codable methods.
let _ = SimpleClass.init(from:) // expected-error {{type 'SimpleClass' has no member 'init(from:)'}}
let _ = SimpleClass.encode(to:) // expected-error {{type 'SimpleClass' has no member 'encode(to:)'}}
// They should not get a CodingKeys type.
let _ = SimpleClass.CodingKeys.self // expected-error {{type 'SimpleClass' has no member 'CodingKeys'}}
|
apache-2.0
|
35ab6df9744cb09b84b6013a0020fe2f
| 54.965517 | 138 | 0.722736 | 4.259843 | false | false | false | false |
acegreen/Bitcoin-Sample-iOS-App
|
Pods/LTMorphingLabel/LTMorphingLabel/LTEmitterView.swift
|
1
|
5058
|
//
// LTEmitterView.swift
// https://github.com/lexrus/LTMorphingLabel
//
// The MIT License (MIT)
// Copyright (c) 2016 Lex Tang, http://lexrus.com
//
// 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 UIKit
fileprivate func < <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
switch (lhs, rhs) {
case let (l?, r?):
return l < r
case (nil, _?):
return true
default:
return false
}
}
fileprivate func > <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
switch (lhs, rhs) {
case let (l?, r?):
return l > r
default:
return rhs < lhs
}
}
public struct LTEmitter {
let layer: CAEmitterLayer = {
let layer = CAEmitterLayer()
layer.emitterPosition = CGPoint(x: 10, y: 10)
layer.emitterSize = CGSize(width: 10, height: 1)
layer.renderMode = kCAEmitterLayerOutline
layer.emitterShape = kCAEmitterLayerLine
return layer
}()
let cell: CAEmitterCell = {
let cell = CAEmitterCell()
cell.name = "sparkle"
cell.birthRate = 150.0
cell.velocity = 50.0
cell.velocityRange = -80.0
cell.lifetime = 0.16
cell.lifetimeRange = 0.1
cell.emissionLongitude = CGFloat(M_PI_2 * 2.0)
cell.emissionRange = CGFloat(M_PI_2 * 2.0)
cell.scale = 0.1
cell.yAcceleration = 100
cell.scaleSpeed = -0.06
cell.scaleRange = 0.1
return cell
}()
public var duration: Float = 0.6
init(name: String, particleName: String, duration: Float) {
cell.name = name
self.duration = duration
var image: UIImage?
defer {
cell.contents = image?.cgImage
}
image = UIImage(named: particleName)
if image != nil {
return
}
// Load from Framework
image = UIImage(
named: particleName,
in: Bundle(for: LTMorphingLabel.self),
compatibleWith: nil)
}
public func play() {
if layer.emitterCells?.count > 0 {
return
}
layer.emitterCells = [cell]
let d = DispatchTime.now() + Double(Int64(duration * Float(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)
DispatchQueue.main.asyncAfter(deadline: d) {
self.layer.birthRate = 0.0
}
}
public func stop() {
if nil != layer.superlayer {
layer.removeFromSuperlayer()
}
}
func update(_ configureClosure: LTEmitterConfigureClosure? = .none) -> LTEmitter {
configureClosure?(layer, cell)
return self
}
}
public typealias LTEmitterConfigureClosure = (CAEmitterLayer, CAEmitterCell) -> Void
open class LTEmitterView: UIView {
open lazy var emitters: Dictionary<String, LTEmitter> = {
var _emitters = Dictionary<String, LTEmitter>()
return _emitters
}()
open func createEmitter(
_ name: String,
particleName: String,
duration: Float,
configureClosure: LTEmitterConfigureClosure?
) -> LTEmitter {
var emitter: LTEmitter
if let e = emitterByName(name) {
emitter = e
} else {
emitter = LTEmitter(
name: name,
particleName: particleName,
duration: duration
)
configureClosure?(emitter.layer, emitter.cell)
layer.addSublayer(emitter.layer)
emitters.updateValue(emitter, forKey: name)
}
return emitter
}
open func emitterByName(_ name: String) -> LTEmitter? {
if let e = emitters[name] {
return e
}
return Optional.none
}
open func removeAllEmitters() {
for (_, emitter) in emitters {
emitter.layer.removeFromSuperlayer()
}
emitters.removeAll(keepingCapacity: false)
}
}
|
mit
|
2e9f3ecef9ca1279800f60ecad5a0ebb
| 27.693182 | 105 | 0.592673 | 4.512958 | false | false | false | false |
jalehman/rottentomatoes
|
RottenTomatoes/AppDelegate.swift
|
1
|
3432
|
//
// AppDelegate.swift
// RottenTomatoes
//
// Created by Josh Lehman on 2/2/15.
// Copyright (c) 2015 Josh Lehman. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
var navigationController: UINavigationController!
var viewModel: MasterViewModel!
var viewModelServices: ViewModelServices!
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
navigationController = UINavigationController()
let viewController = createMasterViewController()
navigationController.pushViewController(viewController, animated: false)
window = UIWindow(frame: UIScreen.mainScreen().bounds)
window!.makeKeyAndVisible()
window!.rootViewController = navigationController
// Why does my tab bar appear different across tabs???
UITabBar.appearance().barTintColor = UIColor.blackColor()
UITabBar.appearance().tintColor = UIColor.yellowColor()
let titleTextAttributes = [NSForegroundColorAttributeName: UIColor.yellowColor()]
UINavigationBar.appearance().titleTextAttributes = titleTextAttributes
UINavigationBar.appearance().barTintColor = UIColor.blackColor()
UINavigationBar.appearance().tintColor = UIColor.yellowColor()
return true
}
func createMasterViewController() -> MasterViewController {
viewModelServices = ViewModelServicesImpl(navigationController: navigationController)
viewModel = MasterViewModel(services: viewModelServices)
return MasterViewController(viewModel: viewModel)
}
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:.
}
}
|
gpl-2.0
|
6ed04c192cb9f5984ec6dab87cd5ff1f
| 45.378378 | 285 | 0.737179 | 6.05291 | false | false | false | false |
tonystone/coherence
|
Sources/Connect/Internal/Queues/ActionQueue.swift
|
1
|
2764
|
///
/// ActionQueue.swift
///
/// Copyright 2016 Tony Stone
///
/// 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.
///
/// Created by Tony Stone on 8/22/16.
///
import Foundation
import TraceLog
import CoreData
internal enum ConcurrencyMode {
case serial
case concurrent
}
internal class ActionQueue {
fileprivate let dispatchQueue: DispatchQueue
fileprivate let operationQueue: OperationQueue
public init(label: String, qos: DispatchQoS, concurrencyMode mode: ConcurrencyMode = .serial, suspended: Bool = false) {
self.concurrencyMode = mode
var queueAttributes = DispatchQueue.Attributes(rawValue: UInt64(0))
if mode == .concurrent {
queueAttributes.insert(.concurrent)
}
self.dispatchQueue = DispatchQueue(label: label, qos: qos, attributes: queueAttributes, autoreleaseFrequency: .inherit)
operationQueue = OperationQueue()
self.operationQueue.underlyingQueue = self.dispatchQueue
operationQueue.name = label
self.operationQueue.isSuspended = suspended
switch (concurrencyMode) {
case .serial: self.operationQueue.maxConcurrentOperationCount = 1; break
case .concurrent: self.operationQueue.maxConcurrentOperationCount = 5; break
}
}
public var label: String {
return self.dispatchQueue.label
}
public var concurrencyMode: ConcurrencyMode
public var suspended: Bool {
get {
return self.operationQueue.isSuspended
}
set {
self.operationQueue.isSuspended = newValue
}
}
public func cancelAllActions() {
self.operationQueue.cancelAllOperations()
}
public func waitUntilAllActionsAreFinished() {
self.operationQueue.waitUntilAllOperationsAreFinished()
}
public func addAction<T: Operation>(_ action: T, waitUntilDone wait: Bool = false) {
self.operationQueue.addOperations([action], waitUntilFinished: wait)
}
}
extension ActionQueue: CustomStringConvertible {
public var description: String {
return "\(type(of: self)) (name: \(self.label), qos: \(self.dispatchQueue.qos), concurrencyMode: \(self.concurrencyMode))"
}
}
|
apache-2.0
|
1d32d970f59596cffd6748c42de46f1d
| 29.373626 | 130 | 0.687048 | 4.883392 | false | false | false | false |
InkAnimator/SKInkAnimator
|
SKInkAnimator/Classes/ActionFactory.swift
|
1
|
3428
|
//
// AnimationFactory.swift
// Pods
//
// Created by Rafael Moura on 16/03/17.
//
//
import Foundation
import AEXML
import SpriteKit
class ActionFactory: NSObject {
static func action(for keyframe: Keyframe, previousKeyframe: Keyframe?, duration: TimeInterval) -> SKAction {
var group = [SKAction]()
if let moveAction = moveAction(with: keyframe, and: previousKeyframe, duration: duration) {
group.append(moveAction)
}
if let rotateAction = rotateAction(with: keyframe, and: previousKeyframe, duration: duration) {
group.append(rotateAction)
}
if let resizeAction = resizeAction(with: keyframe, and: previousKeyframe, duration: duration) {
group.append(resizeAction)
}
if let scaleAction = scaleAction(with: keyframe, and: previousKeyframe, duration: duration) {
group.append(scaleAction)
}
return group.count > 0 ? SKAction.group(group) : SKAction.wait(forDuration: duration)
}
static private func rotateAction(with keyframe: Keyframe, and previousKeyframe: Keyframe?, duration: TimeInterval) -> SKAction? {
if let previousKeyframe = previousKeyframe, keyframe.rotation == previousKeyframe.rotation {
return nil
}
let action: SKAction
action = SKAction.rotate(toAngle: keyframe.rotation, duration: duration, shortestUnitArc: false)
action.timingMode = actionTimingMode(for: keyframe.timingMode)
return action
}
static private func resizeAction(with keyframe: Keyframe, and previousKeyframe: Keyframe?, duration: TimeInterval) -> SKAction? {
if let previousKeyframe = previousKeyframe, keyframe.size == previousKeyframe.size {
return nil
}
let action: SKAction
action = SKAction.resize(toWidth: keyframe.size.width, height: keyframe.size.height, duration: duration)
action.timingMode = actionTimingMode(for: keyframe.timingMode)
return action
}
static private func scaleAction(with keyframe: Keyframe, and previousKeyframe: Keyframe?, duration: TimeInterval) -> SKAction? {
if let previousKeyframe = previousKeyframe, keyframe.scale == previousKeyframe.scale {
return nil
}
let action: SKAction
action = SKAction.scaleX(to: keyframe.scale.x, y: keyframe.scale.y, duration: duration)
return action
}
static private func moveAction(with keyframe: Keyframe, and previousKeyframe: Keyframe?, duration: TimeInterval) -> SKAction? {
if let previousKeyframe = previousKeyframe, keyframe.position == previousKeyframe.position {
return nil
}
let action: SKAction
action = SKAction.move(to: keyframe.position, duration: duration)
action.timingMode = actionTimingMode(for: keyframe.timingMode)
return action
}
static private func actionTimingMode(for timingMode: Keyframe.TimingMode) -> SKActionTimingMode {
switch timingMode {
case .linear:
return .linear
case .easeIn:
return .easeIn
case .easeOut:
return .easeOut
case .easeInEaseOut:
return .easeInEaseOut
}
}
}
|
mit
|
bf629e6cc05ef83b367f41194b01c990
| 33.626263 | 133 | 0.635648 | 5.071006 | false | false | false | false |
byu-oit/ios-byuSuite
|
byuSuite/Classes/Reusable/Clients/ControlDates/YearTerm2.swift
|
2
|
2056
|
//
// YearTerm2.swift
// byuSuite
//
// Created by Erik Brady on 7/31/17.
// Copyright © 2017 Brigham Young University. All rights reserved.
//
private let dateFormatter = DateFormatter.defaultDateFormat("yyyyMMdd HH:mm:ss")
class YearTerm2: Comparable {
var code: String
var title: String?
var dateType: String? //e.g., CLASS_DATES, CURRENT_YYT, CURRICULUM
var startDate: Date?
var endDate: Date?
convenience init(dict: [String: Any]) throws {
guard let yearTermCode = dict["year_term"] as? String else {
throw InvalidModelError()
}
try self.init(yearTerm: yearTermCode)
dateType = dict["date_type"] as? String
dateFormatter.timeZone = TimeZone(abbreviation: "GMT")
startDate = dateFormatter.date(from: dict["start_date"] as? String)
endDate = dateFormatter.date(from: dict["end_date"] as? String)
}
init(yearTerm: String?) throws {
guard let yearTermCode = yearTerm else {
throw InvalidModelError()
}
code = yearTermCode
title = YearTerm2.title(from: yearTerm)
}
//MARK: Helper Methods
private static func title(from yearTerm: String?) -> String? {
if let yearTerm = yearTerm {
let index = yearTerm.index(yearTerm.startIndex, offsetBy: 4)
if let year = Int(yearTerm[..<index]), let term = Int(yearTerm[index...]) {
switch term {
case 1, 2:
return "Winter \(year)"
case 3:
return "Spring \(year)"
case 4:
return "Summer \(year)"
case 5, 6:
return "Fall \(year)"
default:
break
}
}
}
return nil
}
//MARK: Comparable Methods
static func <(lhs: YearTerm2, rhs: YearTerm2) -> Bool {
return lhs.code < rhs.code
}
static func ==(lhs: YearTerm2, rhs: YearTerm2) -> Bool {
return lhs.code == rhs.code
}
}
|
apache-2.0
|
ca7a08481bb9c5cc5d0ecef78158f17d
| 26.77027 | 87 | 0.561557 | 4.021526 | false | false | false | false |
anilgoktas/Protocol-Oriented
|
LocationUsableType.swift
|
1
|
2771
|
/*
LocationUsableType
Copyright © 2016 Anıl Göktaş.
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
protocol LocationUsableType: CLLocationManagerDelegate {
var locationManager: CLLocationManager { get set }
func configureLocationManager()
}
extension LocationUsableType where Self: UIViewController {
func configureLocationManager() {
switch CLLocationManager.authorizationStatus() {
case .NotDetermined:
locationManager.requestWhenInUseAuthorization()
case .AuthorizedAlways, .AuthorizedWhenInUse:
locationManager.delegate = self
locationManager.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
locationManager.distanceFilter = 10.0
locationManager.startUpdatingLocation()
case .Restricted, .Denied:
let alertController = UIAlertController(title: "Location Access Disabled", message: "In order to use app properly, please open settings and set location access to 'WhenInUse'.", preferredStyle: .Alert)
let cancelAction = UIAlertAction(title: "Cancel", style: .Cancel, handler: nil)
alertController.addAction(cancelAction)
let openAction = UIAlertAction(title: "Settings", style: .Default) { (action) in
if let url = NSURL(string: UIApplicationOpenSettingsURLString)
where UIApplication.sharedApplication().canOpenURL(url) {
UIApplication.sharedApplication().openURL(url)
}
}
alertController.addAction(openAction)
presentViewController(alertController, animated: true, completion: nil)
}
}
}
|
mit
|
740f16ad37ab5444aed1421b2e007ed5
| 42.25 | 213 | 0.706903 | 5.752599 | false | false | false | false |
ilya-borshchov-appus/TestApplicationRepo
|
AppCollection/DetailViewController.swift
|
1
|
12258
|
//
// DetailViewController.swift
// AppusApplications
//
// Created by Feather52 on 1/20/17.
// Copyright © 2017 Appus. All rights reserved.
//
import UIKit
import AlamofireImage
import Alamofire
let CellId = "cellId"
let DateFormat = "yyyy-MM-dd'T'HH:mm:ssZ"
let IPhoneString = "iPhone"
let IPadString = "iPad"
let IPodTouchString = "iPod touch"
class DetailViewController: UIViewController {
var selectedApp : AppusApp?
@IBOutlet weak var backgroundView: UIImageView!
@IBOutlet weak var containerView: UIView!
@IBOutlet weak var appRating: FloatRatingView!
@IBOutlet weak var appImage: UIImageView!
@IBOutlet weak var appName: UILabel!
@IBOutlet weak var collectionView: UICollectionView!
@IBOutlet weak var iTunesButton: UIButton!
@IBOutlet weak var detailDescription: UILabel!
@IBOutlet weak var developerInfo: UILabel!
@IBOutlet weak var categoryInfo: UILabel!
@IBOutlet weak var updatedInfo: UILabel!
@IBOutlet weak var ratingInfo: UILabel!
@IBOutlet weak var compatibilityInfo: UILabel!
@IBOutlet weak var languagesInfo: UILabel!
// Static labels
@IBOutlet weak var descriptionLabel: UILabel!
@IBOutlet weak var infoLabel: UILabel!
@IBOutlet weak var developerLabel: UILabel!
@IBOutlet weak var categoryLabel: UILabel!
@IBOutlet weak var updatedLabel: UILabel!
@IBOutlet weak var ratingLabel: UILabel!
@IBOutlet weak var compatibilityLabel: UILabel!
@IBOutlet weak var languagesLabel: UILabel!
// Collections of views
@IBOutlet var separators: [UIView]!
@IBOutlet var sectionTitles: [UILabel]!
@IBOutlet var textLabels: [UILabel]!
@IBOutlet var infoTextLabels: [UILabel]!
fileprivate let settingsManager = SettingsManager.shared
fileprivate var _podBundle : Bundle? = nil
internal var podBundle : Bundle{
get{
if (!(_podBundle != nil)){
let bundlePath = Bundle(for: AppsViewController.self)
let pathResource = bundlePath.path(forResource: BundleName, ofType: BundleType)!
_ = Bundle(path: pathResource)
_podBundle = Bundle(path: pathResource)
}
return _podBundle!
}
set{
}
}
override func viewDidLoad() {
super.viewDidLoad()
self.setupTheme()
self.initLayout()
self.setTitles()
}
// MARK: Init UI
fileprivate func setupTheme() {
self.containerView.backgroundColor = UIColor.clear
self.backgroundView.image = self.settingsManager.backgroundImage
self.view.backgroundColor = self.settingsManager.backgroundColor
self.iTunesButton.setTitleColor(self.settingsManager.purchaseButtonColor, for: .normal)
self.setColor(self.settingsManager.sectionTitleColor, for: self.sectionTitles)
self.setColor(self.settingsManager.textColor, for: self.textLabels)
self.setColor(self.settingsManager.infoTextColor, for: self.infoTextLabels)
for separator in separators {
separator.backgroundColor = self.settingsManager.separatorColor ?? UIColor.lightGray
}
}
fileprivate func setColor(_ color: UIColor, for labels: [UILabel]) {
for label in labels {
label.textColor = color
}
}
fileprivate func initLayout() {
self.appName?.text = selectedApp?.appName
Alamofire.request((selectedApp?.appImagePath)!).responseData { response in
debugPrint(response)
debugPrint(response.result)
if response.result.value != nil {
let image = UIImage(data: response.result.value!)
self.appImage?.image = image
self.appImage.layer.cornerRadius = 15.0
self.appImage.layer.masksToBounds = true
}
}
self.appRating.emptyImage = self.settingsManager.emptyRatingImage
self.appRating.fullImage = self.settingsManager.filledRatingImage
self.appRating.contentMode = UIViewContentMode.scaleAspectFit
self.appRating.rating = Float((self.selectedApp?.averageRating)!) ?? 0
self.appRating.isHidden = self.appRating.rating == 0
self.appRating.editable = false
self.appRating.floatRatings = true
/*if (self.selectedApp?.price == "0"){
self.iTunesButton.setTitle(NSLocalizedString(Localisation.free, comment: ""), for: .normal)
}else{*/
self.iTunesButton.setTitle(self.selectedApp?.price, for: .normal)
//}
self.iTunesButton.layer.cornerRadius = 6.0
self.iTunesButton.layer.borderColor = self.iTunesButton.currentTitleColor.cgColor
self.iTunesButton.layer.borderWidth = 1.0
self.detailDescription.text = self.selectedApp?.appDescription
self.developerInfo.text = self.selectedApp?.companyName
self.categoryInfo.text = self.selectedApp?.primaryGenre
self.updatedInfo.text = Date.dateWithMediumStyleFrom((self.selectedApp?.currentVersionDate)!)
//
var iPhone = false
var iPad = false
for device in (self.selectedApp?.suportedDevices)! {
if ((device as String).range(of: IPhoneString) != nil){
iPhone = true
} else if ((device as String).range(of: IPadString) != nil){
iPad = true
}
if (iPhone && iPad){
continue
}
}
var compatible = ""
if (iPhone && !iPad){
compatible = String(format: "%@ \(IPhoneString) %@ \(IPodTouchString).", NSLocalizedString(Localisation.compatibleWith, tableName: nil, bundle: podBundle, value: "", comment: ""), NSLocalizedString(Localisation.and, tableName: nil, bundle: podBundle, value: "", comment: ""))
} else if (!iPhone && iPad){
compatible = String(format: "%@ \(IPadString).", NSLocalizedString(Localisation.compatibleWith, tableName: nil, bundle: podBundle, value: "", comment: ""))
} else if(iPhone && iPad){
compatible = String(format: "%@ \(IPhoneString), \(IPadString) %@ \(IPodTouchString).", NSLocalizedString(Localisation.compatibleWith, tableName: nil, bundle: podBundle, value: "", comment: ""), NSLocalizedString(Localisation.and, tableName: nil, bundle: podBundle, value: "", comment: ""))
}
self.compatibilityInfo.text = String(format: NSLocalizedString(Localisation.formatRequirements, tableName: nil, bundle: podBundle, value: "", comment: ""), (self.selectedApp?.minVersion)!, compatible)
self.ratingInfo.text = "\(NSLocalizedString(Localisation.rated, tableName: nil, bundle: podBundle, value: "", comment: "")) \((self.selectedApp?.contentAdvisoryRating)!)"
// Repo with all country code in csv format with differenet locales: https://github.com/umpirsky/language-list/
let bundlePath = Bundle(for: AppsViewController.self)
guard let path = bundlePath.path(forResource: NSLocalizedString(Localisation.countriesCSV, tableName: nil, bundle: podBundle, value: "", comment: ""), ofType: "csv") else {
return
}
var keyedRows = [[String]]()
do {
let content = try String(contentsOfFile:path, encoding: String.Encoding.utf8)
let csv = CSwiftV(with: content)
keyedRows = csv.rows
} catch _ as NSError {
return
}
var codeDictionary = [String : String]()
for row in keyedRows {
codeDictionary[row[0]] = row[1]
}
var arrayLanguage = [String]()
for code in (self.selectedApp?.languageCodes)! {
let lowercased = (code as String).lowercased()
if (codeDictionary[lowercased] != nil){
arrayLanguage.append(codeDictionary[lowercased]!)
}
}
self.languagesInfo.text = String(format: "%@", (arrayLanguage.joined(separator: ", ")))
self.collectionView.reloadData()
}
fileprivate func setTitles() {
self.title = NSLocalizedString(Localisation.appDetails, tableName: nil, bundle: podBundle, value: "", comment: "")
self.descriptionLabel.text = NSLocalizedString(Localisation.appDescription, tableName: nil, bundle: podBundle, value: "", comment: "")
self.infoLabel.text = NSLocalizedString(Localisation.info, tableName: nil, bundle: podBundle, value: "", comment: "")
self.developerLabel.text = NSLocalizedString(Localisation.developer, tableName: nil, bundle: podBundle, value: "", comment: "")
self.categoryLabel.text = NSLocalizedString(Localisation.category, tableName: nil, bundle: podBundle, value: "", comment: "")
self.updatedLabel.text = NSLocalizedString(Localisation.updated, tableName: nil, bundle: podBundle, value: "", comment: "")
self.ratingLabel.text = NSLocalizedString(Localisation.rating, tableName: nil, bundle: podBundle, value: "", comment: "")
self.compatibilityLabel.text = NSLocalizedString(Localisation.compatibility, tableName: nil, bundle: podBundle, value: "", comment: "")
self.languagesLabel.text = NSLocalizedString(Localisation.languages, tableName: nil, bundle: podBundle, value: "", comment: "")
}
// MARK : User actions
@IBAction func goToItunesClicked(_ sender: Any) {
guard let urlString = self.selectedApp?.url,
let url = URL(string: urlString) else {
return
}
if #available(iOS 10.0, *) {
UIApplication.shared.open(url, options: [:], completionHandler: nil)
} else {
UIApplication.shared.openURL(url)
}
}
}
extension DetailViewController: UICollectionViewDataSource {
func numberOfSections(in collectionView: UICollectionView) -> Int {
return 1
}
func collectionView(_ collectionView: UICollectionView,
numberOfItemsInSection section: Int) -> Int {
return self.selectedApp!.screenshots.count
}
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath : IndexPath) -> UICollectionViewCell {
let reuseIdentifier = CellId
let cell = collectionView.dequeueReusableCell(withReuseIdentifier: reuseIdentifier,
for: indexPath) as! DetailCollectionViewCell
Alamofire.request((self.selectedApp!.screenshots[indexPath.row])).responseData { response in
if response.result.value != nil {
let image = UIImage(data: response.result.value!)
cell.imageView?.image = image
cell.imageView.layer.borderWidth = 1.0
cell.imageView.layer.borderColor = UIColor(colorLiteralRed: 153.0/255.0, green: 137.0/255.0, blue: 132.0/255.0, alpha: 1.0).cgColor
}
}
return cell
}
}
extension DetailViewController: UICollectionViewDelegateFlowLayout {
func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
let height = collectionView.contentSize.height
if (self.selectedApp?.isIPadScreenshots)! {
return CGSize.init(width: 3.0 / 4.0 * height, height: height)
} else {
return CGSize.init(width: 9.0 / 16.0 * height, height: height)
}
}
}
extension Date {
static func dateWithMediumStyleFrom(_ string: String) -> String {
var dateFormatter = DateFormatter()
dateFormatter.dateFormat = DateFormat
guard let dateFromString = dateFormatter.date(from: string) else {
return string
}
dateFormatter = DateFormatter()
dateFormatter.dateStyle = .medium
return dateFormatter.string(from: dateFromString)
}
}
|
apache-2.0
|
9927e4d5dfb786e529682c24481fe7a7
| 40.976027 | 302 | 0.633352 | 4.956328 | false | false | false | false |
vvusu/LogAnalysis
|
Log Analysis/Libraries/SUSheetXLS/SUStyle.swift
|
1
|
542
|
//
// SUStyle.swift
// Log Analysis
//
// Created by vvusu on 10/30/15.
// Copyright © 2015 vvusu. All rights reserved.
//
import Cocoa
enum VerticalAlign: Int {
case TopAlign = 0
case CenterAlign = 1
case BottomAlign = 2
}
enum HorizontalAlign: Int {
case LeftAlign = 0
case MiddleAlign = 1
case RightAlign = 2
}
class SUStyle: NSObject {
var alignmentV = VerticalAlign.CenterAlign
var alignmentH = HorizontalAlign.MiddleAlign
var font: NSFont!
var color: NSColor!
var size: Float = 0
}
|
lgpl-3.0
|
2d99fed4c6a313573b9f6094753165b0
| 17.655172 | 49 | 0.665434 | 3.467949 | false | false | false | false |
gmertk/Moya
|
Demo/DemoTests/SignalProducer+MoyaSpec.swift
|
1
|
7900
|
import Quick
import ReactiveMoya
import ReactiveCocoa
import Nimble
// Necessary since UIImage(named:) doesn't work correctly in the test bundle
private extension UIImage {
class func testPNGImage(named name: String) -> UIImage {
class TestClass { }
let bundle = NSBundle(forClass: TestClass().dynamicType)
let path = bundle.pathForResource(name, ofType: "png")
return UIImage(contentsOfFile: path!)!
}
}
func signalSendingData(data: NSData, statusCode: Int = 200) -> SignalProducer<MoyaResponse, NSError> {
return SignalProducer(value: MoyaResponse(statusCode: statusCode, data: data, response: nil))
}
class SignalProducerMoyaSpec: QuickSpec {
override func spec() {
describe("status codes filtering") {
it("filters out unrequested status codes") {
let data = NSData()
let signal = signalSendingData(data, statusCode: 10)
var errored = false
signal.filterStatusCodes(0...9).start { (event) -> Void in
switch event {
case .Next(let object):
XCTFail("called on non-correct status code: \(object)")
case .Error:
errored = true
default:
break
}
}
expect(errored).to(beTruthy())
}
it("filters out non-successful status codes") {
let data = NSData()
let signal = signalSendingData(data, statusCode: 404)
var errored = false
signal.filterSuccessfulStatusCodes().start { (event) -> Void in
switch event {
case .Next(let object):
XCTFail("called on non-success status code: \(object)")
case .Error:
errored = true
default:
break
}
}
expect(errored).to(beTruthy())
}
it("passes through correct status codes") {
let data = NSData()
let signal = signalSendingData(data)
var called = false
signal.filterSuccessfulStatusCodes().startWithNext { (object) -> Void in
called = true
}
expect(called).to(beTruthy())
}
it("filters out non-successful status and redirect codes") {
let data = NSData()
let signal = signalSendingData(data, statusCode: 404)
var errored = false
signal.filterSuccessfulStatusAndRedirectCodes().start { (event) -> Void in
switch event {
case .Next(let object):
XCTFail("called on non-success status code: \(object)")
case .Error:
errored = true
default:
break
}
}
expect(errored).to(beTruthy())
}
it("passes through correct status codes") {
let data = NSData()
let signal = signalSendingData(data)
var called = false
signal.filterSuccessfulStatusAndRedirectCodes().startWithNext { (object) -> Void in
called = true
}
expect(called).to(beTruthy())
}
it("passes through correct redirect codes") {
let data = NSData()
let signal = signalSendingData(data, statusCode: 304)
var called = false
signal.filterSuccessfulStatusAndRedirectCodes().startWithNext { (object) -> Void in
called = true
}
expect(called).to(beTruthy())
}
}
describe("image maping") {
it("maps data representing an image to an image") {
let image = UIImage.testPNGImage(named: "testImage")
let data = UIImageJPEGRepresentation(image, 0.75)
let signal = signalSendingData(data!)
var size: CGSize?
signal.mapImage().startWithNext { (image) -> Void in
size = image.size
}
expect(size).to(equal(image.size))
}
it("ignores invalid data") {
let data = NSData()
let signal = signalSendingData(data)
var receivedError: NSError?
signal.mapImage().start { (event) -> Void in
switch event {
case .Next:
XCTFail("next called for invalid data")
case .Error(let error):
receivedError = error
default:
break
}
}
expect(receivedError?.code).to(equal(MoyaErrorCode.ImageMapping.rawValue))
}
}
describe("JSON mapping") {
it("maps data representing some JSON to that JSON") {
let json = ["name": "John Crighton", "occupation": "Astronaut"]
let data = try! NSJSONSerialization.dataWithJSONObject(json, options: .PrettyPrinted)
let signal = signalSendingData(data)
var receivedJSON: [String: String]?
signal.mapJSON().startWithNext { (json) -> Void in
if let json = json as? [String: String] {
receivedJSON = json
}
}
expect(receivedJSON?["name"]).to(equal(json["name"]))
expect(receivedJSON?["occupation"]).to(equal(json["occupation"]))
}
it("returns a Cocoa error domain for invalid JSON") {
let json = "{ \"name\": \"john }"
let data = json.dataUsingEncoding(NSUTF8StringEncoding)
let signal = signalSendingData(data!)
var receivedError: NSError?
signal.mapJSON().start { (event) -> Void in
switch event {
case .Next:
XCTFail("next called for invalid data")
case .Error(let error):
receivedError = error
default:
break
}
}
expect(receivedError).toNot(beNil())
expect(receivedError?.domain).to(equal("\(NSCocoaErrorDomain)"))
}
}
describe("string mapping") {
it("maps data representing a string to a string") {
let string = "You have the rights to the remains of a silent attorney."
let data = string.dataUsingEncoding(NSUTF8StringEncoding)
let signal = signalSendingData(data!)
var receivedString: String?
signal.mapString().startWithNext { (string) -> Void in
receivedString = string
return
}
expect(receivedString).to(equal(string))
}
}
}
}
|
mit
|
5f45e12e698366fb8066b55635f49f0a
| 37.349515 | 102 | 0.453797 | 6.44898 | false | false | false | false |
alexwinston/UIViewprint
|
UIViewprint/AIFlatSwitch.swift
|
1
|
11495
|
//
// AIFlatSwitch.swift
// AIFlatSwitch
//
// Created by cocoatoucher on 11/02/15.
// Copyright (c) 2015 cocoatoucher. All rights reserved.
//
import UIKit
@IBDesignable public class AIFlatSwitch: UIControl {
let finalStrokeEndForCheckmark: CGFloat = 0.85
let finalStrokeStartForCheckmark: CGFloat = 0.3
let checkmarkBounceAmount: CGFloat = 0.1
let animationDuration: CFTimeInterval = 0.3
@IBInspectable public var lineWidth: CGFloat = 2.0 {
didSet {
self.circle.lineWidth = lineWidth
self.checkmark.lineWidth = lineWidth
self.trailCircle.lineWidth = lineWidth
}
}
@IBInspectable public var strokeColor: UIColor = UIColor.blackColor() {
didSet {
self.circle.strokeColor = strokeColor.CGColor
self.checkmark.strokeColor = strokeColor.CGColor
}
}
@IBInspectable public var trailStrokeColor: UIColor = UIColor.grayColor() {
didSet {
self.trailCircle.strokeColor = trailStrokeColor.CGColor
}
}
@IBInspectable public override var selected: Bool {
get {
return selected_internal
}
set {
super.selected = newValue
self.setSelected(newValue, animated: false)
}
}
private var trailCircle: CAShapeLayer = CAShapeLayer()
private var circle: CAShapeLayer = CAShapeLayer()
private var checkmark: CAShapeLayer = CAShapeLayer()
private var checkmarkMidPoint: CGPoint = CGPointZero
private var selected_internal: Bool = false
public override init(frame: CGRect) {
super.init(frame: frame)
self.configure()
}
public required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
self.configure()
}
public override func layoutSublayersOfLayer(layer: CALayer) {
super.layoutSublayersOfLayer(layer)
if layer == self.layer {
var offset: CGPoint = CGPointZero
let radius = fmin(self.bounds.width, self.bounds.height) / 2 - 1
offset.x = (self.bounds.width - radius * 2) / 2.0
offset.y = (self.bounds.height - radius * 2) / 2.0
CATransaction.begin()
CATransaction.setDisableActions(true)
let ovalRect = CGRectMake(offset.x, offset.y, radius * 2, radius * 2)
let circlePath = UIBezierPath(ovalInRect: ovalRect)
trailCircle.path = circlePath.CGPath
circle.transform = CATransform3DIdentity
circle.frame = self.bounds
circle.path = UIBezierPath(ovalInRect: ovalRect).CGPath
circle.transform = CATransform3DMakeRotation(CGFloat(212 * M_PI / 180), 0, 0, 1)
let origin = CGPointMake(offset.x + radius, offset.y + radius)
var checkStartPoint = CGPointZero
checkStartPoint.x = origin.x + radius * CGFloat(cos(212 * M_PI / 180))
checkStartPoint.y = origin.y + radius * CGFloat(sin(212 * M_PI / 180))
let checkmarkPath = UIBezierPath()
checkmarkPath.moveToPoint(checkStartPoint)
self.checkmarkMidPoint = CGPointMake(offset.x + radius * 0.9, offset.y + radius * 1.4)
checkmarkPath.addLineToPoint(self.checkmarkMidPoint)
var checkEndPoint = CGPointZero
checkEndPoint.x = origin.x + radius * CGFloat(cos(320 * M_PI / 180))
checkEndPoint.y = origin.y + radius * CGFloat(sin(320 * M_PI / 180))
checkmarkPath.addLineToPoint(checkEndPoint)
checkmark.frame = self.bounds
checkmark.path = checkmarkPath.CGPath
CATransaction.commit()
}
}
private func configure() {
self.backgroundColor = UIColor.clearColor()
configureShapeLayer(trailCircle)
trailCircle.strokeColor = trailStrokeColor.CGColor
configureShapeLayer(circle)
circle.strokeColor = strokeColor.CGColor
configureShapeLayer(checkmark)
checkmark.strokeColor = strokeColor.CGColor
self.setSelected(false, animated: false)
self.addTarget(self, action: "onTouchUpInside:", forControlEvents: UIControlEvents.TouchUpInside)
}
internal func onTouchUpInside(sender: AnyObject) {
self.setSelected(!self.selected, animated: true)
self.sendActionsForControlEvents(UIControlEvents.ValueChanged)
}
private func configureShapeLayer(shapeLayer: CAShapeLayer) {
shapeLayer.lineJoin = kCALineJoinRound
shapeLayer.lineCap = kCALineCapRound
shapeLayer.lineWidth = self.lineWidth
shapeLayer.fillColor = UIColor.clearColor().CGColor
self.layer.addSublayer(shapeLayer)
}
public func setSelected(isSelected: Bool, animated: Bool) {
self.selected_internal = isSelected
checkmark.removeAllAnimations()
circle.removeAllAnimations()
trailCircle.removeAllAnimations()
self.resetValues(animated: animated)
if animated {
self.addAnimationsForSelected(selected_internal)
}
}
private func resetValues(animated animated: Bool) {
CATransaction.begin()
CATransaction.setDisableActions(true)
if (selected_internal && animated) || (selected_internal == false && animated == false) {
checkmark.strokeEnd = 0.0
checkmark.strokeStart = 0.0
trailCircle.opacity = 0.0
circle.strokeStart = 0.0
circle.strokeEnd = 1.0
} else {
checkmark.strokeEnd = finalStrokeEndForCheckmark
checkmark.strokeStart = finalStrokeStartForCheckmark
trailCircle.opacity = 1.0
circle.strokeStart = 0.0
circle.strokeEnd = 0.0
}
CATransaction.commit()
}
private func addAnimationsForSelected(selected: Bool) {
let circleAnimationDuration = animationDuration * 0.5
let checkmarkEndDuration = animationDuration * 0.8
let checkmarkStartDuration = checkmarkEndDuration - circleAnimationDuration
let checkmarkBounceDuration = animationDuration - checkmarkEndDuration
let checkmarkAnimationGroup = CAAnimationGroup()
checkmarkAnimationGroup.removedOnCompletion = false
checkmarkAnimationGroup.fillMode = kCAFillModeForwards
checkmarkAnimationGroup.duration = animationDuration
checkmarkAnimationGroup.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
let checkmarkStrokeEnd = CAKeyframeAnimation(keyPath: "strokeEnd")
checkmarkStrokeEnd.duration = checkmarkEndDuration + checkmarkBounceDuration
checkmarkStrokeEnd.removedOnCompletion = false
checkmarkStrokeEnd.fillMode = kCAFillModeForwards
checkmarkStrokeEnd.calculationMode = kCAAnimationPaced
if selected {
checkmarkStrokeEnd.values = NSArray(objects: NSNumber(float: 0.0), NSNumber(float: Float(finalStrokeEndForCheckmark + checkmarkBounceAmount)), NSNumber(float: Float(finalStrokeEndForCheckmark))) as [AnyObject]
checkmarkStrokeEnd.keyTimes = [NSNumber(double: 0.0), NSNumber(double: checkmarkEndDuration), NSNumber(double: checkmarkEndDuration + checkmarkBounceDuration)]
} else {
checkmarkStrokeEnd.values = NSArray(objects: NSNumber(float: Float(finalStrokeEndForCheckmark)), NSNumber(float: Float(finalStrokeEndForCheckmark + checkmarkBounceAmount)), NSNumber(float: -0.1)) as [AnyObject]
checkmarkStrokeEnd.keyTimes = [NSNumber(double: 0.0), NSNumber(double: checkmarkBounceDuration), NSNumber(double: checkmarkEndDuration + checkmarkBounceDuration)]
}
let checkmarkStrokeStart = CAKeyframeAnimation(keyPath: "strokeStart")
checkmarkStrokeStart.duration = checkmarkStartDuration + checkmarkBounceDuration
checkmarkStrokeStart.removedOnCompletion = false
checkmarkStrokeStart.fillMode = kCAFillModeForwards
checkmarkStrokeStart.calculationMode = kCAAnimationPaced
if selected {
checkmarkStrokeStart.values = NSArray(objects: NSNumber(float: 0.0), NSNumber(float: Float(finalStrokeStartForCheckmark + checkmarkBounceAmount)), NSNumber(float: Float(finalStrokeStartForCheckmark))) as [AnyObject]
checkmarkStrokeStart.keyTimes = [NSNumber(double: 0.0), NSNumber(double: checkmarkStartDuration), NSNumber(double: checkmarkStartDuration + checkmarkBounceDuration)]
} else {
checkmarkStrokeStart.values = NSArray(objects: NSNumber(float: Float(finalStrokeStartForCheckmark)), NSNumber(float: Float(finalStrokeStartForCheckmark + checkmarkBounceAmount)), NSNumber(float: 0.0)) as [AnyObject]
checkmarkStrokeStart.keyTimes = [NSNumber(double: 0.0), NSNumber(double: checkmarkBounceDuration), NSNumber(double: checkmarkStartDuration + checkmarkBounceDuration)]
}
if selected {
checkmarkStrokeStart.beginTime = circleAnimationDuration
}
checkmarkAnimationGroup.animations = [checkmarkStrokeEnd, checkmarkStrokeStart]
checkmark.addAnimation(checkmarkAnimationGroup, forKey: "checkmarkAnimation")
let circleAnimationGroup = CAAnimationGroup()
circleAnimationGroup.duration = animationDuration
circleAnimationGroup.removedOnCompletion = false
circleAnimationGroup.fillMode = kCAFillModeForwards
circleAnimationGroup.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
let circleStrokeEnd = CABasicAnimation(keyPath: "strokeEnd")
circleStrokeEnd.duration = circleAnimationDuration
if selected {
circleStrokeEnd.beginTime = 0.0
circleStrokeEnd.fromValue = NSNumber(float: 1.0)
circleStrokeEnd.toValue = NSNumber(float: -0.1)
} else {
circleStrokeEnd.beginTime = animationDuration - circleAnimationDuration
circleStrokeEnd.fromValue = NSNumber(float: 0.0)
circleStrokeEnd.toValue = NSNumber(float: 1.0)
}
circleStrokeEnd.removedOnCompletion = false
circleStrokeEnd.fillMode = kCAFillModeForwards
circleAnimationGroup.animations = [circleStrokeEnd]
circle.addAnimation(circleAnimationGroup, forKey: "circleStrokeEnd")
let trailCircleColor = CABasicAnimation(keyPath: "opacity")
trailCircleColor.duration = animationDuration
if selected {
trailCircleColor.fromValue = NSNumber(float: 0.0)
trailCircleColor.toValue = NSNumber(float: 1.0)
} else {
trailCircleColor.fromValue = NSNumber(float: 1.0)
trailCircleColor.toValue = NSNumber(float: 0.0)
}
trailCircleColor.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
trailCircleColor.fillMode = kCAFillModeForwards
trailCircleColor.removedOnCompletion = false
trailCircle.addAnimation(trailCircleColor, forKey: "trailCircleColor")
}
}
|
mit
|
dda7a5124a72f938fc5885f650a02c7e
| 41.420664 | 227 | 0.658982 | 5.399248 | false | false | false | false |
iOSDevLog/iOSDevLog
|
109. Cassini/Cassini/ViewController.swift
|
1
|
909
|
//
// ViewController.swift
// Cassini
//
// Created by jiaxianhua on 15/9/28.
// Copyright © 2015年 com.jiaxh. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
if let ivc = segue.destinationViewController as? ImageViewController {
if let identifier = segue.identifier {
switch identifier {
case "Earth":
ivc.imageURL = DemoURL.NASA.Earth
ivc.title = "Earth"
case "Saturn":
ivc.imageURL = DemoURL.NASA.Saturn
ivc.title = "Saturn"
case "Cassini":
ivc.imageURL = DemoURL.NASA.Cassini
ivc.title = "Cassini"
default: break
}
}
}
}
}
|
mit
|
c138a33e02acfa9a88587f23f930f4bb
| 27.3125 | 81 | 0.523179 | 4.743455 | false | false | false | false |
AfricanSwift/TUIKit
|
TUIKit/dev-barchart.swift
|
1
|
5892
|
//
// File: dev-barchart.swift
// Created by: African Swift
import Foundation
func alphaBar()
{
func generateRandomColor1() -> Ansi.Color
{
let limit = 0.3
let r = Double(arc4random_uniform(255)) / 255.0
let g = Double(arc4random_uniform(255)) / 255.0
let b = Double(arc4random_uniform(255)) / 255.0
func brightenColor(
_ red: Double,
green: Double,
blue: Double) -> (r: Double, g: Double, b: Double)
{
return (r: r <= limit ? r + 0.2 : r,
g: g <= limit ? g + 0.2 : g,
b: b <= limit ? b + 0.2 : b)
}
let part = brightenColor(r, green: g, blue: b)
return Ansi.Color(red: part.r, green: part.g, blue: part.b, alpha: 1)
}
func generateRandomColor2() -> Ansi.Color
{
let limit = 0.3
let r = Double(arc4random_uniform(60)) / 255.0
let g = Double(arc4random_uniform(20)) / 255.0
let b = Double(arc4random_uniform(40)) / 255.0
func brightenColor(
_ red: Double,
green: Double,
blue: Double) -> (r: Double, g: Double, b: Double)
{
return (r: r <= limit ? r + 0.2 : r,
g: g <= limit ? g + 0.2 : g,
b: b <= limit ? b + 0.2 : b)
}
let part = brightenColor(r, green: g, blue: b)
return Ansi.Color(red: part.r, green: part.g, blue: part.b, alpha: 1)
}
func nextColor(color1: Ansi.Color, color2: Ansi.Color, percent: Double) -> Ansi.Color
{
let diffRed = color2.RGB.red - color1.RGB.red
let diffGreen = color2.RGB.green - color1.RGB.green
let diffBlue = color2.RGB.blue - color1.RGB.blue
let newRed = color1.RGB.red + diffRed * percent
let newGreen = color1.RGB.green + diffGreen * percent
let newBlue = color1.RGB.blue + diffBlue * percent
return Ansi.Color(red: newRed, green: newGreen, blue: newBlue, alpha: color1.alpha)
}
func drawBar(
x: Int,
y: Int,
height: Int,
width: Int,
gapWidth: Int,
percent: Double,
v: inout TUIView,
color1: Ansi.Color,
color2: Ansi.Color)
{
let reduce = Int(Double(height) * (1.0 - percent))
for y in stride(from: 0 + reduce, to: height, by: 1)
{
let nc = nextColor(
color1: color1,
color2: color2,
percent: Double(y) / Double(height))
v.drawLine(from: TUIVec2(x: x, y: y),
to: TUIVec2(x: x + width - 1, y: y), color: nc)
}
}
guard let wSize = TUIWindow.ttysize() else { exit(EXIT_FAILURE) }
Ansi.Set.cursorOff().stdout()
let width = Int(wSize.character.width * 2) - 4
let height = Int(wSize.character.height * 4) - 8 - 2 - 8
Ansi.Cursor.column().stdout()
var view = TUIView(x: 0, y: 0, width: width, height: height)
let axisOffset = 8
let maximum = 60
let tickInterval = 8
let axisWidth = 150
view.drawLine(from: TUIVec2(x: axisOffset + 2, y: 0),
to: TUIVec2(x: axisOffset + 2, y: maximum))
view.drawLine(from: TUIVec2(x: axisOffset + 2, y: maximum + 1),
to: TUIVec2(x: axisOffset + 2 + axisWidth, y: maximum + 1))
// for i in stride(from: 0, through: maximum, by: 1)
// {
// let tickWidth = i % tickInterval == 0 ? 2 : 0
// if tickWidth > 0
// {
// view.drawLine(from: TUIVec2(x: axisOffset + 2 - tickWidth, y: i + 1),
// to: TUIVec2(x: axisOffset + 2, y: i + 1))
// }
// if i % tickInterval == 0
// {
// let value = String(format: "%3d", maximum - i)
//
// view.drawText(x: ((axisOffset + 2 - tickWidth) / 2) - 3,
// y: i / 4, text: value,
// color: Ansi.Color(red: 0.4, green: 0.2, blue: 0.4, alpha: 1))
// }
// }
let color = Ansi.Color(red: 0.6, green: 0.2, blue: 0.4, alpha: 1)
var idx = 0
for i in stride(from: 0, to: axisWidth, by: 16)
{
let from = TUIVec2(x: axisOffset + 2 + i, y: maximum + 1)
let to = TUIVec2(x: axisOffset + 2 + i, y: maximum + 1 + 2)
view.drawLine(from: from, to: to)
let text = String(format: "%2d", idx)
view.drawText(x: Int(to.x) / 2 - 1, y: Int(to.y) / 4 + 1, text: text, color: color)
idx += 1000
}
let values = [34, 56, 76, 23, 12, 55, 89, 10]
for i in values.indices
{
let percent = Double(values[i]) / 100
let reduce = Int(Double(height) * (1.0 - percent))
let color1 = generateRandomColor1()
let color2 = generateRandomColor1()
// for x in stride(from: 0, to: axisWidth - reduce, by: 4)
// {
// let rect = TUIRectangle(origin: TUIVec2(x: axisOffset + 2 + x, y: maximum - 4 - (i * 8)),
// size: TUISize(width: axisOffset + 2 + axisWidth - reduce - x, height: 3))
// view.drawRectangle(rect: rect, color: color1)
// }
for x in stride(from: 0, to: axisWidth - reduce, by: 1)
{
let from = TUIVec2(x: axisOffset + 4 + x, y: maximum - 4 - (i * 8))
let to = TUIVec2(x: axisOffset + 4 + x, y: maximum - 1 - (i * 8))
let nc = nextColor(color1: color1, color2: color2, percent: Double(x) / Double(width))
view.drawLine(from: from, to: to, color: nc)
}
}
let param = TUIRenderParameter(colorspace: .foreground256, composite: .first, style: .drawille)
view.draw(parameters: param)
}
/*
Features of bar chart
- Border;
- TUIBorders
- Drawille
- None
- Graph Axis
- Style: TUIBorders, Drawille, None
- Axis Style: Left / Bottom, Right / Bottom, All Sides
- Ticks: inset, outset, width
- Tick Interval: Major, Minor
- Legend:
- Position: Top, Bottom, None
- Border: TUIBorders, Drawille, None
- Bar Type: Horizontal, Vertical, Stacked Horizontal, Stack Vertical
- Bar Character: Drawille, custom
- Render options: bar separate from axis, border and legend
- Value location: Above or Right of bars, below Axis or left of axis, none
- Color: Bar, Border, Legend, Text, Value
*/
|
mit
|
b73cce8615ff6cea15da38ce2f4f6e1d
| 28.908629 | 105 | 0.573489 | 3.08967 | false | false | false | false |
dduan/swift
|
stdlib/public/core/Boolean.swift
|
3
|
1894
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 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 the list of Swift project authors
//
//===----------------------------------------------------------------------===//
// Boolean
//===----------------------------------------------------------------------===//
/// Returns the result of inverting `a`'s logic value.
@warn_unused_result
public prefix func !<T : Boolean>(a: T) -> Bool {
return !a.boolValue
}
/// If `lhs` is `false`, return it. Otherwise, evaluate `rhs` and
/// return its `boolValue`.
@inline(__always)
@warn_unused_result
public func && <T : Boolean, U : Boolean>(
lhs: T, @autoclosure rhs: () throws -> U
) rethrows -> Bool {
return lhs.boolValue ? try rhs().boolValue : false
}
/// If `lhs` is `true`, return it. Otherwise, evaluate `rhs` and
/// return its `boolValue`.
@inline(__always)
@warn_unused_result
public func || <T : Boolean, U : Boolean>(
lhs: T, @autoclosure rhs: () throws -> U
) rethrows -> Bool {
return lhs.boolValue ? true : try rhs().boolValue
}
// FIXME: We can't make the above @_transparent due to
// rdar://problem/19418937, so here are some @_transparent overloads
// for Bool. We've done the same for ObjCBool.
@_transparent
@warn_unused_result
public func && <T : Boolean>(
lhs: T, @autoclosure rhs: () throws -> Bool
) rethrows -> Bool {
return lhs.boolValue ? try rhs().boolValue : false
}
@_transparent
@warn_unused_result
public func || <T : Boolean>(
lhs: T, @autoclosure rhs: () throws -> Bool
) rethrows -> Bool {
return lhs.boolValue ? true : try rhs().boolValue
}
|
apache-2.0
|
77f97017924f90bbfdc3db839792f3dc
| 31.655172 | 80 | 0.590813 | 4.012712 | false | false | false | false |
vmanot/swift-package-manager
|
Sources/PackageDescription4/Product.swift
|
1
|
2637
|
/*
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 http://swift.org/LICENSE.txt for license information
See http://swift.org/CONTRIBUTORS.txt for Swift project authors
*/
/// Defines a product in the package.
public class Product {
/// The name of the product.
public let name: String
init(name: String) {
self.name = name
}
func toJSON() -> JSON {
fatalError("Should be implemented by subclasses")
}
/// Represents an executable product.
public final class Executable: Product {
/// The names of the targets in this product.
public let targets: [String]
init(name: String, targets: [String]) {
self.targets = targets
super.init(name: name)
}
override func toJSON() -> JSON {
return .dictionary([
"name": .string(name),
"product_type": .string("executable"),
"targets": .array(targets.map(JSON.string)),
])
}
}
/// Represents a library product.
public final class Library: Product {
/// The type of library product.
public enum LibraryType: String {
case `static`
case `dynamic`
}
/// The names of the targets in this product.
public let targets: [String]
/// The type of the library.
///
/// If the type is unspecified, package manager will automatically choose a type.
public let type: LibraryType?
init(name: String, type: LibraryType? = nil, targets: [String]) {
self.type = type
self.targets = targets
super.init(name: name)
}
override func toJSON() -> JSON {
return .dictionary([
"name": .string(name),
"product_type": .string("library"),
"type": type.map({ JSON.string($0.rawValue) }) ?? .null,
"targets": .array(targets.map(JSON.string)),
])
}
}
/// Create a libary product.
public static func library(
name: String,
type: Library.LibraryType? = nil,
targets: [String]
) -> Product {
return Library(name: name, type: type, targets: targets)
}
/// Create an executable product.
public static func executable(
name: String,
targets: [String]
) -> Product {
return Executable(name: name, targets: targets)
}
}
|
apache-2.0
|
ecc239526a2a472eb6ac501e3f106f9b
| 27.053191 | 89 | 0.565415 | 4.578125 | false | false | false | false |
russbishop/swift
|
validation-test/Reflection/reflect_NSArray.swift
|
1
|
1335
|
// RUN: rm -rf %t && mkdir -p %t
// RUN: %target-build-swift -lswiftSwiftReflectionTest %s -o %t/reflect_NSArray
// RUN: %target-run %target-swift-reflection-test %t/reflect_NSArray 2>&1 | FileCheck %s --check-prefix=CHECK-%target-ptrsize
// REQUIRES: objc_interop
// REQUIRES: executable_test
import SwiftReflectionTest
import Foundation
class TestClass {
var t: NSArray
init(t: NSArray) {
self.t = t
}
}
var obj = TestClass(t: [1, 2, 3])
reflect(object: obj)
// CHECK-64: Reflecting an object.
// CHECK-64: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}}
// CHECK-64: Type reference:
// CHECK-64: (class reflect_NSArray.TestClass)
// CHECK-64: Type info:
// CHECK-64: (class_instance size=24 alignment=16 stride=32 num_extra_inhabitants=0
// CHECK-64: (field name=t offset=16
// CHECK-64: (reference kind=strong refcounting=unknown)))
// CHECK-32: Reflecting an object.
// CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}}
// CHECK-32: Type reference:
// CHECK-32: (class reflect_NSArray.TestClass)
// CHECK-32: Type info:
// CHECK-32: (class_instance size=16 alignment=16 stride=16 num_extra_inhabitants=0
// CHECK-32: (field name=t offset=12
// CHECK-32: (reference kind=strong refcounting=unknown)))
doneReflecting()
// CHECK-64: Done.
// CHECK-32: Done.
|
apache-2.0
|
ba4df5baae8e092066fd0ad1319cd689
| 28.666667 | 125 | 0.689888 | 3.156028 | false | true | false | false |
siberianisaev/NeutronBarrel
|
NeutronBarrel/Logger.swift
|
1
|
5421
|
//
// Logger.swift
// NeutronBarrel
//
// Created by Andrey Isaev on 27.12.14.
// Copyright (c) 2018 Flerov Laboratory. All rights reserved.
//
import Cocoa
enum LoggerDestination {
case results, gammaAll, gammaGeOnly
}
class Logger {
fileprivate var resultsCSVWriter: CSVWriter
fileprivate var gammaAllCSVWriter: CSVWriter
fileprivate var gammaGeOnlyCSVWriter: CSVWriter
fileprivate var statisticsCSVWriter: CSVWriter
fileprivate var folderName: String
fileprivate var timeStamp: String
fileprivate var dateFormatter: DateFormatter?
init(folder: String) {
let stamp = String.timeStamp()
let name = folder.count > 0 ? folder : stamp
folderName = name
timeStamp = stamp
resultsCSVWriter = CSVWriter(path: FileManager.resultsFilePath(stamp, folderName: name))
gammaAllCSVWriter = CSVWriter(path: FileManager.filePath("gamma_all", timeStamp: stamp, folderName: name))
gammaGeOnlyCSVWriter = CSVWriter(path: FileManager.filePath("gamma_Ge_only", timeStamp: stamp, folderName: name))
statisticsCSVWriter = CSVWriter(path: FileManager.statisticsFilePath(stamp, folderName: name))
let f = DateFormatter()
f.calendar = Calendar(identifier: .gregorian)
f.locale = Locale(identifier: "en_US_POSIX")
f.timeZone = TimeZone(secondsFromGMT: 0)
f.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZ"
dateFormatter = f
}
fileprivate func writerFor(destination: LoggerDestination) -> CSVWriter {
switch destination {
case .results:
return resultsCSVWriter
case .gammaAll:
return gammaAllCSVWriter
case .gammaGeOnly:
return gammaGeOnlyCSVWriter
}
}
func writeLineOfFields(_ fields: [AnyObject]?, destination: LoggerDestination) {
writerFor(destination: destination).writeLineOfFields(fields)
}
func writeField(_ field: AnyObject?, destination: LoggerDestination) {
writerFor(destination: destination).writeField(field)
}
func finishLine(_ destination: LoggerDestination) {
writerFor(destination: destination).finishLine()
}
fileprivate func logString(_ string: String, path: String?) {
if let path = path {
do {
try string.write(toFile: path, atomically: false, encoding: String.Encoding.utf8)
} catch {
print("Error writing to file \(path): \(error)")
}
}
}
func log(multiplicity: NeutronsMultiplicity) {
logString(multiplicity.stringValue(), path: FileManager.multiplicityFilePath(timeStamp, folderName: folderName))
}
func logCalibration(_ string: String) {
logString(string, path: FileManager.calibrationFilePath(timeStamp, folderName: folderName))
}
func logStatistics(_ folders: [String: FolderStatistics]) {
let headers = ["Folder", "First File", "Last File", "First File Created On", "Last File Created On", "~ Folder Last Modified", "Median Energy", "Median Current", "Total Integral", "Calculation Time", "Last Cycle Time (s)", "Correlations"]
statisticsCSVWriter.writeLineOfFields(headers as [AnyObject])
statisticsCSVWriter.finishLine()
let statistics = Array(folders.values).sorted { (fs1: FolderStatistics, fs2: FolderStatistics) -> Bool in
return (fs1.name ?? "") < (fs2.name ?? "")
}
func stringFrom(_ date: Date?) -> String {
return dateFormatter?.string(from: date ?? Date()) ?? ""
}
for folder in statistics {
let name = folder.name ?? ""
let firstCreatedOn = stringFrom(folder.firstFileCreatedOn)
let lastCreatedOn = stringFrom(folder.lastFileCreatedOn)
let firstFile = folder.files.first ?? ""
let lastFile = folder.files.last ?? ""
let energy = String(folder.medianEnergy)
let current = String(folder.medianCurrent)
let integral = String(folder.integral)
let calculationTime = abs(folder.calculationsStart?.timeIntervalSince(folder.calculationsEnd ?? Date()) ?? 0).stringFromSeconds()
let secondsFromStart = folder.secondsFromStart
let lastModified = stringFrom(folder.firstFileCreatedOn?.addingTimeInterval(secondsFromStart))
let correlations = String(folder.correlationsTotal)
let values = [name, firstFile, lastFile, firstCreatedOn, lastCreatedOn, lastModified, energy, current, integral, calculationTime, secondsFromStart, correlations] as [AnyObject]
statisticsCSVWriter.writeLineOfFields(values)
}
statisticsCSVWriter.finishLine()
}
func logSettings() {
if let path = FileManager.settingsFilePath(timeStamp, folderName: folderName) {
let url = URL(fileURLWithPath: path)
Settings.writeToFile(url)
}
}
func logInput(_ image: NSImage?, onEnd: Bool) {
if let path = FileManager.inputFilePath(timeStamp, folderName: folderName, onEnd: onEnd) {
let url = URL.init(fileURLWithPath: path)
do {
try image?.imagePNGRepresentation()?.write(to: url)
} catch {
print("Error writing to file \(path): \(error)")
}
}
}
}
|
mit
|
58a6af017f2a07574ed8dc2e9b4d6b58
| 40.381679 | 246 | 0.646191 | 4.661221 | false | false | false | false |
benlangmuir/swift
|
test/Distributed/Inputs/FakeDistributedActorSystems.swift
|
7
|
12398
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2021 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import Distributed
// ==== Fake Address -----------------------------------------------------------
public struct ActorAddress: Hashable, Sendable, Codable {
public let address: String
public init(parse address: String) {
self.address = address
}
public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
self.address = try container.decode(String.self)
}
public func encode(to encoder: Encoder) throws {
var container = encoder.singleValueContainer()
try container.encode(self.address)
}
}
// ==== Noop Transport ---------------------------------------------------------
@available(SwiftStdlib 5.7, *)
public struct FakeActorSystem: DistributedActorSystem, CustomStringConvertible {
public typealias ActorID = ActorAddress
public typealias InvocationDecoder = FakeInvocationDecoder
public typealias InvocationEncoder = FakeInvocationEncoder
public typealias SerializationRequirement = Codable
public typealias ResultHandler = FakeRoundtripResultHandler
// just so that the struct does not become "trivial"
let someValue: String = ""
let someValue2: String = ""
let someValue3: String = ""
let someValue4: String = ""
public init() {
print("Initialized new FakeActorSystem")
}
public func resolve<Act>(id: ActorID, as actorType: Act.Type) throws -> Act?
where Act: DistributedActor,
Act.ID == ActorID {
nil
}
public func assignID<Act>(_ actorType: Act.Type) -> ActorID
where Act: DistributedActor,
Act.ID == ActorID {
ActorAddress(parse: "xxx")
}
public func actorReady<Act>(_ actor: Act)
where Act: DistributedActor,
Act.ID == ActorID {
}
public func resignID(_ id: ActorID) {
}
public func makeInvocationEncoder() -> InvocationEncoder {
.init()
}
public func remoteCall<Act, Err, Res>(
on actor: Act,
target: RemoteCallTarget,
invocation invocationEncoder: inout InvocationEncoder,
throwing: Err.Type,
returning: Res.Type
) async throws -> Res
where Act: DistributedActor,
Act.ID == ActorID,
Err: Error,
Res: SerializationRequirement {
throw ExecuteDistributedTargetError(message: "\(#function) not implemented.")
}
public func remoteCallVoid<Act, Err>(
on actor: Act,
target: RemoteCallTarget,
invocation invocationEncoder: inout InvocationEncoder,
throwing: Err.Type
) async throws
where Act: DistributedActor,
Act.ID == ActorID,
Err: Error {
throw ExecuteDistributedTargetError(message: "\(#function) not implemented.")
}
public nonisolated var description: Swift.String {
"\(Self.self)()"
}
}
// ==== Fake Roundtrip Transport -----------------------------------------------
// TODO(distributed): not thread safe...
@available(SwiftStdlib 5.7, *)
public final class FakeRoundtripActorSystem: DistributedActorSystem, @unchecked Sendable {
public typealias ActorID = ActorAddress
public typealias InvocationEncoder = FakeInvocationEncoder
public typealias InvocationDecoder = FakeInvocationDecoder
public typealias SerializationRequirement = Codable
public typealias ResultHandler = FakeRoundtripResultHandler
var activeActors: [ActorID: any DistributedActor] = [:]
public init() {}
public func resolve<Act>(id: ActorID, as actorType: Act.Type)
throws -> Act? where Act: DistributedActor {
print("| resolve \(id) as remote // this system always resolves as remote")
return nil
}
public func assignID<Act>(_ actorType: Act.Type) -> ActorID
where Act: DistributedActor {
let id = ActorAddress(parse: "<unique-id>")
print("| assign id: \(id) for \(actorType)")
return id
}
public func actorReady<Act>(_ actor: Act)
where Act: DistributedActor,
Act.ID == ActorID {
print("| actor ready: \(actor)")
self.activeActors[actor.id] = actor
}
public func resignID(_ id: ActorID) {
print("X resign id: \(id)")
}
public func makeInvocationEncoder() -> InvocationEncoder {
.init()
}
private var remoteCallResult: Any? = nil
private var remoteCallError: Error? = nil
public func remoteCall<Act, Err, Res>(
on actor: Act,
target: RemoteCallTarget,
invocation: inout InvocationEncoder,
throwing errorType: Err.Type,
returning returnType: Res.Type
) async throws -> Res
where Act: DistributedActor,
Act.ID == ActorID,
Err: Error,
Res: SerializationRequirement {
print(" >> remoteCall: on:\(actor), target:\(target), invocation:\(invocation), throwing:\(String(reflecting: errorType)), returning:\(String(reflecting: returnType))")
guard let targetActor = activeActors[actor.id] else {
fatalError("Attempted to call mock 'roundtrip' on: \(actor.id) without active actor")
}
func doIt<A: DistributedActor>(active: A) async throws -> Res {
guard (actor.id) == active.id as! ActorID else {
fatalError("Attempted to call mock 'roundtrip' on unknown actor: \(actor.id), known: \(active.id)")
}
let resultHandler = FakeRoundtripResultHandler { value in
self.remoteCallResult = value
self.remoteCallError = nil
} onError: { error in
self.remoteCallResult = nil
self.remoteCallError = error
}
var decoder = invocation.makeDecoder()
try await executeDistributedTarget(
on: active,
target: target,
invocationDecoder: &decoder,
handler: resultHandler
)
switch (remoteCallResult, remoteCallError) {
case (.some(let value), nil):
print(" << remoteCall return: \(value)")
return remoteCallResult! as! Res
case (nil, .some(let error)):
print(" << remoteCall throw: \(error)")
throw error
default:
fatalError("No reply!")
}
}
return try await _openExistential(targetActor, do: doIt)
}
public func remoteCallVoid<Act, Err>(
on actor: Act,
target: RemoteCallTarget,
invocation: inout InvocationEncoder,
throwing errorType: Err.Type
) async throws
where Act: DistributedActor,
Act.ID == ActorID,
Err: Error {
print(" >> remoteCallVoid: on:\(actor), target:\(target), invocation:\(invocation), throwing:\(String(reflecting: errorType))")
guard let targetActor = activeActors[actor.id] else {
fatalError("Attempted to call mock 'roundtrip' on: \(actor.id) without active actor")
}
func doIt<A: DistributedActor>(active: A) async throws {
guard (actor.id) == active.id as! ActorID else {
fatalError("Attempted to call mock 'roundtrip' on unknown actor: \(actor.id), known: \(active.id)")
}
let resultHandler = FakeRoundtripResultHandler { value in
self.remoteCallResult = value
self.remoteCallError = nil
} onError: { error in
self.remoteCallResult = nil
self.remoteCallError = error
}
var decoder = invocation.makeDecoder()
try await executeDistributedTarget(
on: active,
target: target,
invocationDecoder: &decoder,
handler: resultHandler
)
switch (remoteCallResult, remoteCallError) {
case (.some, nil):
return
case (nil, .some(let error)):
print(" << remoteCall throw: \(error)")
throw error
default:
fatalError("No reply!")
}
}
try await _openExistential(targetActor, do: doIt)
}
}
@available(SwiftStdlib 5.7, *)
public struct FakeInvocationEncoder : DistributedTargetInvocationEncoder {
public typealias SerializationRequirement = Codable
var genericSubs: [Any.Type] = []
var arguments: [Any] = []
var returnType: Any.Type? = nil
var errorType: Any.Type? = nil
public mutating func recordGenericSubstitution<T>(_ type: T.Type) throws {
print(" > encode generic sub: \(String(reflecting: type))")
genericSubs.append(type)
}
public mutating func recordArgument<Value: SerializationRequirement>(
_ argument: RemoteCallArgument<Value>) throws {
print(" > encode argument name:\(argument.label ?? "_"), value: \(argument.value)")
arguments.append(argument.value)
}
public mutating func recordErrorType<E: Error>(_ type: E.Type) throws {
print(" > encode error type: \(String(reflecting: type))")
self.errorType = type
}
public mutating func recordReturnType<R: SerializationRequirement>(_ type: R.Type) throws {
print(" > encode return type: \(String(reflecting: type))")
self.returnType = type
}
public mutating func doneRecording() throws {
print(" > done recording")
}
public func makeDecoder() -> FakeInvocationDecoder {
return .init(
args: arguments,
substitutions: genericSubs,
returnType: returnType,
errorType: errorType
)
}
}
// === decoding --------------------------------------------------------------
// !!! WARNING !!!
// This is a 'final class' on purpose, to see that we retain the ad-hoc witness
// for 'decodeNextArgument'; Do not change it to just a class!
@available(SwiftStdlib 5.7, *)
public final class FakeInvocationDecoder: DistributedTargetInvocationDecoder {
public typealias SerializationRequirement = Codable
var genericSubs: [Any.Type] = []
var arguments: [Any] = []
var returnType: Any.Type? = nil
var errorType: Any.Type? = nil
var argumentIndex: Int = 0
fileprivate init(
args: [Any],
substitutions: [Any.Type] = [],
returnType: Any.Type? = nil,
errorType: Any.Type? = nil
) {
self.arguments = args
self.genericSubs = substitutions
self.returnType = returnType
self.errorType = errorType
}
public func decodeGenericSubstitutions() throws -> [Any.Type] {
print(" > decode generic subs: \(genericSubs)")
return genericSubs
}
public func decodeNextArgument<Argument: SerializationRequirement>() throws -> Argument {
guard argumentIndex < arguments.count else {
fatalError("Attempted to decode more arguments than stored! Index: \(argumentIndex), args: \(arguments)")
}
let anyArgument = arguments[argumentIndex]
guard let argument = anyArgument as? Argument else {
fatalError("Cannot cast argument\(anyArgument) to expected \(Argument.self)")
}
print(" > decode argument: \(argument)")
argumentIndex += 1
return argument
}
public func decodeErrorType() throws -> Any.Type? {
print(" > decode return type: \(errorType.map { String(reflecting: $0) } ?? "nil")")
return self.errorType
}
public func decodeReturnType() throws -> Any.Type? {
print(" > decode return type: \(returnType.map { String(reflecting: $0) } ?? "nil")")
return self.returnType
}
}
@available(SwiftStdlib 5.7, *)
public struct FakeRoundtripResultHandler: DistributedTargetInvocationResultHandler {
public typealias SerializationRequirement = Codable
let storeReturn: (any Any) -> Void
let storeError: (any Error) -> Void
init(_ storeReturn: @escaping (Any) -> Void, onError storeError: @escaping (Error) -> Void) {
self.storeReturn = storeReturn
self.storeError = storeError
}
public func onReturn<Success: SerializationRequirement>(value: Success) async throws {
print(" << onReturn: \(value)")
storeReturn(value)
}
public func onReturnVoid() async throws {
print(" << onReturnVoid: ()")
storeReturn(())
}
public func onThrow<Err: Error>(error: Err) async throws {
print(" << onThrow: \(error)")
storeError(error)
}
}
// ==== Helpers ----------------------------------------------------------------
@available(SwiftStdlib 5.7, *)
@_silgen_name("swift_distributed_actor_is_remote")
func __isRemoteActor(_ actor: AnyObject) -> Bool
@available(SwiftStdlib 5.7, *)
func __isLocalActor(_ actor: AnyObject) -> Bool {
return !__isRemoteActor(actor)
}
|
apache-2.0
|
b2b85230322809fc8b2ab509d8a07985
| 29.995 | 173 | 0.648169 | 4.448511 | false | false | false | false |
malaonline/iOS
|
mala-ios/View/TeacherFilterView/FilterView.swift
|
1
|
9178
|
//
// FilterCollectionView.swift
// mala-ios
//
// Created by Elors on 1/16/16.
// Copyright © 2016 Mala Online. All rights reserved.
//
import UIKit
class FilterView: UIScrollView, UIScrollViewDelegate {
// MARK: - Property
/// 父容器
weak var container: TeacherFilterPopupWindow?
/// 年级及下属科目数据源
var grades: [GradeModel]? = nil {
didSet {
self.gradeView.grades = grades
}
}
/// 当前显示科目数据源
var subjects: [GradeModel]? = nil {
didSet {
self.subjectView.subjects = subjects
}
}
/// 风格数据源
var tags: [BaseObjectModel]? = nil {
didSet {
self.styleView.tagsModel = tags
}
}
/// 当前显示面板下标标记
var currentIndex: Int = 1
/// 二级选择标识
var isSecondaryFilter: Bool = false
// MARK: - Components
/// 年级筛选面板
private lazy var gradeView: GradeFilterView = {
let gradeView = GradeFilterView(frame: CGRect.zero,
collectionViewLayout: CommonFlowLayout(type: .filterView),
didTapCallBack: { [weak self] (model) -> () in
MalaCondition.grade = model!
// 如果为一次筛选
if !(self?.isSecondaryFilter ?? false) {
self?.scrollToPanel(2, animated: true)
// 根据所选年级，加载对应的科目
self?.subjects = model!.subjects.map({ (i: NSNumber) -> GradeModel in
let subject = GradeModel()
subject.id = i.intValue
subject.name = MalaConfig.malaSubject()[i.intValue]
return subject
})
}else {
self?.commitCondition()
}
})
return gradeView
}()
/// 科目筛选面板
private lazy var subjectView: SubjectFilterView = {
let subjectView = SubjectFilterView(frame: CGRect.zero,
collectionViewLayout: CommonFlowLayout(type: .subjectView),
didTapCallBack: { [weak self] (model) -> () in
MalaCondition.subject = model!
// 如果为一次筛选
if !(self?.isSecondaryFilter ?? false) {
self?.scrollToPanel(3, animated: true)
}else {
self?.commitCondition()
}
})
return subjectView
}()
/// 风格筛选面板
private lazy var styleView: StyleFilterView = {
let styleView = StyleFilterView(
frame: CGRect(x: 0, y: 0, width: MalaLayout_FilterContentWidth, height: MalaLayout_FilterContentWidth),
tags: []
)
return styleView
}()
/// 观察者对象数组
var observers: [AnyObject] = []
// MARK: - Constructed
override init(frame: CGRect) {
super.init(frame: frame)
configuration()
registerNotification()
setupUserInterface()
loadFilterCondition()
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
/// 滚动到指定面板
///
/// - parameter page: 面板下标，起始为1
func scrollToPanel(_ page: Int, animated: Bool) {
switch page {
case 1:
// 当前显示View为 年级筛选
currentIndex = 1
container?.tTitle = "筛选年级"
container?.tIcon = "grade"
container?.setButtonStatus(showClose: true, showCancel: false, showConfirm: false)
setContentOffset(CGPoint(x: 0, y: 0), animated: animated)
case 2:
// 当前显示View为 科目筛选
currentIndex = 2
container?.tTitle = "筛选科目"
container?.tIcon = "subject"
container?.setButtonStatus(showClose: false, showCancel: true, showConfirm: false)
setContentOffset(CGPoint(x: MalaLayout_FilterContentWidth, y: 0), animated: animated)
case 3:
// 当前显示View为 风格筛选
currentIndex = 3
container?.tTitle = "筛选风格"
container?.tIcon = "style"
container?.setButtonStatus(showClose: false, showCancel: true, showConfirm: true)
setContentOffset(CGPoint(x: MalaLayout_FilterContentWidth*2, y: 0), animated: animated)
default:
break
}
container?.setPageControl(page-1)
}
// MARK: - Private Method
private func configuration() {
self.contentSize = CGSize(width: MalaLayout_FilterContentWidth*3, height: MalaLayout_FilterContentWidth-3)
self.isScrollEnabled = false
self.delegate = self
self.bounces = false
self.showsHorizontalScrollIndicator = false
}
private func registerNotification() {
// pop页面通知处理
let observerPopFilterView = NotificationCenter.default.addObserver(
forName: MalaNotification_PopFilterView,
object: nil,
queue: nil
) { [weak self] (notification) -> Void in
// pop当前面板
self?.scrollToPanel((self?.currentIndex ?? 2) - 1, animated: true)
}
observers.append(observerPopFilterView)
// 确认按钮点击通知处理
let observerConfirm = NotificationCenter.default.addObserver(
forName: MalaNotification_ConfirmFilterView,
object: nil,
queue: nil) { [weak self] (notification) -> Void in
// 将选中字符串数组遍历为对象数组
let tagsCondition = self?.styleView.selectedItems.map({ (string: String) -> BaseObjectModel in
var tagObject = BaseObjectModel()
for object in self?.tags ?? [] {
if object.name == string {
tagObject = object
}
}
return tagObject
})
MalaFilterIndexObject.tags = self?.styleView.selectedItems ?? []
MalaCondition.tags = tagsCondition ?? []
self?.commitCondition()
}
observers.append(observerConfirm)
}
private func setupUserInterface() {
// SubViews
addSubview(gradeView)
addSubview(subjectView)
addSubview(styleView)
// Autolayout
gradeView.snp.makeConstraints { (maker) -> Void in
maker.top.equalTo(self)
maker.left.equalTo(self)
maker.width.equalTo(self)
maker.height.equalTo(self)
}
subjectView.snp.makeConstraints { (maker) -> Void in
maker.top.equalTo(self)
maker.left.equalTo(self).offset(MalaLayout_FilterContentWidth)
maker.width.equalTo(self)
maker.height.equalTo(self)
}
styleView.snp.makeConstraints { (maker) -> Void in
maker.top.equalTo(self)
maker.left.equalTo(subjectView).offset(MalaLayout_FilterContentWidth)
maker.width.equalTo(self)
maker.height.equalTo(self)
}
backgroundColor = UIColor.lightGray
}
private func commitCondition() {
NotificationCenter.default.post(name: MalaNotification_CommitCondition, object: nil)
self.container?.close()
}
private func loadFilterCondition() {
// 读取年级和科目数据
let dataArray = NSArray(contentsOfFile: Bundle.main.path(forResource: "FilterCondition.plist", ofType: nil)!) as [AnyObject]?
var gradeDict: [GradeModel]? = []
for object in dataArray! {
if let dict = object as? [String: AnyObject] {
let set = GradeModel(dict: dict)
gradeDict?.append(set)
}
}
self.grades = gradeDict
// 设置默认科目数据
let subjects = grades![2].subjects.map({ (i: NSNumber) -> GradeModel in
let subject = GradeModel()
subject.id = i.intValue
subject.name = MalaConfig.malaSubject()[i.intValue]
return subject
})
self.subjectView.subjects = subjects
// 获取风格标签
MAProvider.loadTags { tags in
self.tags = tags
}
}
deinit {
println("FilterView Deinit")
// 移除观察者
for observer in observers {
NotificationCenter.default.removeObserver(observer)
self.observers.remove(at: 0)
}
}
}
/// 筛选条件选择下标
open class filterSelectedIndexObject: NSObject {
var gradeIndexPath = IndexPath()
var subjectIndexPath = IndexPath()
var tags: [String] = []
/// 重置
func reset() {
gradeIndexPath = IndexPath()
subjectIndexPath = IndexPath()
tags = []
}
}
|
mit
|
e2254647cc7d9e519ac95b956699a931
| 31.700375 | 133 | 0.547818 | 4.694086 | false | false | false | false |
halo/biosphere
|
Biosphere/Configuration/JSONReader.swift
|
1
|
1156
|
import Foundation
import os.log
class JSONReader {
private var path: String
private var url: URL {
return URL(fileURLWithPath: path)
}
var success: Bool {
return data != nil
}
var failure: Bool {
return !success
}
init(filePath: String) {
self.path = filePath
}
lazy var data: Data? = {
do {
Log.debug("Reading \(self.path)")
let result = try Data(contentsOf: self.url)
Log.debug("Content: \(result)")
Log.debug("Successfuly read it")
return result
} catch let error as NSError {
Log.debug(error.localizedDescription)
return nil
}
}()
lazy var dictionary: [String: Any] = {
guard let jsonData = self.data else {
Log.error("Missing JSON data to parse.")
return [String: Any]()
}
do {
let json = try JSONSerialization.jsonObject(with: jsonData, options: [])
if let object = json as? [String: Any] {
return object
} else {
Log.debug("JSON is not a Key-Value object")
}
} catch let error as NSError {
Log.error(error.localizedDescription)
}
return [String: Any]()
}()
}
|
mit
|
bff96abe4e502c1d12d38e089465d495
| 19.642857 | 78 | 0.596886 | 4 | false | false | false | false |
acrookston/ACRKeyboardObserver
|
ACRKeyboardObserver/ACRKeyboardObserver.swift
|
1
|
9399
|
//
// ACRKeyboardObserver.swift
// ACRKeyboardObserver
//
// Created by Andrew C on 1/30/16.
// Copyright © 2016 Andrew Crookston. All rights reserved.
//
import Foundation
public enum KeyboardState {
case hidden, visible, frameChanged, willHide, didHide, willShow, didShow
}
public struct KeyboardStatus {
public var state: KeyboardState
public var frame: CGRect?
public var animation: KeyboardAnimation?
public var view: UIView?
}
public struct KeyboardAnimation {
public var top: CGFloat
public var curve: UIViewAnimationCurve
public var duration: Double
public var option: UIViewAnimationOptions
}
public protocol ACRKeyboardObserverDelegate : class {
func keyboardChanged(_ status: KeyboardStatus)
}
public class ACRKeyboardObserver: NSObject {
public static var observer = ACRKeyboardObserver()
public var animation: KeyboardAnimation?
public var keyboardStatus = KeyboardStatus(state: .hidden, frame: nil, animation: nil, view: nil) {
didSet { updateDelegates() }
}
public func start() {
NotificationCenter.default.add(observer: self,
selector: #selector(keyboardDidChange),
name: .UIKeyboardDidChangeFrame)
NotificationCenter.default.add(observer: self,
selector: #selector(keyboardWillHide),
name: .UIKeyboardWillHide)
NotificationCenter.default.add(observer: self,
selector: #selector(keyboardDidHide),
name: .UIKeyboardDidHide)
NotificationCenter.default.add(observer: self,
selector: #selector(keyboardWillShow),
name: .UIKeyboardWillShow)
NotificationCenter.default.add(observer: self,
selector: #selector(keyboardDidShow),
name: .UIKeyboardDidShow)
}
public func stop() {
unregisterKeyboardObserver()
NotificationCenter.default.remove(observer: self, name: .UIKeyboardDidChangeFrame)
NotificationCenter.default.remove(observer: self, name: .UIKeyboardWillHide)
NotificationCenter.default.remove(observer: self, name: .UIKeyboardDidHide)
NotificationCenter.default.remove(observer: self, name: .UIKeyboardWillShow)
NotificationCenter.default.remove(observer: self, name: .UIKeyboardDidShow)
}
public func addDelegate(_ delegate: ACRKeyboardObserverDelegate) {
delegates.append(DelegateWrapper(delegate: delegate))
}
public func removeDelegate(_ delegate: ACRKeyboardObserverDelegate) {
var updated = [DelegateWrapper]()
for wrapper in delegates where wrapper.delegate !== delegate {
updated.append(wrapper)
}
delegates = updated
}
// MARK: - Private variables and structs
private struct DelegateWrapper {
weak var delegate: ACRKeyboardObserverDelegate?
func isValid() -> Bool {
return delegate != nil
}
}
private let KVOKey = "position"
private let inputViewPrefix = "<UIInput"
private let inputHostPrefix = "<UIInputSetHostView"
private var delegates = [DelegateWrapper]()
private var keyboard: UIView?
private override init() {
super.init()
registerKeyboardObserver()
}
deinit {
unregisterKeyboardObserver()
}
// MARK: - Notification callbacks
@objc func keyboardDidChange(_ notification: Notification) {
// Since we handle the keyboard frame KVO-style we don't want to send multiple FrameChanged
guard keyboard == nil else { return }
registerKeyboardObserver()
status(.frameChanged, notification: notification)
}
@objc func keyboardWillShow(_ notification: Notification) {
status(.willShow, notification: notification)
}
@objc func keyboardDidShow(_ notification: Notification) {
status(.didShow, notification: notification)
}
@objc func keyboardWillHide(_ notification: Notification) {
status(.willHide, notification: notification)
}
@objc func keyboardDidHide(_ notification: Notification) {
status(.didHide, notification: notification)
}
private func status(_ status: KeyboardState, notification: Notification?) {
animation = extractAnimation(notification)
keyboardStatus = KeyboardStatus(state: status,
frame: keyboard?.layer.frame,
animation: animation,
view: keyboard)
}
private func extractAnimation(_ notification: Notification?) -> KeyboardAnimation? {
guard notification != nil else { return nil }
if let info = (notification! as NSNotification).userInfo {
let keyboardFrame = (info[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue
let curveValue = info[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber
let durationValue = info[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber
if keyboardFrame == nil || curveValue == nil || durationValue == nil {
return nil
}
let app = UIApplication.shared
let height = keyboardFrame!.size.height
let screenHeight = UIScreen.main.bounds.size.height
let statusBarHeight = app.isStatusBarHidden ? 0 : app.statusBarFrame.size.height
let animateToHeight = screenHeight - height - statusBarHeight
let animationCurve = UIViewAnimationCurve(rawValue: Int(curveValue!.int32Value)) ?? .easeInOut
let animationDuration = Double(durationValue!.doubleValue)
let animationOption = UIViewAnimationOptions(rawValue: UInt(curveValue!.int32Value << 16))
// We bitshift animation curve << 16 to convert it from a view animation curve to a view animation option.
// The result is the secret undeclared animation curve that Apple introduced in iOS8.
return KeyboardAnimation(top: animateToHeight,
curve: animationCurve,
duration: animationDuration,
option: animationOption)
}
return nil
}
// MARK: - Handle delegates
private func updateDelegates() {
removeInvalidDelegates()
for wrapper in delegates {
if wrapper.isValid() {
wrapper.delegate?.keyboardChanged(keyboardStatus)
}
}
}
private func removeInvalidDelegates() {
var updated = [DelegateWrapper]()
for wrapper in delegates {
if wrapper.isValid() {
updated.append(wrapper)
}
}
delegates = updated
}
// MARK: - Handle keyboard view
private func getKeyboardView() -> UIView? {
guard UIApplication.shared.windows.count > 0 else { return nil }
for window in UIApplication.shared.windows {
// Because we cant get access to the UIPeripheral throught the SDK we use its UIView.
// UIPeripheral is a subclass of UIView anyway.
// Our keyboard will end up as a UIView reference to the UIPeripheral / UIInput we want.
// For iOS 8+ we have to look a level deeper than 4-7.
// UIPeripheral should work for iOS 4-7 (only confirmed in iOS 7). In 3.0 you would use "<UIKeyboard"
for view in window.subviews {
// If anybody needs iOS 7 support (does Swift even work on 7?) and wants to patch this, go ahead.
// if view.description.hasPrefix("<UIPeripheral") {
// registerKeyboardObserver(view)
// }
// iOS 8+
if view.description.hasPrefix(inputViewPrefix) {
for subview in view.subviews {
if subview.description.hasPrefix(inputHostPrefix) {
return subview
}
}
}
}
}
return nil
}
private func registerKeyboardObserver() {
unregisterKeyboardObserver()
keyboard = getKeyboardView()
keyboard?.layer.addObserver(self, forKeyPath: KVOKey, options: .initial, context: nil)
}
private func unregisterKeyboardObserver() {
guard let keyboard = keyboard else { return }
keyboard.layer.removeObserver(self, forKeyPath: KVOKey)
}
public override func observeValue(forKeyPath keyPath: String?,
of object: Any?,
change: [NSKeyValueChangeKey : Any]?,
context: UnsafeMutableRawPointer?) {
if keyboard != nil && object != nil && keyPath != nil {
if keyboard!.layer == (object as? CALayer) && KVOKey == keyPath! {
status(.frameChanged, notification: nil)
return
}
}
super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
}
}
|
mit
|
f201e3bbed92fa9116e41964655d5e96
| 36.895161 | 118 | 0.606512 | 5.658037 | false | false | false | false |
MichaelSelsky/TheBeatingAtTheGates
|
Carthage/Checkouts/VirtualGameController/Source/Framework/VgcStreamer.swift
|
1
|
17611
|
//
// VgcStreamer.swift
// VirtualGameController
//
// Created by Rob Reuss on 10/28/15.
// Copyright © 2015 Rob Reuss. All rights reserved.
//
import Foundation
#if !os(watchOS)
@objc internal protocol VgcStreamerDelegate {
func receivedNetServiceMessage(elementIdentifier: Int, elementValue: NSData)
optional func disconnect()
optional var deviceInfo: DeviceInfo! {get set}
optional var centralPublisher: VgcCentralPublisher! {get set}
optional func sendInvalidMessageSystemMessage()
}
class VgcStreamer: NSObject, NSNetServiceDelegate, NSStreamDelegate {
private var elements: Elements!
var delegate: VgcStreamerDelegate!
var delegateName: String
var malformedMessageCount: Int = 0
var totalMessageCount: Int = 0
var startTime: NSDate = NSDate()
var dataBuffer: NSMutableData = NSMutableData()
var expectedLength: Int = 0
var elementIdentifier: Int!
var nsStringBuffer: NSString = ""
var cycleCount: Int = 0
let logging = false
var lastTimeStamp = 0.0
init(delegate: VgcStreamerDelegate, delegateName: String) {
self.delegate = delegate
self.delegateName = delegateName
elements = VgcManager.elements
}
deinit {
vgcLogDebug("Streamer deinitalized")
}
func writeElement(element: Element, toStream:NSOutputStream) {
let messageData = element.dataMessage
if logging { vgcLogDebug("Sending Data for \(element.name):\(messageData.length) bytes") }
writeData(messageData, toStream: toStream)
if element.clearValueAfterTransfer {
element.clearValue()
}
}
func delayedWriteData(timer: NSTimer) {
let userInfo = timer.userInfo as! Dictionary<String, AnyObject>
let outputStream = (userInfo["stream"] as! NSOutputStream)
queueRetryTimer[outputStream]!.invalidate()
vgcLogDebug("Timer triggered to process data send queue (\(self.dataSendQueue.length) bytes) to stream \(outputStream) [\(NSDate().timeIntervalSince1970)]")
self.writeData(NSData(), toStream: outputStream)
}
// Two indicators for handling a busy send queue, both of which result in the message being appended
// to an NSMutableData var
var dataSendQueue = NSMutableData()
let lockQueueWriteData = dispatch_queue_create("net.simplyformed.lockQueueWriteData", nil)
var streamerIsBusy: Bool = false
var queueRetryTimer: [NSOutputStream: NSTimer] = [:]
func writeData(var data: NSData, toStream: NSOutputStream) {
if VgcManager.appRole == .Peripheral && VgcManager.peripheral == nil {
vgcLogDebug("Attempt to write without peripheral object setup, exiting")
return
}
// If no connection, clean-up queue and exit
if VgcManager.appRole == .Peripheral && VgcManager.peripheral.haveOpenStreamsToCentral == false {
vgcLogDebug("No connection so clearing write queue (\(self.dataSendQueue.length) bytes)")
dataSendQueue = NSMutableData()
return
}
struct PerformanceVars {
static var messagesSent: Float = 0
static var bytesSent: Int = 0
static var messagesQueued: Int = 0
static var lastPublicationOfPerformance = NSDate()
}
if !toStream.hasSpaceAvailable {
if logging { vgcLogDebug("OutputStream has no space/streamer is busy (Status: \(toStream.streamStatus.rawValue))") }
if data.length > 0 {
dispatch_sync(self.lockQueueWriteData) {
PerformanceVars.messagesQueued++
self.dataSendQueue.appendData(data)
}
if logging { vgcLogDebug("Appended data queue (\(self.dataSendQueue.length) bytes)") }
}
if self.dataSendQueue.length > 0 {
if queueRetryTimer[toStream] == nil || !queueRetryTimer[toStream]!.valid {
vgcLogDebug("Setting data queue retry timer (Stream: \(toStream))")
queueRetryTimer[toStream] = NSTimer.scheduledTimerWithTimeInterval(0.5, target: self, selector: "delayedWriteData:", userInfo: ["stream": toStream], repeats: false)
}
}
return
}
if self.dataSendQueue.length > 0 {
if logging { vgcLogDebug("Processing data queue (\(self.dataSendQueue.length) bytes)") }
dispatch_sync(self.lockQueueWriteData) {
self.dataSendQueue.appendData(data)
data = self.dataSendQueue
self.dataSendQueue = NSMutableData()
}
if queueRetryTimer[toStream] != nil { queueRetryTimer[toStream]!.invalidate() }
}
if data.length > 0 { PerformanceVars.messagesSent = PerformanceVars.messagesSent + 1.0 }
if VgcManager.performanceSamplingEnabled {
PerformanceVars.bytesSent += data.length
if Float(PerformanceVars.lastPublicationOfPerformance.timeIntervalSinceNow) < -(VgcManager.performanceSamplingDisplayFrequency) {
let messagesPerSecond: Float = PerformanceVars.messagesSent / VgcManager.performanceSamplingDisplayFrequency
let kbPerSecond: Float = (Float(PerformanceVars.bytesSent) / VgcManager.performanceSamplingDisplayFrequency) / 1000
vgcLogDebug("\(messagesPerSecond) msgs/sec, \(PerformanceVars.messagesQueued) msgs queued, \(kbPerSecond) kb/sec sent")
PerformanceVars.messagesSent = 0
PerformanceVars.lastPublicationOfPerformance = NSDate()
PerformanceVars.bytesSent = 0
PerformanceVars.messagesQueued = 0
}
}
streamerIsBusy = true
var bytesWritten: NSInteger = 0
if data.length == 0 {
vgcLogError("Attempt to send an empty buffer, exiting")
dispatch_sync(self.lockQueueWriteData) {
self.dataSendQueue = NSMutableData()
}
return
}
while (data.length > bytesWritten) {
let writeResult = toStream.write(UnsafePointer<UInt8>(data.bytes) + bytesWritten, maxLength: data.length - bytesWritten)
if writeResult == -1 {
vgcLogError("NSOutputStream returned -1")
return
} else {
bytesWritten += writeResult
}
}
if data.length != bytesWritten {
vgcLogError("Got data transfer size mismatch")
} else {
if data.length > 300 { vgcLogDebug("Large message sent (\(data.length) bytes, \(data.length / 1000) kb)") }
}
streamerIsBusy = false
}
func stream(aStream: NSStream, handleEvent eventCode: NSStreamEvent) {
struct PerformanceVars {
static var messagesReceived: Float = 0
static var bytesReceived: Int = 0
static var lastPublicationOfPerformance = NSDate()
static var invalidMessages: Float = 0
static var totalTransitTimeMeasurements: Double = 0
static var totalTransitTime: Double = 0
static var averageTransitTime: Double = 0
}
switch (eventCode){
case NSStreamEvent.HasBytesAvailable:
if logging { vgcLogDebug("Stream status: \(aStream.streamStatus.rawValue)") }
var bufferLoops = 0
let headerLength = VgcManager.netServiceHeaderLength
let inputStream = aStream as! NSInputStream
var buffer = Array<UInt8>(count: VgcManager.netServiceBufferSize, repeatedValue: 0)
while inputStream.hasBytesAvailable {
bufferLoops++
let len = inputStream.read(&buffer, maxLength: buffer.count)
if len <= 0 { return }
PerformanceVars.bytesReceived += len
if logging { vgcLogDebug("Length of buffer: \(len)") }
dataBuffer.appendData(NSData(bytes: &buffer, length: len))
}
if logging == true { vgcLogDebug("Buffer size is \(dataBuffer.length) (Cycle count: \(cycleCount)) ((Buffer loops: \(bufferLoops))") }
while dataBuffer.length > 0 {
// This shouldn't happen
if dataBuffer.length <= headerLength {
dataBuffer = NSMutableData()
vgcLogError("Streamer received data too short to have a header (\(dataBuffer.length) bytes)")
PerformanceVars.invalidMessages++
return
}
let headerIdentifier = dataBuffer.subdataWithRange(NSRange.init(location: 0, length: 4))
if headerIdentifier == headerIdentifierAsNSData {
var elementIdentifierUInt8: UInt8 = 0
let elementIdentifierNSData = dataBuffer.subdataWithRange(NSRange.init(location: 4, length: 1))
elementIdentifierNSData.getBytes(&elementIdentifierUInt8, length: sizeof(UInt8))
elementIdentifier = Int(elementIdentifierUInt8)
var expectedLengthUInt32: UInt32 = 0
let valueLengthNSData = dataBuffer.subdataWithRange(NSRange.init(location: 5, length: 4))
valueLengthNSData.getBytes(&expectedLengthUInt32, length: sizeof(UInt32))
expectedLength = Int(expectedLengthUInt32)
if VgcManager.netServiceLatencyLogging {
var timestampDouble: Double = 0
let timestampNSData = dataBuffer.subdataWithRange(NSRange.init(location: 9, length: 8))
timestampNSData.getBytes(×tampDouble, length: sizeof(Double))
let transitTime = round(1000 * (NSDate().timeIntervalSince1970 - timestampDouble))
//if timestampDouble < lastTimeStamp { vgcLogDebug("Time problem") }
//lastTimeStamp = timestampDouble
PerformanceVars.totalTransitTime += transitTime
PerformanceVars.totalTransitTimeMeasurements++
let averageTransitTime = PerformanceVars.totalTransitTime / PerformanceVars.totalTransitTimeMeasurements
let aboveAverageTransitTime = transitTime - averageTransitTime
let percentageAboveAverage = (averageTransitTime / transitTime) * 100
//if percentageAboveAverage > 40 { vgcLogDebug("Above average transit time: \(transitTime)ms by \(aboveAverageTransitTime), \(percentageAboveAverage)% above avg (Avg: \(averageTransitTime))") }
}
} else {
// This shouldn't happen
dataBuffer = NSMutableData()
vgcLogError("Streamer expected header but found no header identifier (\(dataBuffer.length) bytes)")
PerformanceVars.invalidMessages++
return
}
if expectedLength == 0 {
dataBuffer = NSMutableData()
vgcLogError("Streamer got expected length of zero")
PerformanceVars.invalidMessages++
return
}
var elementValueData = NSData()
if dataBuffer.length < (expectedLength + headerLength) {
if logging { vgcLogDebug("Streamer fetching additional data") }
break
}
elementValueData = dataBuffer.subdataWithRange(NSRange.init(location: headerLength, length: expectedLength))
let dataRemainingAfterCurrentElement = dataBuffer.subdataWithRange(NSRange.init(location: headerLength + expectedLength, length: dataBuffer.length - expectedLength - headerLength))
dataBuffer = NSMutableData(data: dataRemainingAfterCurrentElement)
if elementValueData.length == expectedLength {
// Performance testing is about calculating elements received per second
// By sending motion data, it can be compared to expected rates.
PerformanceVars.messagesReceived++
if VgcManager.performanceSamplingEnabled {
if Float(PerformanceVars.lastPublicationOfPerformance.timeIntervalSinceNow) < -(VgcManager.performanceSamplingDisplayFrequency) {
let messagesPerSecond: Float = PerformanceVars.messagesReceived / VgcManager.performanceSamplingDisplayFrequency
let kbPerSecond: Float = (Float(PerformanceVars.bytesReceived) / VgcManager.performanceSamplingDisplayFrequency) / 1000
//let invalidChecksumsPerSec: Float = (PerformanceVars.invalidChecksums / VgcManager.performanceSamplingDisplayFrequency)
vgcLogDebug("\(messagesPerSecond) msgs/sec, \(PerformanceVars.invalidMessages) invalid messages, \(kbPerSecond) kb/sec received")
PerformanceVars.messagesReceived = 0
PerformanceVars.invalidMessages = 0
PerformanceVars.lastPublicationOfPerformance = NSDate()
PerformanceVars.bytesReceived = 0
}
}
//if logging { vgcLogDebug("Got completed data transfer (\(elementValueData.length) of \(expectedLength))") }
let element = elements.elementFromIdentifier(elementIdentifier!)
if element == nil {
vgcLogError("Unrecognized element")
} else {
delegate.receivedNetServiceMessage(elementIdentifier!, elementValue: elementValueData)
}
elementIdentifier = nil
expectedLength = 0
} else {
if logging { vgcLogDebug("Streamer fetching additional data") }
}
}
break
case NSStreamEvent():
NSLog("Streamer: All Zeros")
break
case NSStreamEvent.OpenCompleted:
if aStream is NSInputStream {
vgcLogDebug("\(VgcManager.appRole) input stream is now open for \(delegateName)")
} else {
vgcLogDebug("\(VgcManager.appRole) output stream is now open for \(delegateName)")
}
break
case NSStreamEvent.HasSpaceAvailable:
//vgcLogDebug("HAS SPACE AVAILABLE")
break
case NSStreamEvent.ErrorOccurred:
vgcLogError("Stream ErrorOccurred: Event Code: \(eventCode) (Delegate Name: \(delegateName))")
delegate.disconnect!()
break
case NSStreamEvent.EndEncountered:
vgcLogDebug("Streamer: EndEncountered (Delegate Name: \(delegateName))")
delegate.disconnect!()
break
case NSStreamEvent.None:
vgcLogDebug("Streamer: Event None")
break
default:
NSLog("default")
}
}
func processDataMessage(dataMessage: NSString) {
}
func netService(sender: NSNetService, didUpdateTXTRecordData data: NSData) {
vgcLogDebug("CENTRAL: netService NetService didUpdateTXTRecordData")
}
func netServiceDidPublish(sender: NSNetService) {
if deviceIsTypeOfBridge() {
vgcLogDebug("Bridge streamer is now published on: \(sender.domain + sender.type + sender.name)")
} else {
vgcLogDebug("Central streamer is now published on: \(sender.domain + sender.type + sender.name)")
}
}
func netService(sender: NSNetService, didNotPublish errorDict: [String : NSNumber]) {
vgcLogDebug("CENTRAL: Net service did not publish, error: \(errorDict)")
}
func netServiceWillPublish(sender: NSNetService) {
vgcLogDebug("NetService will be published")
}
func netServiceWillResolve(sender: NSNetService) {
vgcLogDebug("CENTRAL: netServiceWillResolve")
}
func netService(sender: NSNetService, didNotResolve errorDict: [String : NSNumber]) {
vgcLogDebug("CENTRAL: netService didNotResolve: \(errorDict)")
}
func netServiceDidResolveAddress(sender: NSNetService) {
vgcLogDebug("CENTRAL: netServiceDidResolveAddress")
}
func netServiceDidStop(sender: NSNetService) {
vgcLogDebug("CENTRAL: netServiceDidStop")
}
}
#endif
|
mit
|
2a22e5ab0c54bf5b8228556c270ca841
| 40.631206 | 217 | 0.581488 | 5.87 | false | false | false | false |
nixzhu/SuperPreview
|
SuperPreview/PhotosViewController.swift
|
1
|
12320
|
//
// PhotosViewController.swift
// SuperPreview
//
// Created by NIX on 2016/11/28.
// Copyright © 2016年 nixWork. All rights reserved.
//
import UIKit
public enum PhotoDisplayMode {
case normal
case longImagefullScreen
}
open class PhotosViewController: UIViewController {
public var afterStatusBarAppearedAction: (() -> Void)?
private weak var delegate: PhotosViewControllerDelegate?
private let dataSource: PhotosViewControllerDataSource
public let photoDisplayMode: PhotoDisplayMode
private lazy var transitionController = PhotoTransitonController()
private var overlayActionViewWasHiddenBeforeTransition = false
private var heightAnchorConstraint: NSLayoutConstraint!
private lazy var overlayActionView: OverlayActionView = {
let view = OverlayActionView()
view.backgroundColor = UIColor.clear
view.shareAction = { [weak self] in
guard let strongSelf = self else { return }
guard let image = strongSelf.currentlyDisplayedPhoto?.image else { return }
Config.shareImageAction?(image, strongSelf)
}
return view
}()
private lazy var pageViewController: UIPageViewController = {
let vc = UIPageViewController(
transitionStyle: .scroll,
navigationOrientation: .horizontal,
options: [UIPageViewControllerOptionInterPageSpacingKey: 30])
vc.dataSource = self
vc.delegate = self
vc.view.backgroundColor = UIColor.clear
vc.view.addGestureRecognizer(self.panGestureRecognizer)
vc.view.addGestureRecognizer(self.singleTapGestureRecognizer)
return vc
}()
private var currentPhotoViewController: PhotoViewController? {
return pageViewController.viewControllers?.first as? PhotoViewController
}
private var currentlyDisplayedPhoto: Photo? {
return currentPhotoViewController?.photo
}
private var referenceForCurrentPhoto: Reference? {
guard let photo = currentlyDisplayedPhoto else {
return nil
}
return delegate?.photosViewController(self, referenceForPhoto: photo)
}
private lazy var panGestureRecognizer: UIPanGestureRecognizer = {
let pan = UIPanGestureRecognizer()
pan.addTarget(self, action: #selector(PhotosViewController.didPan(_:)))
return pan
}()
private lazy var singleTapGestureRecognizer: UITapGestureRecognizer = {
let tap = UITapGestureRecognizer()
tap.addTarget(self, action: #selector(PhotosViewController.didSingleTap(_:)))
return tap
}()
private var boundsCenterPoint: CGPoint {
return CGPoint(x: view.bounds.midX, y: view.bounds.midY)
}
deinit {
pageViewController.dataSource = nil
pageViewController.delegate = nil
}
// MARK: Init
public init(photos: [Photo], initialPhoto: Photo, delegate: PhotosViewControllerDelegate? = nil, preferredStatusBarStyle: UIStatusBarStyle = .default, photoDisplayMode: PhotoDisplayMode = .normal) {
self.dataSource = PhotosDataSource(photos: photos)
self.delegate = delegate
self._preferredStatusBarStyle = preferredStatusBarStyle
self.photoDisplayMode = photoDisplayMode
super.init(nibName: nil, bundle: nil)
self.modalPresentationStyle = .custom
self.transitioningDelegate = transitionController
self.modalPresentationCapturesStatusBarAppearance = true
let initialPhotoViewController: PhotoViewController
if dataSource.containsPhoto(initialPhoto) {
initialPhotoViewController = newPhotoViewControllerForPhoto(initialPhoto)
} else {
guard let firstPhoto = dataSource.photoAtIndex(0) else {
fatalError("Empty dataSource")
}
initialPhotoViewController = newPhotoViewControllerForPhoto(firstPhoto)
}
setCurrentlyDisplayedViewController(initialPhotoViewController, animated: false)
}
required public init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
private func setOverlayActionViewHidden(_ hidden: Bool, animated: Bool) {
guard overlayActionView.isHidden != hidden else {
return
}
if animated {
overlayActionView.isHidden = false
overlayActionView.alpha = hidden ? 1 : 0
UIView.animate(withDuration: 0.25, delay: 0, options: [.curveEaseIn, .curveEaseOut, .allowAnimatedContent, .allowUserInteraction], animations: { [weak self] in
self?.overlayActionView.alpha = hidden ? 0 : 1
}, completion: { [weak self] finished in
self?.overlayActionView.isHidden = hidden
})
} else {
overlayActionView.isHidden = hidden
}
}
private func newPhotoViewControllerForPhoto(_ photo: Photo) -> PhotoViewController {
let photoViewController = PhotoViewController(photo: photo, photoDisplayMode: photoDisplayMode)
singleTapGestureRecognizer.require(toFail: photoViewController.doubleTapGestureRecognizer)
return photoViewController
}
private func setCurrentlyDisplayedViewController(_ vc: PhotoViewController, animated: Bool) {
pageViewController.setViewControllers([vc], direction: .forward, animated: animated, completion: nil)
}
// MARK: Life Circle
override open func viewDidLoad() {
super.viewDidLoad()
view.tintColor = UIColor.white
view.backgroundColor = UIColor.black
do {
addChildViewController(pageViewController)
view.addSubview(pageViewController.view)
pageViewController.didMove(toParentViewController: self)
}
do {
view.addSubview(overlayActionView)
overlayActionView.translatesAutoresizingMaskIntoConstraints = false
let leading = overlayActionView.leadingAnchor.constraint(equalTo: view.leadingAnchor)
let trailing = overlayActionView.trailingAnchor.constraint(equalTo: view.trailingAnchor)
let bottom = overlayActionView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
heightAnchorConstraint = overlayActionView.heightAnchor.constraint(equalToConstant: 80)
NSLayoutConstraint.activate([leading, trailing, bottom, heightAnchorConstraint])
setOverlayActionViewHidden(true, animated: false)
}
do {
transitionController.setStartingReference(referenceForCurrentPhoto)
if currentlyDisplayedPhoto?.image != nil {
var endingReference: Reference?
if let imageView = currentPhotoViewController?.scalingImageView.imageView {
endingReference = Reference(view: imageView, image: imageView.image)
}
transitionController.setEndingReference(endingReference)
} else {
print("Warning: currentlyDisplayedPhoto.image is nil")
}
}
}
open override func viewSafeAreaInsetsDidChange() {
var bottomSpace: CGFloat = 0
if #available(iOS 11.0, *) {
bottomSpace = view.safeAreaInsets.bottom
}
heightAnchorConstraint.constant = 80 + bottomSpace
}
open override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) { [weak self] in
self?.statusBarHidden = true
}
}
open override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
if !overlayActionViewWasHiddenBeforeTransition {
setOverlayActionViewHidden(false, animated: true)
}
}
open override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
statusBarHidden = false
}
// MARK: Status Bar
private let _preferredStatusBarStyle: UIStatusBarStyle
open override var preferredStatusBarStyle: UIStatusBarStyle {
return _preferredStatusBarStyle
}
private var statusBarHidden: Bool = false {
didSet {
setNeedsStatusBarAppearanceUpdate()
if !statusBarHidden {
afterStatusBarAppearedAction?()
}
}
}
open override var prefersStatusBarHidden : Bool {
return statusBarHidden
}
open override var preferredStatusBarUpdateAnimation : UIStatusBarAnimation {
return .fade
}
// MARK: Selectors
@objc private func didPan(_ sender: UIPanGestureRecognizer) {
switch sender.state {
case .began:
transitionController.forcesNonInteractiveDismissal = false
dismissViewControllerAnimated(true, userInitiated: true, completion: nil)
default:
transitionController.forcesNonInteractiveDismissal = true
transitionController.didPanWithPanGestureRecognizer(sender, viewToPan: pageViewController.view, anchorPoint: boundsCenterPoint)
}
}
@objc private func didSingleTap(_ sender: UITapGestureRecognizer) {
//setOverlayActionViewHidden(!overlayActionView.hidden, animated: true)
dismissViewControllerAnimated(true, userInitiated: true, completion: nil)
}
// MARK: Dismissal
private func dismissViewControllerAnimated(_ animated: Bool, userInitiated: Bool, completion: (() -> Void)? = nil) {
if presentedViewController != nil {
dismiss(animated: animated, completion: completion)
return
}
var startingReference: Reference?
if let imageView = currentPhotoViewController?.scalingImageView.imageView {
startingReference = Reference(view: imageView, image: imageView.image)
}
transitionController.setStartingReference(startingReference)
transitionController.setEndingReference(referenceForCurrentPhoto)
let overlayActionViewWasHidden = overlayActionView.isHidden
self.overlayActionViewWasHiddenBeforeTransition = overlayActionViewWasHidden
setOverlayActionViewHidden(true, animated: animated)
delegate?.photosViewControllerWillDismiss(self)
dismiss(animated: animated) { [weak self] in
let isStillOnscreen = (self?.view.window != nil)
if (isStillOnscreen && !overlayActionViewWasHidden) {
self?.setOverlayActionViewHidden(false, animated: true)
}
if !isStillOnscreen {
if let vc = self {
vc.delegate?.photosViewControllerDidDismiss(vc)
}
}
completion?()
}
}
}
extension PhotosViewController: UIPageViewControllerDataSource {
public func pageViewController(_ pageViewController: UIPageViewController, viewControllerBefore viewController: UIViewController) -> UIViewController? {
guard let viewController = viewController as? PhotoViewController else { return nil }
let photoIndex = dataSource.indexOfPhoto(viewController.photo)
guard let previousPhoto = dataSource.photoAtIndex(photoIndex - 1) else { return nil }
return newPhotoViewControllerForPhoto(previousPhoto)
}
public func pageViewController(_ pageViewController: UIPageViewController, viewControllerAfter viewController: UIViewController) -> UIViewController? {
guard let viewController = viewController as? PhotoViewController else { return nil }
let photoIndex = dataSource.indexOfPhoto(viewController.photo)
guard let previousPhoto = dataSource.photoAtIndex(photoIndex + 1) else { return nil }
return newPhotoViewControllerForPhoto(previousPhoto)
}
}
extension PhotosViewController: UIPageViewControllerDelegate {
public func pageViewController(_ pageViewController: UIPageViewController, didFinishAnimating finished: Bool, previousViewControllers: [UIViewController], transitionCompleted completed: Bool) {
guard completed else { return }
if let photo = currentlyDisplayedPhoto {
let index = dataSource.indexOfPhoto(photo)
delegate?.photosViewController(self, didNavigateToPhoto: photo, atIndex: index)
}
}
}
|
mit
|
fe147e0a26a153a22e44c7412b701c4b
| 38.351438 | 202 | 0.686774 | 5.845752 | false | false | false | false |
antigp/Alamofire
|
Tests/MultipartFormDataTests.swift
|
1
|
36591
|
//
// MultipartFormDataTests.swift
//
// Copyright (c) 2014-2018 Alamofire Software Foundation (http://alamofire.org/)
//
// 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 Alamofire
import Foundation
import XCTest
struct EncodingCharacters {
static let crlf = "\r\n"
}
enum BoundaryGenerator {
enum BoundaryType {
case initial, encapsulated, final
}
static func boundary(forBoundaryType boundaryType: BoundaryType, boundaryKey: String) -> String {
let boundary: String
switch boundaryType {
case .initial:
boundary = "--\(boundaryKey)\(EncodingCharacters.crlf)"
case .encapsulated:
boundary = "\(EncodingCharacters.crlf)--\(boundaryKey)\(EncodingCharacters.crlf)"
case .final:
boundary = "\(EncodingCharacters.crlf)--\(boundaryKey)--\(EncodingCharacters.crlf)"
}
return boundary
}
static func boundaryData(boundaryType: BoundaryType, boundaryKey: String) -> Data {
Data(BoundaryGenerator.boundary(forBoundaryType: boundaryType,
boundaryKey: boundaryKey).utf8)
}
}
private func temporaryFileURL() -> URL { BaseTestCase.testDirectoryURL.appendingPathComponent(UUID().uuidString) }
// MARK: -
class MultipartFormDataPropertiesTestCase: BaseTestCase {
func testThatContentTypeContainsBoundary() {
// Given
let multipartFormData = MultipartFormData()
// When
let boundary = multipartFormData.boundary
// Then
let expectedContentType = "multipart/form-data; boundary=\(boundary)"
XCTAssertEqual(multipartFormData.contentType, expectedContentType, "contentType should match expected value")
}
func testThatContentLengthMatchesTotalBodyPartSize() {
// Given
let multipartFormData = MultipartFormData()
let data1 = Data("Lorem ipsum dolor sit amet.".utf8)
let data2 = Data("Vim at integre alterum.".utf8)
// When
multipartFormData.append(data1, withName: "data1")
multipartFormData.append(data2, withName: "data2")
// Then
let expectedContentLength = UInt64(data1.count + data2.count)
XCTAssertEqual(multipartFormData.contentLength, expectedContentLength, "content length should match expected value")
}
}
// MARK: -
class MultipartFormDataEncodingTestCase: BaseTestCase {
let crlf = EncodingCharacters.crlf
func testEncodingDataBodyPart() {
// Given
let multipartFormData = MultipartFormData()
let data = Data("Lorem ipsum dolor sit amet.".utf8)
multipartFormData.append(data, withName: "data")
var encodedData: Data?
// When
do {
encodedData = try multipartFormData.encode()
} catch {
// No-op
}
// Then
XCTAssertNotNil(encodedData, "encoded data should not be nil")
if let encodedData = encodedData {
let boundary = multipartFormData.boundary
let expectedString = (
BoundaryGenerator.boundary(forBoundaryType: .initial, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"data\"\(crlf)\(crlf)" +
"Lorem ipsum dolor sit amet." +
BoundaryGenerator.boundary(forBoundaryType: .final, boundaryKey: boundary)
)
let expectedData = Data(expectedString.utf8)
XCTAssertEqual(encodedData, expectedData, "encoded data should match expected data")
}
}
func testEncodingMultipleDataBodyParts() {
// Given
let multipartFormData = MultipartFormData()
let frenchData = Data("français".utf8)
let japaneseData = Data("日本語".utf8)
let emojiData = Data("😃👍🏻🍻🎉".utf8)
multipartFormData.append(frenchData, withName: "french")
multipartFormData.append(japaneseData, withName: "japanese", mimeType: "text/plain")
multipartFormData.append(emojiData, withName: "emoji", mimeType: "text/plain")
var encodedData: Data?
// When
do {
encodedData = try multipartFormData.encode()
} catch {
// No-op
}
// Then
XCTAssertNotNil(encodedData, "encoded data should not be nil")
if let encodedData = encodedData {
let boundary = multipartFormData.boundary
let expectedString = (
BoundaryGenerator.boundary(forBoundaryType: .initial, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"french\"\(crlf)\(crlf)" +
"français" +
BoundaryGenerator.boundary(forBoundaryType: .encapsulated, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"japanese\"\(crlf)" +
"Content-Type: text/plain\(crlf)\(crlf)" +
"日本語" +
BoundaryGenerator.boundary(forBoundaryType: .encapsulated, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"emoji\"\(crlf)" +
"Content-Type: text/plain\(crlf)\(crlf)" +
"😃👍🏻🍻🎉" +
BoundaryGenerator.boundary(forBoundaryType: .final, boundaryKey: boundary)
)
let expectedData = Data(expectedString.utf8)
XCTAssertEqual(encodedData, expectedData, "encoded data should match expected data")
}
}
#if !SWIFT_PACKAGE
func testEncodingFileBodyPart() {
// Given
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
multipartFormData.append(unicornImageURL, withName: "unicorn")
var encodedData: Data?
// When
do {
encodedData = try multipartFormData.encode()
} catch {
// No-op
}
// Then
XCTAssertNotNil(encodedData, "encoded data should not be nil")
if let encodedData = encodedData {
let boundary = multipartFormData.boundary
var expectedData = Data()
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: unicornImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(encodedData, expectedData, "data should match expected data")
}
}
func testEncodingMultipleFileBodyParts() {
// Given
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let rainbowImageURL = url(forResource: "rainbow", withExtension: "jpg")
multipartFormData.append(unicornImageURL, withName: "unicorn")
multipartFormData.append(rainbowImageURL, withName: "rainbow")
var encodedData: Data?
// When
do {
encodedData = try multipartFormData.encode()
} catch {
// No-op
}
// Then
XCTAssertNotNil(encodedData, "encoded data should not be nil")
if let encodedData = encodedData {
let boundary = multipartFormData.boundary
var expectedData = Data()
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: unicornImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"rainbow\"; filename=\"rainbow.jpg\"\(crlf)" +
"Content-Type: image/jpeg\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: rainbowImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(encodedData, expectedData, "data should match expected data")
}
}
func testEncodingStreamBodyPart() {
// Given
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let unicornDataLength = UInt64((try! Data(contentsOf: unicornImageURL)).count)
let unicornStream = InputStream(url: unicornImageURL)!
multipartFormData.append(unicornStream,
withLength: unicornDataLength,
name: "unicorn",
fileName: "unicorn.png",
mimeType: "image/png")
var encodedData: Data?
// When
do {
encodedData = try multipartFormData.encode()
} catch {
// No-op
}
// Then
XCTAssertNotNil(encodedData, "encoded data should not be nil")
if let encodedData = encodedData {
let boundary = multipartFormData.boundary
var expectedData = Data()
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: unicornImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(encodedData, expectedData, "data should match expected data")
}
}
func testEncodingMultipleStreamBodyParts() {
// Given
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let unicornDataLength = UInt64((try! Data(contentsOf: unicornImageURL)).count)
let unicornStream = InputStream(url: unicornImageURL)!
let rainbowImageURL = url(forResource: "rainbow", withExtension: "jpg")
let rainbowDataLength = UInt64((try! Data(contentsOf: rainbowImageURL)).count)
let rainbowStream = InputStream(url: rainbowImageURL)!
multipartFormData.append(unicornStream,
withLength: unicornDataLength,
name: "unicorn",
fileName: "unicorn.png",
mimeType: "image/png")
multipartFormData.append(rainbowStream,
withLength: rainbowDataLength,
name: "rainbow",
fileName: "rainbow.jpg",
mimeType: "image/jpeg")
var encodedData: Data?
// When
do {
encodedData = try multipartFormData.encode()
} catch {
// No-op
}
// Then
XCTAssertNotNil(encodedData, "encoded data should not be nil")
if let encodedData = encodedData {
let boundary = multipartFormData.boundary
var expectedData = Data()
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: unicornImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"rainbow\"; filename=\"rainbow.jpg\"\(crlf)" +
"Content-Type: image/jpeg\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: rainbowImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(encodedData, expectedData, "data should match expected data")
}
}
func testEncodingMultipleBodyPartsWithVaryingTypes() {
// Given
let multipartFormData = MultipartFormData()
let loremData = Data("Lorem ipsum.".utf8)
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let rainbowImageURL = url(forResource: "rainbow", withExtension: "jpg")
let rainbowDataLength = UInt64((try! Data(contentsOf: rainbowImageURL)).count)
let rainbowStream = InputStream(url: rainbowImageURL)!
multipartFormData.append(loremData, withName: "lorem")
multipartFormData.append(unicornImageURL, withName: "unicorn")
multipartFormData.append(rainbowStream,
withLength: rainbowDataLength,
name: "rainbow",
fileName: "rainbow.jpg",
mimeType: "image/jpeg")
var encodedData: Data?
// When
do {
encodedData = try multipartFormData.encode()
} catch {
// No-op
}
// Then
XCTAssertNotNil(encodedData, "encoded data should not be nil")
if let encodedData = encodedData {
let boundary = multipartFormData.boundary
var expectedData = Data()
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedData.append(Data(
"Content-Disposition: form-data; name=\"lorem\"\(crlf)\(crlf)".utf8
)
)
expectedData.append(loremData)
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: unicornImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedData.append(Data((
"Content-Disposition: form-data; name=\"rainbow\"; filename=\"rainbow.jpg\"\(crlf)" +
"Content-Type: image/jpeg\(crlf)\(crlf)").utf8
)
)
expectedData.append(try! Data(contentsOf: rainbowImageURL))
expectedData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(encodedData, expectedData, "data should match expected data")
}
}
#endif
}
// MARK: -
class MultipartFormDataWriteEncodedDataToDiskTestCase: BaseTestCase {
let crlf = EncodingCharacters.crlf
func testWritingEncodedDataBodyPartToDisk() {
// Given
let fileURL = temporaryFileURL()
let multipartFormData = MultipartFormData()
let data = Data("Lorem ipsum dolor sit amet.".utf8)
multipartFormData.append(data, withName: "data")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(encodingError, "encoding error should be nil")
if let fileData = try? Data(contentsOf: fileURL) {
let boundary = multipartFormData.boundary
let expectedString = BoundaryGenerator.boundary(forBoundaryType: .initial, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"data\"\(crlf)\(crlf)" +
"Lorem ipsum dolor sit amet." +
BoundaryGenerator.boundary(forBoundaryType: .final, boundaryKey: boundary)
let expectedFileData = Data(expectedString.utf8)
XCTAssertEqual(fileData, expectedFileData, "file data should match expected file data")
} else {
XCTFail("file data should not be nil")
}
}
func testWritingMultipleEncodedDataBodyPartsToDisk() {
// Given
let fileURL = temporaryFileURL()
let multipartFormData = MultipartFormData()
let frenchData = Data("français".utf8)
let japaneseData = Data("日本語".utf8)
let emojiData = Data("😃👍🏻🍻🎉".utf8)
multipartFormData.append(frenchData, withName: "french")
multipartFormData.append(japaneseData, withName: "japanese")
multipartFormData.append(emojiData, withName: "emoji")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(encodingError, "encoding error should be nil")
if let fileData = try? Data(contentsOf: fileURL) {
let boundary = multipartFormData.boundary
let expectedString = (
BoundaryGenerator.boundary(forBoundaryType: .initial, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"french\"\(crlf)\(crlf)" +
"français" +
BoundaryGenerator.boundary(forBoundaryType: .encapsulated, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"japanese\"\(crlf)\(crlf)" +
"日本語" +
BoundaryGenerator.boundary(forBoundaryType: .encapsulated, boundaryKey: boundary) +
"Content-Disposition: form-data; name=\"emoji\"\(crlf)\(crlf)" +
"😃👍🏻🍻🎉" +
BoundaryGenerator.boundary(forBoundaryType: .final, boundaryKey: boundary)
)
let expectedFileData = Data(expectedString.utf8)
XCTAssertEqual(fileData, expectedFileData, "file data should match expected file data")
} else {
XCTFail("file data should not be nil")
}
}
#if !SWIFT_PACKAGE
func testWritingEncodedFileBodyPartToDisk() {
// Given
let fileURL = temporaryFileURL()
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
multipartFormData.append(unicornImageURL, withName: "unicorn")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(encodingError, "encoding error should be nil")
if let fileData = try? Data(contentsOf: fileURL) {
let boundary = multipartFormData.boundary
var expectedFileData = Data()
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: unicornImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(fileData, expectedFileData, "file data should match expected file data")
} else {
XCTFail("file data should not be nil")
}
}
func testWritingMultipleEncodedFileBodyPartsToDisk() {
// Given
let fileURL = temporaryFileURL()
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let rainbowImageURL = url(forResource: "rainbow", withExtension: "jpg")
multipartFormData.append(unicornImageURL, withName: "unicorn")
multipartFormData.append(rainbowImageURL, withName: "rainbow")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(encodingError, "encoding error should be nil")
if let fileData = try? Data(contentsOf: fileURL) {
let boundary = multipartFormData.boundary
var expectedFileData = Data()
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: unicornImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"rainbow\"; filename=\"rainbow.jpg\"\(crlf)" +
"Content-Type: image/jpeg\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: rainbowImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(fileData, expectedFileData, "file data should match expected file data")
} else {
XCTFail("file data should not be nil")
}
}
func testWritingEncodedStreamBodyPartToDisk() {
// Given
let fileURL = temporaryFileURL()
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let unicornDataLength = UInt64((try! Data(contentsOf: unicornImageURL)).count)
let unicornStream = InputStream(url: unicornImageURL)!
multipartFormData.append(unicornStream,
withLength: unicornDataLength,
name: "unicorn",
fileName: "unicorn.png",
mimeType: "image/png")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(encodingError, "encoding error should be nil")
if let fileData = try? Data(contentsOf: fileURL) {
let boundary = multipartFormData.boundary
var expectedFileData = Data()
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: unicornImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(fileData, expectedFileData, "file data should match expected file data")
} else {
XCTFail("file data should not be nil")
}
}
func testWritingMultipleEncodedStreamBodyPartsToDisk() {
// Given
let fileURL = temporaryFileURL()
let multipartFormData = MultipartFormData()
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let unicornDataLength = UInt64((try! Data(contentsOf: unicornImageURL)).count)
let unicornStream = InputStream(url: unicornImageURL)!
let rainbowImageURL = url(forResource: "rainbow", withExtension: "jpg")
let rainbowDataLength = UInt64((try! Data(contentsOf: rainbowImageURL)).count)
let rainbowStream = InputStream(url: rainbowImageURL)!
multipartFormData.append(unicornStream,
withLength: unicornDataLength,
name: "unicorn",
fileName: "unicorn.png",
mimeType: "image/png")
multipartFormData.append(rainbowStream,
withLength: rainbowDataLength,
name: "rainbow",
fileName: "rainbow.jpg",
mimeType: "image/jpeg")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(encodingError, "encoding error should be nil")
if let fileData = try? Data(contentsOf: fileURL) {
let boundary = multipartFormData.boundary
var expectedFileData = Data()
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: unicornImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"rainbow\"; filename=\"rainbow.jpg\"\(crlf)" +
"Content-Type: image/jpeg\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: rainbowImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(fileData, expectedFileData, "file data should match expected file data")
} else {
XCTFail("file data should not be nil")
}
}
func testWritingMultipleEncodedBodyPartsWithVaryingTypesToDisk() {
// Given
let fileURL = temporaryFileURL()
let multipartFormData = MultipartFormData()
let loremData = Data("Lorem ipsum.".utf8)
let unicornImageURL = url(forResource: "unicorn", withExtension: "png")
let rainbowImageURL = url(forResource: "rainbow", withExtension: "jpg")
let rainbowDataLength = UInt64((try! Data(contentsOf: rainbowImageURL)).count)
let rainbowStream = InputStream(url: rainbowImageURL)!
multipartFormData.append(loremData, withName: "lorem")
multipartFormData.append(unicornImageURL, withName: "unicorn")
multipartFormData.append(rainbowStream,
withLength: rainbowDataLength,
name: "rainbow",
fileName: "rainbow.jpg",
mimeType: "image/jpeg")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(encodingError, "encoding error should be nil")
if let fileData = try? Data(contentsOf: fileURL) {
let boundary = multipartFormData.boundary
var expectedFileData = Data()
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .initial, boundaryKey: boundary))
expectedFileData.append(Data(
"Content-Disposition: form-data; name=\"lorem\"\(crlf)\(crlf)".utf8
)
)
expectedFileData.append(loremData)
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"unicorn\"; filename=\"unicorn.png\"\(crlf)" +
"Content-Type: image/png\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: unicornImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .encapsulated, boundaryKey: boundary))
expectedFileData.append(Data((
"Content-Disposition: form-data; name=\"rainbow\"; filename=\"rainbow.jpg\"\(crlf)" +
"Content-Type: image/jpeg\(crlf)\(crlf)").utf8
)
)
expectedFileData.append(try! Data(contentsOf: rainbowImageURL))
expectedFileData.append(BoundaryGenerator.boundaryData(boundaryType: .final, boundaryKey: boundary))
XCTAssertEqual(fileData, expectedFileData, "file data should match expected file data")
} else {
XCTFail("file data should not be nil")
}
}
#endif
}
// MARK: -
class MultipartFormDataFailureTestCase: BaseTestCase {
func testThatAppendingFileBodyPartWithInvalidLastPathComponentReturnsError() {
// Given
let fileURL = NSURL(string: "")! as URL
let multipartFormData = MultipartFormData()
multipartFormData.append(fileURL, withName: "empty_data")
var encodingError: Error?
// When
do {
_ = try multipartFormData.encode()
} catch {
encodingError = error
}
// Then
XCTAssertNotNil(encodingError, "encoding error should not be nil")
XCTAssertEqual(encodingError?.asAFError?.isBodyPartFilenameInvalid, true)
XCTAssertEqual(encodingError?.asAFError?.url, fileURL)
}
func testThatAppendingFileBodyPartThatIsNotFileURLReturnsError() {
// Given
let fileURL = URL(string: "https://example.com/image.jpg")!
let multipartFormData = MultipartFormData()
multipartFormData.append(fileURL, withName: "empty_data")
var encodingError: Error?
// When
do {
_ = try multipartFormData.encode()
} catch {
encodingError = error
}
// Then
XCTAssertNotNil(encodingError, "encoding error should not be nil")
XCTAssertEqual(encodingError?.asAFError?.isBodyPartURLInvalid, true)
XCTAssertEqual(encodingError?.asAFError?.url, fileURL)
}
func testThatAppendingFileBodyPartThatIsNotReachableReturnsError() {
// Given
let filePath = (NSTemporaryDirectory() as NSString).appendingPathComponent("does_not_exist.jpg")
let fileURL = URL(fileURLWithPath: filePath)
let multipartFormData = MultipartFormData()
multipartFormData.append(fileURL, withName: "empty_data")
var encodingError: Error?
// When
do {
_ = try multipartFormData.encode()
} catch {
encodingError = error
}
// Then
XCTAssertNotNil(encodingError, "encoding error should not be nil")
XCTAssertEqual(encodingError?.asAFError?.isBodyPartFileNotReachableWithError, true)
XCTAssertEqual(encodingError?.asAFError?.url, fileURL)
}
func testThatAppendingFileBodyPartThatIsDirectoryReturnsError() {
// Given
let directoryURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
let multipartFormData = MultipartFormData()
multipartFormData.append(directoryURL, withName: "empty_data", fileName: "empty", mimeType: "application/octet")
var encodingError: Error?
// When
do {
_ = try multipartFormData.encode()
} catch {
encodingError = error
}
// Then
XCTAssertNotNil(encodingError, "encoding error should not be nil")
XCTAssertEqual(encodingError?.asAFError?.isBodyPartFileIsDirectory, true)
XCTAssertEqual(encodingError?.asAFError?.url, directoryURL)
}
func testThatWritingEncodedDataToExistingFileURLFails() {
// Given
let fileURL = temporaryFileURL()
var writerError: Error?
do {
try "dummy data".write(to: fileURL, atomically: true, encoding: .utf8)
} catch {
writerError = error
}
let multipartFormData = MultipartFormData()
let data = Data("Lorem ipsum dolor sit amet.".utf8)
multipartFormData.append(data, withName: "data")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNil(writerError, "writer error should be nil")
XCTAssertNotNil(encodingError, "encoding error should not be nil")
XCTAssertEqual(encodingError?.asAFError?.isOutputStreamFileAlreadyExists, true)
}
func testThatWritingEncodedDataToBadURLFails() {
// Given
let fileURL = URL(string: "/this/is/not/a/valid/url")!
let multipartFormData = MultipartFormData()
let data = Data("Lorem ipsum dolor sit amet.".utf8)
multipartFormData.append(data, withName: "data")
var encodingError: Error?
// When
do {
try multipartFormData.writeEncodedData(to: fileURL)
} catch {
encodingError = error
}
// Then
XCTAssertNotNil(encodingError, "encoding error should not be nil")
XCTAssertEqual(encodingError?.asAFError?.isOutputStreamURLInvalid, true)
}
func testThatStreamBodyPartHasUnexpectedLength() {
// Given
let multipartFormData = MultipartFormData()
let data = Data("Lorem ipsum dolor sit amet.".utf8)
multipartFormData.append(data, withName: "data")
var firstError: Error?
var secondError: Error?
// When
do {
_ = try multipartFormData.encode()
} catch {
firstError = error
}
do {
_ = try multipartFormData.encode()
} catch {
secondError = error
}
XCTAssertNil(firstError, "firstError should be nil")
XCTAssertNotNil(secondError, "secondError should not be nil")
XCTAssertEqual(secondError?.asAFError?.isInputStreamReadFailed, true)
XCTAssert(secondError?.asAFError?.underlyingError is AFError.UnexpectedInputStreamLength)
}
}
|
mit
|
f51f9f999965482a909cc4dd5ae97565
| 37.505274 | 124 | 0.610936 | 5.293358 | false | false | false | false |
delba/SwiftyOAuth
|
Source/Supporting Files/Keychain.swift
|
1
|
2962
|
//
// Keychain.swift
//
// Copyright (c) 2016-2019 Damien (http://delba.io)
//
// 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 Security
public struct Keychain {
public static let shared = Keychain()
private init() {}
@discardableResult
public func set(_ dictionary: [String: Any], forKey key: String) -> Bool {
let data = NSKeyedArchiver.archivedData(withRootObject: dictionary)
let query = [
kSecClass as String: kSecClassGenericPassword as String,
kSecAttrAccount as String: key,
kSecValueData as String: data
] as CFDictionary
SecItemDelete(query)
return SecItemAdd(query, nil) == noErr
}
public func dictionary(forKey key: String) -> [String: Any]? {
let query = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String: key,
kSecReturnData as String: kCFBooleanTrue!,
kSecMatchLimit as String: kSecMatchLimitOne
] as CFDictionary
var dataTypeRef: AnyObject?
let status = withUnsafeMutablePointer(to: &dataTypeRef) {
SecItemCopyMatching(query, UnsafeMutablePointer($0))
}
guard status == errSecSuccess, let data = dataTypeRef as? Data else { return nil }
return NSKeyedUnarchiver.unarchiveObject(with: data) as? [String: AnyObject]
}
@discardableResult
public func removeObject(forKey key: String) -> Bool {
let query = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String: key
] as CFDictionary
return SecItemDelete(query) == noErr
}
@discardableResult
internal func reset() -> Bool {
let query = [
kSecClass as String: kSecClassGenericPassword
] as CFDictionary
return SecItemDelete(query) == noErr
}
}
|
mit
|
f98f86e68311086d9c9af08691a1cad1
| 33.44186 | 90 | 0.678933 | 5.106897 | false | false | false | false |
therealbnut/swift
|
stdlib/public/SDK/Foundation/String.swift
|
9
|
1958
|
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
@_exported import Foundation // Clang module
//===----------------------------------------------------------------------===//
// New Strings
//===----------------------------------------------------------------------===//
//
// Conversion from NSString to Swift's native representation
//
extension String {
public init(_ cocoaString: NSString) {
self = String(_cocoaString: cocoaString)
}
}
extension String : _ObjectiveCBridgeable {
@_semantics("convertToObjectiveC")
public func _bridgeToObjectiveC() -> NSString {
// This method should not do anything extra except calling into the
// implementation inside core. (These two entry points should be
// equivalent.)
return unsafeBitCast(_bridgeToObjectiveCImpl() as AnyObject, to: NSString.self)
}
public static func _forceBridgeFromObjectiveC(
_ x: NSString,
result: inout String?
) {
result = String(x)
}
public static func _conditionallyBridgeFromObjectiveC(
_ x: NSString,
result: inout String?
) -> Bool {
self._forceBridgeFromObjectiveC(x, result: &result)
return result != nil
}
public static func _unconditionallyBridgeFromObjectiveC(
_ source: NSString?
) -> String {
// `nil` has historically been used as a stand-in for an empty
// string; map it to an empty string.
if _slowPath(source == nil) { return String() }
return String(source!)
}
}
extension String: CVarArg {}
|
apache-2.0
|
b5d04e48bd9acd79560b878c85632e5d
| 30.079365 | 83 | 0.585802 | 5.207447 | false | false | false | false |
buyiyang/iosstar
|
iOSStar/Scenes/Deal/Controllers/SurePayOrderVC.swift
|
3
|
1669
|
//
// SurePayOrderVC.swift
// iOSStar
//
// Created by sum on 2017/6/13.
// Copyright © 2017年 YunDian. All rights reserved.
//
import UIKit
class SurePayOrderVC: UIViewController {
@IBOutlet var name: UILabel!
@IBOutlet var sure: UIButton!
//订单总价
@IBOutlet var orderAllPrice: UILabel!
//订单总量
@IBOutlet var orderAccount: UILabel!
//订单价格
@IBOutlet var orderPrice: UILabel!
//订单状态
@IBOutlet var orderStatus: UILabel!
//订单信息
@IBOutlet var orderInfoMation: UILabel!
var resultBlock: CompleteBlock?
override func viewDidLoad() {
super.viewDidLoad()
name.text = ShareDataModel.share().orderInfo?.ordertitlename
sure.backgroundColor = UIColor.init(hexString: AppConst.Color.orange)
orderAllPrice.text = ShareDataModel.share().orderInfo?.orderAllPrice
if ((orderAllPrice) != nil){
orderPrice.text = ShareDataModel.share().orderInfo?.orderPrice
}
if((orderAccount) != nil){
orderAccount.text = ShareDataModel.share().orderInfo?.orderAccount
}
orderStatus.text = ShareDataModel.share().orderInfo?.orderStatus
orderInfoMation.text = ShareDataModel.share().orderInfo?.orderInfomation
}
@IBAction func close(_ sender: Any) {
resultBlock?(doStateClick.close as AnyObject)
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
self.navigationController?.setNavigationBarHidden(true, animated: true)
}
@IBAction func sureClick(_ sender: Any) {
resultBlock?(doStateClick.donext as AnyObject)
}
}
|
gpl-3.0
|
89d2fe5b6930609687fd871e681adbfa
| 29.679245 | 79 | 0.676507 | 4.278947 | false | false | false | false |
braintree/braintree-ios-drop-in
|
Demo/Application/DemoMerchantAPIClient.swift
|
1
|
3543
|
import Foundation
class DemoMerchantAPIClient {
private struct ClientToken: Codable {
let clientToken: String
}
private struct TransactionResponse: Codable {
let message: String
}
static let shared = DemoMerchantAPIClient()
private init() {}
func createCustomerAndFetchClientToken(completion: @escaping ((String?, Error?) -> Void)) {
guard var urlComponents = URLComponents(string: DemoSettings.currentEnvironmentURLString + "/client_token") else { return }
if DemoSettings.customerPresent {
var queryItems: [URLQueryItem] = []
if let id = DemoSettings.customerIdentifier, id.count > 0 {
queryItems.append(URLQueryItem(name: "customer_id", value: id))
} else {
queryItems.append(URLQueryItem(name: "customer_id", value: UUID().uuidString))
}
if DemoSettings.createVaultedPaymentMethod {
queryItems.append(URLQueryItem(name: "add_payment_method", value: "true"))
}
if DemoSettings.createVaulted3DS2PaymentMethod {
queryItems.append(URLQueryItem(name: "add_3ds_card", value: "true"))
}
urlComponents.queryItems = queryItems
}
let task = URLSession.shared.dataTask(with: urlComponents.url!) { (data, response, error) in
guard let data = data, error == nil else {
DispatchQueue.main.async { completion(nil, error) }
return
}
let jsonDecoder = JSONDecoder()
jsonDecoder.keyDecodingStrategy = .convertFromSnakeCase
let clientToken = try? jsonDecoder.decode(ClientToken.self, from: data).clientToken
DispatchQueue.main.async { completion(clientToken, nil) }
}
task.resume()
}
func makeTransaction(paymentMethodNonce: String, merchantAccountId: String? = nil, completion: @escaping ((String?, Error?) -> Void)) {
NSLog("Creating a transaction with nonce: %@", paymentMethodNonce)
guard var urlComponents = URLComponents(string: DemoSettings.currentEnvironmentURLString + "/nonce/transaction") else { return }
var queryItems = [URLQueryItem(name: "nonce", value: paymentMethodNonce)]
if (DemoSettings.threeDSecureRequiredStatus == .required) {
queryItems += [URLQueryItem(name: "three_d_secure_required", value: "true")]
} else if (DemoSettings.threeDSecureRequiredStatus == .optional) {
queryItems += [URLQueryItem(name: "three_d_secure_required", value: "false")]
}
if let id = merchantAccountId {
queryItems += [URLQueryItem(name: "merchant_account_id", value: id)]
}
urlComponents.queryItems = queryItems
guard let url = urlComponents.url else { return }
var request = URLRequest(url: url)
request.httpMethod = "POST"
let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
guard let data = data, error == nil else {
DispatchQueue.main.async { completion(nil, error) }
return
}
let message = try? JSONDecoder().decode(TransactionResponse.self, from: data).message
DispatchQueue.main.async { completion(message, nil) }
}
task.resume()
}
}
|
mit
|
fd457b80574c9f29b7bec2389b18d2b6
| 38.366667 | 139 | 0.598081 | 5.134783 | false | false | false | false |
sarahspins/Loop
|
Loop/Extensions/CGPoint.swift
|
2
|
690
|
//
// CGPoint.swift
// Naterade
//
// Created by Nathan Racklyeft on 2/29/16.
// Copyright © 2016 Nathan Racklyeft. All rights reserved.
//
import UIKit
extension CGPoint {
/**
Rounds the coordinates to whole-pixel values
- parameter scale: The display scale to use. Defaults to the main screen scale.
*/
mutating func makeIntegralInPlaceWithDisplayScale(scale: CGFloat = 0) {
var scale = scale
// It's possible for scale values retrieved from traitCollection objects to be 0.
if scale == 0 {
scale = UIScreen.mainScreen().scale
}
x = round(x * scale) / scale
y = round(y * scale) / scale
}
}
|
apache-2.0
|
e2ba2f149c25c878542c2cbcfc82557d
| 23.607143 | 89 | 0.625544 | 4.226994 | false | false | false | false |
Onavoy/Torpedo
|
Torpedo/Classes/Runtime/RuntimeUtils.swift
|
1
|
1280
|
import Foundation
open class RuntimeUtils {
open static func instance(of clz: AnyClass) -> AnyObject {
let tt = clz as! NSObject.Type
return tt.init()
}
open static func classesConforming(toProtocol aProtocol: Protocol) -> [AnyClass] {
var result: [AnyClass] = []
let allClasses = self.allClasses()
for cls in allClasses {
if class_conformsToProtocol(cls, aProtocol) {
result.append(cls)
}
}
return result
}
open static func allClasses() -> [AnyClass] {
let expectedClassCount = objc_getClassList(nil, 0)
let allClasses = UnsafeMutablePointer<AnyClass?>.allocate(capacity: Int(expectedClassCount))
let autoreleasingAllClasses = AutoreleasingUnsafeMutablePointer<AnyClass?>(allClasses)
let actualClassCount:Int32 = objc_getClassList(autoreleasingAllClasses, expectedClassCount)
var classes = [AnyClass]()
for i in 0 ..< actualClassCount {
if let currentClass: AnyClass = allClasses[Int(i)] {
classes.append(currentClass)
}
}
allClasses.deallocate(capacity: Int(expectedClassCount))
return classes
}
}
|
mit
|
1a75ecff4666b39957d72f482e12df01
| 31.820513 | 100 | 0.611719 | 4.86692 | false | false | false | false |
kdawgwilk/vapor
|
Sources/Vapor/Hash/SHAHasher.swift
|
1
|
1335
|
import HMAC
import SHA2
import struct Base.Bytes
/**
Create SHA + HMAC hashes with the
Hash class by applying this driver.
*/
public class SHA2Hasher: Hash {
var variant: Variant
init(variant: Variant) {
self.variant = variant
self.key = ""
self.keyBuffer = []
}
/**
Hashing variant to use
*/
public enum Variant {
case sha256
case sha384
case sha512
}
/**
HMAC key.
*/
public var key: String {
didSet {
keyBuffer = key.bytes
}
}
//
private var keyBuffer: Bytes
/**
Hash given string with key
- parameter message: message to hash
- parameter key: key to hash with
- returns: a hashed string
*/
public func make(_ message: String) -> String {
let msgBuff = message.data.bytes
let hashed: Bytes
switch variant {
case .sha256:
hashed = HMAC<SHA2<SHA256>>.authenticate(message: msgBuff, withKey: keyBuffer)
case .sha384:
hashed = HMAC<SHA2<SHA384>>.authenticate(message: msgBuff, withKey: keyBuffer)
case .sha512:
hashed = HMAC<SHA2<SHA512>>.authenticate(message: msgBuff, withKey: keyBuffer)
}
return hashed.hexString
}
}
|
mit
|
63e2c40c68e63164bf30e29bdd0f3020
| 19.538462 | 90 | 0.562547 | 4.391447 | false | false | false | false |
danielhour/DINC
|
DINC/Account.swift
|
1
|
1396
|
////
//// Account.swift
//// DINC
////
//// Created by dhour on 4/14/16.
//// Copyright © 2016 DHour. All rights reserved.
////
//
//import Foundation
//
//
///**
// *
// */
//struct Account {
//
// ///
// let institutionName: String
// ///
// let id: String
// ///
// let user: String
// ///
// let balance: Double?
// ///
// let productName: String
// ///
// let lastFourDigits: String
// ///
// let limit: NSNumber?
// ///
// let routingNumber: String?
// ///
// let accountNumber: String?
// ///
// let wireRouting: String?
//
// init (account: [String:AnyObject]) {
// let meta = account["meta"] as! [String:AnyObject]
// let accountBalance = account["balance"] as! [String:AnyObject]
// let numbers = account["numbers"] as? [String:AnyObject]
//
// institutionName = account["institution_type"] as! String
// id = account["_id"] as! String
// user = account["_user"] as! String
// balance = accountBalance["current"] as? Double
// productName = meta["name"] as! String
// lastFourDigits = meta["number"] as! String
// limit = meta["limit"] as? NSNumber
// routingNumber = numbers?["routing"] as? String
// accountNumber = numbers?["account"] as? String
// wireRouting = numbers?["wireRouting"] as? String
// }
//}
|
mit
|
8317955444371ef822c203456d495c73
| 24.833333 | 72 | 0.538351 | 3.513854 | false | false | false | false |
TempoDiValse/DCHelper
|
DCHelper/SafariExtensionHandler.swift
|
1
|
5848
|
//
// SafariExtensionHandler.swift
// DCHelper
//
// Created by LaValse on 2016. 11. 1..
// Copyright © 2016년 LaValse. All rights reserved.
//
import SafariServices
class SafariExtensionHandler: SFSafariExtensionHandler {
let BRIDGE_FUNC = "fromExtension"
let defaults = UserDefaults.standard
override func messageReceived(withName messageName: String, from page: SFSafariPage, userInfo: [String : Any]?) {
page.getPropertiesWithCompletionHandler({
let url = $0?.url?.absoluteString
if (url?.hasPrefix(Const.Page.DOMAIN_PREFIX))! {
if((url?.contains(Const.Page.List))! || (url?.contains(Const.Page.View))!){
/* specific function of its page */
guard messageName != Const.MessageType.SendURLFromWeb else {
let href = userInfo!["href"] as! String
let urls = userInfo!["urls"] as! [[String:String]]
/* 이미 꺼져 버린 페이지에서 호출이 일어나 URL 대조가 필요 */
guard href == url else {
return
}
let ctrlr = ImageDownloadController()
ctrlr.setURLs(url: urls)
self.performSelector(onMainThread: #selector(self.openDownloadList), with: ctrlr, waitUntilDone: true)
return
}
guard messageName != Const.MessageType.RecentVisited else {
let list = userInfo?["list"]!
self.defaults.set(list, forKey: Const.USER_RECENT_VISITED)
self.defaults.synchronize()
return
}
/* common function of its page */
let bPerson = self.defaults.array(forKey: Const.USER_BLOCK_ARRAY) as! [String]?
let bTitle = self.defaults.array(forKey: Const.USER_TITLE_BLOCK_ARRAY) as! [String]?
if bPerson?.count != 0 && bTitle?.count != 0 {
let joinPerson = bPerson?.joined(separator:"|") ?? ""
let regTitle = self.arrayToReg(_arr: bTitle)
page.dispatchMessageToScript(withName: self.BRIDGE_FUNC, userInfo: [
"type": Const.MessageType.Block,
"person": joinPerson,
"title": regTitle
])
}
}else if(url?.contains(Const.Page.Write))!{
guard messageName != Const.MessageType.GetImage else{
self.sendFixImage()
return
}
let isAutoAdd = self.defaults.bool(forKey: Const.USER_IMG_ADD_AUTO)
if isAutoAdd {
self.sendFixImage()
}else{
page.dispatchMessageToScript(withName: self.BRIDGE_FUNC, userInfo: ["type": Const.MessageType.AddButton])
}
}
}
})
}
private func arrayToReg(_arr:[String]?) -> String {
guard _arr != nil else{
return ""
}
var buf = "("
for i in 0 ... _arr!.count-1{
let _o = _arr![i]
buf += "\(_o)"
if i < _arr!.count-1 {
buf += "|"
}
}
buf += ")"
return buf;
}
func openDownloadList(sender: Any){
let pVC = self.popoverViewController()
pVC.presentViewController(sender as! ImageDownloadController, asPopoverRelativeTo: NSRect(x: 0, y: 0, width: 0, height: 0), of: pVC.view, preferredEdge: NSRectEdge.maxX, behavior: .transient)
}
func sendFixImage(){
let url = defaults.string(forKey: Const.USER_IMG_SRC)
if url != nil {
do{
let fileName = URL(string:url!)?.lastPathComponent
let data = try Data.init(contentsOf: URL(string:url!)!).base64EncodedString()
let datas = [
"type": Const.MessageType.AutoImage,
"args": [
"fileName": fileName,
"data": data
]
] as [String : Any]
SFSafariApplication.getActiveWindow(completionHandler: {
$0?.getActiveTab(completionHandler: {
$0?.getActivePage(completionHandler: {
$0?.dispatchMessageToScript(withName: self.BRIDGE_FUNC, userInfo: datas)
})
})
})
}catch{
print(error)
}
}
}
override func toolbarItemClicked(in window: SFSafariWindow) {
}
override func validateToolbarItem(in window: SFSafariWindow, validationHandler: @escaping ((Bool, String) -> Void)) {
validationHandler(true, "")
}
override func popoverWillShow(in window: SFSafariWindow) {}
override func popoverDidClose(in window: SFSafariWindow) {}
override func popoverViewController() -> SFSafariExtensionViewController {
return SafariExtensionViewController.shared
}
}
|
mit
|
4db68b7cbe5d3c64b5f6ce1831bb173f
| 36.425806 | 199 | 0.460955 | 5.411381 | false | false | false | false |
JoeLago/MHGDB-iOS
|
Pods/GRDB.swift/GRDB/FTS/FTS5Tokenizer.swift
|
1
|
10522
|
#if SQLITE_ENABLE_FTS5
/// A low-level SQLite function that lets FTS5Tokenizer notify tokens.
///
/// See FTS5Tokenizer.tokenize(context:flags:pText:nText:tokenCallback:)
public typealias FTS5TokenCallback = @convention(c) (_ context: UnsafeMutableRawPointer?, _ flags: Int32, _ pToken: UnsafePointer<Int8>?, _ nToken: Int32, _ iStart: Int32, _ iEnd: Int32) -> Int32
/// The reason why FTS5 is requesting tokenization.
///
/// See https://www.sqlite.org/fts5.html#custom_tokenizers
public struct FTS5Tokenization : OptionSet {
public let rawValue: Int32
public init(rawValue: Int32) {
self.rawValue = rawValue
}
/// FTS5_TOKENIZE_QUERY
public static let query = FTS5Tokenization(rawValue: FTS5_TOKENIZE_QUERY)
/// FTS5_TOKENIZE_PREFIX
public static let prefix = FTS5Tokenization(rawValue: FTS5_TOKENIZE_PREFIX)
/// FTS5_TOKENIZE_DOCUMENT
public static let document = FTS5Tokenization(rawValue: FTS5_TOKENIZE_DOCUMENT)
/// FTS5_TOKENIZE_AUX
public static let aux = FTS5Tokenization(rawValue: FTS5_TOKENIZE_AUX)
}
/// The protocol for FTS5 tokenizers
public protocol FTS5Tokenizer : class {
/// Tokenizes the text described by `pText` and `nText`, and
/// notifies found tokens to the `tokenCallback` function.
///
/// It matches the `xTokenize` function documented at https://www.sqlite.org/fts5.html#custom_tokenizers
///
/// - parameters:
/// - context: An opaque pointer that is the first argument to
/// the `tokenCallback` function
/// - tokenization: The reason why FTS5 is requesting tokenization.
/// - pText: The tokenized text bytes. May or may not be
/// nul-terminated.
/// - nText: The number of bytes in the tokenized text.
/// - tokenCallback: The function to call for each found token.
/// It matches the `xToken` callback at https://www.sqlite.org/fts5.html#custom_tokenizers
func tokenize(context: UnsafeMutableRawPointer?, tokenization: FTS5Tokenization, pText: UnsafePointer<Int8>?, nText: Int32, tokenCallback: @escaping FTS5TokenCallback) -> Int32
}
private class TokenizeContext {
var tokens: [(String, FTS5TokenFlags)] = []
}
extension FTS5Tokenizer {
/// Tokenizes the string argument into an array of
/// (String, FTS5TokenFlags) pairs.
///
/// let tokenizer = try db.makeTokenizer(.ascii())
/// try tokenizer.tokenize("foo bar", for: .document) // [("foo", flags), ("bar", flags)]
///
/// - parameter string: The string to tokenize
/// - parameter tokenization: The reason why tokenization is requested:
/// - .document: Tokenize like a document being inserted into an FTS table.
/// - .query: Tokenize like the search pattern of the MATCH operator.
/// - parameter tokenizer: A FTS5TokenizerDescriptor such as .ascii()
func tokenize(_ string: String, for tokenization: FTS5Tokenization) throws -> [(String, FTS5TokenFlags)] {
return try ContiguousArray(string.utf8).withUnsafeBufferPointer { buffer -> [(String, FTS5TokenFlags)] in
guard let addr = buffer.baseAddress else {
return []
}
let pText = UnsafeMutableRawPointer(mutating: addr).assumingMemoryBound(to: Int8.self)
let nText = Int32(buffer.count)
var context = TokenizeContext()
try withUnsafeMutablePointer(to: &context) { contextPointer in
let code = tokenize(context: UnsafeMutableRawPointer(contextPointer), tokenization: tokenization, pText: pText, nText: nText, tokenCallback: { (contextPointer, flags, pToken, nToken, iStart, iEnd) -> Int32 in
guard let contextPointer = contextPointer else { return SQLITE_ERROR }
// Extract token
guard let token = pToken.flatMap({ String(data: Data(bytesNoCopy: UnsafeMutableRawPointer(mutating: $0), count: Int(nToken), deallocator: .none), encoding: .utf8) }) else {
return SQLITE_OK
}
let context = contextPointer.assumingMemoryBound(to: TokenizeContext.self).pointee
context.tokens.append((token, FTS5TokenFlags(rawValue: flags)))
return SQLITE_OK
})
if (code != SQLITE_OK) {
throw DatabaseError(resultCode: code)
}
}
return context.tokens
}
}
func nonSynonymTokens(in string: String, for tokenization: FTS5Tokenization) throws -> [String] {
var tokens: [String] = []
for (token, flags) in try tokenize(string, for: tokenization) {
if !flags.contains(.colocated) {
tokens.append(token)
}
}
return tokens
}
}
extension Database {
// MARK: - FTS5
/// Private type that makes a pre-registered FTS5 tokenizer available
/// through the FTS5Tokenizer protocol.
private final class FTS5RegisteredTokenizer : FTS5Tokenizer {
let xTokenizer: fts5_tokenizer
let tokenizerPointer: OpaquePointer
init(xTokenizer: fts5_tokenizer, contextPointer: UnsafeMutableRawPointer?, arguments: [String]) throws {
guard let xCreate = xTokenizer.xCreate else {
throw DatabaseError(resultCode: .SQLITE_ERROR, message: "nil fts5_tokenizer.xCreate")
}
self.xTokenizer = xTokenizer
var tokenizerPointer: OpaquePointer? = nil
let code: Int32
if let argument = arguments.first {
// Turn [String] into ContiguousArray<UnsafePointer<Int8>>
// (for an alternative implementation see https://oleb.net/blog/2016/10/swift-array-of-c-strings/)
func convertArguments<Result>(_ array: inout ContiguousArray<UnsafePointer<Int8>>, _ car: String, _ cdr: [String], _ body: (ContiguousArray<UnsafePointer<Int8>>) -> Result) -> Result {
return car.withCString { cString in
if let car = cdr.first {
array.append(cString)
return convertArguments(&array, car, Array(cdr.suffix(from: 1)), body)
} else {
return body(array)
}
}
}
var cStrings = ContiguousArray<UnsafePointer<Int8>>()
code = convertArguments(&cStrings, argument, Array(arguments.suffix(from: 1))) { cStrings in
cStrings.withUnsafeBufferPointer { azArg in
xCreate(contextPointer, UnsafeMutablePointer(OpaquePointer(azArg.baseAddress!)), Int32(cStrings.count), &tokenizerPointer)
}
}
} else {
code = xCreate(contextPointer, nil, 0, &tokenizerPointer)
}
guard code == SQLITE_OK else {
throw DatabaseError(resultCode: code, message: "failed fts5_tokenizer.xCreate")
}
if let tokenizerPointer = tokenizerPointer {
self.tokenizerPointer = tokenizerPointer
} else {
throw DatabaseError(resultCode: code, message: "nil tokenizer")
}
}
deinit {
if let delete = xTokenizer.xDelete {
delete(tokenizerPointer)
}
}
func tokenize(context: UnsafeMutableRawPointer?, tokenization: FTS5Tokenization, pText: UnsafePointer<Int8>?, nText: Int32, tokenCallback: @escaping FTS5TokenCallback) -> Int32 {
guard let xTokenize = xTokenizer.xTokenize else {
return SQLITE_ERROR
}
return xTokenize(tokenizerPointer, context, tokenization.rawValue, pText, nText, tokenCallback)
}
}
/// Creates an FTS5 tokenizer, given its descriptor.
///
/// let unicode61 = try db.makeTokenizer(.unicode61())
///
/// It is a programmer error to use the tokenizer outside of a protected
/// database queue, or after the database has been closed.
///
/// Use this method when you implement a custom wrapper tokenizer:
///
/// final class MyTokenizer : FTS5WrapperTokenizer {
/// var wrappedTokenizer: FTS5Tokenizer
///
/// init(db: Database, arguments: [String]) throws {
/// wrappedTokenizer = try db.makeTokenizer(.unicode61())
/// }
/// }
public func makeTokenizer(_ descriptor: FTS5TokenizerDescriptor) throws -> FTS5Tokenizer {
let api = FTS5.api(self)
let xTokenizerPointer: UnsafeMutablePointer<fts5_tokenizer> = .allocate(capacity: 1)
defer { xTokenizerPointer.deallocate() }
let contextHandle: UnsafeMutablePointer<UnsafeMutableRawPointer?> = .allocate(capacity: 1)
defer { contextHandle.deallocate() }
let code = api.pointee.xFindTokenizer!(
UnsafeMutablePointer(mutating: api),
descriptor.name,
contextHandle,
xTokenizerPointer)
guard code == SQLITE_OK else {
throw DatabaseError(resultCode: code)
}
let contextPointer = contextHandle.pointee
return try FTS5RegisteredTokenizer(xTokenizer: xTokenizerPointer.pointee, contextPointer: contextPointer, arguments: descriptor.arguments)
}
}
#endif
|
mit
|
76cd0f8560a84cd2ac67db6268f859eb
| 48.168224 | 228 | 0.558924 | 5.145232 | false | false | false | false |
caolsen/CircularSlider
|
CircularSliderExample/CircularTrig.swift
|
2
|
6798
|
//
// CircularTrig.swift
//
// Created by Christopher Olsen on 03/03/16.
// Copyright © 2016 Christopher Olsen. All rights reserved.
//
import UIKit
open class CircularTrig {
open class func angleRelativeToNorthFromPoint(_ fromPoint: CGPoint, toPoint: CGPoint) -> CGFloat {
var v = CGPoint(x: toPoint.x - fromPoint.x, y: toPoint.y - fromPoint.y)
let vmag = CGFloat(sqrt(square(Double(v.x)) + square(Double(v.y))))
v.x /= vmag
v.y /= vmag
let cartesianRadians = Double(atan2(v.y, v.x))
// Need to convert from cartesian style radians to compass style
var compassRadians = cartesianToCompass(cartesianRadians)
if (compassRadians < 0) {
compassRadians += (2 * Double.pi)
}
assert(compassRadians >= 0 && compassRadians <= 2 * Double.pi, "angleRelativeToNorth should be always positive")
return CGFloat(toDeg(compassRadians))
}
open class func pointOnRadius(_ radius: CGFloat, atAngleFromNorth: CGFloat) -> CGPoint {
//Get the point on the circle for this angle
var result = CGPoint()
// Need to adjust from 'compass' style angle to cartesian angle
let cartesianAngle = CGFloat(compassToCartesian(toRad(Double(atAngleFromNorth))))
result.y = round(radius * sin(cartesianAngle))
result.x = round(radius * cos(cartesianAngle))
return result
}
// MARK: Draw Arcs
open class func drawFilledCircleInContext(_ ctx: CGContext, center: CGPoint, radius: CGFloat) -> CGRect {
let frame = CGRect(x: center.x - radius, y: center.y - radius, width: 2 * radius, height: 2 * radius)
ctx.fillEllipse(in: frame)
return frame
}
open class func drawUnfilledCircleInContext(_ ctx: CGContext, center: CGPoint, radius: CGFloat, lineWidth: CGFloat, maximumAngle: CGFloat, lineCap: CGLineCap) {
// by using maximumAngle an incomplete circle can be drawn
drawUnfilledArcInContext(ctx, center: center, radius: radius, lineWidth: lineWidth, fromAngleFromNorth: 0, toAngleFromNorth: maximumAngle, lineCap: lineCap)
}
open class func drawUnfilledArcInContext(_ ctx: CGContext, center: CGPoint, radius: CGFloat, lineWidth: CGFloat, fromAngleFromNorth: CGFloat, toAngleFromNorth: CGFloat, lineCap: CGLineCap) {
let cartesianFromAngle = compassToCartesian(toRad(Double(fromAngleFromNorth)))
let cartesianToAngle = compassToCartesian(toRad(Double(toAngleFromNorth)))
ctx.addArc(
center: CGPoint(x: center.x, y: center.y), // arc start point
radius: radius, // arc radius from center
startAngle: CGFloat(cartesianFromAngle),
endAngle: CGFloat(cartesianToAngle),
clockwise: false) // iOS flips the y coordinate so anti-clockwise becomes clockwise (desired)!
ctx.setLineWidth(lineWidth)
ctx.setLineCap(lineCap)
ctx.drawPath(using: CGPathDrawingMode.stroke)
}
open class func drawUnfilledGradientArcInContext(_ ctx: CGContext, center: CGPoint, radius: CGFloat, lineWidth: CGFloat, maximumAngle: CGFloat, colors: [UIColor], lineCap: CGLineCap) {
// ensure two colors exist to create a gradient between
guard colors.count == 2 else {
return
}
let cartesianFromAngle = compassToCartesian(toRad(Double(0)))
let cartesianToAngle = compassToCartesian(toRad(Double(maximumAngle)))
ctx.saveGState()
let path = UIBezierPath(arcCenter: center, radius: radius, startAngle: CGFloat(cartesianFromAngle), endAngle: CGFloat(cartesianToAngle), clockwise: true)
let containerPath = CGPath(__byStroking: path.cgPath, transform: nil, lineWidth: CGFloat(lineWidth), lineCap: lineCap, lineJoin: CGLineJoin.round, miterLimit: lineWidth)
if let containerPath = containerPath {
ctx.addPath(containerPath)
}
ctx.clip()
let baseSpace = CGColorSpaceCreateDeviceRGB()
let colors = [colors[1].cgColor, colors[0].cgColor] as CFArray
let gradient = CGGradient(colorsSpace: baseSpace, colors: colors, locations: nil)
let startPoint = CGPoint(x: center.x - radius, y: center.y + radius)
let endPoint = CGPoint(x: center.x + radius, y: center.y - radius)
if let gradient = gradient {
ctx.drawLinearGradient(gradient, start: startPoint, end: endPoint, options: .drawsBeforeStartLocation)
}
ctx.restoreGState()
}
open class func degreesForArcLength(_ arcLength: CGFloat, onCircleWithRadius radius: CGFloat, withMaximumAngle degrees: CGFloat) -> CGFloat {
let totalCircumference = CGFloat(2 * Double.pi) * radius
let arcRatioToCircumference = arcLength / totalCircumference
return degrees * arcRatioToCircumference // If arcLength is exactly half circumference, that is exactly half a circle in degrees
}
// MARK: Calculate radii of arcs with line widths
/*
* For an unfilled arc.
*
* Radius of outer arc (center to outside edge) | ---------
* = radius + 0.5 * lineWidth | +++++++++++++++
* | /++/++++ --- ++++\++\
* Radius of inner arc (center to inside edge) | /++/++/ \++\++\
* = radius - (0.5 * lineWidth) | |++|++| . |++|++|
* outer edge^ ^-radius-^ ^inner edge
*
*/
open class func outerRadiuOfUnfilledArcWithRadius(_ radius: CGFloat, lineWidth: CGFloat) -> CGFloat {
return radius + 0.5 * lineWidth
}
open class func innerRadiusOfUnfilledArcWithRadius(_ radius :CGFloat, lineWidth: CGFloat) -> CGFloat {
return radius - 0.5 * lineWidth
}
}
// MARK: - Utility Math
extension CircularTrig {
/**
* Macro for converting radian degrees from 'compass style' reference (0 radians is along Y axis (ie North on a compass))
* to cartesian reference (0 radians is along X axis).
*
* @param rad Radian degrees to convert from 'Compass' reference
*
* @return Radian Degrees in Cartesian reference
*/
fileprivate class func toRad(_ degrees: Double) -> Double {
return ((Double.pi * degrees) / 180.0)
}
fileprivate class func toDeg(_ radians: Double) -> Double {
return ((180.0 * radians) / Double.pi)
}
fileprivate class func square(_ value: Double) -> Double {
return value * value
}
/**
* Macro for converting radian degrees from cartesian reference (0 radians is along X axis)
* to 'compass style' reference (0 radians is along Y axis (ie North on a compass)).
*
* @param rad Radian degrees to convert from Cartesian reference
*
* @return Radian Degrees in 'Compass' reference
*/
fileprivate class func cartesianToCompass(_ radians: Double) -> Double {
return radians + (Double.pi/2)
}
fileprivate class func compassToCartesian(_ radians: Double) -> Double {
return radians - (Double.pi/2)
}
}
|
mit
|
e8b0b1a3103f80eeb2b52d85354f0e9a
| 40.699387 | 192 | 0.675886 | 4.200865 | false | false | false | false |
daniel-barros/TV-Calendar
|
TraktKit/Common/Search.swift
|
1
|
3550
|
//
// Search.swift
// TraktKit
//
// Created by Maximilian Litteral on 11/26/15.
// Copyright © 2015 Maximilian Litteral. All rights reserved.
//
import Foundation
extension TraktManager {
/**
Search by titles, descriptions, translated titles, aliases, and people. Results are ordered by the most relevant score. Specify the type of results by sending a single value or a comma delimited string for multiple types.
Status Code: 200
📄 Pagination
✨ Extended Info
🎚 Filters
*/
@discardableResult
public func search(query: String,
types: [SearchType],
extended: [ExtendedType] = [.Min],
pagination: Pagination? = nil,
filters: [Filter]? = nil,
fields: [SearchType.Field]? = nil,
completion: @escaping SearchCompletionHandler) -> URLSessionDataTask? {
let typesString = types.map { $0.rawValue }.joined(separator: ",") // Search with multiple types
var query: [String: String] = ["query": query,
"extended": extended.queryString()]
// pagination
if let pagination = pagination {
for (key, value) in pagination.value() {
query[key] = value
}
}
// Filters
if let filters = filters {
for (key, value) in (filters.map { $0.value() }) {
query[key] = value
}
}
// Fields
if let fields = fields {
query["fields"] = fields.map { $0.title }.joined(separator: ",")
}
//
guard let request = mutableRequest(
forPath: "search/\(typesString)",
withQuery: query,
isAuthorized: false,
withHTTPMethod: .GET
)
else { return nil }
return performRequest(request: request, expectingStatusCode: StatusCodes.Success, completion: completion)
}
/**
Lookup items by their Trakt, IMDB, TMDB, TVDB, or TVRage ID. If you use the search url without a `type` it might return multiple items if the `id_type` is not globally unique. Specify the `type` of results by sending a single value or a comma delimited string for multiple types.
Status Code: 200
📄 Pagination
✨ Extended Info
*/
@discardableResult
public func lookup(id: LookupType,
extended: [ExtendedType] = [.Min],
type: SearchType,
pagination: Pagination? = nil,
completion: @escaping SearchCompletionHandler) -> URLSessionDataTask? {
var query: [String: String] = ["extended": extended.queryString(),
"type": type.rawValue]
// pagination
if let pagination = pagination {
for (key, value) in pagination.value() {
query[key] = value
}
}
guard
let request = mutableRequest(forPath: "search/\(id.name())/\(id.id())",
withQuery: query,
isAuthorized: false,
withHTTPMethod: .GET) else { return nil }
return performRequest(request: request, expectingStatusCode: StatusCodes.Success, completion: completion)
}
}
|
gpl-3.0
|
fba7e5c8c827a4b5270e5ebdfe36789a
| 36.221053 | 284 | 0.526584 | 5.34947 | false | false | false | false |
bengottlieb/HelpKit
|
HelpKit/Framework Code/Walkthrough.Scene.swift
|
1
|
2787
|
//
// Walkthrough.Scene.swift
// HelpKit
//
// Created by Ben Gottlieb on 2/18/17.
// Copyright © 2017 Stand Alone, Inc. All rights reserved.
//
import UIKit
//extension Walkthrough {
open class WalkthroughScene: UIViewController {
public var replacesExisting = false
public var walkthrough: Walkthrough!
public var script = Walkthrough.Script()
open override func viewDidLoad() {
super.viewDidLoad()
self.view.backgroundColor = nil
}
public func hide(batchID: String) {
self.walkthrough.viewsWith(batchID: batchID).forEach { $0.isHidden = true }
}
public func hideAll() {
self.view.subviews.forEach { $0.isHidden = true }
}
func remove() {
if !self.isViewLoaded || self.view.superview == nil { return }
self.viewWillDisappear(true)
self.view.removeFromSuperview()
self.viewDidDisappear(true)
}
@discardableResult public func apply(_ transition: Walkthrough.Transition, direction: Walkthrough.Direction = .out, over duration: TimeInterval) -> TimeInterval {
return self.walkthrough.apply(transition, direction: direction, to: self.view.subviews, over: duration)
}
func show(in parent: Walkthrough) {
self.view.frame = parent.contentFrame
self.viewWillAppear(true)
parent.view.addSubview(self.view)
self.script.start(in: self)
self.viewDidAppear(true)
}
}
//}
extension UIView {
func apply(_ transition: Walkthrough.Transition?, for direction: Walkthrough.Direction, duration: TimeInterval, in scene: Scene, completion: (() -> Void)? = nil) -> TimeInterval {
guard let transition = transition else {
completion?()
return 0
}
let finalState: AnimatableState?
let actualDuration = duration == 0 ? transition.duration ?? 0 : duration
switch direction {
case .in:
self.animatableState = transition.transform(state: self.animatableState, direction: .in, endPoint: .begin, in: scene)
finalState = transition.transform(state: self.animatableState, direction: .in, endPoint: .end, in: scene)
self.isHidden = false
case .out:
self.animatableState = transition.transform(state: self.animatableState, direction: .out, endPoint: .begin, in: scene)
finalState = transition.transform(state: self.animatableState, direction: .out, endPoint: .end, in: scene)
case .none:
finalState = transition.transform(state: self.animatableState, direction: .in, endPoint: .end, in: scene)
self.isHidden = false
}
UIView.animate(withDuration: actualDuration, delay: transition.delay, options: [], animations: {
self.animatableState = finalState
}) { finished in
completion?()
}
return transition.delay > 0 ? 0 : actualDuration
}
}
extension WalkthroughScene {
struct PersistedView {
let oldView: UIView
let newView: UIView
}
}
|
mit
|
f951ec49455ed4ba0bee19bef62f65e0
| 28.638298 | 180 | 0.712491 | 3.759784 | false | false | false | false |
josve05a/wikipedia-ios
|
Wikipedia/Code/EditFunnel.swift
|
2
|
9433
|
@objc public enum EditFunnelSource: Int {
case titleDescription
case pencil
case highlight
case unknown
var stringValue: String? {
switch self {
case .titleDescription:
return "title_description"
case .pencil:
return "pencil"
case .highlight:
return "highlight"
case .unknown:
return nil
}
}
}
// https://meta.wikimedia.org/wiki/Schema:MobileWikiAppEdit
@objc final class EditFunnel: EventLoggingFunnel, EventLoggingStandardEventProviding {
@objc public static let shared = EditFunnel()
var sessionToken: String?
private override init() {
super.init(schema: "MobileWikiAppEdit", version: 19082700)
}
enum Action: String {
case start
case preview
case saved
case captchaShown
case captchaFailure
case abuseFilterWarning
case abuseFilterError
case editSummaryTap
case editSummaryShown
case abuseFilterWarningIgnore
case abuseFilterWarningBack
case saveAttempt
case error
case ready
case onboarding
}
private enum WikidataDescriptionEdit: String {
case new
case existing
init(isAddingNewTitleDescription: Bool) {
self = isAddingNewTitleDescription ? .new : .existing
}
}
private func event(action: Action, source: EditFunnelSource? = nil, sessionToken: String? = nil, wikidataDescriptionEdit: WikidataDescriptionEdit? = nil, editSummaryType: EditSummaryViewCannedButtonType? = nil, abuseFilterName: String? = nil, errorText: String? = nil, revision: Int? = nil) -> Dictionary<String, Any> {
var event: [String : Any] = ["action": action.rawValue]
if let source = source, let stringValue = source.stringValue {
event["source"] = stringValue
}
if let revision = revision {
event["revID"] = revision
}
if let editSummaryType = editSummaryType {
event["editSummaryTapped"] = editSummaryType.eventLoggingKey
}
if let abuseFilterName = abuseFilterName {
event["abuseFilterName"] = abuseFilterName
}
if let sessionToken = sessionToken {
event["session_token"] = sessionToken
}
if let wikidataDescriptionEdit = wikidataDescriptionEdit {
event["wikidataDescriptionEdit"] = wikidataDescriptionEdit.rawValue
}
if let errorText = errorText {
event["errorText"] = errorText
}
return event
}
override func preprocessData(_ eventData: [AnyHashable : Any]) -> [AnyHashable : Any] {
guard
let sessionID = sessionID,
let appInstallID = appInstallID
else {
assertionFailure("Missing required properties (sessionID or appInstallID); event won't be logged")
return eventData
}
guard let event = eventData as? [String: Any] else {
assertionFailure("Expected dictionary with keys of type String")
return eventData
}
let requiredData: [String: Any] = ["session_token": sessionID, "anon": isAnon, "app_install_id": appInstallID, "client_dt": timestamp]
return requiredData.merging(event, uniquingKeysWith: { (first, _) in first })
}
// MARK: Start
@objc(logSectionEditingStartFromSource:language:)
public func logSectionEditingStart(from source: EditFunnelSource, language: String) {
logStart(source: source, language: language)
}
@objc(logTitleDescriptionEditingStartFromSource:language:)
public func logTitleDescriptionEditingStart(from source: EditFunnelSource, language: String) {
let wikidataDescriptionEdit: WikidataDescriptionEdit
if source == .titleDescription {
wikidataDescriptionEdit = .new
} else {
wikidataDescriptionEdit = .existing
}
logStart(source: source, wikidataDescriptionEdit: wikidataDescriptionEdit, language: language)
}
private func logStart(source: EditFunnelSource, wikidataDescriptionEdit: WikidataDescriptionEdit? = nil, language: String) {
// session token should be regenerated at every 'start' event
sessionToken = singleUseUUID()
log(event(action: .start, source: source, sessionToken: sessionToken, wikidataDescriptionEdit: wikidataDescriptionEdit), language: language)
}
// MARK: Onboarding
@objc(logOnboardingPresentationInitiatedBySource:language:)
public func logOnboardingPresentation(initiatedBy source: EditFunnelSource, language: String) {
logOnboardingPresentation(source: source, language: language)
}
private func logOnboardingPresentation(source: EditFunnelSource, language: String) {
log(event(action: .onboarding, source: source), language: language)
}
// MARK: Ready
@objc(logTitleDescriptionReadyToEditFromSource:isAddingNewTitleDescription:language:)
public func logTitleDescriptionReadyToEditFrom(from source: EditFunnelSource, isAddingNewTitleDescription: Bool, language: String) {
log(event(action: .ready, source: source, wikidataDescriptionEdit: WikidataDescriptionEdit(isAddingNewTitleDescription: isAddingNewTitleDescription)), language: language)
}
public func logSectionReadyToEdit(from source: EditFunnelSource, language: String?) {
log(event(action: .ready, source: source), language: language)
}
// MARK: Preview
public func logEditPreviewForArticle(from source: EditFunnelSource, language: String?) {
log(event(action: .preview, source: source), language: language)
}
// MARK: Save attempt
public func logTitleDescriptionSaveAttempt(source: EditFunnelSource, isAddingNewTitleDescription: Bool, language: String?) {
log(event(action: .saveAttempt, source: source, wikidataDescriptionEdit: WikidataDescriptionEdit(isAddingNewTitleDescription: isAddingNewTitleDescription)), language: language)
}
public func logSectionSaveAttempt(source: EditFunnelSource, language: String?) {
log(event(action: .saveAttempt, source: source), language: language)
}
// MARK: Saved
public func logTitleDescriptionSaved(source: EditFunnelSource, isAddingNewTitleDescription: Bool, language: String?) {
log(event(action: .saved, source: source, wikidataDescriptionEdit: WikidataDescriptionEdit(isAddingNewTitleDescription: isAddingNewTitleDescription)), language: language)
}
public func logSectionSaved(source: EditFunnelSource, revision: Int?, language: String?) {
log(event(action: .saved, source: source, revision: revision), language: language)
}
// MARK: Error
public func logTitleDescriptionSaveError(source: EditFunnelSource, isAddingNewTitleDescription: Bool, language: String?, errorText: String) {
log(event(action: .error, source: source, wikidataDescriptionEdit: WikidataDescriptionEdit(isAddingNewTitleDescription: isAddingNewTitleDescription), errorText: errorText), language: language)
}
public func logSectionSaveError(source: EditFunnelSource, language: String?, errorText: String) {
log(event(action: .error, source: source, errorText: errorText), language: language)
}
public func logSectionHighlightToEditError(language: String?) {
log(event(action: .error, source: .highlight, errorText: "non-editable"), language: language)
}
// MARK: Section edit summary
public func logSectionEditSummaryTap(source: EditFunnelSource, editSummaryType: EditSummaryViewCannedButtonType, language: String?) {
log(event(action: .editSummaryTap, source: source, editSummaryType: editSummaryType), language: language)
}
public func logSectionEditSummaryShown(source: EditFunnelSource, language: String?) {
log(event(action: .editSummaryShown, source: source), language: language)
}
// MARK: Captcha
public func logCaptchaShownForSectionEdit(source: EditFunnelSource, language: String?) {
log(event(action: .captchaShown, source: source), language: language)
}
public func logCaptchaFailedForSectionEdit(source: EditFunnelSource, language: String?) {
log(event(action: .captchaFailure, source: source), language: language)
}
// MARK: Abuse filter
public func logAbuseFilterWarningForSectionEdit(abuseFilterName: String, source: EditFunnelSource, language: String?) {
log(event(action: .abuseFilterWarning, source: source, abuseFilterName: abuseFilterName), language: language)
}
public func logAbuseFilterWarningBackForSectionEdit(abuseFilterName: String, source: EditFunnelSource, language: String?) {
log(event(action: .abuseFilterWarningBack, source: source, abuseFilterName: abuseFilterName), language: language)
}
public func logAbuseFilterWarningIgnoreForSectionEdit(abuseFilterName: String, source: EditFunnelSource, language: String?) {
log(event(action: .abuseFilterWarningIgnore, source: source, abuseFilterName: abuseFilterName), language: language)
}
public func logAbuseFilterErrorForSectionEdit(abuseFilterName: String, source: EditFunnelSource, language: String?) {
log(event(action: .abuseFilterError, source: source, abuseFilterName: abuseFilterName), language: language)
}
}
|
mit
|
d237c364c32b1404d3aff95cb83bebca
| 40.555066 | 323 | 0.702958 | 5.326369 | false | false | false | false |
paymentez/paymentez-ios
|
PaymentSDK/PaymentAddViewController.swift
|
1
|
2050
|
//
// PaymentAddViewController.swift
// PaymentSDK
//
// Created by Gustavo Sotelo on 11/05/16.
// Copyright © 2016 Payment. All rights reserved.
//
import UIKit
class PaymentAddViewController: UIViewController, UIWebViewDelegate {
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
var urlToLoad = ""
var callback:((_ error:PaymentSDKError?, _ isClose:Bool, _ added:Bool) -> Void)? = nil
@IBOutlet weak var webView: UIWebView!
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
}
init(callback:@escaping (_ error:PaymentSDKError?, _ isClose:Bool, _ added:Bool) -> Void)
{
self.urlToLoad = ""
self.callback = callback
let privatePath : NSString? = Bundle.main.privateFrameworksPath as NSString?
if privatePath != nil {
let path = privatePath!.appendingPathComponent("PaymentSDK.framework")
let bundle = Bundle(path: path)
super.init(nibName: "PaymentAddViewController", bundle: bundle)
}
else
{
super.init()
}
}
override func viewDidLoad() {
super.viewDidLoad()
self.activityIndicator.startAnimating()
// Do any additional setup after loading the view.
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
@IBAction func closeAction(_ sender: Any) {
self.dismiss(animated: true) {
self.callback!(nil, true, false)
}
}
}
/*
// 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.
}
*/
|
mit
|
c2f6008e2229e170c5c1c74c22a07627
| 26.689189 | 106 | 0.618838 | 4.961259 | false | false | false | false |
KrishMunot/swift
|
test/SILGen/errors.swift
|
1
|
42431
|
// RUN: %target-swift-frontend -parse-stdlib -emit-silgen -verify %s | FileCheck %s
import Swift
class Cat {}
enum HomeworkError : ErrorProtocol {
case TooHard
case TooMuch
case CatAteIt(Cat)
}
// CHECK: sil hidden @_TF6errors10make_a_cat{{.*}} : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol) {
// CHECK: [[T0:%.*]] = function_ref @_TFC6errors3CatC{{.*}} : $@convention(method) (@thick Cat.Type) -> @owned Cat
// CHECK-NEXT: [[T1:%.*]] = metatype $@thick Cat.Type
// CHECK-NEXT: [[T2:%.*]] = apply [[T0]]([[T1]])
// CHECK-NEXT: return [[T2]] : $Cat
func make_a_cat() throws -> Cat {
return Cat()
}
// CHECK: sil hidden @_TF6errors15dont_make_a_cat{{.*}} : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol) {
// CHECK: [[BOX:%.*]] = alloc_existential_box $ErrorProtocol, $HomeworkError
// CHECK-NEXT: [[ADDR:%.*]] = project_existential_box $HomeworkError in [[BOX]] : $ErrorProtocol
// CHECK-NEXT: [[T0:%.*]] = metatype $@thin HomeworkError.Type
// CHECK-NEXT: [[T1:%.*]] = enum $HomeworkError, #HomeworkError.TooHard!enumelt
// CHECK-NEXT: store [[T1]] to [[ADDR]]
// CHECK-NEXT: builtin "willThrow"
// CHECK-NEXT: throw [[BOX]]
func dont_make_a_cat() throws -> Cat {
throw HomeworkError.TooHard
}
// CHECK: sil hidden @_TF6errors11dont_return{{.*}} : $@convention(thin) <T> (@in T) -> (@out T, @error ErrorProtocol) {
// CHECK: [[BOX:%.*]] = alloc_existential_box $ErrorProtocol, $HomeworkError
// CHECK-NEXT: [[ADDR:%.*]] = project_existential_box $HomeworkError in [[BOX]] : $ErrorProtocol
// CHECK-NEXT: [[T0:%.*]] = metatype $@thin HomeworkError.Type
// CHECK-NEXT: [[T1:%.*]] = enum $HomeworkError, #HomeworkError.TooMuch!enumelt
// CHECK-NEXT: store [[T1]] to [[ADDR]]
// CHECK-NEXT: builtin "willThrow"
// CHECK-NEXT: destroy_addr %1 : $*T
// CHECK-NEXT: throw [[BOX]]
func dont_return<T>(_ argument: T) throws -> T {
throw HomeworkError.TooMuch
}
// CHECK: sil hidden @_TF6errors16all_together_nowFSbCS_3Cat : $@convention(thin) (Bool) -> @owned Cat {
// CHECK: bb0(%0 : $Bool):
// CHECK: [[DR_FN:%.*]] = function_ref @_TF6errors11dont_returnur{{.*}} :
// Branch on the flag.
// CHECK: cond_br {{%.*}}, [[FLAG_TRUE:bb[0-9]+]], [[FLAG_FALSE:bb[0-9]+]]
// In the true case, call make_a_cat().
// CHECK: [[FLAG_TRUE]]:
// CHECK: [[MAC_FN:%.*]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol)
// CHECK-NEXT: try_apply [[MAC_FN]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[MAC_NORMAL:bb[0-9]+]], error [[MAC_ERROR:bb[0-9]+]]
// CHECK: [[MAC_NORMAL]]([[T0:%.*]] : $Cat):
// CHECK-NEXT: br [[TERNARY_CONT:bb[0-9]+]]([[T0]] : $Cat)
// In the false case, call dont_make_a_cat().
// CHECK: [[FLAG_FALSE]]:
// CHECK: [[DMAC_FN:%.*]] = function_ref @_TF6errors15dont_make_a_catFzT_CS_3Cat : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol)
// CHECK-NEXT: try_apply [[DMAC_FN]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[DMAC_NORMAL:bb[0-9]+]], error [[DMAC_ERROR:bb[0-9]+]]
// CHECK: [[DMAC_NORMAL]]([[T0:%.*]] : $Cat):
// CHECK-NEXT: br [[TERNARY_CONT]]([[T0]] : $Cat)
// Merge point for the ternary operator. Call dont_return with the result.
// CHECK: [[TERNARY_CONT]]([[T0:%.*]] : $Cat):
// CHECK-NEXT: [[ARG_TEMP:%.*]] = alloc_stack $Cat
// CHECK-NEXT: store [[T0]] to [[ARG_TEMP]]
// CHECK-NEXT: [[RET_TEMP:%.*]] = alloc_stack $Cat
// CHECK-NEXT: try_apply [[DR_FN]]<Cat>([[RET_TEMP]], [[ARG_TEMP]]) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @error ErrorProtocol), normal [[DR_NORMAL:bb[0-9]+]], error [[DR_ERROR:bb[0-9]+]]
// CHECK: [[DR_NORMAL]]({{%.*}} : $()):
// CHECK-NEXT: [[T0:%.*]] = load [[RET_TEMP]] : $*Cat
// CHECK-NEXT: dealloc_stack [[RET_TEMP]]
// CHECK-NEXT: dealloc_stack [[ARG_TEMP]]
// CHECK-NEXT: br [[RETURN:bb[0-9]+]]([[T0]] : $Cat)
// Return block.
// CHECK: [[RETURN]]([[T0:%.*]] : $Cat):
// CHECK-NEXT: return [[T0]] : $Cat
// Catch dispatch block.
// CHECK: [[CATCH:bb[0-9]+]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: [[SRC_TEMP:%.*]] = alloc_stack $ErrorProtocol
// CHECK-NEXT: store [[ERROR]] to [[SRC_TEMP]]
// CHECK-NEXT: [[DEST_TEMP:%.*]] = alloc_stack $HomeworkError
// CHECK-NEXT: checked_cast_addr_br copy_on_success ErrorProtocol in [[SRC_TEMP]] : $*ErrorProtocol to HomeworkError in [[DEST_TEMP]] : $*HomeworkError, [[IS_HWE:bb[0-9]+]], [[NOT_HWE:bb[0-9]+]]
// Catch HomeworkError.
// CHECK: [[IS_HWE]]:
// CHECK-NEXT: [[T0:%.*]] = load [[DEST_TEMP]] : $*HomeworkError
// CHECK-NEXT: switch_enum [[T0]] : $HomeworkError, case #HomeworkError.CatAteIt!enumelt.1: [[MATCH:bb[0-9]+]], default [[NO_MATCH:bb[0-9]+]]
// Catch HomeworkError.CatAteIt.
// CHECK: [[MATCH]]([[T0:%.*]] : $Cat):
// CHECK-NEXT: debug_value
// CHECK-NEXT: dealloc_stack [[DEST_TEMP]]
// CHECK-NEXT: destroy_addr [[SRC_TEMP]]
// CHECK-NEXT: dealloc_stack [[SRC_TEMP]]
// CHECK-NEXT: br [[RETURN]]([[T0]] : $Cat)
// Catch other HomeworkErrors.
// CHECK: [[NO_MATCH]]:
// CHECK-NEXT: dealloc_stack [[DEST_TEMP]]
// CHECK-NEXT: dealloc_stack [[SRC_TEMP]]
// CHECK-NEXT: br [[CATCHALL:bb[0-9]+]]
// Catch other types.
// CHECK: [[NOT_HWE]]:
// CHECK-NEXT: dealloc_stack [[DEST_TEMP]]
// CHECK-NEXT: dealloc_stack [[SRC_TEMP]]
// CHECK-NEXT: br [[CATCHALL:bb[0-9]+]]
// Catch all.
// CHECK: [[CATCHALL]]:
// CHECK: [[T0:%.*]] = function_ref @_TFC6errors3CatC{{.*}} : $@convention(method) (@thick Cat.Type) -> @owned Cat
// CHECK-NEXT: [[T1:%.*]] = metatype $@thick Cat.Type
// CHECK-NEXT: [[T2:%.*]] = apply [[T0]]([[T1]])
// CHECK-NEXT: strong_release [[ERROR]] : $ErrorProtocol
// CHECK-NEXT: br [[RETURN]]([[T2]] : $Cat)
// Landing pad.
// CHECK: [[MAC_ERROR]]([[T0:%.*]] : $ErrorProtocol):
// CHECK-NEXT: br [[CATCH]]([[T0]] : $ErrorProtocol)
// CHECK: [[DMAC_ERROR]]([[T0:%.*]] : $ErrorProtocol):
// CHECK-NEXT: br [[CATCH]]([[T0]] : $ErrorProtocol)
// CHECK: [[DR_ERROR]]([[T0:%.*]] : $ErrorProtocol):
// CHECK-NEXT: dealloc_stack
// CHECK-NEXT: dealloc_stack
// CHECK-NEXT: br [[CATCH]]([[T0]] : $ErrorProtocol)
func all_together_now(_ flag: Bool) -> Cat {
do {
return try dont_return(flag ? make_a_cat() : dont_make_a_cat())
} catch HomeworkError.CatAteIt(let cat) {
return cat
} catch _ {
return Cat()
}
}
// Catch in non-throwing context.
// CHECK-LABEL: sil hidden @_TF6errors11catch_a_catFT_CS_3Cat : $@convention(thin) () -> @owned Cat
// CHECK-NEXT: bb0:
// CHECK: [[F:%.*]] = function_ref @_TFC6errors3CatC{{.*}} : $@convention(method) (@thick Cat.Type) -> @owned Cat
// CHECK-NEXT: [[M:%.*]] = metatype $@thick Cat.Type
// CHECK-NEXT: [[V:%.*]] = apply [[F]]([[M]])
// CHECK-NEXT: return [[V]] : $Cat
func catch_a_cat() -> Cat {
do {
return Cat()
} catch _ as HomeworkError {} // expected-warning {{'catch' block is unreachable because no errors are thrown in 'do' block}}
}
// Initializers.
class HasThrowingInit {
var field: Int
init(value: Int) throws {
field = value
}
}
// CHECK-LABEL: sil hidden @_TFC6errors15HasThrowingInitc{{.*}} : $@convention(method) (Int, @owned HasThrowingInit) -> (@owned HasThrowingInit, @error ErrorProtocol) {
// CHECK: [[T0:%.*]] = mark_uninitialized [rootself] %1 : $HasThrowingInit
// CHECK-NEXT: [[T1:%.*]] = ref_element_addr [[T0]] : $HasThrowingInit
// CHECK-NEXT: assign %0 to [[T1]] : $*Int
// CHECK-NEXT: return [[T0]] : $HasThrowingInit
// CHECK-LABEL: sil hidden @_TFC6errors15HasThrowingInitC{{.*}} : $@convention(method) (Int, @thick HasThrowingInit.Type) -> (@owned HasThrowingInit, @error ErrorProtocol)
// CHECK: [[SELF:%.*]] = alloc_ref $HasThrowingInit
// CHECK: [[T0:%.*]] = function_ref @_TFC6errors15HasThrowingInitc{{.*}} : $@convention(method) (Int, @owned HasThrowingInit) -> (@owned HasThrowingInit, @error ErrorProtocol)
// CHECK-NEXT: try_apply [[T0]](%0, [[SELF]]) : $@convention(method) (Int, @owned HasThrowingInit) -> (@owned HasThrowingInit, @error ErrorProtocol), normal bb1, error bb2
// CHECK: bb1([[SELF:%.*]] : $HasThrowingInit):
// CHECK-NEXT: return [[SELF]]
// CHECK: bb2([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: builtin "willThrow"
// CHECK-NEXT: throw [[ERROR]]
enum ColorError : ErrorProtocol {
case Red, Green, Blue
}
//CHECK-LABEL: sil hidden @_TF6errors6IThrowFzT_Vs5Int32
//CHECK: builtin "willThrow"
//CHECK-NEXT: throw
func IThrow() throws -> Int32 {
throw ColorError.Red
return 0 // expected-warning {{will never be executed}}
}
// Make sure that we are not emitting calls to 'willThrow' on rethrow sites.
//CHECK-LABEL: sil hidden @_TF6errors12DoesNotThrowFzT_Vs5Int32
//CHECK-NOT: builtin "willThrow"
//CHECK: return
func DoesNotThrow() throws -> Int32 {
try IThrow()
return 2
}
// rdar://20782111
protocol Doomed {
func check() throws
}
// CHECK-LABEL: sil hidden [transparent] [thunk] @_TTWV6errors12DoomedStructS_6DoomedS_FS1_5check{{.*}} : $@convention(witness_method) (@in_guaranteed DoomedStruct) -> @error ErrorProtocol
// CHECK: [[TEMP:%.*]] = alloc_stack $DoomedStruct
// CHECK: copy_addr %0 to [initialization] [[TEMP]]
// CHECK: [[SELF:%.*]] = load [[TEMP]] : $*DoomedStruct
// CHECK: [[T0:%.*]] = function_ref @_TFV6errors12DoomedStruct5check{{.*}} : $@convention(method) (DoomedStruct) -> @error ErrorProtocol
// CHECK-NEXT: try_apply [[T0]]([[SELF]])
// CHECK: bb1([[T0:%.*]] : $()):
// CHECK: [[T0:%.*]] = tuple ()
// CHECK: dealloc_stack [[TEMP]]
// CHECK: return [[T0]] : $()
// CHECK: bb2([[T0:%.*]] : $ErrorProtocol):
// CHECK: builtin "willThrow"([[T0]] : $ErrorProtocol)
// CHECK: dealloc_stack [[TEMP]]
// CHECK: throw [[T0]] : $ErrorProtocol
struct DoomedStruct : Doomed {
func check() throws {}
}
// CHECK-LABEL: sil hidden [transparent] [thunk] @_TTWC6errors11DoomedClassS_6DoomedS_FS1_5check{{.*}} : $@convention(witness_method) (@in_guaranteed DoomedClass) -> @error ErrorProtocol {
// CHECK: [[TEMP:%.*]] = alloc_stack $DoomedClass
// CHECK: copy_addr %0 to [initialization] [[TEMP]]
// CHECK: [[SELF:%.*]] = load [[TEMP]] : $*DoomedClass
// CHECK: [[T0:%.*]] = class_method [[SELF]] : $DoomedClass, #DoomedClass.check!1 : (DoomedClass) -> () throws -> () , $@convention(method) (@guaranteed DoomedClass) -> @error ErrorProtocol
// CHECK-NEXT: try_apply [[T0]]([[SELF]])
// CHECK: bb1([[T0:%.*]] : $()):
// CHECK: [[T0:%.*]] = tuple ()
// CHECK: strong_release [[SELF]] : $DoomedClass
// CHECK: dealloc_stack [[TEMP]]
// CHECK: return [[T0]] : $()
// CHECK: bb2([[T0:%.*]] : $ErrorProtocol):
// CHECK: builtin "willThrow"([[T0]] : $ErrorProtocol)
// CHECK: strong_release [[SELF]] : $DoomedClass
// CHECK: dealloc_stack [[TEMP]]
// CHECK: throw [[T0]] : $ErrorProtocol
class DoomedClass : Doomed {
func check() throws {}
}
// CHECK-LABEL: sil hidden [transparent] [thunk] @_TTWV6errors11HappyStructS_6DoomedS_FS1_5check{{.*}} : $@convention(witness_method) (@in_guaranteed HappyStruct) -> @error ErrorProtocol
// CHECK: [[TEMP:%.*]] = alloc_stack $HappyStruct
// CHECK: copy_addr %0 to [initialization] [[TEMP]]
// CHECK: [[SELF:%.*]] = load [[TEMP]] : $*HappyStruct
// CHECK: [[T0:%.*]] = function_ref @_TFV6errors11HappyStruct5check{{.*}} : $@convention(method) (HappyStruct) -> ()
// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
// CHECK: [[T1:%.*]] = tuple ()
// CHECK: dealloc_stack [[TEMP]]
// CHECK: return [[T1]] : $()
struct HappyStruct : Doomed {
func check() {}
}
// CHECK-LABEL: sil hidden [transparent] [thunk] @_TTWC6errors10HappyClassS_6DoomedS_FS1_5check{{.*}} : $@convention(witness_method) (@in_guaranteed HappyClass) -> @error ErrorProtocol
// CHECK: [[TEMP:%.*]] = alloc_stack $HappyClass
// CHECK: copy_addr %0 to [initialization] [[TEMP]]
// CHECK: [[SELF:%.*]] = load [[TEMP]] : $*HappyClass
// CHECK: [[T0:%.*]] = class_method [[SELF]] : $HappyClass, #HappyClass.check!1 : (HappyClass) -> () -> () , $@convention(method) (@guaranteed HappyClass) -> ()
// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
// CHECK: [[T1:%.*]] = tuple ()
// CHECK: strong_release [[SELF]] : $HappyClass
// CHECK: dealloc_stack [[TEMP]]
// CHECK: return [[T1]] : $()
class HappyClass : Doomed {
func check() {}
}
func create<T>(_ fn: () throws -> T) throws -> T {
return try fn()
}
func testThunk(_ fn: () throws -> Int) throws -> Int {
return try create(fn)
}
// CHECK-LABEL: sil shared [transparent] [reabstraction_thunk] @_TTRXFo__dSizoPs13ErrorProtocol__XFo__iSizoPS___ : $@convention(thin) (@owned @callee_owned () -> (Int, @error ErrorProtocol)) -> (@out Int, @error ErrorProtocol)
// CHECK: bb0(%0 : $*Int, %1 : $@callee_owned () -> (Int, @error ErrorProtocol)):
// CHECK: try_apply %1()
// CHECK: bb1([[T0:%.*]] : $Int):
// CHECK: store [[T0]] to %0 : $*Int
// CHECK: [[T0:%.*]] = tuple ()
// CHECK: return [[T0]]
// CHECK: bb2([[T0:%.*]] : $ErrorProtocol):
// CHECK: builtin "willThrow"([[T0]] : $ErrorProtocol)
// CHECK: throw [[T0]] : $ErrorProtocol
func createInt(_ fn: () -> Int) throws {}
func testForceTry(_ fn: () -> Int) {
try! createInt(fn)
}
// CHECK-LABEL: sil hidden @_TF6errors12testForceTryFFT_SiT_ : $@convention(thin) (@owned @callee_owned () -> Int) -> ()
// CHECK: [[T0:%.*]] = function_ref @_TF6errors9createIntFzFT_SiT_ : $@convention(thin) (@owned @callee_owned () -> Int) -> @error ErrorProtocol
// CHECK: try_apply [[T0]](%0)
// CHECK: strong_release
// CHECK: return
// CHECK: builtin "unexpectedError"
// CHECK: unreachable
func testForceTryMultiple() {
_ = try! (make_a_cat(), make_a_cat())
}
// CHECK-LABEL: sil hidden @_TF6errors20testForceTryMultipleFT_T_
// CHECK-NEXT: bb0:
// CHECK: [[FN_1:%.+]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat
// CHECK-NEXT: try_apply [[FN_1]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[SUCCESS_1:[^ ]+]], error [[CLEANUPS_1:[^ ]+]],
// CHECK: [[SUCCESS_1]]([[VALUE_1:%.+]] : $Cat)
// CHECK: [[FN_2:%.+]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat
// CHECK-NEXT: try_apply [[FN_2]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[SUCCESS_2:[^ ]+]], error [[CLEANUPS_2:[^ ]+]],
// CHECK: [[SUCCESS_2]]([[VALUE_2:%.+]] : $Cat)
// CHECK-NEXT: strong_release [[VALUE_2]] : $Cat
// CHECK-NEXT: strong_release [[VALUE_1]] : $Cat
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK: [[FAILURE:.+]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: = builtin "unexpectedError"([[ERROR]] : $ErrorProtocol)
// CHECK-NEXT: unreachable
// CHECK: [[CLEANUPS_1]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: [[CLEANUPS_2]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[VALUE_1]] : $Cat
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: {{^}$}}
// Make sure we balance scopes correctly inside a switch.
// <rdar://problem/20923654>
enum CatFood {
case Canned
case Dry
}
// Something we can switch on that throws.
func preferredFood() throws -> CatFood {
return CatFood.Canned
}
func feedCat() throws -> Int {
switch try preferredFood() {
case .Canned:
return 0
case .Dry:
return 1
}
}
// CHECK-LABEL: sil hidden @_TF6errors7feedCatFzT_Si : $@convention(thin) () -> (Int, @error ErrorProtocol)
// CHECK: %0 = function_ref @_TF6errors13preferredFoodFzT_OS_7CatFood : $@convention(thin) () -> (CatFood, @error ErrorProtocol)
// CHECK: try_apply %0() : $@convention(thin) () -> (CatFood, @error ErrorProtocol), normal bb1, error bb5
// CHECK: bb1([[VAL:%.*]] : $CatFood):
// CHECK: switch_enum [[VAL]] : $CatFood, case #CatFood.Canned!enumelt: bb2, case #CatFood.Dry!enumelt: bb3
// CHECK: bb5([[ERROR:%.*]] : $ErrorProtocol)
// CHECK: throw [[ERROR]] : $ErrorProtocol
// Throwing statements inside cases.
func getHungryCat(_ food: CatFood) throws -> Cat {
switch food {
case .Canned:
return try make_a_cat()
case .Dry:
return try dont_make_a_cat()
}
}
// errors.getHungryCat throws (errors.CatFood) -> errors.Cat
// CHECK-LABEL: sil hidden @_TF6errors12getHungryCatFzOS_7CatFoodCS_3Cat : $@convention(thin) (CatFood) -> (@owned Cat, @error ErrorProtocol)
// CHECK: bb0(%0 : $CatFood):
// CHECK: switch_enum %0 : $CatFood, case #CatFood.Canned!enumelt: bb1, case #CatFood.Dry!enumelt: bb3
// CHECK: bb1:
// CHECK: [[FN:%.*]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol)
// CHECK: try_apply [[FN]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal bb2, error bb6
// CHECK: bb3:
// CHECK: [[FN:%.*]] = function_ref @_TF6errors15dont_make_a_catFzT_CS_3Cat : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol)
// CHECK: try_apply [[FN]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal bb4, error bb7
// CHECK: bb6([[ERROR:%.*]] : $ErrorProtocol):
// CHECK: br bb8([[ERROR:%.*]] : $ErrorProtocol)
// CHECK: bb7([[ERROR:%.*]] : $ErrorProtocol):
// CHECK: br bb8([[ERROR]] : $ErrorProtocol)
// CHECK: bb8([[ERROR:%.*]] : $ErrorProtocol):
// CHECK: throw [[ERROR]] : $ErrorProtocol
func take_many_cats(_ cats: Cat...) throws {}
func test_variadic(_ cat: Cat) throws {
try take_many_cats(make_a_cat(), cat, make_a_cat(), make_a_cat())
}
// CHECK-LABEL: sil hidden @_TF6errors13test_variadicFzCS_3CatT_
// CHECK: [[TAKE_FN:%.*]] = function_ref @_TF6errors14take_many_catsFztGSaCS_3Cat__T_ : $@convention(thin) (@owned Array<Cat>) -> @error ErrorProtocol
// CHECK: [[N:%.*]] = integer_literal $Builtin.Word, 4
// CHECK: [[T0:%.*]] = function_ref @_TFs27_allocateUninitializedArray
// CHECK: [[T1:%.*]] = apply [[T0]]<Cat>([[N]])
// CHECK: [[ARRAY:%.*]] = tuple_extract [[T1]] : $(Array<Cat>, Builtin.RawPointer), 0
// CHECK: [[T2:%.*]] = tuple_extract [[T1]] : $(Array<Cat>, Builtin.RawPointer), 1
// CHECK: [[ELT0:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to $*Cat
// Element 0.
// CHECK: [[T0:%.*]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol)
// CHECK: try_apply [[T0]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[NORM_0:bb[0-9]+]], error [[ERR_0:bb[0-9]+]]
// CHECK: [[NORM_0]]([[CAT0:%.*]] : $Cat):
// CHECK-NEXT: store [[CAT0]] to [[ELT0]]
// Element 1.
// CHECK-NEXT: [[T0:%.*]] = integer_literal $Builtin.Word, 1
// CHECK-NEXT: [[ELT1:%.*]] = index_addr [[ELT0]] : $*Cat, [[T0]]
// CHECK-NEXT: strong_retain %0
// CHECK-NEXT: store %0 to [[ELT1]]
// Element 2.
// CHECK-NEXT: [[T0:%.*]] = integer_literal $Builtin.Word, 2
// CHECK-NEXT: [[ELT2:%.*]] = index_addr [[ELT0]] : $*Cat, [[T0]]
// CHECK-NEXT: // function_ref
// CHECK-NEXT: [[T0:%.*]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol)
// CHECK-NEXT: try_apply [[T0]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[NORM_2:bb[0-9]+]], error [[ERR_2:bb[0-9]+]]
// CHECK: [[NORM_2]]([[CAT2:%.*]] : $Cat):
// CHECK-NEXT: store [[CAT2]] to [[ELT2]]
// Element 3.
// CHECK-NEXT: [[T0:%.*]] = integer_literal $Builtin.Word, 3
// CHECK-NEXT: [[ELT3:%.*]] = index_addr [[ELT0]] : $*Cat, [[T0]]
// CHECK-NEXT: // function_ref
// CHECK-NEXT: [[T0:%.*]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol)
// CHECK-NEXT: try_apply [[T0]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[NORM_3:bb[0-9]+]], error [[ERR_3:bb[0-9]+]]
// CHECK: [[NORM_3]]([[CAT3:%.*]] : $Cat):
// CHECK-NEXT: store [[CAT3]] to [[ELT3]]
// Complete the call and return.
// CHECK-NEXT: try_apply [[TAKE_FN]]([[ARRAY]]) : $@convention(thin) (@owned Array<Cat>) -> @error ErrorProtocol, normal [[NORM_CALL:bb[0-9]+]], error [[ERR_CALL:bb[0-9]+]]
// CHECK: [[NORM_CALL]]([[T0:%.*]] : $()):
// CHECK-NEXT: strong_release %0 : $Cat
// CHECK-NEXT: [[T0:%.*]] = tuple ()
// CHECK-NEXT: return
// Failure from element 0.
// CHECK: [[ERR_0]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: // function_ref
// CHECK-NEXT: [[T0:%.*]] = function_ref @_TFs29_deallocateUninitializedArray
// CHECK-NEXT: apply [[T0]]<Cat>([[ARRAY]])
// CHECK-NEXT: br [[RETHROW:.*]]([[ERROR]] : $ErrorProtocol)
// Failure from element 2.
// CHECK: [[ERR_2]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: destroy_addr [[ELT1]]
// CHECK-NEXT: destroy_addr [[ELT0]]
// CHECK-NEXT: // function_ref
// CHECK-NEXT: [[T0:%.*]] = function_ref @_TFs29_deallocateUninitializedArray
// CHECK-NEXT: apply [[T0]]<Cat>([[ARRAY]])
// CHECK-NEXT: br [[RETHROW]]([[ERROR]] : $ErrorProtocol)
// Failure from element 3.
// CHECK: [[ERR_3]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: destroy_addr [[ELT2]]
// CHECK-NEXT: destroy_addr [[ELT1]]
// CHECK-NEXT: destroy_addr [[ELT0]]
// CHECK-NEXT: // function_ref
// CHECK-NEXT: [[T0:%.*]] = function_ref @_TFs29_deallocateUninitializedArray
// CHECK-NEXT: apply [[T0]]<Cat>([[ARRAY]])
// CHECK-NEXT: br [[RETHROW]]([[ERROR]] : $ErrorProtocol)
// Failure from call.
// CHECK: [[ERR_CALL]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: br [[RETHROW]]([[ERROR]] : $ErrorProtocol)
// Rethrow.
// CHECK: [[RETHROW]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: strong_release %0 : $Cat
// CHECK-NEXT: throw [[ERROR]]
// rdar://20861374
// Clear out the self box before delegating.
class BaseThrowingInit : HasThrowingInit {
var subField: Int
init(value: Int, subField: Int) throws {
self.subField = subField
try super.init(value: value)
}
}
// CHECK: sil hidden @_TFC6errors16BaseThrowingInitc{{.*}} : $@convention(method) (Int, Int, @owned BaseThrowingInit) -> (@owned BaseThrowingInit, @error ErrorProtocol)
// CHECK: [[BOX:%.*]] = alloc_box $BaseThrowingInit
// CHECK: [[PB:%.*]] = project_box [[BOX]]
// CHECK: [[MARKED_BOX:%.*]] = mark_uninitialized [derivedself] [[PB]]
// Initialize subField.
// CHECK: [[T0:%.*]] = load [[MARKED_BOX]]
// CHECK-NEXT: [[T1:%.*]] = ref_element_addr [[T0]] : $BaseThrowingInit, #BaseThrowingInit.subField
// CHECK-NEXT: assign %1 to [[T1]]
// Super delegation.
// CHECK-NEXT: [[T0:%.*]] = load [[MARKED_BOX]]
// CHECK-NEXT: [[T2:%.*]] = upcast [[T0]] : $BaseThrowingInit to $HasThrowingInit
// CHECK: [[T3:%[0-9]+]] = function_ref @_TFC6errors15HasThrowingInitcfzT5valueSi_S0_ : $@convention(method) (Int, @owned HasThrowingInit) -> (@owned HasThrowingInit, @error ErrorProtocol)
// CHECK-NEXT: apply [[T3]](%0, [[T2]])
// Cleanups for writebacks.
protocol Supportable {
mutating func support() throws
}
protocol Buildable {
associatedtype Structure : Supportable
var firstStructure: Structure { get set }
subscript(name: String) -> Structure { get set }
}
func supportFirstStructure<B: Buildable>(_ b: inout B) throws {
try b.firstStructure.support()
}
// CHECK-LABEL: sil hidden @_TF6errors21supportFirstStructure{{.*}} : $@convention(thin) <B where B : Buildable, B.Structure : Supportable> (@inout B) -> @error ErrorProtocol {
// CHECK: [[SUPPORT:%.*]] = witness_method $B.Structure, #Supportable.support!1 :
// CHECK: [[MATBUFFER:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
// CHECK: [[BUFFER:%.*]] = alloc_stack $B.Structure
// CHECK: [[BUFFER_CAST:%.*]] = address_to_pointer [[BUFFER]] : $*B.Structure to $Builtin.RawPointer
// CHECK: [[MAT:%.*]] = witness_method $B, #Buildable.firstStructure!materializeForSet.1 :
// CHECK: [[T1:%.*]] = apply [[MAT]]<B, B.Structure>([[BUFFER_CAST]], [[MATBUFFER]], [[BASE:%[0-9]*]])
// CHECK: [[T2:%.*]] = tuple_extract [[T1]] : {{.*}}, 0
// CHECK: [[CALLBACK:%.*]] = tuple_extract [[T1]] : {{.*}}, 1
// CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to $*B.Structure
// CHECK: [[T4:%.*]] = mark_dependence [[T3]] : $*B.Structure on [[BASE]] : $*B
// CHECK: try_apply [[SUPPORT]]<B.Structure>([[T4]]) : {{.*}}, normal [[BB_NORMAL:bb[0-9]+]], error [[BB_ERROR:bb[0-9]+]]
// CHECK: [[BB_NORMAL]]
// CHECK: switch_enum [[CALLBACK]]
// CHECK: apply
// CHECK: dealloc_stack [[BUFFER]]
// CHECK: dealloc_stack [[MATBUFFER]]
// CHECK: return
// CHECK: [[BB_ERROR]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK: switch_enum [[CALLBACK]]
// CHECK: apply
// CHECK: dealloc_stack [[BUFFER]]
// CHECK: dealloc_stack [[MATBUFFER]]
// CHECK: throw [[ERROR]]
func supportStructure<B: Buildable>(_ b: inout B, name: String) throws {
try b[name].support()
}
// CHECK-LABEL: sil hidden @_TF6errors16supportStructure
// CHECK: [[SUPPORT:%.*]] = witness_method $B.Structure, #Supportable.support!1 :
// CHECK: retain_value [[INDEX:%1]] : $String
// CHECK: [[MATBUFFER:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
// CHECK: [[BUFFER:%.*]] = alloc_stack $B.Structure
// CHECK: [[BUFFER_CAST:%.*]] = address_to_pointer [[BUFFER]] : $*B.Structure to $Builtin.RawPointer
// CHECK: [[MAT:%.*]] = witness_method $B, #Buildable.subscript!materializeForSet.1 :
// CHECK: [[T1:%.*]] = apply [[MAT]]<B, B.Structure>([[BUFFER_CAST]], [[MATBUFFER]], [[INDEX]], [[BASE:%[0-9]*]])
// CHECK: [[T2:%.*]] = tuple_extract [[T1]] : {{.*}}, 0
// CHECK: [[CALLBACK:%.*]] = tuple_extract [[T1]] : {{.*}}, 1
// CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to $*B.Structure
// CHECK: [[T4:%.*]] = mark_dependence [[T3]] : $*B.Structure on [[BASE]] : $*B
// CHECK: try_apply [[SUPPORT]]<B.Structure>([[T4]]) : {{.*}}, normal [[BB_NORMAL:bb[0-9]+]], error [[BB_ERROR:bb[0-9]+]]
// CHECK: [[BB_NORMAL]]
// CHECK: switch_enum [[CALLBACK]]
// CHECK: apply
// CHECK: dealloc_stack [[BUFFER]]
// CHECK: dealloc_stack [[MATBUFFER]]
// CHECK: release_value [[INDEX]] : $String
// CHECK: return
// CHECK: [[BB_ERROR]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK: switch_enum [[CALLBACK]]
// CHECK: apply
// CHECK: dealloc_stack [[BUFFER]]
// CHECK: dealloc_stack [[MATBUFFER]]
// CHECK: release_value [[INDEX]] : $String
// CHECK: throw [[ERROR]]
struct Pylon {
var name: String
mutating func support() throws {}
}
struct Bridge {
var mainPylon : Pylon
subscript(name: String) -> Pylon {
get {
return mainPylon
}
set {}
}
}
func supportStructure(_ b: inout Bridge, name: String) throws {
try b[name].support()
}
// CHECK: sil hidden @_TF6errors16supportStructureFzTRVS_6Bridge4nameSS_T_ :
// CHECK: [[SUPPORT:%.*]] = function_ref @_TFV6errors5Pylon7support
// CHECK: retain_value [[INDEX:%1]] : $String
// CHECK-NEXT: retain_value [[INDEX]] : $String
// CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $Pylon
// CHECK-NEXT: [[BASE:%.*]] = load [[B:%[0-9]*]] : $*Bridge
// CHECK-NEXT: retain_value [[BASE]]
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[GETTER:%.*]] = function_ref @_TFV6errors6Bridgeg9subscriptFSSVS_5Pylon :
// CHECK-NEXT: [[T0:%.*]] = apply [[GETTER]]([[INDEX]], [[BASE]])
// CHECK-NEXT: release_value [[BASE]]
// CHECK-NEXT: store [[T0]] to [[TEMP]]
// CHECK-NEXT: try_apply [[SUPPORT]]([[TEMP]]) : {{.*}}, normal [[BB_NORMAL:bb[0-9]+]], error [[BB_ERROR:bb[0-9]+]]
// CHECK: [[BB_NORMAL]]
// CHECK-NEXT: [[T0:%.*]] = load [[TEMP]]
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[SETTER:%.*]] = function_ref @_TFV6errors6Bridges9subscriptFSSVS_5Pylon :
// CHECK-NEXT: apply [[SETTER]]([[T0]], [[INDEX]], [[B]])
// CHECK-NEXT: dealloc_stack [[TEMP]]
// CHECK-NEXT: release_value [[INDEX]] : $String
// CHECK-NEXT: copy_addr
// CHECK-NEXT: strong_release
// CHECK-NEXT: tuple ()
// CHECK-NEXT: return
// We end up with ugly redundancy here because we don't want to
// consume things during cleanup emission. It's questionable.
// CHECK: [[BB_ERROR]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: [[T0:%.*]] = load [[TEMP]]
// CHECK-NEXT: retain_value [[T0]]
// CHECK-NEXT: retain_value [[INDEX]] : $String
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[SETTER:%.*]] = function_ref @_TFV6errors6Bridges9subscriptFSSVS_5Pylon :
// CHECK-NEXT: apply [[SETTER]]([[T0]], [[INDEX]], [[B]])
// CHECK-NEXT: destroy_addr [[TEMP]]
// CHECK-NEXT: dealloc_stack [[TEMP]]
// CHECK-NEXT: release_value [[INDEX]] : $String
// CHECK-NEXT: release_value [[INDEX]] : $String
// CHECK-NEXT: copy_addr
// CHECK-NEXT: strong_release
// CHECK-NEXT: throw [[ERROR]]
struct OwnedBridge {
var owner : Builtin.UnknownObject
subscript(name: String) -> Pylon {
addressWithOwner { return (nil, owner) }
mutableAddressWithOwner { return (nil, owner) }
}
}
func supportStructure(_ b: inout OwnedBridge, name: String) throws {
try b[name].support()
}
// CHECK: sil hidden @_TF6errors16supportStructureFzTRVS_11OwnedBridge4nameSS_T_ :
// CHECK: [[SUPPORT:%.*]] = function_ref @_TFV6errors5Pylon7support
// CHECK: retain_value [[INDEX:%1]] : $String
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[ADDRESSOR:%.*]] = function_ref @_TFV6errors11OwnedBridgeaO9subscriptFSSVS_5Pylon :
// CHECK-NEXT: [[T0:%.*]] = apply [[ADDRESSOR]]([[INDEX]], [[BASE:%[0-9]*]])
// CHECK-NEXT: [[T1:%.*]] = tuple_extract [[T0]] : {{.*}}, 0
// CHECK-NEXT: [[OWNER:%.*]] = tuple_extract [[T0]] : {{.*}}, 1
// CHECK-NEXT: [[T3:%.*]] = struct_extract [[T1]]
// CHECK-NEXT: [[T4:%.*]] = pointer_to_address [[T3]]
// CHECK-NEXT: [[T5:%.*]] = mark_dependence [[T4]] : $*Pylon on [[OWNER]]
// CHECK-NEXT: try_apply [[SUPPORT]]([[T5]]) : {{.*}}, normal [[BB_NORMAL:bb[0-9]+]], error [[BB_ERROR:bb[0-9]+]]
// CHECK: [[BB_NORMAL]]
// CHECK-NEXT: strong_release [[OWNER]] : $Builtin.UnknownObject
// CHECK-NEXT: release_value [[INDEX]] : $String
// CHECK-NEXT: copy_addr
// CHECK-NEXT: strong_release
// CHECK-NEXT: tuple ()
// CHECK-NEXT: return
// CHECK: [[BB_ERROR]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[OWNER]] : $Builtin.UnknownObject
// CHECK-NEXT: release_value [[INDEX]] : $String
// CHECK-NEXT: copy_addr
// CHECK-NEXT: strong_release
// CHECK-NEXT: throw [[ERROR]]
struct PinnedBridge {
var owner : Builtin.NativeObject
subscript(name: String) -> Pylon {
addressWithPinnedNativeOwner { return (nil, owner) }
mutableAddressWithPinnedNativeOwner { return (nil, owner) }
}
}
func supportStructure(_ b: inout PinnedBridge, name: String) throws {
try b[name].support()
}
// CHECK: sil hidden @_TF6errors16supportStructureFzTRVS_12PinnedBridge4nameSS_T_ :
// CHECK: [[SUPPORT:%.*]] = function_ref @_TFV6errors5Pylon7support
// CHECK: retain_value [[INDEX:%1]] : $String
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[ADDRESSOR:%.*]] = function_ref @_TFV6errors12PinnedBridgeap9subscriptFSSVS_5Pylon :
// CHECK-NEXT: [[T0:%.*]] = apply [[ADDRESSOR]]([[INDEX]], [[BASE:%[0-9]*]])
// CHECK-NEXT: [[T1:%.*]] = tuple_extract [[T0]] : {{.*}}, 0
// CHECK-NEXT: [[OWNER:%.*]] = tuple_extract [[T0]] : {{.*}}, 1
// CHECK-NEXT: [[T3:%.*]] = struct_extract [[T1]]
// CHECK-NEXT: [[T4:%.*]] = pointer_to_address [[T3]]
// CHECK-NEXT: [[T5:%.*]] = mark_dependence [[T4]] : $*Pylon on [[OWNER]]
// CHECK-NEXT: try_apply [[SUPPORT]]([[T5]]) : {{.*}}, normal [[BB_NORMAL:bb[0-9]+]], error [[BB_ERROR:bb[0-9]+]]
// CHECK: [[BB_NORMAL]]
// CHECK-NEXT: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
// CHECK-NEXT: release_value [[INDEX]] : $String
// CHECK-NEXT: copy_addr
// CHECK-NEXT: strong_release
// CHECK-NEXT: tuple ()
// CHECK-NEXT: return
// CHECK: [[BB_ERROR]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: retain_value [[OWNER]]
// CHECK-NEXT: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
// CHECK-NEXT: release_value [[OWNER]]
// CHECK-NEXT: release_value [[INDEX]] : $String
// CHECK-NEXT: copy_addr
// CHECK-NEXT: strong_release
// CHECK-NEXT: throw [[ERROR]]
// ! peepholes its argument with getSemanticsProvidingExpr().
// Test that that doesn't look through try!.
// rdar://21515402
func testForcePeephole(_ f: () throws -> Int?) -> Int {
let x = (try! f())!
return x
}
// CHECK-LABEL: sil hidden @_TF6errors15testOptionalTryFT_T_
// CHECK-NEXT: bb0:
// CHECK: [[FN:%.+]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat
// CHECK-NEXT: try_apply [[FN]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[SUCCESS:[^ ]+]], error [[CLEANUPS:[^ ]+]],
// CHECK: [[SUCCESS]]([[VALUE:%.+]] : $Cat)
// CHECK-NEXT: [[WRAPPED:%.+]] = enum $Optional<Cat>, #Optional.some!enumelt.1, [[VALUE]]
// CHECK-NEXT: br [[DONE:[^ ]+]]([[WRAPPED]] : $Optional<Cat>)
// CHECK: [[DONE]]([[RESULT:%.+]] : $Optional<Cat>):
// CHECK-NEXT: release_value [[RESULT]] : $Optional<Cat>
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK: [[FAILURE:.+]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[ERROR]]
// CHECK-NEXT: [[NONE:%.+]] = enum $Optional<Cat>, #Optional.none!enumelt
// CHECK-NEXT: br [[DONE]]([[NONE]] : $Optional<Cat>)
// CHECK: [[CLEANUPS]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: {{^}$}}
func testOptionalTry() {
_ = try? make_a_cat()
}
// CHECK-LABEL: sil hidden @_TF6errors18testOptionalTryVarFT_T_
// CHECK-NEXT: bb0:
// CHECK-NEXT: [[BOX:%.+]] = alloc_box $Optional<Cat>
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: [[BOX_DATA:%.+]] = init_enum_data_addr [[PB]] : $*Optional<Cat>, #Optional.some!enumelt.1
// CHECK: [[FN:%.+]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat
// CHECK-NEXT: try_apply [[FN]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[SUCCESS:[^ ]+]], error [[CLEANUPS:[^ ]+]],
// CHECK: [[SUCCESS]]([[VALUE:%.+]] : $Cat)
// CHECK-NEXT: store [[VALUE]] to [[BOX_DATA]] : $*Cat
// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<Cat>, #Optional.some!enumelt.1
// CHECK-NEXT: br [[DONE:[^ ]+]],
// CHECK: [[DONE]]:
// CHECK-NEXT: strong_release [[BOX]] : $@box Optional<Cat>
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK: [[FAILURE:.+]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[ERROR]]
// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<Cat>, #Optional.none!enumelt
// CHECK-NEXT: br [[DONE]]
// CHECK: [[CLEANUPS]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: {{^}$}}
func testOptionalTryVar() {
var cat = try? make_a_cat() // expected-warning {{initialization of variable 'cat' was never used; consider replacing with assignment to '_' or removing it}}
}
// CHECK-LABEL: sil hidden @_TF6errors26testOptionalTryAddressOnly
// CHECK: bb0(%0 : $*T):
// CHECK: [[BOX:%.+]] = alloc_stack $Optional<T>
// CHECK-NEXT: [[BOX_DATA:%.+]] = init_enum_data_addr [[BOX]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK: [[FN:%.+]] = function_ref @_TF6errors11dont_return
// CHECK-NEXT: [[ARG_BOX:%.+]] = alloc_stack $T
// CHECK-NEXT: copy_addr %0 to [initialization] [[ARG_BOX]] : $*T
// CHECK-NEXT: try_apply [[FN]]<T>([[BOX_DATA]], [[ARG_BOX]]) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @error ErrorProtocol), normal [[SUCCESS:[^ ]+]], error [[CLEANUPS:[^ ]+]],
// CHECK: [[SUCCESS]]({{%.+}} : $()):
// CHECK-NEXT: inject_enum_addr [[BOX]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK-NEXT: dealloc_stack [[ARG_BOX]] : $*T
// CHECK-NEXT: br [[DONE:[^ ]+]],
// CHECK: [[DONE]]:
// CHECK-NEXT: destroy_addr [[BOX]] : $*Optional<T>
// CHECK-NEXT: dealloc_stack [[BOX]] : $*Optional<T>
// CHECK-NEXT: destroy_addr %0 : $*T
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK: [[FAILURE:.+]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[ERROR]]
// CHECK-NEXT: inject_enum_addr [[BOX]] : $*Optional<T>, #Optional.none!enumelt
// CHECK-NEXT: br [[DONE]]
// CHECK: [[CLEANUPS]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: dealloc_stack [[ARG_BOX]] : $*T
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: {{^}$}}
func testOptionalTryAddressOnly<T>(_ obj: T) {
_ = try? dont_return(obj)
}
// CHECK-LABEL: sil hidden @_TF6errors29testOptionalTryAddressOnlyVar
// CHECK: bb0(%0 : $*T):
// CHECK: [[BOX:%.+]] = alloc_box $Optional<T>
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: [[BOX_DATA:%.+]] = init_enum_data_addr [[PB]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK: [[FN:%.+]] = function_ref @_TF6errors11dont_return
// CHECK-NEXT: [[ARG_BOX:%.+]] = alloc_stack $T
// CHECK-NEXT: copy_addr %0 to [initialization] [[ARG_BOX]] : $*T
// CHECK-NEXT: try_apply [[FN]]<T>([[BOX_DATA]], [[ARG_BOX]]) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> (@out τ_0_0, @error ErrorProtocol), normal [[SUCCESS:[^ ]+]], error [[CLEANUPS:[^ ]+]],
// CHECK: [[SUCCESS]]({{%.+}} : $()):
// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK-NEXT: dealloc_stack [[ARG_BOX]] : $*T
// CHECK-NEXT: br [[DONE:[^ ]+]],
// CHECK: [[DONE]]:
// CHECK-NEXT: strong_release [[BOX]] : $@box Optional<T>
// CHECK-NEXT: destroy_addr %0 : $*T
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK: [[FAILURE:.+]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[ERROR]]
// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<T>, #Optional.none!enumelt
// CHECK-NEXT: br [[DONE]]
// CHECK: [[CLEANUPS]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: dealloc_stack [[ARG_BOX]] : $*T
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: {{^}$}}
func testOptionalTryAddressOnlyVar<T>(_ obj: T) {
var copy = try? dont_return(obj) // expected-warning {{initialization of variable 'copy' was never used; consider replacing with assignment to '_' or removing it}}
}
// CHECK-LABEL: sil hidden @_TF6errors23testOptionalTryMultipleFT_T_
// CHECK: bb0:
// CHECK: [[FN_1:%.+]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat
// CHECK-NEXT: try_apply [[FN_1]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[SUCCESS_1:[^ ]+]], error [[CLEANUPS_1:[^ ]+]],
// CHECK: [[SUCCESS_1]]([[VALUE_1:%.+]] : $Cat)
// CHECK: [[FN_2:%.+]] = function_ref @_TF6errors10make_a_catFzT_CS_3Cat
// CHECK-NEXT: try_apply [[FN_2]]() : $@convention(thin) () -> (@owned Cat, @error ErrorProtocol), normal [[SUCCESS_2:[^ ]+]], error [[CLEANUPS_2:[^ ]+]],
// CHECK: [[SUCCESS_2]]([[VALUE_2:%.+]] : $Cat)
// CHECK-NEXT: [[TUPLE:%.+]] = tuple ([[VALUE_1]] : $Cat, [[VALUE_2]] : $Cat)
// CHECK-NEXT: [[WRAPPED:%.+]] = enum $Optional<(Cat, Cat)>, #Optional.some!enumelt.1, [[TUPLE]]
// CHECK-NEXT: br [[DONE:[^ ]+]]([[WRAPPED]] : $Optional<(Cat, Cat)>)
// CHECK: [[DONE]]([[RESULT:%.+]] : $Optional<(Cat, Cat)>):
// CHECK-NEXT: release_value [[RESULT]] : $Optional<(Cat, Cat)>
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK: [[FAILURE:.+]]([[ERROR:%.*]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[ERROR]]
// CHECK-NEXT: [[NONE:%.+]] = enum $Optional<(Cat, Cat)>, #Optional.none!enumelt
// CHECK-NEXT: br [[DONE]]([[NONE]] : $Optional<(Cat, Cat)>)
// CHECK: [[CLEANUPS_1]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: [[CLEANUPS_2]]([[ERROR:%.+]] : $ErrorProtocol):
// CHECK-NEXT: strong_release [[VALUE_1]] : $Cat
// CHECK-NEXT: br [[FAILURE]]([[ERROR]] : $ErrorProtocol)
// CHECK: {{^}$}}
func testOptionalTryMultiple() {
_ = try? (make_a_cat(), make_a_cat())
}
// CHECK-LABEL: sil hidden @_TF6errors25testOptionalTryNeverFailsFT_T_
// CHECK: bb0:
// CHECK-NEXT: [[VALUE:%.+]] = tuple ()
// CHECK-NEXT: = enum $Optional<()>, #Optional.some!enumelt.1, [[VALUE]]
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK: {{^}$}}
func testOptionalTryNeverFails() {
_ = try? () // expected-warning {{no calls to throwing functions occur within 'try' expression}}
}
// CHECK-LABEL: sil hidden @_TF6errors28testOptionalTryNeverFailsVarFT_T_
// CHECK: bb0:
// CHECK-NEXT: [[BOX:%.+]] = alloc_box $Optional<()>
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: = init_enum_data_addr [[PB]] : $*Optional<()>, #Optional.some!enumelt.1
// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<()>, #Optional.some!enumelt.1
// CHECK-NEXT: strong_release [[BOX]] : $@box Optional<()>
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK-NEXT: {{^}$}}
func testOptionalTryNeverFailsVar() {
var unit: ()? = try? () // expected-warning {{no calls to throwing functions occur within 'try' expression}} expected-warning {{initialization of variable 'unit' was never used; consider replacing with assignment to '_' or removing it}}
}
// CHECK-LABEL: sil hidden @_TF6errors36testOptionalTryNeverFailsAddressOnly
// CHECK: bb0(%0 : $*T):
// CHECK: [[BOX:%.+]] = alloc_stack $Optional<T>
// CHECK-NEXT: [[BOX_DATA:%.+]] = init_enum_data_addr [[BOX]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK-NEXT: copy_addr %0 to [initialization] [[BOX_DATA]] : $*T
// CHECK-NEXT: inject_enum_addr [[BOX]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK-NEXT: destroy_addr [[BOX]] : $*Optional<T>
// CHECK-NEXT: dealloc_stack [[BOX]] : $*Optional<T>
// CHECK-NEXT: destroy_addr %0 : $*T
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK-NEXT: {{^}$}}
func testOptionalTryNeverFailsAddressOnly<T>(_ obj: T) {
_ = try? obj // expected-warning {{no calls to throwing functions occur within 'try' expression}}
}
// CHECK-LABEL: sil hidden @_TF6errors39testOptionalTryNeverFailsAddressOnlyVar
// CHECK: bb0(%0 : $*T):
// CHECK: [[BOX:%.+]] = alloc_box $Optional<T>
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: [[BOX_DATA:%.+]] = init_enum_data_addr [[PB]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK-NEXT: copy_addr %0 to [initialization] [[BOX_DATA]] : $*T
// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<T>, #Optional.some!enumelt.1
// CHECK-NEXT: strong_release [[BOX]] : $@box Optional<T>
// CHECK-NEXT: destroy_addr %0 : $*T
// CHECK-NEXT: [[VOID:%.+]] = tuple ()
// CHECK-NEXT: return [[VOID]] : $()
// CHECK-NEXT: {{^}$}}
func testOptionalTryNeverFailsAddressOnlyVar<T>(_ obj: T) {
var copy = try? obj // expected-warning {{no calls to throwing functions occur within 'try' expression}} expected-warning {{initialization of variable 'copy' was never used; consider replacing with assignment to '_' or removing it}}
}
|
apache-2.0
|
b721e03fb33348a300e0603ce98ea52a
| 46.988688 | 238 | 0.609401 | 3.254469 | false | false | false | false |
samodom/CoreDataSwagger
|
CoreDataSwagger/CoreDataStackFetching.swift
|
1
|
5229
|
//
// CoreDataStackFetching.swift
// CoreDataSwagger
//
// Created by Sam Odom on 10/12/14.
// Copyright (c) 2014 Swagger Soft. All rights reserved.
//
import CoreData
public extension CoreDataStack {
/**
Simpler interface for performing a fetch request on a managed object context and returning managed objects.
@param request Fetch request to execute on the managed object context.
@return A mutually exclusive ordered pair with the results of performing the fetch or any error encountered.
@discussion The fetch request must have the `resultsType` set to `ManagedObjectResultType` (which it is by default).
*/
public func fetch(request: NSFetchRequest) -> CoreDataObjectFetchResults {
assert(request.resultType == .ManagedObjectResultType, "The fetch request must be configured to return managed objects")
var error: NSError?
let results = context.executeFetchRequest(request, error: &error) as [NSManagedObject]?
return (results, error)
}
/**
Simpler interface for performing a fetch request on a managed object context and returning managed object identifiers.
@param request Fetch request to execute on the managed object context.
@return A mutually exclusive ordered pair with the results of performing the fetch or any error encountered.
@discussion The fetch request must have the `resultsType` set to `ManagedObjectIDResultType`.
*/
public func fetchIDs(request: NSFetchRequest) -> CoreDataObjectIDFetchResults {
assert(request.resultType == .ManagedObjectIDResultType, "The fetch request must be configured to return managed object identifiers")
var error: NSError?
let results = context.executeFetchRequest(request, error: &error) as [NSManagedObjectID]?
return (results, error)
}
/**
Simpler interface for performing a fetch request on a managed object context and returning dictionaries with object values.
@param request Fetch request to execute on the managed object context.
@return A mutually exclusive ordered pair with the results of performing the fetch or any error encountered.
@discussion The fetch request must have the `resultsType` set to `DictionaryResultType`.
*/
public func fetchDictionaries(request: NSFetchRequest) -> CoreDataDictionaryFetchResults {
assert(request.resultType == .DictionaryResultType, "The fetch request must be configured to return object dictionaries")
var error: NSError?
let results = context.executeFetchRequest(request, error: &error)
return (results, error)
}
/**
Simpler interface for performing a count fetch request on a managed object context and returning an object count.
@param request Fetch request to execute on the managed object context.
@return A mutually exclusive ordered pair with the count of the results that would be returned when performing the fetch or any error encountered.
@discussion The fetch request must have the `resultsType` set to `CountResultType`.
*/
public func count(request: NSFetchRequest) -> CoreDataCountFetchResults {
assert(request.resultType == .CountResultType, "The fetch request must be configured to return an object count")
var error: NSError?
var resultCount = context.countForFetchRequest(request, error: &error)
if error != nil {
return (nil, error)
}
return (UInt(resultCount), nil)
}
/**
Simpler interface for performing a fetch request on a managed object context and returning managed objects by simply providing the name of a known entity.
@param entityName Name of entity to fetch.
@return A mutually exclusive ordered pair with the results of performing the fetch or any error encountered.
*/
public func fetch(entityName: String) -> CoreDataObjectFetchResults {
let request = NSFetchRequest(entityName: entityName)
var error: NSError?
let results = context.executeFetchRequest(request, error: &error) as [NSManagedObject]?
return (results, error)
}
/**
Simpler interface for performing a fetch request on a managed object context and returning managed objects by simply providing an entity description.
@param entityDescription Entity description of entity to fetch.
@return A mutually exclusive ordered pair with the results of performing the fetch or any error encountered.
*/
public func fetch(entityDescription: NSEntityDescription) -> CoreDataObjectFetchResults {
let request = NSFetchRequest()
request.entity = entityDescription
var error: NSError?
let results = context.executeFetchRequest(request, error: &error) as [NSManagedObject]?
return (results, error)
}
}
public typealias CoreDataObjectFetchResults = ([NSManagedObject]?, NSError?)
public typealias CoreDataObjectIDFetchResults = ([NSManagedObjectID]?, NSError?)
public typealias CoreDataDictionaryFetchResults = ([AnyObject]?, NSError?)
public typealias CoreDataCountFetchResults = (UInt?, NSError?)
|
mit
|
48ececa9c084a1c5619c12960bb22251
| 51.818182 | 158 | 0.719067 | 5.346626 | false | false | false | false |
ortuman/SwiftForms
|
Sources/SwiftFormsPackage/controllers/FormViewController.swift
|
1
|
9297
|
//
// FormViewController.swift
// SwiftForms
//
// Created by Miguel Angel Ortuño on 20/08/14.
// Copyright (c) 2014 Miguel Angel Ortuño. All rights reserved.
//
import UIKit
open class FormViewController : UITableViewController {
private static var __once: () = {
FormViewController.defaultCellClasses[.text] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.label] = FormLabelCell.self
FormViewController.defaultCellClasses[.number] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.numbersAndPunctuation] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.decimal] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.name] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.phone] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.url] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.twitter] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.namePhone] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.email] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.asciiCapable] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.password] = FormTextFieldCell.self
FormViewController.defaultCellClasses[.button] = FormButtonCell.self
FormViewController.defaultCellClasses[.booleanSwitch] = FormSwitchCell.self
FormViewController.defaultCellClasses[.booleanCheck] = FormCheckCell.self
FormViewController.defaultCellClasses[.segmentedControl] = FormSegmentedControlCell.self
FormViewController.defaultCellClasses[.picker] = FormPickerCell.self
FormViewController.defaultCellClasses[.date] = FormDateCell.self
FormViewController.defaultCellClasses[.time] = FormDateCell.self
FormViewController.defaultCellClasses[.dateAndTime] = FormDateCell.self
FormViewController.defaultCellClasses[.stepper] = FormStepperCell.self
FormViewController.defaultCellClasses[.slider] = FormSliderCell.self
FormViewController.defaultCellClasses[.multipleSelector] = FormSelectorCell.self
FormViewController.defaultCellClasses[.multilineText] = FormTextViewCell.self
}()
// MARK: Class variables
fileprivate static var onceDefaultCellClass: Int = 0
fileprivate static var defaultCellClasses: [FormRowDescriptor.RowType : FormBaseCell.Type] = [:]
// MARK: Properties
open var form = FormDescriptor()
// MARK: Init
public convenience init() {
self.init(style: .grouped)
}
public convenience init(form: FormDescriptor) {
self.init(style: .grouped)
self.form = form
}
public override init(style: UITableView.Style) {
super.init(style: style)
}
public override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: Bundle?) {
super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
}
public required init(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)!
}
// MARK: View life cycle
open override func viewDidLoad() {
super.viewDidLoad()
navigationItem.title = form.title
}
// MARK: Public interface
open func valueForTag(_ tag: String) -> AnyObject? {
for section in form.sections {
for row in section.rows {
if row.tag == tag {
return row.value
}
}
}
return nil
}
open func setValue(_ value: AnyObject, forTag tag: String) {
for (sectionIndex, section) in form.sections.enumerated() {
for (rowIndex, row) in section.rows.enumerated() {
if row.tag == tag {
form.sections[sectionIndex].rows[rowIndex].value = value
if let cell = self.tableView.cellForRow(at: IndexPath(row: rowIndex, section: sectionIndex)) as? FormBaseCell {
cell.update()
}
return
}
}
}
}
// MARK: UITableViewDataSource
open override func numberOfSections(in tableView: UITableView) -> Int {
return form.sections.count
}
open override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return form.sections[section].rows.count
}
open override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let rowDescriptor = formRowDescriptorAtIndexPath(indexPath)
let formBaseCellClass = formBaseCellClassFromRowDescriptor(rowDescriptor)
let reuseIdentifier = NSStringFromClass(formBaseCellClass!)
var cell = tableView.dequeueReusableCell(withIdentifier: reuseIdentifier) as? FormBaseCell
if cell == nil {
cell = formBaseCellClass?.init(style: .default, reuseIdentifier: reuseIdentifier)
cell?.formViewController = self
cell?.configure()
}
cell?.rowDescriptor = rowDescriptor
// apply cell custom design
for (keyPath, value) in rowDescriptor.configuration.cell.appearance {
cell?.setValue(value, forKeyPath: keyPath)
}
return cell!
}
open override func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
return form.sections[section].headerTitle
}
open override func tableView(_ tableView: UITableView, titleForFooterInSection section: Int) -> String? {
return form.sections[section].footerTitle
}
open override func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
guard let headerView = form.sections[section].headerView else { return nil }
return headerView
}
open override func tableView(_ tableView: UITableView, viewForFooterInSection section: Int) -> UIView? {
guard let footerView = form.sections[section].footerView else { return nil }
return footerView
}
open override func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
guard let headerView = form.sections[section].headerView , headerView.translatesAutoresizingMaskIntoConstraints else {
return form.sections[section].headerViewHeight
}
return headerView.frame.size.height
}
open override func tableView(_ tableView: UITableView, heightForFooterInSection section: Int) -> CGFloat {
guard let footerView = form.sections[section].footerView , footerView.translatesAutoresizingMaskIntoConstraints else {
return form.sections[section].footerViewHeight
}
return footerView.frame.size.height
}
// MARK: UITableViewDelegate
open override func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
let rowDescriptor = formRowDescriptorAtIndexPath(indexPath)
if let formBaseCellClass = formBaseCellClassFromRowDescriptor(rowDescriptor) {
return formBaseCellClass.formRowCellHeight()
}
return super.tableView(tableView, heightForRowAt: indexPath)
}
open override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
let rowDescriptor = formRowDescriptorAtIndexPath(indexPath)
if let selectedRow = tableView.cellForRow(at: indexPath) as? FormBaseCell {
if let formBaseCellClass = formBaseCellClassFromRowDescriptor(rowDescriptor) {
formBaseCellClass.formViewController(self, didSelectRow: selectedRow)
}
}
if let didSelectClosure = rowDescriptor.configuration.button.didSelectClosure {
didSelectClosure(rowDescriptor)
}
tableView.deselectRow(at: indexPath, animated: true)
}
fileprivate class func defaultCellClassForRowType(_ rowType: FormRowDescriptor.RowType) -> FormBaseCell.Type {
_ = FormViewController.__once
return FormViewController.defaultCellClasses[rowType]!
}
fileprivate func formRowDescriptorAtIndexPath(_ indexPath: IndexPath) -> FormRowDescriptor {
let section = form.sections[(indexPath as NSIndexPath).section]
let rowDescriptor = section.rows[(indexPath as NSIndexPath).row]
return rowDescriptor
}
fileprivate func formBaseCellClassFromRowDescriptor(_ rowDescriptor: FormRowDescriptor) -> FormBaseCell.Type! {
var formBaseCellClass: FormBaseCell.Type
if let cellClass = rowDescriptor.configuration.cell.cellClass as? FormBaseCell.Type {
formBaseCellClass = cellClass
} else {
formBaseCellClass = FormViewController.defaultCellClassForRowType(rowDescriptor.type)
}
return formBaseCellClass
}
}
|
mit
|
41c2bce6e254b5e849faeb9ee05218b9
| 40.311111 | 131 | 0.6695 | 5.809375 | false | false | false | false |
nacuteodor/ProcessTestSummaries
|
ProcessTestSummaries/SwiftyJSON.swift
|
1
|
41529
|
// SwiftyJSON.swift
//
// Copyright (c) 2014 - 2017 Ruoyu Fu, Pinglin Tang
//
// 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
// MARK: - Error
///Error domain
public let ErrorDomain: String = "SwiftyJSONErrorDomain"
///Error code
public let ErrorUnsupportedType: Int = 999
public let ErrorIndexOutOfBounds: Int = 900
public let ErrorWrongType: Int = 901
public let ErrorNotExist: Int = 500
public let ErrorInvalidJSON: Int = 490
// MARK: - JSON Type
/**
JSON's type definitions.
See http://www.json.org
*/
public enum Type :Int{
case number
case string
case bool
case array
case dictionary
case null
case unknown
}
// MARK: - JSON Base
public struct JSON {
/**
Creates a JSON using the data.
- parameter data: The NSData used to convert to json.Top level object in data is an NSArray or NSDictionary
- parameter opt: The JSON serialization reading options. `.AllowFragments` by default.
- parameter error: The NSErrorPointer used to return the error. `nil` by default.
- returns: The created JSON
*/
public init(data: Data, options opt: JSONSerialization.ReadingOptions = .allowFragments, error: NSErrorPointer = nil) {
do {
let object: Any = try JSONSerialization.jsonObject(with: data, options: opt)
self.init(jsonObject: object)
} catch let aError as NSError {
if error != nil {
error?.pointee = aError
}
self.init(jsonObject: NSNull())
}
}
/**
Creates a JSON object
- parameter object: the object
- note: this does not parse a `String` into JSON, instead use `init(parseJSON: String)`
- returns: the created JSON object
*/
public init(_ object: Any) {
switch object {
case let object as [JSON] where object.count > 0:
self.init(array: object)
case let object as [String: JSON] where object.count > 0:
self.init(dictionary: object)
case let object as Data:
self.init(data: object)
default:
self.init(jsonObject: object)
}
}
/**
Parses the JSON string into a JSON object
- parameter json: the JSON string
- returns: the created JSON object
*/
public init(parseJSON jsonString: String) {
if let data = jsonString.data(using: .utf8) {
self.init(data)
} else {
self.init(NSNull())
}
}
/**
Creates a JSON from JSON string
- parameter string: Normal json string like '{"a":"b"}'
- returns: The created JSON
*/
@available(*, deprecated: 3.2, message: "Use instead `init(parseJSON: )`")
public static func parse(_ json: String) -> JSON {
return json.data(using: String.Encoding.utf8)
.flatMap{ JSON(data: $0) } ?? JSON(NSNull())
}
/**
Creates a JSON using the object.
- parameter object: The object must have the following properties: All objects are NSString/String, NSNumber/Int/Float/Double/Bool, NSArray/Array, NSDictionary/Dictionary, or NSNull; All dictionary keys are NSStrings/String; NSNumbers are not NaN or infinity.
- returns: The created JSON
*/
fileprivate init(jsonObject: Any) {
self.object = jsonObject
}
/**
Creates a JSON from a [JSON]
- parameter jsonArray: A Swift array of JSON objects
- returns: The created JSON
*/
fileprivate init(array: [JSON]) {
self.init(array.map { $0.object })
}
/**
Creates a JSON from a [String: JSON]
- parameter jsonDictionary: A Swift dictionary of JSON objects
- returns: The created JSON
*/
fileprivate init(dictionary: [String: JSON]) {
var newDictionary = [String: Any](minimumCapacity: dictionary.count)
for (key, json) in dictionary {
newDictionary[key] = json.object
}
self.init(newDictionary)
}
/**
Merges another JSON into this JSON, whereas primitive values which are not present in this JSON are getting added,
present values getting overwritten, array values getting appended and nested JSONs getting merged the same way.
- parameter other: The JSON which gets merged into this JSON
- throws `ErrorWrongType` if the other JSONs differs in type on the top level.
*/
public mutating func merge(with other: JSON) throws {
try self.merge(with: other, typecheck: true)
}
/**
Merges another JSON into this JSON and returns a new JSON, whereas primitive values which are not present in this JSON are getting added,
present values getting overwritten, array values getting appended and nested JSONS getting merged the same way.
- parameter other: The JSON which gets merged into this JSON
- returns: New merged JSON
- throws `ErrorWrongType` if the other JSONs differs in type on the top level.
*/
public func merged(with other: JSON) throws -> JSON {
var merged = self
try merged.merge(with: other, typecheck: true)
return merged
}
// Private woker function which does the actual merging
// Typecheck is set to true for the first recursion level to prevent total override of the source JSON
fileprivate mutating func merge(with other: JSON, typecheck: Bool) throws {
if self.type == other.type {
switch self.type {
case .dictionary:
for (key, _) in other {
try self[key].merge(with: other[key], typecheck: false)
}
case .array:
self = JSON(self.arrayValue + other.arrayValue)
default:
self = other
}
} else {
if typecheck {
throw NSError(domain: ErrorDomain, code: ErrorWrongType, userInfo: [NSLocalizedDescriptionKey: "Couldn't merge, because the JSONs differ in type on top level."])
} else {
self = other
}
}
}
/// Private object
fileprivate var rawArray: [Any] = []
fileprivate var rawDictionary: [String : Any] = [:]
fileprivate var rawString: String = ""
fileprivate var rawNumber: NSNumber = 0
fileprivate var rawNull: NSNull = NSNull()
fileprivate var rawBool: Bool = false
/// Private type
fileprivate var _type: Type = .null
/// prviate error
fileprivate var _error: NSError? = nil
/// Object in JSON
public var object: Any {
get {
switch self.type {
case .array:
return self.rawArray
case .dictionary:
return self.rawDictionary
case .string:
return self.rawString
case .number:
return self.rawNumber
case .bool:
return self.rawBool
default:
return self.rawNull
}
}
set {
_error = nil
switch newValue {
case let number as NSNumber:
if number.isBool {
_type = .bool
self.rawBool = number.boolValue
} else {
_type = .number
self.rawNumber = number
}
case let string as String:
_type = .string
self.rawString = string
case _ as NSNull:
_type = .null
case _ as [JSON]:
_type = .array
case nil:
_type = .null
case let array as [Any]:
_type = .array
self.rawArray = array
case let dictionary as [String : Any]:
_type = .dictionary
self.rawDictionary = dictionary
default:
_type = .unknown
_error = NSError(domain: ErrorDomain, code: ErrorUnsupportedType, userInfo: [NSLocalizedDescriptionKey: "It is a unsupported type"])
}
}
}
/// JSON type
public var type: Type { get { return _type } }
/// Error in JSON
public var error: NSError? { get { return self._error } }
/// The static null JSON
@available(*, unavailable, renamed:"null")
public static var nullJSON: JSON { get { return null } }
public static var null: JSON { get { return JSON(NSNull()) } }
}
public enum Index<T: Any>: Comparable
{
case array(Int)
case dictionary(DictionaryIndex<String, T>)
case null
static public func ==(lhs: Index, rhs: Index) -> Bool {
switch (lhs, rhs) {
case (.array(let left), .array(let right)):
return left == right
case (.dictionary(let left), .dictionary(let right)):
return left == right
case (.null, .null): return true
default:
return false
}
}
static public func <(lhs: Index, rhs: Index) -> Bool {
switch (lhs, rhs) {
case (.array(let left), .array(let right)):
return left < right
case (.dictionary(let left), .dictionary(let right)):
return left < right
default:
return false
}
}
}
public typealias JSONIndex = Index<JSON>
public typealias JSONRawIndex = Index<Any>
extension JSON: Collection
{
public typealias Index = JSONRawIndex
public var startIndex: Index
{
switch type
{
case .array:
return .array(rawArray.startIndex)
case .dictionary:
return .dictionary(rawDictionary.startIndex)
default:
return .null
}
}
public var endIndex: Index
{
switch type
{
case .array:
return .array(rawArray.endIndex)
case .dictionary:
return .dictionary(rawDictionary.endIndex)
default:
return .null
}
}
public func index(after i: Index) -> Index
{
switch i
{
case .array(let idx):
return .array(rawArray.index(after: idx))
case .dictionary(let idx):
return .dictionary(rawDictionary.index(after: idx))
default:
return .null
}
}
public subscript (position: Index) -> (String, JSON)
{
switch position
{
case .array(let idx):
return (String(idx), JSON(self.rawArray[idx]))
case .dictionary(let idx):
let (key, value) = self.rawDictionary[idx]
return (key, JSON(value))
default:
return ("", JSON.null)
}
}
}
// MARK: - Subscript
/**
* To mark both String and Int can be used in subscript.
*/
public enum JSONKey
{
case index(Int)
case key(String)
}
public protocol JSONSubscriptType {
var jsonKey:JSONKey { get }
}
extension Int: JSONSubscriptType {
public var jsonKey:JSONKey {
return JSONKey.index(self)
}
}
extension String: JSONSubscriptType {
public var jsonKey:JSONKey {
return JSONKey.key(self)
}
}
extension JSON {
/// If `type` is `.Array`, return json whose object is `array[index]`, otherwise return null json with error.
fileprivate subscript(index index: Int) -> JSON {
get {
if self.type != .array {
var r = JSON.null
r._error = self._error ?? NSError(domain: ErrorDomain, code: ErrorWrongType, userInfo: [NSLocalizedDescriptionKey: "Array[\(index)] failure, It is not an array"])
return r
} else if index >= 0 && index < self.rawArray.count {
return JSON(self.rawArray[index])
} else {
var r = JSON.null
r._error = NSError(domain: ErrorDomain, code:ErrorIndexOutOfBounds , userInfo: [NSLocalizedDescriptionKey: "Array[\(index)] is out of bounds"])
return r
}
}
set {
if self.type == .array {
if self.rawArray.count > index && newValue.error == nil {
self.rawArray[index] = newValue.object
}
}
}
}
/// If `type` is `.Dictionary`, return json whose object is `dictionary[key]` , otherwise return null json with error.
fileprivate subscript(key key: String) -> JSON {
get {
var r = JSON.null
if self.type == .dictionary {
if let o = self.rawDictionary[key] {
r = JSON(o)
} else {
r._error = NSError(domain: ErrorDomain, code: ErrorNotExist, userInfo: [NSLocalizedDescriptionKey: "Dictionary[\"\(key)\"] does not exist"])
}
} else {
r._error = self._error ?? NSError(domain: ErrorDomain, code: ErrorWrongType, userInfo: [NSLocalizedDescriptionKey: "Dictionary[\"\(key)\"] failure, It is not an dictionary"])
}
return r
}
set {
if self.type == .dictionary && newValue.error == nil {
self.rawDictionary[key] = newValue.object
}
}
}
/// If `sub` is `Int`, return `subscript(index:)`; If `sub` is `String`, return `subscript(key:)`.
fileprivate subscript(sub sub: JSONSubscriptType) -> JSON {
get {
switch sub.jsonKey {
case .index(let index): return self[index: index]
case .key(let key): return self[key: key]
}
}
set {
switch sub.jsonKey {
case .index(let index): self[index: index] = newValue
case .key(let key): self[key: key] = newValue
}
}
}
/**
Find a json in the complex data structures by using array of Int and/or String as path.
- parameter path: The target json's path. Example:
let json = JSON[data]
let path = [9,"list","person","name"]
let name = json[path]
The same as: let name = json[9]["list"]["person"]["name"]
- returns: Return a json found by the path or a null json with error
*/
public subscript(path: [JSONSubscriptType]) -> JSON {
get {
return path.reduce(self) { $0[sub: $1] }
}
set {
switch path.count {
case 0:
return
case 1:
self[sub:path[0]].object = newValue.object
default:
var aPath = path; aPath.remove(at: 0)
var nextJSON = self[sub: path[0]]
nextJSON[aPath] = newValue
self[sub: path[0]] = nextJSON
}
}
}
/**
Find a json in the complex data structures by using array of Int and/or String as path.
- parameter path: The target json's path. Example:
let name = json[9,"list","person","name"]
The same as: let name = json[9]["list"]["person"]["name"]
- returns: Return a json found by the path or a null json with error
*/
public subscript(path: JSONSubscriptType...) -> JSON {
get {
return self[path]
}
set {
self[path] = newValue
}
}
}
// MARK: - LiteralConvertible
extension JSON: Swift.ExpressibleByStringLiteral {
public init(stringLiteral value: StringLiteralType) {
self.init(value as Any)
}
public init(extendedGraphemeClusterLiteral value: StringLiteralType) {
self.init(value as Any)
}
public init(unicodeScalarLiteral value: StringLiteralType) {
self.init(value as Any)
}
}
extension JSON: Swift.ExpressibleByIntegerLiteral {
public init(integerLiteral value: IntegerLiteralType) {
self.init(value as Any)
}
}
extension JSON: Swift.ExpressibleByBooleanLiteral {
public init(booleanLiteral value: BooleanLiteralType) {
self.init(value as Any)
}
}
extension JSON: Swift.ExpressibleByFloatLiteral {
public init(floatLiteral value: FloatLiteralType) {
self.init(value as Any)
}
}
extension JSON: Swift.ExpressibleByDictionaryLiteral {
public init(dictionaryLiteral elements: (String, Any)...) {
let array = elements
self.init(dictionaryLiteral: array)
}
public init(dictionaryLiteral elements: [(String, Any)]) {
let jsonFromDictionaryLiteral: ([String : Any]) -> JSON = { dictionary in
let initializeElement = Array(dictionary.keys).compactMap { key -> (String, Any)? in
if let value = dictionary[key] {
return (key, value)
}
return nil
}
return JSON(dictionaryLiteral: initializeElement)
}
var dict = [String : Any](minimumCapacity: elements.count)
for element in elements {
let elementToSet: Any
if let json = element.1 as? JSON {
elementToSet = json.object
} else if let jsonArray = element.1 as? [JSON] {
elementToSet = JSON(jsonArray).object
} else if let dictionary = element.1 as? [String : Any] {
elementToSet = jsonFromDictionaryLiteral(dictionary).object
} else if let dictArray = element.1 as? [[String : Any]] {
let jsonArray = dictArray.map { jsonFromDictionaryLiteral($0) }
elementToSet = JSON(jsonArray).object
} else {
elementToSet = element.1
}
dict[element.0] = elementToSet
}
self.init(dict)
}
}
extension JSON: Swift.ExpressibleByArrayLiteral {
public init(arrayLiteral elements: Any...) {
self.init(elements as Any)
}
}
extension JSON: Swift.ExpressibleByNilLiteral {
@available(*, deprecated, message: "use JSON.null instead. Will be removed in future versions")
public init(nilLiteral: ()) {
self.init(NSNull() as Any)
}
}
// MARK: - Raw
extension JSON: Swift.RawRepresentable {
public init?(rawValue: Any) {
if JSON(rawValue).type == .unknown {
return nil
} else {
self.init(rawValue)
}
}
public var rawValue: Any {
return self.object
}
public func rawData(options opt: JSONSerialization.WritingOptions = JSONSerialization.WritingOptions(rawValue: 0)) throws -> Data {
guard JSONSerialization.isValidJSONObject(self.object) else {
throw NSError(domain: ErrorDomain, code: ErrorInvalidJSON, userInfo: [NSLocalizedDescriptionKey: "JSON is invalid"])
}
return try JSONSerialization.data(withJSONObject: self.object, options: opt)
}
public func rawString(_ encoding: String.Encoding = .utf8, options opt: JSONSerialization.WritingOptions = .prettyPrinted) -> String? {
do {
return try _rawString(encoding, options: [.jsonSerialization: opt])
} catch {
print("Could not serialize object to JSON because:", error.localizedDescription)
return nil
}
}
public func rawString(_ options: [writtingOptionsKeys: Any]) -> String? {
let encoding = options[.encoding] as? String.Encoding ?? String.Encoding.utf8
let maxObjectDepth = options[.maxObjextDepth] as? Int ?? 10
do {
return try _rawString(encoding, options: options, maxObjectDepth: maxObjectDepth)
} catch {
print("Could not serialize object to JSON because:", error.localizedDescription)
return nil
}
}
fileprivate func _rawString(
_ encoding: String.Encoding = .utf8,
options: [writtingOptionsKeys: Any],
maxObjectDepth: Int = 10
) throws -> String? {
if (maxObjectDepth < 0) {
throw NSError(domain: ErrorDomain, code: ErrorInvalidJSON, userInfo: [NSLocalizedDescriptionKey: "Element too deep. Increase maxObjectDepth and make sure there is no reference loop"])
}
switch self.type {
case .dictionary:
do {
if !(options[.castNilToNSNull] as? Bool ?? false) {
let jsonOption = options[.jsonSerialization] as? JSONSerialization.WritingOptions ?? JSONSerialization.WritingOptions.prettyPrinted
let data = try self.rawData(options: jsonOption)
return String(data: data, encoding: encoding)
}
guard let dict = self.object as? [String: Any?] else {
return nil
}
let body = try dict.keys.map { key throws -> String in
guard let value = dict[key] else {
return "\"\(key)\": null"
}
guard let unwrappedValue = value else {
return "\"\(key)\": null"
}
let nestedValue = JSON(unwrappedValue)
guard let nestedString = try nestedValue._rawString(encoding, options: options, maxObjectDepth: maxObjectDepth - 1) else {
throw NSError(domain: ErrorDomain, code: ErrorInvalidJSON, userInfo: [NSLocalizedDescriptionKey: "Could not serialize nested JSON"])
}
if nestedValue.type == .string {
return "\"\(key)\": \"\(nestedString.replacingOccurrences(of: "\\", with: "\\\\").replacingOccurrences(of: "\"", with: "\\\""))\""
} else {
return "\"\(key)\": \(nestedString)"
}
}
return "{\(body.joined(separator: ","))}"
} catch _ {
return nil
}
case .array:
do {
if !(options[.castNilToNSNull] as? Bool ?? false) {
let jsonOption = options[.jsonSerialization] as? JSONSerialization.WritingOptions ?? JSONSerialization.WritingOptions.prettyPrinted
let data = try self.rawData(options: jsonOption)
return String(data: data, encoding: encoding)
}
guard let array = self.object as? [Any?] else {
return nil
}
let body = try array.map { value throws -> String in
guard let unwrappedValue = value else {
return "null"
}
let nestedValue = JSON(unwrappedValue)
guard let nestedString = try nestedValue._rawString(encoding, options: options, maxObjectDepth: maxObjectDepth - 1) else {
throw NSError(domain: ErrorDomain, code: ErrorInvalidJSON, userInfo: [NSLocalizedDescriptionKey: "Could not serialize nested JSON"])
}
if nestedValue.type == .string {
return "\"\(nestedString.replacingOccurrences(of: "\\", with: "\\\\").replacingOccurrences(of: "\"", with: "\\\""))\""
} else {
return nestedString
}
}
return "[\(body.joined(separator: ","))]"
} catch _ {
return nil
}
case .string:
return self.rawString
case .number:
return self.rawNumber.stringValue
case .bool:
return self.rawBool.description
case .null:
return "null"
default:
return nil
}
}
}
// MARK: - Printable, DebugPrintable
extension JSON: Swift.CustomStringConvertible, Swift.CustomDebugStringConvertible {
public var description: String {
if let string = self.rawString(options:.prettyPrinted) {
return string
} else {
return "unknown"
}
}
public var debugDescription: String {
return description
}
}
// MARK: - Array
extension JSON {
//Optional [JSON]
public var array: [JSON]? {
get {
if self.type == .array {
return self.rawArray.map{ JSON($0) }
} else {
return nil
}
}
}
//Non-optional [JSON]
public var arrayValue: [JSON] {
get {
return self.array ?? []
}
}
//Optional [Any]
public var arrayObject: [Any]? {
get {
switch self.type {
case .array:
return self.rawArray
default:
return nil
}
}
set {
if let array = newValue {
self.object = array as Any
} else {
self.object = NSNull()
}
}
}
}
// MARK: - Dictionary
extension JSON {
//Optional [String : JSON]
public var dictionary: [String : JSON]? {
if self.type == .dictionary {
var d = [String : JSON](minimumCapacity: rawDictionary.count)
for (key, value) in rawDictionary {
d[key] = JSON(value)
}
return d
} else {
return nil
}
}
//Non-optional [String : JSON]
public var dictionaryValue: [String : JSON] {
return self.dictionary ?? [:]
}
//Optional [String : Any]
public var dictionaryObject: [String : Any]? {
get {
switch self.type {
case .dictionary:
return self.rawDictionary
default:
return nil
}
}
set {
if let v = newValue {
self.object = v as Any
} else {
self.object = NSNull()
}
}
}
}
// MARK: - Bool
extension JSON { // : Swift.Bool
//Optional bool
public var bool: Bool? {
get {
switch self.type {
case .bool:
return self.rawBool
default:
return nil
}
}
set {
if let newValue = newValue {
self.object = newValue as Bool
} else {
self.object = NSNull()
}
}
}
//Non-optional bool
public var boolValue: Bool {
get {
switch self.type {
case .bool:
return self.rawBool
case .number:
return self.rawNumber.boolValue
case .string:
return ["true", "y", "t"].contains() { (truthyString) in
return self.rawString.caseInsensitiveCompare(truthyString) == .orderedSame
}
default:
return false
}
}
set {
self.object = newValue
}
}
}
// MARK: - String
extension JSON {
//Optional string
public var string: String? {
get {
switch self.type {
case .string:
return self.object as? String
default:
return nil
}
}
set {
if let newValue = newValue {
self.object = NSString(string:newValue)
} else {
self.object = NSNull()
}
}
}
//Non-optional string
public var stringValue: String {
get {
switch self.type {
case .string:
return self.object as? String ?? ""
case .number:
return self.rawNumber.stringValue
case .bool:
return (self.object as? Bool).map { String($0) } ?? ""
default:
return ""
}
}
set {
self.object = NSString(string:newValue)
}
}
}
// MARK: - Number
extension JSON {
//Optional number
public var number: NSNumber? {
get {
switch self.type {
case .number:
return self.rawNumber
case .bool:
return NSNumber(value: self.rawBool ? 1 : 0)
default:
return nil
}
}
set {
self.object = newValue ?? NSNull()
}
}
//Non-optional number
public var numberValue: NSNumber {
get {
switch self.type {
case .string:
let decimal = NSDecimalNumber(string: self.object as? String)
if decimal == NSDecimalNumber.notANumber { // indicates parse error
return NSDecimalNumber.zero
}
return decimal
case .number:
return self.object as? NSNumber ?? NSNumber(value: 0)
case .bool:
return NSNumber(value: self.rawBool ? 1 : 0)
default:
return NSNumber(value: 0.0)
}
}
set {
self.object = newValue
}
}
}
//MARK: - Null
extension JSON {
public var null: NSNull? {
get {
switch self.type {
case .null:
return self.rawNull
default:
return nil
}
}
set {
self.object = NSNull()
}
}
public func exists() -> Bool{
if let errorValue = error, errorValue.code == ErrorNotExist ||
errorValue.code == ErrorIndexOutOfBounds ||
errorValue.code == ErrorWrongType {
return false
}
return true
}
}
//MARK: - URL
extension JSON {
//Optional URL
public var url: URL? {
get {
switch self.type {
case .string:
// Check for existing percent escapes first to prevent double-escaping of % character
if let _ = self.rawString.range(of: "%[0-9A-Fa-f]{2}", options: .regularExpression, range: nil, locale: nil) {
return Foundation.URL(string: self.rawString)
} else if let encodedString_ = self.rawString.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed) {
// We have to use `Foundation.URL` otherwise it conflicts with the variable name.
return Foundation.URL(string: encodedString_)
} else {
return nil
}
default:
return nil
}
}
set {
self.object = newValue?.absoluteString ?? NSNull()
}
}
}
// MARK: - Int, Double, Float, Int8, Int16, Int32, Int64
extension JSON {
public var double: Double? {
get {
return self.number?.doubleValue
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var doubleValue: Double {
get {
return self.numberValue.doubleValue
}
set {
self.object = NSNumber(value: newValue)
}
}
public var float: Float? {
get {
return self.number?.floatValue
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var floatValue: Float {
get {
return self.numberValue.floatValue
}
set {
self.object = NSNumber(value: newValue)
}
}
public var int: Int?
{
get
{
return self.number?.intValue
}
set
{
if let newValue = newValue
{
self.object = NSNumber(value: newValue)
} else
{
self.object = NSNull()
}
}
}
public var intValue: Int {
get {
return self.numberValue.intValue
}
set {
self.object = NSNumber(value: newValue)
}
}
public var uInt: UInt? {
get {
return self.number?.uintValue
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var uIntValue: UInt {
get {
return self.numberValue.uintValue
}
set {
self.object = NSNumber(value: newValue)
}
}
public var int8: Int8? {
get {
return self.number?.int8Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: Int(newValue))
} else {
self.object = NSNull()
}
}
}
public var int8Value: Int8 {
get {
return self.numberValue.int8Value
}
set {
self.object = NSNumber(value: Int(newValue))
}
}
public var uInt8: UInt8? {
get {
return self.number?.uint8Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var uInt8Value: UInt8 {
get {
return self.numberValue.uint8Value
}
set {
self.object = NSNumber(value: newValue)
}
}
public var int16: Int16? {
get {
return self.number?.int16Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var int16Value: Int16 {
get {
return self.numberValue.int16Value
}
set {
self.object = NSNumber(value: newValue)
}
}
public var uInt16: UInt16? {
get {
return self.number?.uint16Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var uInt16Value: UInt16 {
get {
return self.numberValue.uint16Value
}
set {
self.object = NSNumber(value: newValue)
}
}
public var int32: Int32? {
get {
return self.number?.int32Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var int32Value: Int32 {
get {
return self.numberValue.int32Value
}
set {
self.object = NSNumber(value: newValue)
}
}
public var uInt32: UInt32? {
get {
return self.number?.uint32Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var uInt32Value: UInt32 {
get {
return self.numberValue.uint32Value
}
set {
self.object = NSNumber(value: newValue)
}
}
public var int64: Int64? {
get {
return self.number?.int64Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var int64Value: Int64 {
get {
return self.numberValue.int64Value
}
set {
self.object = NSNumber(value: newValue)
}
}
public var uInt64: UInt64? {
get {
return self.number?.uint64Value
}
set {
if let newValue = newValue {
self.object = NSNumber(value: newValue)
} else {
self.object = NSNull()
}
}
}
public var uInt64Value: UInt64 {
get {
return self.numberValue.uint64Value
}
set {
self.object = NSNumber(value: newValue)
}
}
}
//MARK: - Comparable
extension JSON : Swift.Comparable {}
public func ==(lhs: JSON, rhs: JSON) -> Bool {
switch (lhs.type, rhs.type) {
case (.number, .number):
return lhs.rawNumber == rhs.rawNumber
case (.string, .string):
return lhs.rawString == rhs.rawString
case (.bool, .bool):
return lhs.rawBool == rhs.rawBool
case (.array, .array):
return lhs.rawArray as NSArray == rhs.rawArray as NSArray
case (.dictionary, .dictionary):
return lhs.rawDictionary as NSDictionary == rhs.rawDictionary as NSDictionary
case (.null, .null):
return true
default:
return false
}
}
public func <=(lhs: JSON, rhs: JSON) -> Bool {
switch (lhs.type, rhs.type) {
case (.number, .number):
return lhs.rawNumber <= rhs.rawNumber
case (.string, .string):
return lhs.rawString <= rhs.rawString
case (.bool, .bool):
return lhs.rawBool == rhs.rawBool
case (.array, .array):
return lhs.rawArray as NSArray == rhs.rawArray as NSArray
case (.dictionary, .dictionary):
return lhs.rawDictionary as NSDictionary == rhs.rawDictionary as NSDictionary
case (.null, .null):
return true
default:
return false
}
}
public func >=(lhs: JSON, rhs: JSON) -> Bool {
switch (lhs.type, rhs.type) {
case (.number, .number):
return lhs.rawNumber >= rhs.rawNumber
case (.string, .string):
return lhs.rawString >= rhs.rawString
case (.bool, .bool):
return lhs.rawBool == rhs.rawBool
case (.array, .array):
return lhs.rawArray as NSArray == rhs.rawArray as NSArray
case (.dictionary, .dictionary):
return lhs.rawDictionary as NSDictionary == rhs.rawDictionary as NSDictionary
case (.null, .null):
return true
default:
return false
}
}
public func >(lhs: JSON, rhs: JSON) -> Bool {
switch (lhs.type, rhs.type) {
case (.number, .number):
return lhs.rawNumber > rhs.rawNumber
case (.string, .string):
return lhs.rawString > rhs.rawString
default:
return false
}
}
public func <(lhs: JSON, rhs: JSON) -> Bool {
switch (lhs.type, rhs.type) {
case (.number, .number):
return lhs.rawNumber < rhs.rawNumber
case (.string, .string):
return lhs.rawString < rhs.rawString
default:
return false
}
}
private let trueNumber = NSNumber(value: true)
private let falseNumber = NSNumber(value: false)
private let trueObjCType = String(cString: trueNumber.objCType)
private let falseObjCType = String(cString: falseNumber.objCType)
// MARK: - NSNumber: Comparable
extension NSNumber {
var isBool:Bool {
get {
let objCType = String(cString: self.objCType)
if (self.compare(trueNumber) == .orderedSame && objCType == trueObjCType) || (self.compare(falseNumber) == .orderedSame && objCType == falseObjCType){
return true
} else {
return false
}
}
}
}
func ==(lhs: NSNumber, rhs: NSNumber) -> Bool {
switch (lhs.isBool, rhs.isBool) {
case (false, true):
return false
case (true, false):
return false
default:
return lhs.compare(rhs) == .orderedSame
}
}
func !=(lhs: NSNumber, rhs: NSNumber) -> Bool {
return !(lhs == rhs)
}
func <(lhs: NSNumber, rhs: NSNumber) -> Bool {
switch (lhs.isBool, rhs.isBool) {
case (false, true):
return false
case (true, false):
return false
default:
return lhs.compare(rhs) == .orderedAscending
}
}
func >(lhs: NSNumber, rhs: NSNumber) -> Bool {
switch (lhs.isBool, rhs.isBool) {
case (false, true):
return false
case (true, false):
return false
default:
return lhs.compare(rhs) == ComparisonResult.orderedDescending
}
}
func <=(lhs: NSNumber, rhs: NSNumber) -> Bool {
switch (lhs.isBool, rhs.isBool) {
case (false, true):
return false
case (true, false):
return false
default:
return lhs.compare(rhs) != .orderedDescending
}
}
func >=(lhs: NSNumber, rhs: NSNumber) -> Bool {
switch (lhs.isBool, rhs.isBool) {
case (false, true):
return false
case (true, false):
return false
default:
return lhs.compare(rhs) != .orderedAscending
}
}
public enum writtingOptionsKeys {
case jsonSerialization
case castNilToNSNull
case maxObjextDepth
case encoding
}
|
mit
|
5cf71b7c96faba8ef4fbe9308afbd0b1
| 26.965657 | 265 | 0.546702 | 4.658329 | false | false | false | false |
liuxuan30/SwiftCharts
|
SwiftCharts/Axis/ChartAxisXLayerDefault.swift
|
1
|
5107
|
//
// ChartAxisXLayerDefault.swift
// SwiftCharts
//
// Created by ischuetz on 25/04/15.
// Copyright (c) 2015 ivanschuetz. All rights reserved.
//
import UIKit
class ChartAxisXLayerDefault: ChartAxisLayerDefault {
override var width: CGFloat {
return self.p2.x - self.p1.x
}
lazy var labelsTotalHeight: CGFloat = {
return self.rowHeights.reduce(0) {sum, height in
sum + height + self.settings.labelsSpacing
}
}()
lazy var rowHeights: [CGFloat] = {
return self.calculateRowHeights()
}()
override var height: CGFloat {
return self.labelsTotalHeight + self.settings.axisStrokeWidth + self.settings.labelsToAxisSpacingX + self.settings.axisTitleLabelsToLabelsSpacing + self.axisTitleLabelsHeight
}
override var length: CGFloat {
return p2.x - p1.x
}
override func chartViewDrawing(#context: CGContextRef, chart: Chart) {
super.chartViewDrawing(context: context, chart: chart)
}
override func generateLineDrawer(#offset: CGFloat) -> ChartLineDrawer {
let p1 = CGPointMake(self.p1.x, self.p1.y + offset)
let p2 = CGPointMake(self.p2.x, self.p2.y + offset)
return ChartLineDrawer(p1: p1, p2: p2, color: self.settings.lineColor)
}
override func generateAxisTitleLabelsDrawers(#offset: CGFloat) -> [ChartLabelDrawer] {
return self.generateAxisTitleLabelsDrawers(self.axisTitleLabels, spacingLabelAxisX: self.settings.labelsToAxisSpacingX, spacingLabelBetweenAxis: self.settings.labelsSpacing, offset: offset)
}
private func generateAxisTitleLabelsDrawers(labels: [ChartAxisLabel], spacingLabelAxisX: CGFloat, spacingLabelBetweenAxis: CGFloat, offset: CGFloat) -> [ChartLabelDrawer] {
let rowHeights = self.rowHeightsForRows(rows: labels.map{[$0]})
return Array(enumerate(labels)).map{(index, label) in
let rowY = self.calculateRowY(rowHeights: rowHeights, rowIndex: index, spacing: spacingLabelBetweenAxis)
let labelWidth = ChartUtils.textSize(label.text, font: label.settings.font).width
let x = (self.p2.x - self.p1.x) / 2 + self.p1.x - labelWidth / 2
let y = self.p1.y + offset + rowY
let drawer = ChartLabelDrawer(text: label.text, screenLoc: CGPointMake(x, y), settings: label.settings)
drawer.hidden = label.hidden
return drawer
}
}
override func screenLocForScalar(scalar: CGFloat, firstAxisScalar: CGFloat) -> CGFloat {
return self.p1.x + self.innerScreenLocForScalar(scalar, firstAxisScalar: firstAxisScalar)
}
// calculate row heights (max text height) for each row
private func calculateRowHeights() -> [CGFloat] {
// organize labels in rows
let maxRowCount = self.axisValues.reduce(-1) {maxCount, axisValue in
max(maxCount, axisValue.labels.count)
}
let rows:[[ChartAxisLabel?]] = (0..<maxRowCount).map {row in
self.axisValues.map {axisValue in
let labels = axisValue.labels
return row < labels.count ? labels[row] : nil
}
}
return self.rowHeightsForRows(rows: rows)
}
override func generateLabelDrawers(#offset: CGFloat) -> [ChartLabelDrawer] {
let modelLength = self.modelLength
let spacingLabelBetweenAxis = self.settings.labelsSpacing
let rowHeights = self.rowHeights
// generate all the label drawers, in a flat list
return self.axisValues.flatMap {axisValue in
return Array(enumerate(axisValue.labels)).map {index, label in
let rowY = self.calculateRowY(rowHeights: rowHeights, rowIndex: index, spacing: spacingLabelBetweenAxis)
let x = self.screenLocForScalar(axisValue.scalar)
let y = self.p1.y + offset + rowY
let labelSize = ChartUtils.textSize(label.text, font: label.settings.font)
let labelX = x - (labelSize.width / 2)
let labelDrawer = ChartLabelDrawer(text: label.text, screenLoc: CGPointMake(labelX, y), settings: label.settings)
labelDrawer.hidden = label.hidden
return labelDrawer
}
}
}
// Get the y offset of row relative to the y position of the first row
private func calculateRowY(#rowHeights: [CGFloat], rowIndex: Int, spacing: CGFloat) -> CGFloat {
return Array(0..<rowIndex).reduce(0) {y, index in
y + rowHeights[index] + spacing
}
}
// Get max text height for each row of axis values
private func rowHeightsForRows(#rows: [[ChartAxisLabel?]]) -> [CGFloat] {
return rows.map {row in
row.reduce(-1) {maxHeight, labelMaybe in
return max(maxHeight, self.labelMaybeSize(labelMaybe).height)
}
}
}
}
|
apache-2.0
|
c4db8b18935168677757135273ef386c
| 37.984733 | 197 | 0.62522 | 4.6301 | false | false | false | false |
srn214/Floral
|
Floral/Pods/NVActivityIndicatorView/Source/NVActivityIndicatorView/Animations/NVActivityIndicatorAnimationPacman.swift
|
3
|
5002
|
//
// NVActivityIndicatorAnimationPacman.swift
// NVActivityIndicatorView
//
// The MIT License (MIT)
// Copyright (c) 2016 Vinh Nguyen
// 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 UIKit
class NVActivityIndicatorAnimationPacman: NVActivityIndicatorAnimationDelegate {
func setUpAnimation(in layer: CALayer, size: CGSize, color: UIColor) {
circleInLayer(layer, size: size, color: color)
pacmanInLayer(layer, size: size, color: color)
}
func pacmanInLayer(_ layer: CALayer, size: CGSize, color: UIColor) {
let pacmanSize = 2 * size.width / 3
let pacmanDuration: CFTimeInterval = 0.5
#if swift(>=4.2)
let timingFunction = CAMediaTimingFunction(name: .default)
#else
let timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionDefault)
#endif
// Stroke start animation
let strokeStartAnimation = CAKeyframeAnimation(keyPath: "strokeStart")
strokeStartAnimation.keyTimes = [0, 0.5, 1]
strokeStartAnimation.timingFunctions = [timingFunction, timingFunction]
strokeStartAnimation.values = [0.125, 0, 0.125]
strokeStartAnimation.duration = pacmanDuration
// Stroke end animation
let strokeEndAnimation = CAKeyframeAnimation(keyPath: "strokeEnd")
strokeEndAnimation.keyTimes = [0, 0.5, 1]
strokeEndAnimation.timingFunctions = [timingFunction, timingFunction]
strokeEndAnimation.values = [0.875, 1, 0.875]
strokeEndAnimation.duration = pacmanDuration
// Animation
let animation = CAAnimationGroup()
animation.animations = [strokeStartAnimation, strokeEndAnimation]
animation.duration = pacmanDuration
animation.repeatCount = HUGE
animation.isRemovedOnCompletion = false
// Draw pacman
let pacman = NVActivityIndicatorShape.pacman.layerWith(size: CGSize(width: pacmanSize, height: pacmanSize), color: color)
let frame = CGRect(
x: (layer.bounds.size.width - size.width) / 2,
y: (layer.bounds.size.height - pacmanSize) / 2,
width: pacmanSize,
height: pacmanSize
)
pacman.frame = frame
pacman.add(animation, forKey: "animation")
layer.addSublayer(pacman)
}
func circleInLayer(_ layer: CALayer, size: CGSize, color: UIColor) {
let circleSize = size.width / 5
let circleDuration: CFTimeInterval = 1
// Translate animation
let translateAnimation = CABasicAnimation(keyPath: "transform.translation.x")
translateAnimation.fromValue = 0
translateAnimation.toValue = -size.width / 2
translateAnimation.duration = circleDuration
// Opacity animation
let opacityAnimation = CABasicAnimation(keyPath: "opacity")
opacityAnimation.fromValue = 1
opacityAnimation.toValue = 0.7
opacityAnimation.duration = circleDuration
// Animation
let animation = CAAnimationGroup()
animation.animations = [translateAnimation, opacityAnimation]
#if swift(>=4.2)
animation.timingFunction = CAMediaTimingFunction(name: .linear)
#else
animation.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
#endif
animation.duration = circleDuration
animation.repeatCount = HUGE
animation.isRemovedOnCompletion = false
// Draw circles
let circle = NVActivityIndicatorShape.circle.layerWith(size: CGSize(width: circleSize, height: circleSize), color: color)
let frame = CGRect(
x: (layer.bounds.size.width - size.width) / 2 + size.width - circleSize,
y: (layer.bounds.size.height - circleSize) / 2,
width: circleSize,
height: circleSize
)
circle.frame = frame
circle.add(animation, forKey: "animation")
layer.addSublayer(circle)
}
}
|
mit
|
a6c75213818fb33f5ec2a457f289badf
| 38.078125 | 129 | 0.686126 | 5.083333 | false | false | false | false |
srn214/Floral
|
Floral/Pods/CLImagePickerTool/CLImagePickerTool/CLImagePickerTool/Board/DrawBoard.swift
|
2
|
9686
|
//
// DrawBoard.swift
// testDemoSwift
//
// Created by 陈亮陈亮 on 2017/5/19.
// Copyright © 2017年 陈亮陈亮. All rights reserved.
// 参考：http://blog.csdn.net/zhangao0086/article/details/43836789
import UIKit
// 开始编辑就改变撤销按钮的状态，让其可以点击
typealias beginDrawClouse = () -> ()
// 当撤销到第一张图片，
typealias undoUnableActionClouse = () -> ()
// 前进到最后一张图片就让按钮不可点击
typealias redoUnableActionClouse = () -> ()
enum DrawingState {
case began, moved, ended
}
class DrawBoard: UIImageView {
// 开始绘画就让控制器中的返回按钮可点击
@objc var beginDraw: beginDrawClouse?
// 不能再撤销或者前进
@objc var unableDraw: undoUnableActionClouse?
@objc var reableDraw: redoUnableActionClouse?
fileprivate var boardUndoManager = DBUndoManager() // 缓存或Undo控制器
@objc var canUndo: Bool {
get {
return self.boardUndoManager.canUndo
}
}
@objc var canRedo: Bool {
get {
return self.boardUndoManager.canRedo
}
}
// 绘图状态
fileprivate var drawingState: DrawingState!
// 绘图的基类
@objc var brush: BaseBrush?
//保存当前的图形
fileprivate var realImage: UIImage?
@objc var strokeWidth: CGFloat = 3
// 画笔颜色，文本输入框的字体颜色
@objc var strokeColor: UIColor = UIColor.red
// 和马赛克相关的图片
@objc var masicImage: UIImage!
// 高斯模糊
@objc var strokeGauussianColor: UIColor = UIColor.clear
// 橡皮擦效果图片
@objc lazy var eraserImage: UIImageView = {
let img = UIImageView.init(frame: CGRect(x: 0, y: 0, width: 0, height: 0))
self.addSubview(img)
return img
}()
override init(frame: CGRect) {
super.init(frame: frame)
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
if let brush = self.brush {
brush.lastPoint = nil
brush.beginPoint = touches.first!.location(in: self)
brush.endPoint = brush.beginPoint
self.drawingState = .began
// 如果是橡皮擦，展示橡皮擦的效果
if self.brush?.classForKeyedArchiver == EraserBrush.classForCoder() {
self.eraserImage.isHidden = false
let imageW = self.strokeWidth*10
self.eraserImage.frame = CGRect(origin: brush.beginPoint, size: CGSize(width: imageW, height: imageW))
self.eraserImage.layer.cornerRadius = imageW*0.5
self.eraserImage.layer.masksToBounds = true
self.eraserImage.backgroundColor = mainColor
}
// 如果是文本输入就展示文本，其他的是绘图
if self.brush?.classForKeyedArchiver == InputBrush.classForCoder() {
} else {
self.drawingImage()
if beginDraw != nil {
self.beginDraw!()
}
}
}
}
override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
if let brush = self.brush {
brush.endPoint = touches.first!.location(in: self)
self.drawingState = .moved
// 如果是橡皮擦，展示橡皮擦的效果
if self.brush?.classForKeyedArchiver == EraserBrush.classForCoder() {
let imageW = self.strokeWidth*10
self.eraserImage.frame = CGRect(origin: brush.endPoint, size: CGSize(width: imageW, height: imageW))
}
if self.brush?.classForKeyedArchiver == InputBrush.classForCoder() {
} else {
self.drawingImage()
}
}
}
override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
if let brush = self.brush {
brush.endPoint = nil
}
}
override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
if let brush = self.brush {
brush.endPoint = touches.first!.location(in: self)
self.drawingState = .ended
// 如果是橡皮擦，展示橡皮擦的效果
if self.brush?.classForKeyedArchiver == EraserBrush.classForCoder() {
self.eraserImage.isHidden = true
}
if self.brush?.classForKeyedArchiver == InputBrush.classForCoder() {
} else {
self.drawingImage()
}
}
}
//MARK: - 返回画板上的图片，用于保存
@objc func takeImage() -> UIImage {
UIGraphicsBeginImageContextWithOptions(self.bounds.size, false, UIScreen.main.scale)
self.backgroundColor?.setFill()
UIRectFill(self.bounds)
self.image?.draw(in: self.bounds)
let image = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
return image!
}
// 撤销
@objc func undo() {
if self.canUndo == false {
return
}
self.image = self.boardUndoManager.imageForUndo()
self.realImage = self.image
// 已经撤销到第一张图片
if self.boardUndoManager.index == -1 {
if self.unableDraw != nil {
self.unableDraw!()
}
}
}
// 前进
@objc func redo() {
if self.canRedo == false {
return
}
self.image = self.boardUndoManager.imageForRedo()
self.realImage = self.image
// 已经撤前进到最后一张图片
if self.boardUndoManager.index == self.boardUndoManager.imageArray.count-1 {
if self.reableDraw != nil {
self.reableDraw!()
}
}
}
// 还原
@objc func retureAction() {
self.image = nil
self.realImage = self.image
}
// 是否可以撤销
@objc func canBack() -> Bool {
return self.canUndo
}
// 是否可以前进
@objc func canForward() -> Bool {
return self.canRedo
}
deinit {
//移除通知
NotificationCenter.default.removeObserver(self)
}
}
extension DrawBoard {
// MARK: - drawing
fileprivate func drawingImage() {
if let brush = self.brush {
// 1.开启一个新的ImageContext，为保存每次的绘图状态作准备。
UIGraphicsBeginImageContextWithOptions(self.bounds.size, false, UIScreen.main.scale)
// 2.初始化context，进行基本设置（画笔宽度、画笔颜色、画笔的圆润度等）。
let context = UIGraphicsGetCurrentContext()
UIColor.clear.setFill()
UIRectFill(self.bounds)
context?.setLineCap(CGLineCap.round)
context?.setLineWidth(self.strokeWidth)
context?.setStrokeColor(self.strokeColor.cgColor)
if self.brush?.classForKeyedArchiver == GaussianBlurBrush.classForCoder() {
context?.setLineWidth(self.strokeWidth*10)
context?.setStrokeColor(self.strokeGauussianColor.cgColor)
}
if self.brush?.classForKeyedArchiver == EraserBrush.classForCoder() {
context?.setLineWidth(self.strokeWidth*10)
context?.setStrokeColor(self.strokeGauussianColor.cgColor)
}
// 马赛克
if self.brush?.classForKeyedArchiver == RectangleBrush.classForCoder() {
context?.setLineWidth(30)
context?.setStrokeColor(UIColor.init(patternImage: self.masicImage).cgColor)
}
// 3.把之前保存的图片绘制进context中。
if let realImage = self.realImage {
realImage.draw(in: self.bounds)
}
// 4.设置brush的基本属性，以便子类更方便的绘图；调用具体的绘图方法，并最终添加到context中。
brush.strokeWidth = self.strokeWidth
brush.drawInContext(context!)
context?.strokePath()
// 5.从当前的context中，得到Image，如果是ended状态或者需要支持连续不断的绘图，则将Image保存到realImage中。
let previewImage = UIGraphicsGetImageFromCurrentImageContext()
if self.drawingState == .ended || brush.supportedContinuousDrawing() {
self.realImage = previewImage
}
UIGraphicsEndImageContext()
// 6.实时显示当前的绘制状态，并记录绘制的最后一个点
self.image = previewImage;
// 用 Ended 事件代替原先的 Began 事件
if self.drawingState == .ended {
// 如果是第一次绘制,同时让前进按钮处于不可点击状态
if self.boardUndoManager.index == -1 {
if self.reableDraw != nil {
self.reableDraw!()
}
}
self.boardUndoManager.addImage(self.image!)
}
brush.lastPoint = brush.endPoint
}
}
}
|
mit
|
bc26110511c89d7876178aa99996833e
| 29.971731 | 118 | 0.553908 | 4.429005 | false | false | false | false |
IcyButterfly/MappingAce
|
MappingAce/KeyMapping.swift
|
2
|
1406
|
//
// KeyMapping.swift
// Mapping
//
// Created by ET|冰琳 on 16/10/24.
// Copyright © 2016年 Ice Butterfly. All rights reserved.
//
import Foundation
public protocol KeyMapping {
static func mappedKeyFor(key: String) -> String?
}
/// 从字段里获取对应key的值
///
/// - parameter propertyName: property name write in entity
/// - parameter d: dic to get property value from
/// - parameter type:
///
/// - returns:
func valueFor(propertyName: String, fromDic d: [String : Any], type: Any.Type) -> Any?{
if let value = valueFor(keyPath: propertyName, fromDic: d){
return value
}
/// 如果没有key映射 或者无对应key映射的值
guard let t = type as? KeyMapping.Type , let mappedKey = t.mappedKeyFor(key: propertyName) else{
return nil
}
/// 有key映射值
return valueFor(keyPath: mappedKey, fromDic: d)
}
func valueFor(keyPath: String, fromDic d: [String : Any]) -> Any? {
/// key
let value = d[keyPath]
if let value = value{
return value
}
/// keyPath
let seperatedStr = keyPath.components(separatedBy: ".")
if seperatedStr.count > 1 {
var returnValue: Any? = d
for key in seperatedStr{
returnValue = (returnValue as? [String : Any])?[key]
}
return returnValue
}
return nil
}
|
mit
|
029da49c42fde5a979c4d0372cff8e37
| 20.983607 | 100 | 0.598061 | 3.864553 | false | false | false | false |
flibbertigibbet/CycleSaver
|
CycleSaver/Controllers/TripListController.swift
|
1
|
6213
|
//
// TripListController.swift
// CycleSaver
//
// Created by Kathryn Killebrew on 12/5/15.
// Copyright © 2015 Kathryn Killebrew. All rights reserved.
//
import Foundation
import UIKit
import CoreData
private let tripCellIdentifier = "tripCellReuseIdentifier"
class TripListController: UIViewController {
@IBOutlet weak var tripTableView: UITableView!
var fetchedResultsController : NSFetchedResultsController!
lazy var coreDataStack = (UIApplication.sharedApplication().delegate as! AppDelegate).coreDataStack
let formatter = NSDateFormatter()
override func viewDidLoad() {
super.viewDidLoad()
formatter.dateStyle = .ShortStyle
formatter.timeStyle = .ShortStyle
let fetchRequest = NSFetchRequest(entityName: "Trip")
let startSort = NSSortDescriptor(key: "start", ascending: true)
let stopSort = NSSortDescriptor(key: "stop", ascending: true)
fetchRequest.sortDescriptors = [startSort, stopSort]
fetchedResultsController = NSFetchedResultsController(fetchRequest: fetchRequest,
managedObjectContext: coreDataStack.context, sectionNameKeyPath: nil, cacheName: nil)
fetchedResultsController.delegate = self
tripTableView.delegate = self
do {
try fetchedResultsController.performFetch()
tripTableView.reloadData()
} catch let error as NSError {
print("Error: \(error.localizedDescription)")
}
}
func configureCell(cell: TripCell, indexPath: NSIndexPath) {
let trip = fetchedResultsController.objectAtIndexPath(indexPath) as! Trip
if let tripStart = trip.start {
cell.startLabel.text = formatter.stringFromDate(tripStart)
}
if let tripStop = trip.stop {
cell.stopLabel.text = formatter.stringFromDate(tripStop)
}
cell.coordsCount.text = "???"
// TODO: how to get related obj
}
}
extension TripListController: UITableViewDataSource {
func numberOfSectionsInTableView (tableView: UITableView) -> Int {
return fetchedResultsController.sections!.count
}
func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
let sectionInfo = fetchedResultsController.sections![section]
return sectionInfo.name
}
func tableView(tableView: UITableView,
numberOfRowsInSection section: Int) -> Int {
let sectionInfo =
fetchedResultsController.sections![section]
return sectionInfo.numberOfObjects
}
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier(tripCellIdentifier, forIndexPath: indexPath) as! TripCell
configureCell(cell, indexPath: indexPath)
return cell
}
}
extension TripListController: UITableViewDelegate {
func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
let trip = fetchedResultsController.objectAtIndexPath(indexPath) as! Trip
print("Selected trip that started at \(trip.start).")
self.performSegueWithIdentifier("ShowTripMap", sender: trip)
}
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
if (segue.identifier == "ShowTripMap") {
if let tripMapController = segue.destinationViewController as? TripDetailController {
tripMapController.trip = sender as? Trip
tripMapController.coreDataStack = coreDataStack
}
}
}
func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
return true
}
func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
switch editingStyle {
case .Delete:
// delete from data source here; this will then trigger deletion on the NSFetchedResultsControllerDelegate, which updates the view
let trip = fetchedResultsController.objectAtIndexPath(indexPath) as! Trip
coreDataStack.context.deleteObject(trip)
coreDataStack.saveContext()
default: break
}
}
}
extension TripListController: NSFetchedResultsControllerDelegate {
func controllerWillChangeContent(controller: NSFetchedResultsController) {
tripTableView.beginUpdates()
}
func controller(controller: NSFetchedResultsController, didChangeObject anObject: AnyObject, atIndexPath indexPath: NSIndexPath?, forChangeType type: NSFetchedResultsChangeType, newIndexPath: NSIndexPath?) {
switch type {
case .Insert:
tripTableView.insertRowsAtIndexPaths([newIndexPath!], withRowAnimation: .Automatic)
case .Delete:
tripTableView.deleteRowsAtIndexPaths([indexPath!], withRowAnimation: .Automatic)
case .Update:
let cell = tripTableView.cellForRowAtIndexPath(indexPath!) as! TripCell
configureCell(cell, indexPath: indexPath!)
case .Move:
tripTableView.deleteRowsAtIndexPaths([indexPath!], withRowAnimation: .Automatic)
tripTableView.insertRowsAtIndexPaths([newIndexPath!], withRowAnimation: .Automatic)
}
}
func controllerDidChangeContent(controller: NSFetchedResultsController) {
tripTableView.endUpdates()
}
func controller(controller: NSFetchedResultsController, didChangeSection sectionInfo: NSFetchedResultsSectionInfo, atIndex sectionIndex: Int,forChangeType type: NSFetchedResultsChangeType) {
let indexSet = NSIndexSet(index: sectionIndex)
switch type {
case .Insert:
tripTableView.insertSections(indexSet, withRowAnimation: .Automatic)
case .Delete:
tripTableView.deleteSections(indexSet, withRowAnimation: .Automatic)
default :
break
}
}
}
|
apache-2.0
|
20518aa2d227ee7d6c16a24eef701b65
| 35.757396 | 211 | 0.682711 | 6.072336 | false | false | false | false |
SkrewEverything/Swift-Keylogger
|
Keylogger/Keylogger/Keylogger.swift
|
1
|
10040
|
//
// Keylogger.swift
// Keylogger
//
// Created by Skrew Everything on 14/01/17.
// Copyright © 2017 Skrew Everything. All rights reserved.
//
import Foundation
import IOKit.hid
import Cocoa
class Keylogger
{
var manager: IOHIDManager
var deviceList = NSArray() // Used in multiple matching dictionary
var bundlePathURL = Bundle.main.bundleURL // Path to where the executable is present - Change this to use custom path
var appName = "" // Active App name
var appData:URL // Folder
var keyData:URL // Folder
var devicesData:URL // Folder
init()
{
appData = bundlePathURL.appendingPathComponent("Data").appendingPathComponent("App") // Creates App Folder in Data Folder
keyData = bundlePathURL.appendingPathComponent("Data").appendingPathComponent("Key") // Creates Key Folder in Data Folder
devicesData = bundlePathURL.appendingPathComponent("Data").appendingPathComponent("Devices") // Creates Devices Folder in Data Folder
manager = IOHIDManagerCreate(kCFAllocatorDefault, IOOptionBits(kIOHIDOptionsTypeNone))
if !(FileManager.default.fileExists(atPath: appData.path) && FileManager.default.fileExists(atPath: keyData.path))
{
do
{
try FileManager.default.createDirectory(at: bundlePathURL.appendingPathComponent("Data"), withIntermediateDirectories: false, attributes: nil)
try FileManager.default.createDirectory(at: appData, withIntermediateDirectories: false, attributes: nil)
try FileManager.default.createDirectory(at: keyData, withIntermediateDirectories: false, attributes: nil)
try FileManager.default.createDirectory(at: devicesData, withIntermediateDirectories: false, attributes: nil)
}
catch
{
print("Can't create directories!")
}
}
if (CFGetTypeID(manager) != IOHIDManagerGetTypeID())
{
print("Can't create manager")
exit(1);
}
deviceList = deviceList.adding(CreateDeviceMatchingDictionary(inUsagePage: kHIDPage_GenericDesktop, inUsage: kHIDUsage_GD_Keyboard)) as NSArray
deviceList = deviceList.adding(CreateDeviceMatchingDictionary(inUsagePage: kHIDPage_GenericDesktop, inUsage: kHIDUsage_GD_Keypad)) as NSArray
IOHIDManagerSetDeviceMatchingMultiple(manager, deviceList as CFArray)
let observer = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
/* App switching notification*/
NSWorkspace.shared.notificationCenter.addObserver(self,
selector: #selector(activatedApp),
name: NSWorkspace.didActivateApplicationNotification,
object: nil)
/* Connected and Disconnected Call Backs */
IOHIDManagerRegisterDeviceMatchingCallback(manager, CallBackFunctions.Handle_DeviceMatchingCallback, observer)
IOHIDManagerRegisterDeviceRemovalCallback(manager, CallBackFunctions.Handle_DeviceRemovalCallback, observer)
/* Input value Call Backs */
IOHIDManagerRegisterInputValueCallback(manager, CallBackFunctions.Handle_IOHIDInputValueCallback, observer);
/* Open HID Manager */
let ioreturn: IOReturn = openHIDManager()
if ioreturn != kIOReturnSuccess
{
print("Can't open HID!")
}
}
@objc dynamic func activatedApp(notification: NSNotification)
{
if let info = notification.userInfo,
let app = info[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication,
let name = app.localizedName
{
self.appName = name
let dateFolder = "\(CallBackFunctions.calander.component(.day, from: Date()))-\(CallBackFunctions.calander.component(.month, from: Date()))-\(CallBackFunctions.calander.component(.year, from: Date()))"
let path = self.appData.appendingPathComponent(dateFolder)
if !FileManager.default.fileExists(atPath: path.path)
{
do
{
try FileManager.default.createDirectory(at: path , withIntermediateDirectories: false, attributes: nil)
}
catch
{
print("Can't Create Folder")
}
}
let fileName = path.appendingPathComponent("Time Stamps of Apps").path
if !FileManager.default.fileExists(atPath: fileName )
{
if !FileManager.default.createFile(atPath: fileName, contents: nil, attributes: nil)
{
print("Can't Create File!")
}
}
let fh = FileHandle.init(forWritingAtPath: fileName)
fh?.seekToEndOfFile()
let timeStamp = Date().description(with: Locale.current) + "\t\(self.appName)" + "\n"
fh?.write(timeStamp.data(using: .utf8)!)
}
}
/* For Keyboard */
func CreateDeviceMatchingDictionary(inUsagePage: Int ,inUsage: Int ) -> CFMutableDictionary
{
/* // note: the usage is only valid if the usage page is also defined */
let resultAsSwiftDic = [kIOHIDDeviceUsagePageKey: inUsagePage, kIOHIDDeviceUsageKey : inUsage]
let resultAsCFDic: CFMutableDictionary = resultAsSwiftDic as! CFMutableDictionary
return resultAsCFDic
}
func openHIDManager() -> IOReturn
{
return IOHIDManagerOpen(manager, IOOptionBits(kIOHIDOptionsTypeNone));
}
/* Scheduling the HID Loop */
func start()
{
IOHIDManagerScheduleWithRunLoop(manager, CFRunLoopGetMain(), CFRunLoopMode.defaultMode.rawValue)
}
/* Un-scheduling the HID Loop */
func stop()
{
IOHIDManagerUnscheduleFromRunLoop(manager, CFRunLoopGetMain(), CFRunLoopMode.defaultMode.rawValue);
}
var keyMap: [UInt32:[String]]
{
var map = [UInt32:[String]]()
map[4] = ["a","A"]
map[5] = ["b","B"]
map[6] = ["c","C"]
map[7] = ["d","D"]
map[8] = ["e","E"]
map[9] = ["f","F"]
map[10] = ["g","G"]
map[11] = ["h","H"]
map[12] = ["i","I"]
map[13] = ["j","J"]
map[14] = ["k","K"]
map[15] = ["l","L"]
map[16] = ["m","M"]
map[17] = ["n","N"]
map[18] = ["o","O"]
map[19] = ["p","P"]
map[20] = ["q","Q"]
map[21] = ["r","R"]
map[22] = ["s","S"]
map[23] = ["t","T"]
map[24] = ["u","U"]
map[25] = ["v","V"]
map[26] = ["w","W"]
map[27] = ["x","X"]
map[28] = ["y","Y"]
map[29] = ["z","Z"]
map[30] = ["1","!"]
map[31] = ["2","@"]
map[32] = ["3","#"]
map[33] = ["4","$"]
map[34] = ["5","%"]
map[35] = ["6","^"]
map[36] = ["7","&"]
map[37] = ["8","*"]
map[38] = ["9","("]
map[39] = ["0",")"]
map[40] = ["\n","\n"]
map[41] = ["\\ESCAPE","\\ESCAPE"]
map[42] = ["\\DELETE|BACKSPACE","\\DELETE|BACKSPACE"] //
map[43] = ["\\TAB","\\TAB"]
map[44] = [" "," "]
map[45] = ["-","_"]
map[46] = ["=","+"]
map[47] = ["[","{"]
map[48] = ["]","}"]
map[49] = ["\\","|"]
map[50] = ["",""] // Keyboard Non-US# and ~2
map[51] = [";",":"]
map[52] = ["'","\""]
map[53] = ["`","~"]
map[54] = [",","<"]
map[55] = [".",">"]
map[56] = ["/","?"]
map[57] = ["\\CAPSLOCK","\\CAPSLOCK"]
map[58] = ["\\F1","\\F1"]
map[59] = ["\\F2","\\F2"]
map[60] = ["\\F3","\\F3"]
map[61] = ["\\F4","\\F4"]
map[62] = ["\\F5","\\F5"]
map[63] = ["\\F6","\\F6"]
map[64] = ["\\F7","\\F7"]
map[65] = ["\\F8","\\F8"]
map[66] = ["\\F9","\\F9"]
map[67] = ["\\F10","\\F10"]
map[68] = ["\\F11","\\F11"]
map[69] = ["\\F12","\\F12"]
map[70] = ["\\PRINTSCREEN","\\PRINTSCREEN"]
map[71] = ["\\SCROLL-LOCK","\\SCROLL-LOCK"]
map[72] = ["\\PAUSE","\\PAUSE"]
map[73] = ["\\INSERT","\\INSERT"]
map[74] = ["\\HOME","\\HOME"]
map[75] = ["\\PAGEUP","\\PAGEUP"]
map[76] = ["\\DELETE-FORWARD","\\DELETE-FORWARD"] //
map[77] = ["\\END","\\END"]
map[78] = ["\\PAGEDOWN","\\PAGEDOWN"]
map[79] = ["\\RIGHTARROW","\\RIGHTARROW"]
map[80] = ["\\LEFTARROW","\\LEFTARROW"]
map[81] = ["\\DOWNARROW","\\DOWNARROW"]
map[82] = ["\\UPARROW","\\UPARROW"]
map[83] = ["\\NUMLOCK","\\CLEAR"]
// Keypads
map[84] = ["/","/"]
map[85] = ["*","*"]
map[86] = ["-","-"]
map[87] = ["+","+"]
map[88] = ["\\ENTER","\\ENTER"]
map[89] = ["1","\\END"]
map[90] = ["2","\\DOWNARROW"]
map[91] = ["3","\\PAGEDOWN"]
map[92] = ["4","\\LEFTARROW"]
map[93] = ["5","5"]
map[94] = ["6","\\RIGHTARROW"]
map[95] = ["7","\\HOME"]
map[96] = ["8","\\UPARROW"]
map[97] = ["9","\\PAGEUP"]
map[98] = ["0","\\INSERT"]
map[99] = [".","\\DELETE"]
map[100] = ["",""] //
/////
map[224] = ["\\LC","\\LC"] // left control
map[225] = ["\\LS","\\LS"] // left shift
map[226] = ["\\LA","\\LA"] // left alt
map[227] = ["\\LCMD","\\LCMD"] // left cmd
map[228] = ["\\RC","\\RC"] // right control
map[229] = ["\\RS","\\RS"] // right shift
map[230] = ["\\RA","\\RA"] // right alt
map[231] = ["\\RCMD","\\RCMD"] // right cmd
return map
}
}
|
mit
|
0b2f8ccf1f6b41879074146bb584c4b1
| 37.910853 | 213 | 0.50523 | 3.966416 | false | false | false | false |
ronaldho/visionproject
|
EMIT/EMIT/Medication.swift
|
1
|
926
|
//
// Medication.swift
// EMIT Project
//
// Created by Andrew on 21/04/16.
// Copyright © 2016 Andrew. All rights reserved.
//
import UIKit
class Medication: NSObject {
var name: String;
var image: UIImage?;
var croppedImage: UIImage?;
var id: String;
var imageUrl: String?;
var pageUrl: String?;
override init(){
self.name = "";
self.id = "0";
super.init();
};
init(withName name:String, andImage image: UIImage?, andCroppedImage croppedImage: UIImage?, andId id:String, andImageUrl imageUrl: String?, andPageUrl pageUrl: String?){
self.name = name;
self.image = image;
self.croppedImage = croppedImage;
self.id = id;
self.imageUrl = imageUrl;
self.pageUrl = pageUrl;
super.init();
}
func toString() -> String{
return "Medication: { Name: \(name), Id: \(id) }";
}
}
|
mit
|
d5f411dd6e10b8cbe81a1285e22f9960
| 23.342105 | 174 | 0.584865 | 3.886555 | false | false | false | false |
garygriswold/Bible.js
|
Plugins/AudioPlayer/src/ios/AudioPlayer/AudioReference.swift
|
1
|
4158
|
//
// AudioReference.swift
// AudioPlayer
//
// Created by Gary Griswold on 8/14/17.
// Copyright © 2017 ShortSands. All rights reserved.
//
class AudioReference {
let tocAudioBook: AudioTOCBook
private let chapter: String
let fileType: String
var audioChapter: AudioTOCChapter?
init(book: AudioTOCBook, chapter: String, fileType: String) {
self.tocAudioBook = book
self.chapter = chapter
self.fileType = fileType
//print("***** Init AudioReference ***** \(self.toString())")
}
convenience init(book: AudioTOCBook, chapterNum: Int, fileType: String) {
let chapter = String(chapterNum)
switch chapter.count {
case 1:
self.init(book: book, chapter: "00" + chapter, fileType: fileType)
case 2:
self.init(book: book, chapter: "0" + chapter, fileType: fileType)
default:
self.init(book: book, chapter: chapter, fileType: fileType)
}
}
deinit {
//print("***** Deinit AudioReference ***** \(self.toString())")
}
var bibleId: String {
get {
return self.tocAudioBook.testament.bible.bibleId
}
}
var bibleName: String {
get {
return self.tocAudioBook.testament.bible.bibleName
}
}
var iso3: String {
get {
return self.tocAudioBook.testament.bible.iso3
}
}
var damId: String {
get {
return self.tocAudioBook.testament.damId
}
}
private var sequence: String {
get {
return self.tocAudioBook.bookOrder
}
}
var sequenceNum: Int {
get {
return self.tocAudioBook.sequence
}
}
var bookId: String {
get {
return self.tocAudioBook.bookId
}
}
var chapterNum: Int {
get {
return Int(self.chapter) ?? 1
}
}
var localName: String {
get {
return self.tocAudioBook.bookName + " " + String(Int(self.chapter) ?? 1)
}
}
private var dbpBookName: String {
get {
return self.tocAudioBook.dbpBookName
}
}
func nextChapter() -> AudioReference? {
return self.tocAudioBook.testament.nextChapter(reference: self)
}
func priorChapter() -> AudioReference? {
return self.tocAudioBook.testament.priorChapter(reference: self)
}
func getS3Bucket() -> String {
return self.tocAudioBook.testament.bible.audioBucket! // Unsafe
}
func getS3Key() -> String {
var chapNum = self.chapter
if self.bookId != "PSA" {
chapNum = "_" + String(chapNum.dropFirst(1))
}
var name: String = self.dbpBookName.replacingOccurrences(of: " ", with: "_")
name = name.padding(toLength: 12, withPad: "_", startingAt: 0)
let parts = self.damId.split(separator: "/")
let damId2 = (parts.count > 2) ? parts[2] : parts[0] // If parts[0] is selected expect ERROR
let key = "\(self.damId)/\(self.sequence)__\(chapNum)_\(name)\(damId2).\(self.fileType)"
return key
}
func getNodeId(verse: Int) -> String {
if verse > 0 {
return self.bookId + ":" + String(self.chapterNum) + ":" + String(verse)
} else {
return self.bookId + ":" + String(self.chapterNum)
}
}
func getReference() -> String {
return "\(self.bibleId):\(self.bookId):\(self.chapterNum)"
}
func isEqual(reference: AudioReference) -> Bool {
if (self.chapter != reference.chapter) { return false }
if (self.bookId != reference.bookId) { return false }
if (self.sequence != reference.sequence) { return false }
if (self.damId != reference.damId) { return false }
if (self.fileType != reference.fileType) { return false }
return true
}
func toString() -> String {
return self.damId + "_" + self.sequence + "_" + self.bookId + "_" + self.chapter + "." + self.fileType
}
}
|
mit
|
ca7979350ad080382f73c9a7f8c6e227
| 27.087838 | 110 | 0.556651 | 4.039845 | false | false | false | false |
MadAppGang/SmartLog
|
iOS/Pods/Dip/Sources/RuntimeArguments.swift
|
3
|
14332
|
//
// Dip
//
// Copyright (c) 2015 Olivier Halligon <[email protected]>
//
// 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.
//
#if swift(>=3.0)
extension DependencyContainer {
/**
Register factory for type `T` and associate it with an optional tag.
- parameters:
- scope: The scope to use for instance created by the factory. Default value is `Shared`.
- type: Type to register definition for. Default value is return value of factory.
- tag: The arbitrary tag to associate this factory with. Pass `nil` to associate with any tag. Default value is `nil`.
- factory: The factory that produces instance of `type`. Will be used to resolve instances of `type`.
- returns: A registered definition.
- note: You should cast the factory return type to the protocol you want to register it for
(unless you want to register concrete type) or provide `type` parameter.
- seealso: `Definition`, `ComponentScope`, `DependencyTagConvertible`
**Example**:
```swift
//Register ServiceImp as Service
container.register { ServiceImp() as Service }
//Register ServiceImp as Service named by "service"
container.register(tag: "service") { ServiceImp() as Service }
//Register unique ServiceImp as Service
container.register(.unique) { ServiceImp() as Service }
//Register ClientImp as Client and resolve it's service dependency
container.register { try ClientImp(service: container.resolve() as Service) as Client }
//Register ServiceImp as concrete type
container.register { ServiceImp() }
container.register(factory: ServiceImp.init)
//Register ServiceImp as Service
container.register(Service.self, factory: ServiceImp.init)
//Register ClientImp as Client
container.register(Client.self, factory: ClientImp.init(service:))
```
*/
@discardableResult public func register<T>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping () throws -> T) -> Definition<T, ()> {
let definition = DefinitionBuilder<T, ()> {
$0.scope = scope
$0.factory = factory
}.build()
register(definition, tag: tag)
return definition
}
/**
Register generic factory and auto-wiring factory and associate it with an optional tag.
- parameters:
- tag: The arbitrary tag to associate this factory with. Pass `nil` to associate with any tag. Default value is `nil`.
- scope: The scope to use for instance created by the factory.
- factory: The factory to register.
- numberOfArguments: The number of factory arguments. Will be used on auto-wiring to sort definitions.
- autoWiringFactory: The factory to be used on auto-wiring to resolve component.
- returns: A registered definition.
- note: You _should not_ call this method directly, instead call any of other `register` methods.
You _should_ use this method only to register dependency with more runtime arguments
than _Dip_ supports (currently it's up to six) like in the following example:
```swift
public func register<T, A, B, C, ...>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: Tag? = nil, factory: (A, B, C, ...) throws -> T) -> Definition<T, (A, B, C, ...)> {
return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: ...) { container, tag in
try factory(container.resolve(tag: tag), ...)
}
}
```
Though before you do so you should probably review your design and try to reduce number of depnedencies.
*/
public func register<T, U>(scope: ComponentScope, type: T.Type, tag: DependencyTagConvertible?, factory: @escaping (U) throws -> T, numberOfArguments: Int, autoWiringFactory: @escaping (DependencyContainer, Tag?) throws -> T) -> Definition<T, U> {
let definition = DefinitionBuilder<T, U> {
$0.scope = scope
$0.factory = factory
$0.numberOfArguments = numberOfArguments
$0.autoWiringFactory = autoWiringFactory
}.build()
register(definition, tag: tag)
return definition
}
// MARK: 1 Runtime Argument
/**
Register factory that accepts one runtime argument of type `A`. You can use up to six runtime arguments.
- note: You can have several factories with different number or types of arguments registered for same type,
optionally associated with some tags. When container resolves that type it matches the type,
__number__, __types__ and __order__ of runtime arguments and optional tag that you pass to `resolve(tag:arguments:)` method.
- parameters:
- tag: The arbitrary tag to associate this factory with. Pass `nil` to associate with any tag. Default value is `nil`.
- scope: The scope to use for this component. Default value is `Shared`.
- factory: The factory to register.
- seealso: `register(_:type:tag:factory:)`
*/
@discardableResult public func register<T, A>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A) throws -> T) -> Definition<T, A> {
return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 1) { container, tag in try factory(container.resolve(tag: tag)) }
}
/**
Resolve type `T` using one runtime argument.
- note: When resolving a type container will first try to use definition
that exactly matches types of arguments that you pass to resolve method.
If it fails or no such definition is found container will try to _auto-wire_ component.
For that it will iterate through all the definitions registered for that type
which factories accept any number of runtime arguments and are tagged with the same tag,
passed to `resolve` method, or with no tag. Container will try to use these definitions
to resolve a component one by one until one of them succeeds, starting with tagged definitions
in order of decreasing their's factories number of arguments. If none of them succeds it will
throw an error. If it finds two definitions with the same number of arguments - it will throw
an error.
- parameters:
- tag: The arbitrary tag to lookup registered definition.
- arg1: The first argument to pass to the definition's factory.
- throws: `DipError.DefinitionNotFound`, `DipError.AutoInjectionFailed`, `DipError.AmbiguousDefinitions`
- returns: An instance of type `T`.
- seealso: `register(_:type:tag:factory:)`, `resolve(tag:builder:)`
*/
public func resolve<T, A>(tag: DependencyTagConvertible? = nil, arguments arg1: A) throws -> T {
return try resolve(tag: tag) { factory in try factory(arg1) }
}
///- seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
public func resolve<A>(_ type: Any.Type, tag: DependencyTagConvertible? = nil, arguments arg1: A) throws -> Any {
return try resolve(type, tag: tag) { factory in try factory(arg1) }
}
// MARK: 2 Runtime Arguments
/// - seealso: `register(_:type:tag:factory:)`
@discardableResult public func register<T, A, B>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B) throws -> T) -> Definition<T, (A, B)> {
return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 2) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag)) }
}
/// - seealso: `resolve(tag:arguments:)`
public func resolve<T, A, B>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B) throws -> T {
return try resolve(tag: tag) { factory in try factory(arg1, arg2) }
}
///- seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
public func resolve<A, B>(_ type: Any.Type, tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B) throws -> Any {
return try resolve(type, tag: tag) { factory in try factory((arg1, arg2)) }
}
// MARK: 3 Runtime Arguments
/// - seealso: `register(_:type:tag:factory:)`
@discardableResult public func register<T, A, B, C>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C) throws -> T) -> Definition<T, (A, B, C)> {
return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 3) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
}
/// - seealso: `resolve(tag:arguments:)`
public func resolve<T, A, B, C>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C) throws -> T {
return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3) }
}
///- seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
public func resolve<A, B, C>(_ type: Any.Type, tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C) throws -> Any {
return try resolve(type, tag: tag) { factory in try factory((arg1, arg2, arg3)) }
}
// MARK: 4 Runtime Arguments
/// - seealso: `register(_:type:tag:factory:)`
@discardableResult public func register<T, A, B, C, D>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C, D) throws -> T) -> Definition<T, (A, B, C, D)> {
return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 4) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
}
/// - seealso: `resolve(tag:arguments:)`
public func resolve<T, A, B, C, D>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D) throws -> T {
return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3, arg4) }
}
/// - seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
public func resolve<A, B, C, D>(_ type: Any.Type, tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D) throws -> Any {
return try resolve(type, tag: tag) { factory in try factory((arg1, arg2, arg3, arg4)) }
}
// MARK: 5 Runtime Arguments
/// - seealso: `register(_:type:tag:factory:)`
@discardableResult public func register<T, A, B, C, D, E>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C, D, E) throws -> T) -> Definition<T, (A, B, C, D, E)> {
return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 5) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
}
/// - seealso: `resolve(tag:arguments:)`
public func resolve<T, A, B, C, D, E>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D, _ arg5: E) throws -> T {
return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3, arg4, arg5) }
}
///- seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
public func resolve<A, B, C, D, E>(_ type: Any.Type, tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D, _ arg5: E) throws -> Any {
return try resolve(type, tag: tag) { factory in try factory((arg1, arg2, arg3, arg4, arg5)) }
}
// MARK: 6 Runtime Arguments
/// - seealso: `register(_:type:tag:factory:)`
@discardableResult public func register<T, A, B, C, D, E, F>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C, D, E, F) throws -> T) -> Definition<T, (A, B, C, D, E, F)> {
return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 6) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
}
/// - seealso: `resolve(tag:arguments:)`
public func resolve<T, A, B, C, D, E, F>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D, _ arg5: E, _ arg6: F) throws -> T {
return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3, arg4, arg5, arg6) }
}
/// - seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
public func resolve<A, B, C, D, E, F>(_ type: Any.Type, tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D, _ arg5: E, _ arg6: F) throws -> Any {
return try resolve(type, tag: tag) { factory in try factory((arg1, arg2, arg3, arg4, arg5, arg6)) }
}
}
#endif
|
mit
|
311a014d6d75f4241eca393077ca5ab0
| 54.984375 | 305 | 0.657061 | 3.949297 | false | false | false | false |
mathcamp/lightbase
|
Example/Todotastic/Carthage/Checkouts/hldb/hldb/Lib/hldb.swift
|
2
|
24041
|
//
// DBTable.swift
// HLModular
//
// Created by Ben Garrett on 7/10/15.
// Copyright (c) 2015 Mathcamp. All rights reserved.
//
import Foundation
import BrightFutures
import Result
// Allows two Rows in a HLDB.Table to be compared using ==
public func ==(lhs: HLDB.Table.Row, rhs: HLDB.Table.Row) -> Bool {
var leftKeys: [String] = lhs.fields.allKeys as! [String]
var rightKeys: [String] = rhs.fields.allKeys as! [String]
if leftKeys.count != rightKeys.count { return false }
leftKeys.sortInPlace { $0 < $1 }
rightKeys.sortInPlace { $0 < $1 }
for (idx, k) in leftKeys.enumerate() {
if rightKeys[idx] != k { return false }
var valuesMatch = false
if let leftVal = lhs.fields[k] as? String {
if let rightVal = rhs.fields[k] as? String {
if leftVal == rightVal {
valuesMatch = true
}
}
}
if let leftVal = lhs.fields[k] as? Int {
if let rightVal = rhs.fields[k] as? Int {
if leftVal == rightVal {
valuesMatch = true
}
}
}
if let leftVal = lhs.fields[k] as? Double {
if let rightVal = rhs.fields[k] as? Double {
if leftVal == rightVal {
valuesMatch = true
}
}
}
if let leftVal = lhs.fields[k] as? Bool {
if let rightVal = rhs.fields[k] as? Bool {
if leftVal == rightVal {
valuesMatch = true
}
}
}
if !valuesMatch { return false }
}
return true
}
public class HLDB {
public class DB {
public var queue: FMDatabaseQueue?
public let fileName: String
public let dbPath: String
public enum Result {
case Success
case Items([NSDictionary])
case Error(Int, String)
}
public struct QueryArgs {
let query: String
let args: [AnyObject]
}
public init(fileName: String) {
self.fileName = fileName
self.dbPath = DB.pathForDBFile(fileName)
print("HLDB: inited at path=\(self.dbPath)")
}
public class func pathForDBFile(fileName: String) -> String {
let documentsFolder = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0]
return (documentsFolder as NSString).stringByAppendingPathComponent(fileName)
}
class func deleteDB(fileName: String) -> NSError? {
let dbPath = DB.pathForDBFile(fileName)
var error: NSError? = nil
let fm = NSFileManager.defaultManager()
if fm.fileExistsAtPath(dbPath) {
do {
try fm.removeItemAtPath(dbPath)
} catch let error1 as NSError {
error = error1
}
}
return error
}
public func getQueue() -> FMDatabaseQueue? {
if queue == nil {
queue = FMDatabaseQueue(path: self.dbPath)
}
return queue
}
// do a query that does not return results without using a transaction
public func updateWithoutTx(query: String, args:[AnyObject] = []) -> Future<Result, NoError> {
let p = Promise<Result, NoError>()
getQueue()?.inDatabase() { db in
if !db.executeUpdate(query, withArgumentsInArray:args as [AnyObject]) {
print("DB Query \(self.fileName) failed: \(db.lastErrorMessage())")
p.success(Result.Error(Int(db.lastErrorCode()), db.lastErrorMessage()))
return
}
p.success(Result.Success)
}
return p.future
}
// do a query that does not return result using a transaction and rollback upon failure
public func update(queries: [QueryArgs]) -> Future<Result, NoError> {
let p = Promise<Result, NoError>()
getQueue()?.inTransaction() { db, rollback in
for query in queries {
// NSLog("Running query=\(query.query) argCount=\(query.args.count) args=\(query.args)")
if !db.executeUpdate(query.query, withArgumentsInArray:query.args as [AnyObject]) {
rollback.initialize(true)
print("DB Query \(self.fileName) failed: \(db.lastErrorMessage())")
p.success(Result.Error(Int(db.lastErrorCode()), db.lastErrorMessage()))
return
}
}
p.success(Result.Success)
}
return p.future
}
// do a select style query that returns result
public func query(query: String, args:[AnyObject] = []) -> Future<Result, NoError> {
let p = Promise<Result, NoError>()
getQueue()?.inDatabase() {
db in
if let rs = db.executeQuery(query, withArgumentsInArray:args as [AnyObject]) {
var items = [NSDictionary]()
while rs.next() {
items.append(rs.resultDictionary())
}
p.success(Result.Items(items))
} else {
print("DB Query \(self.fileName) failed: \(db.lastErrorMessage()) query: \(query)")
p.success(Result.Error(Int(db.lastErrorCode()), db.lastErrorMessage()))
}
}
return p.future
}
// only use within txBlock
public func txUpdate(db: FMDatabase, queries: [QueryArgs]) -> Result {
for query in queries {
if !db.executeUpdate(query.query, withArgumentsInArray:query.args as [AnyObject]) {
print("DB Query \(self.fileName) failed: \(db.lastErrorMessage())")
return Result.Error(Int(db.lastErrorCode()), db.lastErrorMessage())
}
}
return Result.Success
}
// only use within txBlock
public func txQuery(db: FMDatabase, query: String, args:[AnyObject] = []) -> Result {
if let rs = db.executeQuery(query, withArgumentsInArray:args as [AnyObject]) {
var items = [NSDictionary]()
while rs.next() {
items.append(rs.resultDictionary())
}
return Result.Items(items)
} else {
print("DB Query \(self.fileName) failed: \(db.lastErrorMessage()) query: \(query)")
return Result.Error(Int(db.lastErrorCode()), db.lastErrorMessage())
}
}
public func txBlock(block: (FMDatabase) -> (Result)) -> Future<Result, NoError> {
let p = Promise<Result, NoError>()
getQueue()?.inTransaction() { db, rollback in
let result = block(db)
switch result {
case .Error: rollback.initialize(true)
default: break
}
p.success(result)
}
return p.future
}
}
public class Table {
public enum Type: String {
case Integer = "INT"
case Real = "REAL"
case Text = "TEXT"
case Blob = "BLOB"
case Bool = "BOOL"
}
public enum Index: String {
case None = "none"
case PrimaryKey = "primaryKey"
case Unique = "unique"
case Index = "index"
case Packed = "packed"
case Private = "private"
}
public enum Default {
case None
case NonNull
case Value(AnyObject)
}
public struct Field {
let name: String
let type: Type
let index: Index
let defaultValue: Default
public init(name: String, type: Type, index: Index, defaultValue: Default) {
self.name = name
self.type = type
self.index = index
self.defaultValue = defaultValue
}
public init(fromDict: NSDictionary) {
defaultValue = .NonNull
if let name = fromDict["name"] as? String {
self.name = name
} else {
name = ""
}
if let typeValue = fromDict["type"] as? String {
if let type = Type(rawValue: typeValue) {
self.type = type
} else {
type = .Text
}
} else {
type = .Text
}
if let isPrimaryKey = fromDict["pk"] as? Int {
if isPrimaryKey == 1 {
self.index = .PrimaryKey
} else {
index = .None
}
} else {
index = .None
}
}
public func toDictionary() -> NSDictionary {
let outDict = NSMutableDictionary()
outDict["name"] = name
outDict["type"] = type.rawValue
outDict["index"] = index.rawValue
return outDict
}
}
public struct Row: Equatable {
let fields: NSMutableDictionary
public init(fields: NSMutableDictionary) {
self.fields = fields
}
}
public let name: String
public let primaryKey: String
public let definition: [String: Field]
public let db: DB
public var debug: Bool = false
public lazy var fieldNames: [String] = Array(self.definition.keys)
public lazy var fieldNamesPlaceholderStr: String = {
var holders: [String] = []
for field in self.fieldNames {
holders.append("?")
}
return holders.joinWithSeparator(",")
}()
public lazy var fieldNamesStr: String = self.fieldNames.joinWithSeparator(",")
public init(db: DB, name: String, fields:[Field]) {
self.db = db
self.name = name
var foundPrimaryKey = false
var pKey = ""
var def: [String: Field] = [:]
for field in fields {
def[field.name] = field
if !foundPrimaryKey && field.index == .PrimaryKey {
pKey = field.name
foundPrimaryKey = true
}
}
// TODO: Add packed data later
// let packedDataFieldName = "packeddata"
// definition[packedDataFieldName] = Field(name: packedDataFieldName, type: .Blob, index: .Private, defaultValue: .NonNull)
// add a primary key if there wasn't one
if !foundPrimaryKey {
pKey = "id"
def[pKey] = Field(name: pKey, type: .Text, index: .PrimaryKey, defaultValue: .NonNull)
}
self.primaryKey = pKey
self.definition = def
}
var createTableQueryString: String {
var fields: [String] = []
for (_, field) in definition {
let fieldType = field.type.rawValue
var constraintStr = ""
switch field.index {
case .Unique:
constraintStr = " UNIQUE"
case .PrimaryKey:
constraintStr = " PRIMARY KEY"
default:
break
}
var fieldDefault = ""
switch field.defaultValue {
case .None:
break
case .NonNull:
fieldDefault = " NOT NULL"
case .Value(let v):
fieldDefault = " DEFAULT \(v)"
}
fields.append("\(field.name) \(fieldType)\(constraintStr)\(fieldDefault)")
}
let fieldsStr = fields.joinWithSeparator(",")
return "CREATE TABLE IF NOT EXISTS \(name) (\(fieldsStr));"
}
var indicesToBeCreated: [String] {
var statements: [String] = []
for (_, field) in definition {
switch field.index {
case .Unique:
statements.append("CREATE UNIQUE INDEX IF NOT EXISTS \(self.name)_\(field.name) ON \(self.name)(\(field.name));")
case .Index:
statements.append("CREATE INDEX IF NOT EXISTS \(self.name)_\(field.name) ON \(self.name)(\(field.name));")
default:
break
}
}
return statements
}
public func schema() -> Future<[Field], NoError> {
let p = Promise<[Field], NoError>()
let query = "pragma table_info(\(name))"
db.txBlock { fmdb in
return self.db.txQuery(fmdb, query: query)
}.onSuccess { result in
var fields: [Field] = []
switch result {
case .Items(let items):
for item in items {
let f = Field(fromDict: item)
fields.append(f)
}
p.success(fields)
default:
p.success([])
break
}
}
return p.future
}
public func create() -> Future<Void, NoError> {
//NSLog("Create table query string =\(createTableQueryString)")
let p = Promise<Void, NoError>()
db.updateWithoutTx(createTableQueryString).onSuccess { result in
switch result {
case .Success:
for statement in self.indicesToBeCreated {
self.db.updateWithoutTx(statement)
}
default:
break
}
p.success()
}
return p.future
}
public func drop() -> Future<Void, NoError> {
let p = Promise<Void, NoError>()
db.updateWithoutTx("DROP TABLE \(name)").onSuccess {_ in
p.success()
}
return p.future
}
public func dropAndCreate() -> Future<Void, NoError> {
let p = Promise<Void, NoError>()
drop().onSuccess {
self.create().onSuccess {
p.success()
}
}
return p.future
}
func rowFields(r: Row) -> [String] {
// TODO: implement packed
var fieldStrArr = [String]()
for (fieldName, field) in definition {
switch field.type {
case .Integer:
var value = 0
if let v = r.fields[fieldName] as? Int {
value = v
} else {
switch field.defaultValue {
case .Value(let v):
if let v = v as? Int {
value = v
}
default:
break
}
}
fieldStrArr.append("\(value)")
case .Real:
var value: Double = 0.0
if let v = r.fields[fieldName] as? Double {
value = v
} else {
switch field.defaultValue {
case .Value(let v):
if let v = v as? Double {
value = v
}
default:
break
}
}
fieldStrArr.append("\(value)")
break
case .Text:
var value = ""
if let v = r.fields[fieldName] as? String {
value = v
} else {
switch field.defaultValue {
case .Value(let v):
if let v = v as? String {
value = v
}
default:
break
}
}
fieldStrArr.append("\(value)")
break
case .Blob:
// TODO: implement blobs
fieldStrArr.append("NOBLOBS")
break
case .Bool:
var value = false
if let v = r.fields[fieldName] as? Bool {
value = v
} else {
switch field.defaultValue {
case .Value(let v):
if let v = v as? Bool {
value = v
}
default:
break
}
}
fieldStrArr.append("\(value)")
break
}
}
return fieldStrArr
}
func insertAndUpdate(insertRows: [Row], updateRows: [Row]) -> Future<DB.Result, NoError> {
var queries: [DB.QueryArgs] = []
if insertRows.count > 0 {
let query = "INSERT INTO \(name) (\(fieldNamesStr)) values (\(fieldNamesPlaceholderStr))"
for row in insertRows {
let args = rowFields(row)
// log("Q=\(query) Inserting=\(args)")
queries.append(DB.QueryArgs(query: query, args: args))
}
}
if updateRows.count > 0 {
for row in updateRows {
if let primaryKeyVal = row.fields[primaryKey] as? String {
var pairs: [String] = []
var args: [AnyObject] = []
for (k, v) in row.fields {
if let k = k as? String {
if k == primaryKey { continue }
pairs.append("\(k) = ?")
args.append(v)
}
}
let pairsStr = pairs.joinWithSeparator(", ")
let query = "UPDATE \(name) SET \(pairsStr) WHERE \(primaryKey) = ?"
args.append(primaryKeyVal)
queries.append(DB.QueryArgs(query: query, args: args))
} else {
let p = Promise<DB.Result, NoError>()
p.success(.Error(-1, "Cannot update without primary key!"))
return p.future
}
}
}
return db.update(queries)
}
public func insert(rows: [Row]) -> Future<DB.Result, NoError> {
return insertAndUpdate(rows, updateRows: [])
}
public func update(rows: [Row]) -> Future<DB.Result, NoError> {
return insertAndUpdate([], updateRows: rows)
}
public func upsert(rows: [Row]) -> Future<DB.Result, NoError> {
let p = Promise<DB.Result, NoError>()
// bail if you are trying to upsert nothing
if rows.count == 0 {
p.trySuccess(.Success)
return p.future
}
var idList: [String] = []
var placeholderList: [String] = []
for row in rows {
if let rowId = row.fields[primaryKey] as? String {
idList.append(rowId)
placeholderList.append("?")
}
}
let placeholderListStr = placeholderList.joinWithSeparator(",")
let selectQuery = "SELECT \(primaryKey) FROM \(name) WHERE \(primaryKey) in (\(placeholderListStr))"
if debug { NSLog("HLDB: \(name): Upsert idList=\(idList) selectQuery=\(selectQuery)") }
db.txBlock { fmdb in
var foundIds: [String: Bool] = [:]
let selectResult = self.db.txQuery(fmdb, query: selectQuery, args: idList)
switch selectResult {
case .Success:
break
case .Error:
return selectResult
case .Items(let items):
if self.debug { NSLog("HLDB: \(self.name): Found \(items.count) items out of idList of count=\(idList.count)") }
for item in items {
if let v = item[self.primaryKey] as? String {
foundIds[v] = true
}
}
}
if self.debug { NSLog("HLDB: \(self.name): Upsert numRows=\(rows.count) foundRows=\(foundIds)") }
if foundIds.count == 0 {
// Simple case: everything should be inserted
return self.insertWithinTx(fmdb, rows: rows)
} else {
// Complex case: mixture of insert and update
var insertRows: [Row] = []
var updateRows: [Row] = []
for row in rows {
if let rowId = row.fields[self.primaryKey] as? String {
if let _ = foundIds[rowId] {
updateRows.append(row)
} else {
insertRows.append(row)
}
}
}
if self.debug { NSLog("HLDB: \(self.name): Upsert insertRows=\(insertRows.count) updateRows=\(updateRows.count)") }
return self.insertAndUpdateWithinTx(fmdb, insertRows: insertRows, updateRows: updateRows)
}
}.onSuccess { result in
p.success(result)
}
return p.future
}
public func upsertNoTx(rows: [Row]) -> Future<DB.Result, NoError> {
let p = Promise<DB.Result, NoError>()
// bail if you are trying to upsert nothing
if rows.count == 0 {
p.trySuccess(.Success)
return p.future
}
var idList: [String] = []
var placeholderList: [String] = []
for row in rows {
if let rowId = row.fields[primaryKey] as? String {
idList.append(rowId)
placeholderList.append("?")
}
}
let placeholderListStr = placeholderList.joinWithSeparator(",")
var foundIds: [String: Bool] = [:]
let selectQuery = "SELECT \(primaryKey) FROM \(name) WHERE \(primaryKey) in (\(placeholderListStr))"
if debug { NSLog("HLDB: \(name): Upsert idList=\(idList) selectQuery=\(selectQuery)") }
db.query(selectQuery, args: idList).onSuccess(Queue.global.context) { result in
switch result {
case .Success:
break
case .Error:
return p.success(result)
case .Items(let items):
if self.debug { NSLog("HLDB: \(self.name): Found \(items.count) items out of idList of count=\(idList.count)") }
for item in items {
if let v = item[self.primaryKey] as? String {
foundIds[v] = true
}
}
}
if self.debug { NSLog("HLDB: \(self.name): Upsert numRows=\(rows.count) foundRows=\(foundIds)") }
if foundIds.count == 0 {
// Simple case: everything should be inserted
self.insert(rows).onSuccess(Queue.global.context) { result in
p.success(result)
}
} else {
// Complex case: mixture of insert and update
var insertRows: [Row] = []
var updateRows: [Row] = []
for row in rows {
if let rowId = row.fields[self.primaryKey] as? String {
if let _ = foundIds[rowId] {
updateRows.append(row)
} else {
insertRows.append(row)
}
}
}
if self.debug { NSLog("HLDB: \(self.name): Upsert insertRows=\(insertRows.count) updateRows=\(updateRows.count)") }
self.insertAndUpdate(insertRows, updateRows: updateRows).onSuccess(Queue.global.context) { result in
p.success(result)
}
}
}
return p.future
}
public func select(whereStr: String = "") -> Future<DB.Result, NoError> {
let finalWhereString = whereStr
let query = "SELECT * FROM \(name) \(finalWhereString)"
return db.query(query)
}
public func deleteAll() -> Future<DB.Result, NoError> {
var queries: [DB.QueryArgs] = []
let query = "DELETE FROM \(name)"
queries.append(DB.QueryArgs(query: query, args: []))
return db.update(queries)
}
public func delete(rows: [Row]) -> Future<DB.Result, NoError> {
var queries: [DB.QueryArgs] = []
for row in rows {
if let primaryKeyValue: AnyObject = row.fields[primaryKey] {
let query = "DELETE FROM \(name) WHERE \(primaryKey) = ?"
queries.append(DB.QueryArgs(query: query, args: [primaryKeyValue]))
} else {
let p = Promise<DB.Result, NoError>()
p.success(.Error(-1, "Cannot update without primary key!"))
return p.future
}
}
return db.update(queries)
}
private func insertAndUpdateWithinTx(fmdb: FMDatabase, insertRows: [Row], updateRows: [Row]) -> DB.Result {
var queries: [DB.QueryArgs] = []
if insertRows.count > 0 {
let query = "INSERT INTO \(name) (\(fieldNamesStr)) values (\(fieldNamesPlaceholderStr))"
for row in insertRows {
let args = rowFields(row)
// log("Q=\(query) Inserting=\(args)")
queries.append(DB.QueryArgs(query: query, args: args))
}
}
if updateRows.count > 0 {
for row in updateRows {
if let primaryKeyVal = row.fields[primaryKey] as? String {
var pairs: [String] = []
var args: [AnyObject] = []
for (k, v) in row.fields {
if let k = k as? String {
if k == primaryKey { continue }
pairs.append("\(k) = ?")
args.append(v)
}
}
let pairsStr = pairs.joinWithSeparator(", ")
let query = "UPDATE \(name) SET \(pairsStr) WHERE \(primaryKey) = ?"
args.append(primaryKeyVal)
queries.append(DB.QueryArgs(query: query, args: args))
} else {
return .Error(-1, "Cannot update without primary key!")
}
}
}
return db.txUpdate(fmdb, queries: queries)
}
public func insertWithinTx(fmdb: FMDatabase, rows: [Row]) -> DB.Result {
return insertAndUpdateWithinTx(fmdb, insertRows: rows, updateRows: [])
}
public func updateWithinTx(fmdb: FMDatabase, rows: [Row]) -> DB.Result {
return insertAndUpdateWithinTx(fmdb, insertRows: [], updateRows: rows)
}
}
}
|
mit
|
1f5213c73922a9e5c71353635b640cb2
| 30.262679 | 129 | 0.539578 | 4.371091 | false | false | false | false |
simeonpp/home-hunt
|
ios-client/Pods/Swinject/Sources/DebugHelper.swift
|
9
|
1816
|
//
// DebugHelper.swift
// Swinject
//
// Created by Jakub Vaňo on 26/09/16.
// Copyright © 2016 Swinject Contributors. All rights reserved.
//
internal protocol DebugHelper {
func resolutionFailed<Service>(
serviceType: Service.Type,
key: ServiceKey,
availableRegistrations: [ServiceKey: ServiceEntryProtocol]
)
}
internal final class LoggingDebugHelper: DebugHelper {
func resolutionFailed<Service>(
serviceType: Service.Type,
key: ServiceKey,
availableRegistrations: [ServiceKey: ServiceEntryProtocol]
) {
var output = [
"Swinject: Resolution failed. Expected registration:",
"\t{ \(description(serviceType: serviceType, serviceKey: key)) }",
"Available registrations:",
]
output += availableRegistrations
.filter { $0.1 is ServiceEntry<Service> }
.map { "\t{ " + $0.1.describeWithKey($0.0) + " }" }
Container.log(output.joined(separator: "\n"))
}
}
internal func description<Service>(
serviceType: Service.Type,
serviceKey: ServiceKey,
objectScope: ObjectScopeProtocol? = nil,
initCompleted: FunctionType? = nil
) -> String {
// The protocol order in "protocol<>" is non-deterministic.
let nameDescription = serviceKey.name.map { ", Name: \"\($0)\"" } ?? ""
let optionDescription = serviceKey.option.map { ", \($0)" } ?? ""
let initCompletedDescription = initCompleted.map { _ in ", InitCompleted: Specified" } ?? ""
let objectScopeDescription = objectScope.map { ", ObjectScope: \($0)" } ?? ""
return "Service: \(serviceType)"
+ nameDescription
+ optionDescription
+ ", Factory: \(serviceKey.factoryType)"
+ objectScopeDescription
+ initCompletedDescription
}
|
mit
|
711462f43dae0b4110e423429ac03adf
| 32.592593 | 96 | 0.633407 | 4.490099 | false | false | false | false |
peiweichen/SurfingNavigationBar
|
SurfingNavigationBarDemo/SurfingNavigationBarDemo/DemoViewController.swift
|
1
|
3296
|
//
// DemoViewController.swift
// SurfingNavigationBarDemo
//
// Created by chenpeiwei on 6/15/16.
// Copyright © 2016 chenpeiwei. All rights reserved.
//
import UIKit
class DemoViewController: UITableViewController {
override func viewDidLoad() {
super.viewDidLoad()
let titleLabel = UILabel(frame: CGRect(x: 0, y: 0, width: 100, height: 20))
titleLabel.contentMode = .Center
titleLabel.text = "BackgroundColorDemo"
let titleFont : UIFont = UIFont(name: "American Typewriter", size: 18.0)!
titleLabel.font = titleFont
titleLabel.textColor = UIColor.whiteColor()
self.navigationItem.titleView = titleLabel
self.tableView.backgroundColor = UIColor.blackColor()
self.tableView.registerClass(UITableViewCell.classForCoder(), forCellReuseIdentifier: "cellIdentifier")
self.tableView.tableFooterView = UIView()
self.tableView.separatorStyle = .None
self.navigationController?.navigationBar.surfing_setBackgroundColor(UIColor.clearColor())
}
override func scrollViewDidScroll(scrollView: UIScrollView) {
let offsetY = fabs(scrollView.contentOffset.y)
let offsetColorNumber = (offsetY+50)%255
self.navigationController?.navigationBar.surfing_setBackgroundColor(UIColor(red: offsetColorNumber*0.8/255.0, green: offsetColorNumber*0.2/255.0, blue: offsetColorNumber*0.5/255.0, alpha: 1.0))
}
override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
return 1
}
override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return 1
}
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier("cellIdentifier")
cell?.selectionStyle = .None
cell?.backgroundColor = UIColor.clearColor()
let imageView = UIImageView(image: UIImage(named: "surfing_sunset.jpg"))
imageView.translatesAutoresizingMaskIntoConstraints = false
imageView.contentMode = .ScaleAspectFill
imageView.clipsToBounds = true
cell?.contentView.addSubview(imageView)
cell?.contentView.addConstraint(NSLayoutConstraint(item: imageView, attribute: .Top, relatedBy: .Equal, toItem: cell?.contentView, attribute: .Top, multiplier: 1, constant: 0))
cell?.contentView.addConstraint(NSLayoutConstraint(item: imageView, attribute: .Leading, relatedBy: .Equal, toItem: cell?.contentView, attribute: .Leading, multiplier: 1, constant: 0))
cell?.contentView.addConstraint(NSLayoutConstraint(item: imageView, attribute: .Trailing, relatedBy: .Equal, toItem: cell?.contentView, attribute: .Trailing, multiplier: 1, constant: 0))
cell?.contentView.addConstraint(NSLayoutConstraint(item: imageView, attribute: .Bottom, relatedBy: .Equal, toItem: cell?.contentView, attribute: .Bottom, multiplier: 1, constant: 0))
return cell!
}
override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
return 300
}
}
|
mit
|
7da2bcd7c8727ab65597c7e093c1be6f
| 39.679012 | 201 | 0.694082 | 5.100619 | false | false | false | false |
CarlosMChica/swift-dojos
|
SocialNetworkKata/SocialNetworkKata/actions/PostMessageAction.swift
|
1
|
578
|
class PostMessageAction: Action {
private let identifier = "->"
private let postRepository: PostRepository
private let clock: Clock
init(postRepository: PostRepository, clock: Clock) {
self.postRepository = postRepository
self.clock = clock
}
func canExecute(input: Input) -> Bool {
return input.hasIdentifier(identifier)
}
func execute(input: Input) {
let user = User(name: input.getFirstArgument())
let message = input.getIdentifierArgument(identifier)!
postRepository.store(Post(user: user, message: message, timestamp: 0))
}
}
|
apache-2.0
|
664357a8580ad63a6bd1df44611e4d7c
| 25.272727 | 74 | 0.716263 | 4.25 | false | false | false | false |
lorentey/Attabench
|
SampleBenchmark.attabench/Sources/main.swift
|
2
|
1467
|
// Copyright © 2017 Károly Lőrentey.
// This file is part of Attabench: https://github.com/attaswift/Attabench
// For licensing information, see the file LICENSE.md in the Git repository above.
import Benchmarking
let benchmark = Benchmark<([Int], [Int])>(title: "Sample")
benchmark.descriptiveTitle = "Time spent on all elements"
benchmark.descriptiveAmortizedTitle = "Average time spent on a single element"
benchmark.addTask(title: "Array.contains") { (input, lookups) in
guard input.count <= 16384 else { return nil }
return { timer in
for value in lookups {
guard input.contains(value) else { fatalError() }
}
}
}
benchmark.addTask(title: "Set.contains") { (input, lookups) in
let set = Set(input)
return { timer in
for value in lookups {
guard set.contains(value) else { fatalError() }
}
}
}
benchmark.addTask(title: "SortedArray.binarySearch") { (input, lookups) in
let array = input.sorted()
return { timer in
for value in lookups {
var i = 0
var j = array.count
while i < j {
let middle = i + (j - i) / 2
if value > array[middle] {
i = middle + 1
}
else {
j = middle
}
}
guard i < array.count && array[i] == value else { fatalError() }
}
}
}
benchmark.start()
|
mit
|
8ceb462f978e2fdc31d88ecf91160bcb
| 28.28 | 82 | 0.566257 | 4.194842 | false | false | false | false |
stephentyrone/swift
|
test/IRGen/prespecialized-metadata/enum-extradata-payload_size-no_trailing_flags.swift
|
3
|
2859
|
// RUN: %target-swift-frontend -enable-library-evolution -emit-ir %s | %FileCheck %s -DINT=i%target-ptrsize -DALIGNMENT=%target-alignment
// REQUIRES: OS=macosx || OS=ios || OS=tvos || OS=watchos || OS=linux-gnu
// UNSUPPORTED: CPU=i386 && OS=ios
// UNSUPPORTED: CPU=armv7 && OS=ios
// UNSUPPORTED: CPU=armv7s && OS=ios
// CHECK: [[EXTRA_DATA_PATTERN:@[0-9]+]] = internal constant { [[INT]] } {
// The payload size is 8: the larger payload is the size of an Int64.
// CHECK-SAME: [[INT]] 8
// CHECK-SAME: }, align [[ALIGNMENT]]
// CHECK: @"$s4main6EitherOMP" = internal constant <{
// : i32,
// : i32,
// : i32,
// : i32,
// : i32,
// : i16,
// : i16
// : }> <{
// : i32 trunc (
// : i64 sub (
// : i64 ptrtoint (
// : %swift.type* (
// : %swift.type_descriptor*,
// : i8**,
// : i8*
// : )* @"$s4main6EitherOMi" to i64
// : ),
// : i64 ptrtoint (
// : <{ i32, i32, i32, i32, i32, i16, i16 }>* @"$s4main6EitherOMP" to i64
// : )
// : ) to i32
// : ),
// : i32 0,
// : i32 1075838979,
// : i32 trunc (
// : i64 sub (
// : i64 ptrtoint (
// : %swift.enum_vwtable* @"$s4main6EitherOWV" to i64
// : ),
// : i64 ptrtoint (
// : i32* getelementptr inbounds (
// : <{ i32, i32, i32, i32, i32, i16, i16 }>,
// : <{ i32, i32, i32, i32, i32, i16, i16 }>* @"$s4main6EitherOMP",
// : i32 0,
// : i32 3
// : ) to i64
// : )
// : ) to i32
// : ),
// : i32 trunc (
// CHECK-SAME: [[INT]] sub (
// CHECK-SAME: [[INT]] ptrtoint (
// CHECK-SAME: { [[INT]] }* [[EXTRA_DATA_PATTERN]] to [[INT]]
// CHECK-SAME: ),
// CHECK-SAME: [[INT]] ptrtoint (
// CHECK-SAME: i32* getelementptr inbounds (
// CHECK-SAME: <{ i32, i32, i32, i32, i32, i16, i16 }>,
// CHECK-SAME: <{ i32, i32, i32, i32, i32, i16, i16 }>* @"$s4main6EitherOMP",
// CHECK-SAME: i32 0,
// CHECK-SAME: i32 4
// CHECK-SAME: ) to [[INT]]
// CHECK-SAME: )
// CHECK-SAME: )
// : ),
// : i16 1,
// : i16 2
// : }>,
// : align 8
public struct First<T> {
public let value: Int32
}
public struct Second {
public let value: Int64
}
@frozen
public enum Either<T> {
case first(First<T>)
case second(Second)
}
|
apache-2.0
|
16812cf67a6689fac6e76225a918c692
| 31.488636 | 137 | 0.401889 | 3.044728 | false | false | false | false |
uphold/uphold-sdk-ios
|
Source/Model/Transaction.swift
|
1
|
10025
|
import Foundation
import PromiseKit
import ObjectMapper
import SwiftClient
/// Transaction model.
open class Transaction: BaseModel, Mappable {
/// The id of the transaction.
public private(set) final var id: String?
/// The date and time the transaction was initiated.
public private(set) final var createdAt: String?
/// The funds to be transferred.
public private(set) final var denomination: Denomination?
/// The recipient of the funds.
public private(set) final var destination: Destination?
/// The transaction fees.
public private(set) final var fees: [Fee]?
/// A message or note provided by the user at the time the transaction was initiated, with the intent of communicating additional information and context about the nature/purpose of the transaction.
public private(set) final var message: String?
/// The network of the transaction.
public private(set) final var network: String?
/// The transaction details normalized.
public private(set) final var normalized: [NormalizedTransaction]?
/// The sender of the funds.
public private(set) final var origin: Origin?
/// Other parameters of this transaction.
public private(set) final var params: Parameters?
/// The reference of this transaction.
public private(set) final var reference: String?
/// When a transaction is cancelled this contains the transaction ID of the transaction which refunds the amount back to the user.
public private(set) final var refundedById: String?
/// The current status of the transaction.
public private(set) final var status: String?
/// The nature of the transaction.
public private(set) final var type: String?
/// The card id path.
private var cardIdPath: String? {
get {
if let type = self.type, type.caseInsensitiveCompare("deposit") == .orderedSame {
return destination?.cardId
}
return origin?.cardId
}
}
/**
Constructor.
- parameter id: The id of the transaction.
- parameter createdAt: The date and time the transaction was initiated.
- parameter denomination: The funds to be transferred.
- parameter destination: The recipient of the funds.
- parameter fees: The transaction fees.
- parameter message: A message or note provided by the user at the time the transaction was initiated, with the intent of communicating additional information and context about the nature/purpose of the transaction.
- parameter network: The network of the transaction.
- parameter normalized: The transaction details normalized.
- parameter origin: The sender of the funds.
- parameter params: Other parameters of this transaction.
- parameter reference: The reference of the transaction.
- parameter refundedById: When a transaction is cancelled this contains the transaction ID of the transaction which refunds the amount back to the user.
- parameter status: The current status of the transaction.
- parameter type: The nature of the transaction.
*/
public init(id: String, createdAt: String, denomination: Denomination, destination: Destination, fees: [Fee], message: String, network: String, normalized: [NormalizedTransaction], origin: Origin, params: Parameters, reference: String, refundedById: String, status: String, type: String) {
self.id = id
self.createdAt = createdAt
self.denomination = denomination
self.destination = destination
self.fees = fees
self.message = message
self.network = network
self.normalized = normalized
self.origin = origin
self.params = params
self.reference = reference
self.refundedById = refundedById
self.status = status
self.type = type
}
// MARK: Required by the ObjectMapper.
/**
Constructor.
- parameter map: Mapping data object.
*/
required public init?(map: Map) {
}
/**
Maps the JSON to the Object.
- parameter map: The object to map.
*/
open func mapping(map: Map) {
id <- map["id"]
createdAt <- map["createdAt"]
denomination <- map["denomination"]
destination <- map["destination"]
fees <- map["fees"]
message <- map["message"]
network <- map["network"]
normalized <- map["normalized"]
origin <- map["origin"]
params <- map["params"]
reference <- map["reference"]
refundedById <- map["RefundedById"]
status <- map["status"]
type <- map["type"]
}
/**
Cancel a transaction.
- returns: A promise with the transaction.
*/
open func cancel() -> Promise<Transaction> {
guard let id = self.id else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Transaction id should not be nil."))
}
if (self.type?.caseInsensitiveCompare("deposit") == .orderedSame) {
guard let _ = self.origin?.accountId else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Origin accountId is missing from this transaction."))
}
guard let _ = self.destination?.cardId else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Destination cardId is missing from this transaction."))
}
}
if (self.origin?.cardId == nil && self.destination?.cardId == nil) {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Origin cardId is missing from this transaction."))
}
guard let cardIdPath = self.cardIdPath else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Unexpected cardId is missing."))
}
guard let status = self.status else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Transaction status should not be nil."))
}
switch (status) {
case "pending":
return Promise<Transaction>(error: LogicError(code: nil, message: "Unable to cancel uncommited transaction."))
case "waiting":
let request = self.adapter.buildRequest(request: UserCardService.cancelTransaction(cardId: cardIdPath, transactionId: id))
return self.adapter.buildResponse(request: request)
default:
return Promise<Transaction>(error: LogicError(code: nil, message: String(format: "This transaction cannot be cancelled, because the current status is %@.", status)))
}
}
/**
Confirm a transaction.
- returns: A promise with the transaction.
*/
open func commit() -> Promise<Transaction> {
return commit(otp: nil, transactionCommit: nil)
}
/**
Confirm a transaction.
- parameter otp: The otp code to confirm the transaction.
- returns: A promise with the transaction.
*/
open func commit(otp: String) -> Promise<Transaction> {
return commit(otp: otp, transactionCommit: nil)
}
/**
Confirm a transaction.
- parameter transactionCommit: A transactionCommitRequest with an optional transaction message.
- returns: A promise with the transaction.
*/
open func commit(transactionCommit: TransactionCommitRequest) -> Promise<Transaction> {
return commit(otp: nil, transactionCommit: nil)
}
/**
Confirm a transaction.
- parameter otp: The otp code to confirm the transaction.
- parameter transactionCommit: A transactionCommitRequest with an optional transaction message.
- returns: A promise with the transaction.
*/
open func commit(otp: String?, transactionCommit: TransactionCommitRequest?) -> Promise<Transaction> {
guard let id = self.id else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Transaction id should not be nil."))
}
if (self.type?.caseInsensitiveCompare("deposit") == .orderedSame) {
guard let _ = self.origin?.accountId else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Origin accountId is missing from this transaction."))
}
guard let _ = self.destination?.cardId else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Destination cardId is missing from this transaction."))
}
}
if (self.origin?.cardId == nil && self.destination?.cardId == nil) {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Origin cardId is missing from this transaction."))
}
guard let status = self.status else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Transaction status should not be nil."))
}
if (status != "pending") {
return Promise<Transaction>(error: LogicError(code: nil, message: String(format: "This transaction cannot be committed, because the current status is %@.", status)))
}
guard let cardIdPath = self.cardIdPath else {
return Promise<Transaction>(error: UnexpectedResponseError(message: "Unexpected cardId is missing."))
}
let request: Request
guard let transactionCommit = transactionCommit else {
request = self.adapter.buildRequest(request: UserCardService.confirmTransaction(cardId: cardIdPath, otp: otp, transactionId: id, transactionCommitRequest: nil))
return self.adapter.buildResponse(request: request)
}
request = self.adapter.buildRequest(request: UserCardService.confirmTransaction(cardId: cardIdPath, otp: otp, transactionId: id, transactionCommitRequest: Mapper().toJSON(transactionCommit)))
return self.adapter.buildResponse(request: request)
}
}
|
mit
|
160dfeed2aa783454e95dce488129d97
| 38.007782 | 293 | 0.661347 | 5.032631 | false | false | false | false |
docileninja/Calvin-and-Hobbes-Viewer
|
Viewer/Calvin and Hobbes/Model/Comic.swift
|
1
|
1310
|
//
// Comic.swift
// Calvin and Hobbes
//
// Created by Adam Van Prooyen on 10/1/15.
// Copyright © 2015 Adam Van Prooyen. All rights reserved.
//
import Foundation
import UIKit
class Comic {
let date: Date
var image: UIImage?
var url: String?
var panelSeparators: [Int]?
// Lets you register completion handler for comic download after initialization
var onComplete: () -> () = {}
init(date: Date) {
self.date = date
ComicDownloader.getComic(date, completionHandler: {
self.url = $0
self.panelSeparators = $1
self.image = $2
self.onComplete()
})
}
init(date: Date, image: UIImage) {
self.date = date
self.image = image
}
func panels() -> [UIImage]? {
if let image = self.image, let seps = self.panelSeparators {
let cgImage = image.cgImage!
var panels: [UIImage] = []
for (start, end) in zip([0] + seps, seps + [Int(image.size.width)]) {
let panel = cgImage.cropping(to: CGRect(x: start, y: 0, width: end - start, height: Int(image.size.height)))
panels.append(UIImage(cgImage: panel!))
}
return panels
}
return nil
}
}
|
mit
|
455a6f85e1819c0e86f07f969f4788e8
| 25.18 | 124 | 0.546218 | 3.966667 | false | false | false | false |
MaticConradi/Blink
|
Blink/PhotoGalleryViewController.swift
|
1
|
11578
|
//
// PhotoGalleryViewController.swift
// Blink
//
// Created by Matic Conradi on 14/04/2017.
// Copyright © 2017 Conradi.si. All rights reserved.
//
import UIKit
class PhotoGalleryViewController: UIViewController {
@IBOutlet weak var imageView: UIImageView!
@IBOutlet weak var scrollView: UIScrollView!
@IBOutlet weak var imageViewBottomConstraint: NSLayoutConstraint!
@IBOutlet weak var imageViewLeadingConstraint: NSLayoutConstraint!
@IBOutlet weak var imageViewTopConstraint: NSLayoutConstraint!
@IBOutlet weak var imageViewTrailingConstraint: NSLayoutConstraint!
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
@IBOutlet weak var dismissToolbar: UIToolbar!
var imageURL: String?
var imageText: String?
var dismissToolbarHidden = false
var width: CGFloat = 0
var height: CGFloat = 0
var animateDuration = 0.0
var interactor: Interactor? = nil
override func viewDidLoad() {
prepareVars()
scrollView.minimumZoomScale = 1;
scrollView.maximumZoomScale = 1;
scrollView.isHidden = true
activityIndicator.startAnimating()
if let url = imageURL {
imageView.sd_setImage(with: URL(string: url), placeholderImage: nil, options: SDWebImageOptions.highPriority, completed: { (image, error, cacheType, imageURL) in
self.activityIndicator.stopAnimating()
self.activityIndicator.isHidden = true
self.scrollView.isHidden = false
self.updateConstraintsForSize(size: self.view.bounds.size)
self.updateMinZoomScaleForSize(size: self.view.bounds.size)
})
}
//Toolbar
let color3 = UIColor(red: 0, green: 0, blue: 0, alpha: 0).cgColor
let color4 = UIColor(red: 0, green: 0, blue: 0, alpha: 0.66).cgColor
let gradient: CAGradientLayer = CAGradientLayer()
gradient.colors = [color3, color4]
gradient.locations = [0.0 , 1.0]
gradient.frame = CGRect(x: 0.0, y: 0.0, width: width, height: 64)
dismissToolbar.layer.insertSublayer(gradient, at: 0)
dismissToolbar.setBackgroundImage(UIImage(), forToolbarPosition: UIBarPosition.any, barMetrics: UIBarMetrics.default)
dismissToolbar.setShadowImage(UIImage(), forToolbarPosition: UIBarPosition.any)
setupGestureRecognizer()
}
func setupGestureRecognizer() {
let doubleTap = UITapGestureRecognizer(target: self, action: #selector(PhotoGalleryViewController.handleDoubleTap(recognizer:)))
doubleTap.numberOfTapsRequired = 2
scrollView.addGestureRecognizer(doubleTap)
let tap = UITapGestureRecognizer(target: self, action: #selector(PhotoGalleryViewController.handleTap(recognizer:)))
tap.numberOfTapsRequired = 1
scrollView.addGestureRecognizer(tap)
let longPressGesture = UILongPressGestureRecognizer(target: self, action: #selector(PhotoGalleryViewController.save(recognizer:)))
longPressGesture.minimumPressDuration = 1.0 // 1 second press
longPressGesture.allowableMovement = 15 // 15 points
scrollView.addGestureRecognizer(longPressGesture)
}
override func willRotate(to toInterfaceOrientation: UIInterfaceOrientation, duration: TimeInterval) {
UIView.animate(withDuration: duration / 2) {
self.scrollView.layer.opacity = 0
self.animateDuration = duration / 2.0
}
}
override func didRotate(from fromInterfaceOrientation: UIInterfaceOrientation) {
if !scrollView.isHidden {
self.updateConstraintsForSize(size: self.view.bounds.size)
self.updateMinZoomScaleForSize(size: self.view.bounds.size)
UIView.animate(withDuration: animateDuration) {
self.scrollView.layer.opacity = 1
}
}
}
@IBAction func handleGesture(_ sender: UIPanGestureRecognizer) {
let percentThreshold:CGFloat = 0.2
// convert y-position to downward pull progress (percentage)
let translation = sender.translation(in: view)
let verticalMovement = translation.y / view.bounds.height
let downwardMovement = fmaxf(Float(verticalMovement), 0.0)
let downwardMovementPercent = fminf(downwardMovement, 1.0)
let progress = CGFloat(downwardMovementPercent)
guard let interactor = interactor else { return }
switch sender.state {
case .began:
interactor.hasStarted = true
dismiss(animated: true, completion: nil)
case .changed:
interactor.shouldFinish = progress > percentThreshold
interactor.update(progress)
case .cancelled:
interactor.hasStarted = false
interactor.cancel()
case .ended:
interactor.hasStarted = false
interactor.shouldFinish
? interactor.finish()
: interactor.cancel()
default:
break
}
}
@objc func handleDoubleTap(recognizer: UITapGestureRecognizer) {
if (scrollView.zoomScale > scrollView.minimumZoomScale) {
scrollView.setZoomScale(scrollView.minimumZoomScale, animated: true)
}else{
scrollView.setZoomScale(scrollView.maximumZoomScale, animated: true)
}
}
@objc func handleTap(recognizer: UITapGestureRecognizer) {
if dismissToolbarHidden {
UIView.animate(withDuration: 0.5, delay: 0, options: .curveEaseInOut, animations: {
self.dismissToolbar.transform = CGAffineTransform(translationX: 0, y: 0)
})
}else{
UIView.animate(withDuration: 0.5, delay: 0, options: .curveEaseInOut, animations: {
self.dismissToolbar.transform = CGAffineTransform(translationX: 0, y: 64)
})
}
dismissToolbarHidden = !dismissToolbarHidden
}
func updateMinZoomScaleForSize(size: CGSize) {
let widthScale = size.width / imageView.bounds.width
let heightScale = size.height / imageView.bounds.height
let minScale = min(widthScale, heightScale)
scrollView.minimumZoomScale = minScale
scrollView.zoomScale = minScale
}
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
//updateMinZoomScaleForSize(size: view.bounds.size)
}
func updateConstraintsForSize(size: CGSize) {
let yOffset = max(0, (size.height - imageView.frame.height) / 2)
imageViewTopConstraint.constant = yOffset
imageViewBottomConstraint.constant = yOffset
let xOffset = max(0, (size.width - imageView.frame.width) / 2)
imageViewLeadingConstraint.constant = xOffset
imageViewTrailingConstraint.constant = xOffset
view.layoutIfNeeded()
}
@objc func save(recognizer: UILongPressGestureRecognizer) {
//Disable gesture recognizers so
for recognizer in scrollView.gestureRecognizers! {
recognizer.isEnabled = false
recognizer.isEnabled = true
}
share(needSrecognizer: true, recognizer: recognizer, barButton: nil)
}
@IBAction func shareAction(_ sender: Any) {
share(needSrecognizer: false, recognizer: nil, barButton: sender)
}
func share(needSrecognizer: Bool, recognizer: UILongPressGestureRecognizer?, barButton: Any?) {
let actionSheet = UIAlertController(title: nil, message: nil, preferredStyle: .actionSheet)
let shareAction = UIAlertAction(title: "Share", style: .default, handler: {
(alert: UIAlertAction!) -> Void in
let isSharing = true
let manager = SDWebImageManager.shared()
manager.loadImage(with: URL(string: self.imageURL!), options: .highPriority, progress: nil, completed: { (image, data, error, cacheType, finished, url) in
if isSharing {
if let shareImage = image {
var objectsToShare = [Any]()
objectsToShare.append("\(self.imageText ?? "")\n\nvia Blink for iPhone: https://appsto.re/si/jxhUib.i")
objectsToShare.append(shareImage)
let activityViewController = UIActivityViewController(activityItems: objectsToShare, applicationActivities: nil)
activityViewController.popoverPresentationController?.sourceView = self.view
activityViewController.excludedActivityTypes = [UIActivityType.airDrop, UIActivityType.addToReadingList, UIActivityType.postToVimeo, UIActivityType.openInIBooks]
if needSrecognizer {
activityViewController.popoverPresentationController?.sourceRect = CGRect(x: recognizer!.location(ofTouch: 0, in: nil).x, y: recognizer!.location(ofTouch: 0, in: nil).y, width: 0, height: 0)
}else{
activityViewController.popoverPresentationController?.barButtonItem = barButton as? UIBarButtonItem
}
self.present(activityViewController, animated: true, completion: nil)
}
}
})
})
let saveAction = UIAlertAction(title: "Save", style: .default, handler: {
(alert: UIAlertAction!) -> Void in
let isSharing = true
let manager = SDWebImageManager.shared()
manager.loadImage(with: URL(string: self.imageURL!), options: .highPriority, progress: nil, completed: { (image, data, error, cacheType, finished, url) in
if isSharing {
if let shareImage = image {
UIImageWriteToSavedPhotosAlbum(shareImage, nil, nil, nil)
}
}
})
})
let cancelAction = UIAlertAction(title: "Cancel", style: .cancel, handler: {
(alert: UIAlertAction!) -> Void in
})
actionSheet.addAction(shareAction)
actionSheet.addAction(saveAction)
actionSheet.addAction(cancelAction)
if needSrecognizer {
actionSheet.popoverPresentationController?.sourceRect = CGRect(x: recognizer!.location(ofTouch: 0, in: nil).x, y: recognizer!.location(ofTouch: 0, in: nil).y, width: 0, height: 0)
}else{
actionSheet.popoverPresentationController?.barButtonItem = barButton as? UIBarButtonItem
}
present(actionSheet, animated: true, completion: nil)
}
@IBAction func dismiss(_ sender: Any) {
dismiss(animated: true, completion: nil)
}
func prepareVars() {
if UIScreen.main.bounds.size.height > UIScreen.main.bounds.size.width {
width = UIScreen.main.bounds.size.width
height = UIScreen.main.bounds.size.height
}else{
width = UIScreen.main.bounds.size.height
height = UIScreen.main.bounds.size.width
}
}
}
extension PhotoGalleryViewController: UIScrollViewDelegate {
func viewForZooming(in scrollView: UIScrollView) -> UIView? {
return imageView
}
func scrollViewDidZoom(_ scrollView: UIScrollView) {
updateConstraintsForSize(size: view.bounds.size)
}
}
|
gpl-3.0
|
2816fab125964c19b377250e8c263189
| 42.037175 | 218 | 0.634793 | 5.352288 | false | false | false | false |
22377832/ccyswift
|
CoreData1/CoreData1/AppDelegate.swift
|
1
|
4581
|
//
// AppDelegate.swift
// CoreData1
//
// Created by sks on 17/2/24.
// Copyright © 2017年 chen. All rights reserved.
//
import UIKit
import CoreData
@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:.
// Saves changes in the application's managed object context before the application terminates.
self.saveContext()
}
// MARK: - Core Data stack
lazy var persistentContainer: NSPersistentContainer = {
/*
The persistent container for the application. This implementation
creates and returns a container, having loaded the store for the
application to it. This property is optional since there are legitimate
error conditions that could cause the creation of the store to fail.
*/
let container = NSPersistentContainer(name: "CoreData1")
container.loadPersistentStores(completionHandler: { (storeDescription, error) in
if let error = error as NSError? {
// Replace this implementation with code to handle the error appropriately.
// fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
/*
Typical reasons for an error here include:
* The parent directory does not exist, cannot be created, or disallows writing.
* The persistent store is not accessible, due to permissions or data protection when the device is locked.
* The device is out of space.
* The store could not be migrated to the current model version.
Check the error message to determine what the actual problem was.
*/
fatalError("Unresolved error \(error), \(error.userInfo)")
}
})
return container
}()
// MARK: - Core Data Saving support
func saveContext () {
let context = persistentContainer.viewContext
if context.hasChanges {
do {
try context.save()
} catch {
// Replace this implementation with code to handle the error appropriately.
// fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
let nserror = error as NSError
fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
}
}
}
}
|
mit
|
aa795b0356b471d935ca01b0b5081472
| 48.225806 | 285 | 0.685234 | 5.846743 | false | false | false | false |
SanjoDeundiak/Wardrobe
|
Sources/App/Models/Category.swift
|
1
|
1399
|
//
// Category.swift
// Hello
//
// Created by Oleksandr Deundiak on 6/13/17.
//
//
import Foundation
enum UpperSubcategory: String {
case shirt = "shirt"
}
enum LowerSubcategory: String {
case jeans = "jeans"
case skirt = "skirt"
}
enum ShoesSubcategory: String {
case snickers = "snickers"
case shoes = "shoes"
case boots = "boots"
}
enum Category: String {
case upper = "upper"
case lower = "lower"
case shoes = "shoes"
}
enum ItemType {
case upper(UpperSubcategory)
case lower(LowerSubcategory)
case shoes(ShoesSubcategory)
init?(rawValue: String) {
if let up = UpperSubcategory(rawValue: rawValue) {
self = .upper(up)
}
else if let low = LowerSubcategory(rawValue: rawValue) {
self = .lower(low)
}
else if let shoes = ShoesSubcategory(rawValue: rawValue) {
self = .shoes(shoes)
}
else {
return nil
}
}
var rawValue: String {
switch self {
case .upper(let up): return up.rawValue
case .lower(let low): return low.rawValue
case .shoes(let shoes): return shoes.rawValue
}
}
var category: Category {
switch self {
case .upper(_): return .upper
case .lower(_): return .lower
case .shoes(_): return .shoes
}
}
}
|
mit
|
2b648ba233d7751f435dbaebc8412098
| 19.880597 | 66 | 0.566833 | 3.760753 | false | false | false | false |
liwenban/uploadDemo
|
uploadDemo/Pods/Alamofire/Source/SessionDelegate.swift
|
117
|
35318
|
//
// SessionDelegate.swift
//
// Copyright (c) 2014-2016 Alamofire Software Foundation (http://alamofire.org/)
//
// 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
/// Responsible for handling all delegate callbacks for the underlying session.
open class SessionDelegate: NSObject {
// MARK: URLSessionDelegate Overrides
/// Overrides default behavior for URLSessionDelegate method `urlSession(_:didBecomeInvalidWithError:)`.
open var sessionDidBecomeInvalidWithError: ((URLSession, Error?) -> Void)?
/// Overrides default behavior for URLSessionDelegate method `urlSession(_:didReceive:completionHandler:)`.
open var sessionDidReceiveChallenge: ((URLSession, URLAuthenticationChallenge) -> (URLSession.AuthChallengeDisposition, URLCredential?))?
/// Overrides all behavior for URLSessionDelegate method `urlSession(_:didReceive:completionHandler:)` and requires the caller to call the `completionHandler`.
open var sessionDidReceiveChallengeWithCompletion: ((URLSession, URLAuthenticationChallenge, @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) -> Void)?
/// Overrides default behavior for URLSessionDelegate method `urlSessionDidFinishEvents(forBackgroundURLSession:)`.
open var sessionDidFinishEventsForBackgroundURLSession: ((URLSession) -> Void)?
// MARK: URLSessionTaskDelegate Overrides
/// Overrides default behavior for URLSessionTaskDelegate method `urlSession(_:task:willPerformHTTPRedirection:newRequest:completionHandler:)`.
open var taskWillPerformHTTPRedirection: ((URLSession, URLSessionTask, HTTPURLResponse, URLRequest) -> URLRequest?)?
/// Overrides all behavior for URLSessionTaskDelegate method `urlSession(_:task:willPerformHTTPRedirection:newRequest:completionHandler:)` and
/// requires the caller to call the `completionHandler`.
open var taskWillPerformHTTPRedirectionWithCompletion: ((URLSession, URLSessionTask, HTTPURLResponse, URLRequest, @escaping (URLRequest?) -> Void) -> Void)?
/// Overrides default behavior for URLSessionTaskDelegate method `urlSession(_:task:didReceive:completionHandler:)`.
open var taskDidReceiveChallenge: ((URLSession, URLSessionTask, URLAuthenticationChallenge) -> (URLSession.AuthChallengeDisposition, URLCredential?))?
/// Overrides all behavior for URLSessionTaskDelegate method `urlSession(_:task:didReceive:completionHandler:)` and
/// requires the caller to call the `completionHandler`.
open var taskDidReceiveChallengeWithCompletion: ((URLSession, URLSessionTask, URLAuthenticationChallenge, @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) -> Void)?
/// Overrides default behavior for URLSessionTaskDelegate method `urlSession(_:task:needNewBodyStream:)`.
open var taskNeedNewBodyStream: ((URLSession, URLSessionTask) -> InputStream?)?
/// Overrides all behavior for URLSessionTaskDelegate method `urlSession(_:task:needNewBodyStream:)` and
/// requires the caller to call the `completionHandler`.
open var taskNeedNewBodyStreamWithCompletion: ((URLSession, URLSessionTask, @escaping (InputStream?) -> Void) -> Void)?
/// Overrides default behavior for URLSessionTaskDelegate method `urlSession(_:task:didSendBodyData:totalBytesSent:totalBytesExpectedToSend:)`.
open var taskDidSendBodyData: ((URLSession, URLSessionTask, Int64, Int64, Int64) -> Void)?
/// Overrides default behavior for URLSessionTaskDelegate method `urlSession(_:task:didCompleteWithError:)`.
open var taskDidComplete: ((URLSession, URLSessionTask, Error?) -> Void)?
// MARK: URLSessionDataDelegate Overrides
/// Overrides default behavior for URLSessionDataDelegate method `urlSession(_:dataTask:didReceive:completionHandler:)`.
open var dataTaskDidReceiveResponse: ((URLSession, URLSessionDataTask, URLResponse) -> URLSession.ResponseDisposition)?
/// Overrides all behavior for URLSessionDataDelegate method `urlSession(_:dataTask:didReceive:completionHandler:)` and
/// requires caller to call the `completionHandler`.
open var dataTaskDidReceiveResponseWithCompletion: ((URLSession, URLSessionDataTask, URLResponse, @escaping (URLSession.ResponseDisposition) -> Void) -> Void)?
/// Overrides default behavior for URLSessionDataDelegate method `urlSession(_:dataTask:didBecome:)`.
open var dataTaskDidBecomeDownloadTask: ((URLSession, URLSessionDataTask, URLSessionDownloadTask) -> Void)?
/// Overrides default behavior for URLSessionDataDelegate method `urlSession(_:dataTask:didReceive:)`.
open var dataTaskDidReceiveData: ((URLSession, URLSessionDataTask, Data) -> Void)?
/// Overrides default behavior for URLSessionDataDelegate method `urlSession(_:dataTask:willCacheResponse:completionHandler:)`.
open var dataTaskWillCacheResponse: ((URLSession, URLSessionDataTask, CachedURLResponse) -> CachedURLResponse?)?
/// Overrides all behavior for URLSessionDataDelegate method `urlSession(_:dataTask:willCacheResponse:completionHandler:)` and
/// requires caller to call the `completionHandler`.
open var dataTaskWillCacheResponseWithCompletion: ((URLSession, URLSessionDataTask, CachedURLResponse, @escaping (CachedURLResponse?) -> Void) -> Void)?
// MARK: URLSessionDownloadDelegate Overrides
/// Overrides default behavior for URLSessionDownloadDelegate method `urlSession(_:downloadTask:didFinishDownloadingTo:)`.
open var downloadTaskDidFinishDownloadingToURL: ((URLSession, URLSessionDownloadTask, URL) -> Void)?
/// Overrides default behavior for URLSessionDownloadDelegate method `urlSession(_:downloadTask:didWriteData:totalBytesWritten:totalBytesExpectedToWrite:)`.
open var downloadTaskDidWriteData: ((URLSession, URLSessionDownloadTask, Int64, Int64, Int64) -> Void)?
/// Overrides default behavior for URLSessionDownloadDelegate method `urlSession(_:downloadTask:didResumeAtOffset:expectedTotalBytes:)`.
open var downloadTaskDidResumeAtOffset: ((URLSession, URLSessionDownloadTask, Int64, Int64) -> Void)?
// MARK: URLSessionStreamDelegate Overrides
#if !os(watchOS)
/// Overrides default behavior for URLSessionStreamDelegate method `urlSession(_:readClosedFor:)`.
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
open var streamTaskReadClosed: ((URLSession, URLSessionStreamTask) -> Void)? {
get {
return _streamTaskReadClosed as? (URLSession, URLSessionStreamTask) -> Void
}
set {
_streamTaskReadClosed = newValue
}
}
/// Overrides default behavior for URLSessionStreamDelegate method `urlSession(_:writeClosedFor:)`.
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
open var streamTaskWriteClosed: ((URLSession, URLSessionStreamTask) -> Void)? {
get {
return _streamTaskWriteClosed as? (URLSession, URLSessionStreamTask) -> Void
}
set {
_streamTaskWriteClosed = newValue
}
}
/// Overrides default behavior for URLSessionStreamDelegate method `urlSession(_:betterRouteDiscoveredFor:)`.
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
open var streamTaskBetterRouteDiscovered: ((URLSession, URLSessionStreamTask) -> Void)? {
get {
return _streamTaskBetterRouteDiscovered as? (URLSession, URLSessionStreamTask) -> Void
}
set {
_streamTaskBetterRouteDiscovered = newValue
}
}
/// Overrides default behavior for URLSessionStreamDelegate method `urlSession(_:streamTask:didBecome:outputStream:)`.
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
open var streamTaskDidBecomeInputAndOutputStreams: ((URLSession, URLSessionStreamTask, InputStream, OutputStream) -> Void)? {
get {
return _streamTaskDidBecomeInputStream as? (URLSession, URLSessionStreamTask, InputStream, OutputStream) -> Void
}
set {
_streamTaskDidBecomeInputStream = newValue
}
}
var _streamTaskReadClosed: Any?
var _streamTaskWriteClosed: Any?
var _streamTaskBetterRouteDiscovered: Any?
var _streamTaskDidBecomeInputStream: Any?
#endif
// MARK: Properties
var retrier: RequestRetrier?
weak var sessionManager: SessionManager?
private var requests: [Int: Request] = [:]
private let lock = NSLock()
/// Access the task delegate for the specified task in a thread-safe manner.
open subscript(task: URLSessionTask) -> Request? {
get {
lock.lock() ; defer { lock.unlock() }
return requests[task.taskIdentifier]
}
set {
lock.lock() ; defer { lock.unlock() }
requests[task.taskIdentifier] = newValue
}
}
// MARK: Lifecycle
/// Initializes the `SessionDelegate` instance.
///
/// - returns: The new `SessionDelegate` instance.
public override init() {
super.init()
}
// MARK: NSObject Overrides
/// Returns a `Bool` indicating whether the `SessionDelegate` implements or inherits a method that can respond
/// to a specified message.
///
/// - parameter selector: A selector that identifies a message.
///
/// - returns: `true` if the receiver implements or inherits a method that can respond to selector, otherwise `false`.
open override func responds(to selector: Selector) -> Bool {
#if !os(macOS)
if selector == #selector(URLSessionDelegate.urlSessionDidFinishEvents(forBackgroundURLSession:)) {
return sessionDidFinishEventsForBackgroundURLSession != nil
}
#endif
#if !os(watchOS)
if #available(iOS 9.0, macOS 10.11, tvOS 9.0, *) {
switch selector {
case #selector(URLSessionStreamDelegate.urlSession(_:readClosedFor:)):
return streamTaskReadClosed != nil
case #selector(URLSessionStreamDelegate.urlSession(_:writeClosedFor:)):
return streamTaskWriteClosed != nil
case #selector(URLSessionStreamDelegate.urlSession(_:betterRouteDiscoveredFor:)):
return streamTaskBetterRouteDiscovered != nil
case #selector(URLSessionStreamDelegate.urlSession(_:streamTask:didBecome:outputStream:)):
return streamTaskDidBecomeInputAndOutputStreams != nil
default:
break
}
}
#endif
switch selector {
case #selector(URLSessionDelegate.urlSession(_:didBecomeInvalidWithError:)):
return sessionDidBecomeInvalidWithError != nil
case #selector(URLSessionDelegate.urlSession(_:didReceive:completionHandler:)):
return (sessionDidReceiveChallenge != nil || sessionDidReceiveChallengeWithCompletion != nil)
case #selector(URLSessionTaskDelegate.urlSession(_:task:willPerformHTTPRedirection:newRequest:completionHandler:)):
return (taskWillPerformHTTPRedirection != nil || taskWillPerformHTTPRedirectionWithCompletion != nil)
case #selector(URLSessionDataDelegate.urlSession(_:dataTask:didReceive:completionHandler:)):
return (dataTaskDidReceiveResponse != nil || dataTaskDidReceiveResponseWithCompletion != nil)
default:
return type(of: self).instancesRespond(to: selector)
}
}
}
// MARK: - URLSessionDelegate
extension SessionDelegate: URLSessionDelegate {
/// Tells the delegate that the session has been invalidated.
///
/// - parameter session: The session object that was invalidated.
/// - parameter error: The error that caused invalidation, or nil if the invalidation was explicit.
open func urlSession(_ session: URLSession, didBecomeInvalidWithError error: Error?) {
sessionDidBecomeInvalidWithError?(session, error)
}
/// Requests credentials from the delegate in response to a session-level authentication request from the
/// remote server.
///
/// - parameter session: The session containing the task that requested authentication.
/// - parameter challenge: An object that contains the request for authentication.
/// - parameter completionHandler: A handler that your delegate method must call providing the disposition
/// and credential.
open func urlSession(
_ session: URLSession,
didReceive challenge: URLAuthenticationChallenge,
completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)
{
guard sessionDidReceiveChallengeWithCompletion == nil else {
sessionDidReceiveChallengeWithCompletion?(session, challenge, completionHandler)
return
}
var disposition: URLSession.AuthChallengeDisposition = .performDefaultHandling
var credential: URLCredential?
if let sessionDidReceiveChallenge = sessionDidReceiveChallenge {
(disposition, credential) = sessionDidReceiveChallenge(session, challenge)
} else if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust {
let host = challenge.protectionSpace.host
if
let serverTrustPolicy = session.serverTrustPolicyManager?.serverTrustPolicy(forHost: host),
let serverTrust = challenge.protectionSpace.serverTrust
{
if serverTrustPolicy.evaluate(serverTrust, forHost: host) {
disposition = .useCredential
credential = URLCredential(trust: serverTrust)
} else {
disposition = .cancelAuthenticationChallenge
}
}
}
completionHandler(disposition, credential)
}
#if !os(macOS)
/// Tells the delegate that all messages enqueued for a session have been delivered.
///
/// - parameter session: The session that no longer has any outstanding requests.
open func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
sessionDidFinishEventsForBackgroundURLSession?(session)
}
#endif
}
// MARK: - URLSessionTaskDelegate
extension SessionDelegate: URLSessionTaskDelegate {
/// Tells the delegate that the remote server requested an HTTP redirect.
///
/// - parameter session: The session containing the task whose request resulted in a redirect.
/// - parameter task: The task whose request resulted in a redirect.
/// - parameter response: An object containing the server’s response to the original request.
/// - parameter request: A URL request object filled out with the new location.
/// - parameter completionHandler: A closure that your handler should call with either the value of the request
/// parameter, a modified URL request object, or NULL to refuse the redirect and
/// return the body of the redirect response.
open func urlSession(
_ session: URLSession,
task: URLSessionTask,
willPerformHTTPRedirection response: HTTPURLResponse,
newRequest request: URLRequest,
completionHandler: @escaping (URLRequest?) -> Void)
{
guard taskWillPerformHTTPRedirectionWithCompletion == nil else {
taskWillPerformHTTPRedirectionWithCompletion?(session, task, response, request, completionHandler)
return
}
var redirectRequest: URLRequest? = request
if let taskWillPerformHTTPRedirection = taskWillPerformHTTPRedirection {
redirectRequest = taskWillPerformHTTPRedirection(session, task, response, request)
}
completionHandler(redirectRequest)
}
/// Requests credentials from the delegate in response to an authentication request from the remote server.
///
/// - parameter session: The session containing the task whose request requires authentication.
/// - parameter task: The task whose request requires authentication.
/// - parameter challenge: An object that contains the request for authentication.
/// - parameter completionHandler: A handler that your delegate method must call providing the disposition
/// and credential.
open func urlSession(
_ session: URLSession,
task: URLSessionTask,
didReceive challenge: URLAuthenticationChallenge,
completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)
{
guard taskDidReceiveChallengeWithCompletion == nil else {
taskDidReceiveChallengeWithCompletion?(session, task, challenge, completionHandler)
return
}
if let taskDidReceiveChallenge = taskDidReceiveChallenge {
let result = taskDidReceiveChallenge(session, task, challenge)
completionHandler(result.0, result.1)
} else if let delegate = self[task]?.delegate {
delegate.urlSession(
session,
task: task,
didReceive: challenge,
completionHandler: completionHandler
)
} else {
urlSession(session, didReceive: challenge, completionHandler: completionHandler)
}
}
/// Tells the delegate when a task requires a new request body stream to send to the remote server.
///
/// - parameter session: The session containing the task that needs a new body stream.
/// - parameter task: The task that needs a new body stream.
/// - parameter completionHandler: A completion handler that your delegate method should call with the new body stream.
open func urlSession(
_ session: URLSession,
task: URLSessionTask,
needNewBodyStream completionHandler: @escaping (InputStream?) -> Void)
{
guard taskNeedNewBodyStreamWithCompletion == nil else {
taskNeedNewBodyStreamWithCompletion?(session, task, completionHandler)
return
}
if let taskNeedNewBodyStream = taskNeedNewBodyStream {
completionHandler(taskNeedNewBodyStream(session, task))
} else if let delegate = self[task]?.delegate {
delegate.urlSession(session, task: task, needNewBodyStream: completionHandler)
}
}
/// Periodically informs the delegate of the progress of sending body content to the server.
///
/// - parameter session: The session containing the data task.
/// - parameter task: The data task.
/// - parameter bytesSent: The number of bytes sent since the last time this delegate method was called.
/// - parameter totalBytesSent: The total number of bytes sent so far.
/// - parameter totalBytesExpectedToSend: The expected length of the body data.
open func urlSession(
_ session: URLSession,
task: URLSessionTask,
didSendBodyData bytesSent: Int64,
totalBytesSent: Int64,
totalBytesExpectedToSend: Int64)
{
if let taskDidSendBodyData = taskDidSendBodyData {
taskDidSendBodyData(session, task, bytesSent, totalBytesSent, totalBytesExpectedToSend)
} else if let delegate = self[task]?.delegate as? UploadTaskDelegate {
delegate.URLSession(
session,
task: task,
didSendBodyData: bytesSent,
totalBytesSent: totalBytesSent,
totalBytesExpectedToSend: totalBytesExpectedToSend
)
}
}
#if !os(watchOS)
/// Tells the delegate that the session finished collecting metrics for the task.
///
/// - parameter session: The session collecting the metrics.
/// - parameter task: The task whose metrics have been collected.
/// - parameter metrics: The collected metrics.
@available(iOS 10.0, macOS 10.12, tvOS 10.0, *)
@objc(URLSession:task:didFinishCollectingMetrics:)
open func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
self[task]?.delegate.metrics = metrics
}
#endif
/// Tells the delegate that the task finished transferring data.
///
/// - parameter session: The session containing the task whose request finished transferring data.
/// - parameter task: The task whose request finished transferring data.
/// - parameter error: If an error occurred, an error object indicating how the transfer failed, otherwise nil.
open func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
/// Executed after it is determined that the request is not going to be retried
let completeTask: (URLSession, URLSessionTask, Error?) -> Void = { [weak self] session, task, error in
guard let strongSelf = self else { return }
strongSelf.taskDidComplete?(session, task, error)
strongSelf[task]?.delegate.urlSession(session, task: task, didCompleteWithError: error)
NotificationCenter.default.post(
name: Notification.Name.Task.DidComplete,
object: strongSelf,
userInfo: [Notification.Key.Task: task]
)
strongSelf[task] = nil
}
guard let request = self[task], let sessionManager = sessionManager else {
completeTask(session, task, error)
return
}
// Run all validations on the request before checking if an error occurred
request.validations.forEach { $0() }
// Determine whether an error has occurred
var error: Error? = error
if request.delegate.error != nil {
error = request.delegate.error
}
/// If an error occurred and the retrier is set, asynchronously ask the retrier if the request
/// should be retried. Otherwise, complete the task by notifying the task delegate.
if let retrier = retrier, let error = error {
retrier.should(sessionManager, retry: request, with: error) { [weak self] shouldRetry, timeDelay in
guard shouldRetry else { completeTask(session, task, error) ; return }
DispatchQueue.utility.after(timeDelay) { [weak self] in
guard let strongSelf = self else { return }
let retrySucceeded = strongSelf.sessionManager?.retry(request) ?? false
if retrySucceeded, let task = request.task {
strongSelf[task] = request
return
} else {
completeTask(session, task, error)
}
}
}
} else {
completeTask(session, task, error)
}
}
}
// MARK: - URLSessionDataDelegate
extension SessionDelegate: URLSessionDataDelegate {
/// Tells the delegate that the data task received the initial reply (headers) from the server.
///
/// - parameter session: The session containing the data task that received an initial reply.
/// - parameter dataTask: The data task that received an initial reply.
/// - parameter response: A URL response object populated with headers.
/// - parameter completionHandler: A completion handler that your code calls to continue the transfer, passing a
/// constant to indicate whether the transfer should continue as a data task or
/// should become a download task.
open func urlSession(
_ session: URLSession,
dataTask: URLSessionDataTask,
didReceive response: URLResponse,
completionHandler: @escaping (URLSession.ResponseDisposition) -> Void)
{
guard dataTaskDidReceiveResponseWithCompletion == nil else {
dataTaskDidReceiveResponseWithCompletion?(session, dataTask, response, completionHandler)
return
}
var disposition: URLSession.ResponseDisposition = .allow
if let dataTaskDidReceiveResponse = dataTaskDidReceiveResponse {
disposition = dataTaskDidReceiveResponse(session, dataTask, response)
}
completionHandler(disposition)
}
/// Tells the delegate that the data task was changed to a download task.
///
/// - parameter session: The session containing the task that was replaced by a download task.
/// - parameter dataTask: The data task that was replaced by a download task.
/// - parameter downloadTask: The new download task that replaced the data task.
open func urlSession(
_ session: URLSession,
dataTask: URLSessionDataTask,
didBecome downloadTask: URLSessionDownloadTask)
{
if let dataTaskDidBecomeDownloadTask = dataTaskDidBecomeDownloadTask {
dataTaskDidBecomeDownloadTask(session, dataTask, downloadTask)
} else {
self[downloadTask]?.delegate = DownloadTaskDelegate(task: downloadTask)
}
}
/// Tells the delegate that the data task has received some of the expected data.
///
/// - parameter session: The session containing the data task that provided data.
/// - parameter dataTask: The data task that provided data.
/// - parameter data: A data object containing the transferred data.
open func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
if let dataTaskDidReceiveData = dataTaskDidReceiveData {
dataTaskDidReceiveData(session, dataTask, data)
} else if let delegate = self[dataTask]?.delegate as? DataTaskDelegate {
delegate.urlSession(session, dataTask: dataTask, didReceive: data)
}
}
/// Asks the delegate whether the data (or upload) task should store the response in the cache.
///
/// - parameter session: The session containing the data (or upload) task.
/// - parameter dataTask: The data (or upload) task.
/// - parameter proposedResponse: The default caching behavior. This behavior is determined based on the current
/// caching policy and the values of certain received headers, such as the Pragma
/// and Cache-Control headers.
/// - parameter completionHandler: A block that your handler must call, providing either the original proposed
/// response, a modified version of that response, or NULL to prevent caching the
/// response. If your delegate implements this method, it must call this completion
/// handler; otherwise, your app leaks memory.
open func urlSession(
_ session: URLSession,
dataTask: URLSessionDataTask,
willCacheResponse proposedResponse: CachedURLResponse,
completionHandler: @escaping (CachedURLResponse?) -> Void)
{
guard dataTaskWillCacheResponseWithCompletion == nil else {
dataTaskWillCacheResponseWithCompletion?(session, dataTask, proposedResponse, completionHandler)
return
}
if let dataTaskWillCacheResponse = dataTaskWillCacheResponse {
completionHandler(dataTaskWillCacheResponse(session, dataTask, proposedResponse))
} else if let delegate = self[dataTask]?.delegate as? DataTaskDelegate {
delegate.urlSession(
session,
dataTask: dataTask,
willCacheResponse: proposedResponse,
completionHandler: completionHandler
)
} else {
completionHandler(proposedResponse)
}
}
}
// MARK: - URLSessionDownloadDelegate
extension SessionDelegate: URLSessionDownloadDelegate {
/// Tells the delegate that a download task has finished downloading.
///
/// - parameter session: The session containing the download task that finished.
/// - parameter downloadTask: The download task that finished.
/// - parameter location: A file URL for the temporary file. Because the file is temporary, you must either
/// open the file for reading or move it to a permanent location in your app’s sandbox
/// container directory before returning from this delegate method.
open func urlSession(
_ session: URLSession,
downloadTask: URLSessionDownloadTask,
didFinishDownloadingTo location: URL)
{
if let downloadTaskDidFinishDownloadingToURL = downloadTaskDidFinishDownloadingToURL {
downloadTaskDidFinishDownloadingToURL(session, downloadTask, location)
} else if let delegate = self[downloadTask]?.delegate as? DownloadTaskDelegate {
delegate.urlSession(session, downloadTask: downloadTask, didFinishDownloadingTo: location)
}
}
/// Periodically informs the delegate about the download’s progress.
///
/// - parameter session: The session containing the download task.
/// - parameter downloadTask: The download task.
/// - parameter bytesWritten: The number of bytes transferred since the last time this delegate
/// method was called.
/// - parameter totalBytesWritten: The total number of bytes transferred so far.
/// - parameter totalBytesExpectedToWrite: The expected length of the file, as provided by the Content-Length
/// header. If this header was not provided, the value is
/// `NSURLSessionTransferSizeUnknown`.
open func urlSession(
_ session: URLSession,
downloadTask: URLSessionDownloadTask,
didWriteData bytesWritten: Int64,
totalBytesWritten: Int64,
totalBytesExpectedToWrite: Int64)
{
if let downloadTaskDidWriteData = downloadTaskDidWriteData {
downloadTaskDidWriteData(session, downloadTask, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)
} else if let delegate = self[downloadTask]?.delegate as? DownloadTaskDelegate {
delegate.urlSession(
session,
downloadTask: downloadTask,
didWriteData: bytesWritten,
totalBytesWritten: totalBytesWritten,
totalBytesExpectedToWrite: totalBytesExpectedToWrite
)
}
}
/// Tells the delegate that the download task has resumed downloading.
///
/// - parameter session: The session containing the download task that finished.
/// - parameter downloadTask: The download task that resumed. See explanation in the discussion.
/// - parameter fileOffset: If the file's cache policy or last modified date prevents reuse of the
/// existing content, then this value is zero. Otherwise, this value is an
/// integer representing the number of bytes on disk that do not need to be
/// retrieved again.
/// - parameter expectedTotalBytes: The expected length of the file, as provided by the Content-Length header.
/// If this header was not provided, the value is NSURLSessionTransferSizeUnknown.
open func urlSession(
_ session: URLSession,
downloadTask: URLSessionDownloadTask,
didResumeAtOffset fileOffset: Int64,
expectedTotalBytes: Int64)
{
if let downloadTaskDidResumeAtOffset = downloadTaskDidResumeAtOffset {
downloadTaskDidResumeAtOffset(session, downloadTask, fileOffset, expectedTotalBytes)
} else if let delegate = self[downloadTask]?.delegate as? DownloadTaskDelegate {
delegate.urlSession(
session,
downloadTask: downloadTask,
didResumeAtOffset: fileOffset,
expectedTotalBytes: expectedTotalBytes
)
}
}
}
// MARK: - URLSessionStreamDelegate
#if !os(watchOS)
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
extension SessionDelegate: URLSessionStreamDelegate {
/// Tells the delegate that the read side of the connection has been closed.
///
/// - parameter session: The session.
/// - parameter streamTask: The stream task.
open func urlSession(_ session: URLSession, readClosedFor streamTask: URLSessionStreamTask) {
streamTaskReadClosed?(session, streamTask)
}
/// Tells the delegate that the write side of the connection has been closed.
///
/// - parameter session: The session.
/// - parameter streamTask: The stream task.
open func urlSession(_ session: URLSession, writeClosedFor streamTask: URLSessionStreamTask) {
streamTaskWriteClosed?(session, streamTask)
}
/// Tells the delegate that the system has determined that a better route to the host is available.
///
/// - parameter session: The session.
/// - parameter streamTask: The stream task.
open func urlSession(_ session: URLSession, betterRouteDiscoveredFor streamTask: URLSessionStreamTask) {
streamTaskBetterRouteDiscovered?(session, streamTask)
}
/// Tells the delegate that the stream task has been completed and provides the unopened stream objects.
///
/// - parameter session: The session.
/// - parameter streamTask: The stream task.
/// - parameter inputStream: The new input stream.
/// - parameter outputStream: The new output stream.
open func urlSession(
_ session: URLSession,
streamTask: URLSessionStreamTask,
didBecome inputStream: InputStream,
outputStream: OutputStream)
{
streamTaskDidBecomeInputAndOutputStreams?(session, streamTask, inputStream, outputStream)
}
}
#endif
|
apache-2.0
|
e938eb270848729462f6b0fb11bc9f3c
| 48.112656 | 192 | 0.67504 | 6.158354 | false | false | false | false |
PopcornTimeTV/PopcornTimeTV
|
PopcornTime/UI/iOS/Table View Cells/AirPlayTableViewCell.swift
|
1
|
1965
|
import Foundation
import MediaPlayer
import PopcornKit.MPAVRoutingController
class AirPlayTableViewCell: UITableViewCell {
let volumeView = MPVolumeView()
var routingController: MPAVRoutingController {
return volumeView.value(forKey: "routingController") as! MPAVRoutingController
}
var routeButton: UIButton {
return volumeView.value(forKey: "_routeButton") as! UIButton
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
volumeView.showsVolumeSlider = false
volumeView.showsRouteButton = true
addSubview(volumeView)
NotificationCenter.default.addObserver(self, selector: #selector(activeRouteDidChange), name: .MPVolumeViewWirelessRouteActiveDidChange, object: nil)
}
override func layoutSubviews() {
super.layoutSubviews()
volumeView.frame = bounds
routeButton.isHidden = true
}
@objc func activeRouteDidChange() {
if #available(iOS 11.4, *){
}else{
if let picked = routingController.pickedRoute, let video = picked.wirelessDisplay {
let alertController = UIAlertController(title: "Mirroring route detected".localized, message: "Would you like to mirror current display to device?".localized, preferredStyle: .alert)
alertController.addAction(UIAlertAction(title: "Yes".localized, style: .default, handler: { (_) in
self.routingController.pick(video)
}))
alertController.addAction(UIAlertAction(title: "No".localized, style: .cancel, handler: nil))
parent?.present(alertController, animated: true)
}
}
}
deinit {
NotificationCenter.default.removeObserver(self, name: .MPVolumeViewWirelessRouteActiveDidChange, object: nil)
}
}
|
gpl-3.0
|
c9d63671580ae9d2515fbe53be7f95ee
| 32.87931 | 198 | 0.637659 | 5.254011 | false | false | false | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.