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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
azadibogolubov/InterestDestroyer | iOS Version/Interest Destroyer/Charts/Classes/Charts/RadarChartView.swift | 12 | 9293 | //
// RadarChartView.swift
// Charts
//
// Created by Daniel Cohen Gindi on 4/3/15.
//
// Copyright 2015 Daniel Cohen Gindi & Philipp Jahoda
// A port of MPAndroidChart for iOS
// Licensed under Apache License 2.0
//
// https://github.com/danielgindi/ios-charts
//
import Foundation
import CoreGraphics
import UIKit
/// Implementation of the RadarChart, a "spidernet"-like chart. It works best
/// when displaying 5-10 entries per DataSet.
public class RadarChartView: PieRadarChartViewBase
{
/// width of the web lines that come from the center.
public var webLineWidth = CGFloat(1.5)
/// width of the web lines that are in between the lines coming from the center
public var innerWebLineWidth = CGFloat(0.75)
/// color for the web lines that come from the center
public var webColor = UIColor(red: 122/255.0, green: 122/255.0, blue: 122.0/255.0, alpha: 1.0)
/// color for the web lines in between the lines that come from the center.
public var innerWebColor = UIColor(red: 122/255.0, green: 122/255.0, blue: 122.0/255.0, alpha: 1.0)
/// transparency the grid is drawn with (0.0 - 1.0)
public var webAlpha: CGFloat = 150.0 / 255.0
/// flag indicating if the web lines should be drawn or not
public var drawWeb = true
/// modulus that determines how many labels and web-lines are skipped before the next is drawn
private var _webModulus = 1
/// the object reprsenting the y-axis labels
private var _yAxis: ChartYAxis!
/// the object representing the x-axis labels
private var _xAxis: ChartXAxis!
internal var _yAxisRenderer: ChartYAxisRendererRadarChart!
internal var _xAxisRenderer: ChartXAxisRendererRadarChart!
public override init(frame: CGRect)
{
super.init(frame: frame)
}
public required init?(coder aDecoder: NSCoder)
{
super.init(coder: aDecoder)
}
internal override func initialize()
{
super.initialize()
_yAxis = ChartYAxis(position: .Left)
_xAxis = ChartXAxis()
_xAxis.spaceBetweenLabels = 0
renderer = RadarChartRenderer(chart: self, animator: _animator, viewPortHandler: _viewPortHandler)
_yAxisRenderer = ChartYAxisRendererRadarChart(viewPortHandler: _viewPortHandler, yAxis: _yAxis, chart: self)
_xAxisRenderer = ChartXAxisRendererRadarChart(viewPortHandler: _viewPortHandler, xAxis: _xAxis, chart: self)
}
internal override func calcMinMax()
{
super.calcMinMax()
let minLeft = _data.getYMin(.Left)
let maxLeft = _data.getYMax(.Left)
_chartXMax = Double(_data.xVals.count) - 1.0
_deltaX = CGFloat(abs(_chartXMax - _chartXMin))
let leftRange = CGFloat(abs(maxLeft - (_yAxis.isStartAtZeroEnabled ? 0.0 : minLeft)))
let topSpaceLeft = Double(leftRange * _yAxis.spaceTop)
let bottomSpaceLeft = Double(leftRange * _yAxis.spaceBottom)
// Consider sticking one of the edges of the axis to zero (0.0)
if _yAxis.isStartAtZeroEnabled
{
if minLeft < 0.0 && maxLeft < 0.0
{
// If the values are all negative, let's stay in the negative zone
_yAxis.axisMinimum = min(0.0, !isnan(_yAxis.customAxisMin) ? _yAxis.customAxisMin : (minLeft - bottomSpaceLeft))
_yAxis.axisMaximum = 0.0
}
else if minLeft >= 0.0
{
// We have positive values only, stay in the positive zone
_yAxis.axisMinimum = 0.0
_yAxis.axisMaximum = max(0.0, !isnan(_yAxis.customAxisMax) ? _yAxis.customAxisMax : (maxLeft + topSpaceLeft))
}
else
{
// Stick the minimum to 0.0 or less, and maximum to 0.0 or more (startAtZero for negative/positive at the same time)
_yAxis.axisMinimum = min(0.0, !isnan(_yAxis.customAxisMin) ? _yAxis.customAxisMin : (minLeft - bottomSpaceLeft))
_yAxis.axisMaximum = max(0.0, !isnan(_yAxis.customAxisMax) ? _yAxis.customAxisMax : (maxLeft + topSpaceLeft))
}
}
else
{
// Use the values as they are
_yAxis.axisMinimum = !isnan(_yAxis.customAxisMin) ? _yAxis.customAxisMin : (minLeft - bottomSpaceLeft)
_yAxis.axisMaximum = !isnan(_yAxis.customAxisMax) ? _yAxis.customAxisMax : (maxLeft + topSpaceLeft)
}
_chartXMax = Double(_data.xVals.count) - 1.0
_deltaX = CGFloat(abs(_chartXMax - _chartXMin))
_yAxis.axisRange = abs(_yAxis.axisMaximum - _yAxis.axisMinimum)
}
public override func getMarkerPosition(entry entry: ChartDataEntry, highlight: ChartHighlight) -> CGPoint
{
let angle = self.sliceAngle * CGFloat(entry.xIndex) + self.rotationAngle
let val = CGFloat(entry.value) * self.factor
let c = self.centerOffsets
let p = CGPoint(x: c.x + val * cos(angle * ChartUtils.Math.FDEG2RAD),
y: c.y + val * sin(angle * ChartUtils.Math.FDEG2RAD))
return p
}
public override func notifyDataSetChanged()
{
if (_dataNotSet)
{
return
}
calcMinMax()
_yAxis?._defaultValueFormatter = _defaultValueFormatter
_yAxisRenderer?.computeAxis(yMin: _yAxis.axisMinimum, yMax: _yAxis.axisMaximum)
_xAxisRenderer?.computeAxis(xValAverageLength: _data.xValAverageLength, xValues: _data.xVals)
if (_legend !== nil && !_legend.isLegendCustom)
{
_legendRenderer?.computeLegend(_data)
}
calculateOffsets()
setNeedsDisplay()
}
public override func drawRect(rect: CGRect)
{
super.drawRect(rect)
if (_dataNotSet)
{
return
}
let context = UIGraphicsGetCurrentContext()
_xAxisRenderer?.renderAxisLabels(context: context)
if (drawWeb)
{
renderer!.drawExtras(context: context)
}
_yAxisRenderer.renderLimitLines(context: context)
renderer!.drawData(context: context)
if (valuesToHighlight())
{
renderer!.drawHighlighted(context: context, indices: _indicesToHightlight)
}
_yAxisRenderer.renderAxisLabels(context: context)
renderer!.drawValues(context: context)
_legendRenderer.renderLegend(context: context)
drawDescription(context: context)
drawMarkers(context: context)
}
/// - returns: the factor that is needed to transform values into pixels.
public var factor: CGFloat
{
let content = _viewPortHandler.contentRect
return min(content.width / 2.0, content.height / 2.0)
/ CGFloat(_yAxis.axisRange)
}
/// - returns: the angle that each slice in the radar chart occupies.
public var sliceAngle: CGFloat
{
return 360.0 / CGFloat(_data.xValCount)
}
public override func indexForAngle(angle: CGFloat) -> Int
{
// take the current angle of the chart into consideration
let a = ChartUtils.normalizedAngleFromAngle(angle - self.rotationAngle)
let sliceAngle = self.sliceAngle
for (var i = 0; i < _data.xValCount; i++)
{
if (sliceAngle * CGFloat(i + 1) - sliceAngle / 2.0 > a)
{
return i
}
}
return 0
}
/// - returns: the object that represents all y-labels of the RadarChart.
public var yAxis: ChartYAxis
{
return _yAxis
}
/// - returns: the object that represents all x-labels that are placed around the RadarChart.
public var xAxis: ChartXAxis
{
return _xAxis
}
/// Sets the number of web-lines that should be skipped on chart web before the next one is drawn. This targets the lines that come from the center of the RadarChart.
/// if count = 1 -> 1 line is skipped in between
public var skipWebLineCount: Int
{
get
{
return _webModulus - 1
}
set
{
_webModulus = max(0, newValue) + 1
}
}
internal override var requiredBottomOffset: CGFloat
{
return _legend.font.pointSize * 4.0
}
internal override var requiredBaseOffset: CGFloat
{
return _xAxis.isEnabled && _xAxis.isDrawLabelsEnabled ? _xAxis.labelWidth : 10.0
}
public override var radius: CGFloat
{
let content = _viewPortHandler.contentRect
return min(content.width / 2.0, content.height / 2.0)
}
/// - returns: the maximum value this chart can display on it's y-axis.
public override var chartYMax: Double { return _yAxis.axisMaximum; }
/// - returns: the minimum value this chart can display on it's y-axis.
public override var chartYMin: Double { return _yAxis.axisMinimum; }
/// - returns: the range of y-values this chart can display.
public var yRange: Double { return _yAxis.axisRange}
} | apache-2.0 | c6c2f8ab0d6dc661f0ee1560da7f07a9 | 31.840989 | 170 | 0.609168 | 4.710086 | false | false | false | false |
carabina/Lantern | LanternModel/PageInfo.swift | 1 | 10715 | //
// PageInfo.swift
// Hoverlytics
//
// Created by Patrick Smith on 28/04/2015.
// Copyright (c) 2015 Burnt Caramel. All rights reserved.
//
import Foundation
import Alamofire
import Ono
public enum BaseContentType {
case Unknown
case LocalHTMLPage
case Text
case Image
case Feed
case Redirect
case Essential
}
extension BaseContentType: DebugPrintable {
public var debugDescription: String {
switch self {
case .Unknown:
return "Unknown"
case .LocalHTMLPage:
return "LocalHTMLPage"
case .Text:
return "Text"
case .Image:
return "Image"
case .Feed:
return "Feed"
case .Redirect:
return "Redirect"
case .Essential:
return "Essential"
}
}
}
private typealias ONOXMLElementFilter = (element: ONOXMLElement) -> Bool
extension ONOXMLDocument {
private func allElementsWithCSS(selector: String, filter: ONOXMLElementFilter? = nil) -> [ONOXMLElement] {
var elements = [ONOXMLElement]()
self.enumerateElementsWithCSS(selector) { (element, index, stop) in
if filter?(element: element) == false {
return
}
elements.append(element)
}
return elements
}
}
public enum PageResponseType: Int {
case Successful = 2
case Redirects = 3
case RequestErrors = 4
case ResponseErrors = 5
case Unknown = 0
}
extension PageResponseType {
public init(statusCode: Int) {
switch statusCode {
case 200..<300:
self = .Successful
case 300..<400:
self = .Redirects
case 400..<500:
self = .RequestErrors
case 500..<600:
self = .ResponseErrors
default:
self = .Unknown
}
}
}
internal func URLIsExternal(URLToTest: NSURL, #localHost: String) -> Bool {
if let host = URLToTest.host {
if host.caseInsensitiveCompare(localHost) != .OrderedSame {
return true
}
}
return false
}
private let fileDownloadFileExtensions = Set<String>(["zip", "dmg", "exe", "pdf", "gz", "tar", "doc", "docx", "xls", "wav", "aiff", "mp3", "mp4", "mov", "avi", "wmv"])
func linkedURLLooksLikeFileDownload(URL: NSURL) -> Bool {
if let path = URL.path {
let pathExtension = path.pathExtension
if fileDownloadFileExtensions.contains(pathExtension) {
return true
}
}
return false
}
public struct MIMETypeString {
public let stringValue: String
}
extension MIMETypeString {
init?(_ stringValue: String?) {
if let stringValue = stringValue {
self.stringValue = stringValue
}
else {
return nil
}
}
var isHTML: Bool {
return stringValue == "text/html"
}
var isText: Bool {
return stringValue.hasPrefix("text/")
}
var isImage: Bool {
return stringValue.hasPrefix("image/")
}
private static let feedTypes = Set<String>(["application/rss+xml", "application/rdf+xml", "application/atom+xml", "application/xml", "text/xml"])
var isFeed: Bool {
let feedTypes = MIMETypeString.feedTypes
return feedTypes.contains(stringValue)
}
var baseContentType: BaseContentType {
if isHTML {
return .LocalHTMLPage
}
else if isText {
return .Text
}
else if isImage {
return .Image
}
else if isFeed {
return .Feed
}
else {
return .Unknown
}
}
}
extension MIMETypeString: Printable {
public var description: String {
return stringValue
}
}
struct PageContentInfoOptions {
var separateLinksToImageTypes = true
}
public struct PageContentInfo {
public let data: NSData
private let document: ONOXMLDocument!
let stringEncoding: NSStringEncoding!
public let preBodyByteCount: Int?
public let pageTitleElements: [ONOXMLElement]
public let metaDescriptionElements: [ONOXMLElement]
public let openGraphElements: [ONOXMLElement]
private let uniqueFeedURLs: UniqueURLArray
public var feedURLs: [NSURL] {
return uniqueFeedURLs.orderedURLs
}
public let feedLinkElements: [ONOXMLElement]
private let uniqueExternalPageURLs: UniqueURLArray
public var externalPageURLs: [NSURL] {
return uniqueExternalPageURLs.orderedURLs
}
public let aExternalLinkElements: [ONOXMLElement]
private let uniqueLocalPageURLs: UniqueURLArray
public var localPageURLs: [NSURL] {
return uniqueLocalPageURLs.orderedURLs
}
public func containsLocalPageURL(URL: NSURL) -> Bool {
return uniqueLocalPageURLs.contains(URL)
}
public let aLocalLinkElements: [ONOXMLElement]
public let imageURLs: Set<NSURL>
public func containsImageURL(URL: NSURL) -> Bool {
return imageURLs.contains(URL)
}
public let imageElements: [ONOXMLElement]
//public let stylesheetURLs: Set<NSURL>
//public let stylesheetElements: [ONOXMLElement]
public let h1Elements: [ONOXMLElement]
public let richSnippetElements: [ONOXMLElement]
init(data: NSData, localURL: NSURL, options: PageContentInfoOptions = PageContentInfoOptions()) {
self.data = data
var error: NSError?
if let document = ONOXMLDocument.HTMLDocumentWithData(data, error: &error) {
self.stringEncoding = document.stringEncodingWithFallback()
// Must store document to also save references to all found elements.
self.document = document
let stringEncoding = document.stringEncodingWithFallback()
if let bodyTagData = "<body".dataUsingEncoding(stringEncoding, allowLossyConversion: false) {
let bodyTagRange = data.rangeOfData(bodyTagData, options: .allZeros, range: NSMakeRange(0, data.length))
if bodyTagRange.location != NSNotFound {
preBodyByteCount = bodyTagRange.location
}
else {
preBodyByteCount = nil
}
}
else {
preBodyByteCount = nil
}
pageTitleElements = document.allElementsWithCSS("head title")
metaDescriptionElements = document.allElementsWithCSS("head meta[name][content]") { element in
if let name = element["name"] as? String {
return name.caseInsensitiveCompare("description") == .OrderedSame
}
return false
}
openGraphElements = document.allElementsWithCSS("head meta[property]") { element in
if let name = element["property"] as? String {
return name.rangeOfString("og:", options: .AnchoredSearch | .CaseInsensitiveSearch) != nil
}
return false
}
var uniqueFeedURLs = UniqueURLArray()
feedLinkElements = document.allElementsWithCSS("head link[type][href]") { element in
if
let typeRaw = element["type"] as? String,
let MIMEType = MIMETypeString(typeRaw.lowercaseString),
let linkURLString = element["href"] as? String,
let linkURL = NSURL(string: linkURLString, relativeToURL: localURL)
{
if MIMEType.isFeed {
uniqueFeedURLs.insertReturningConformedURLIfNew(linkURL)
return true
}
}
return false
}
self.uniqueFeedURLs = uniqueFeedURLs
let localHost = localURL.host!
let separateLinksToImageTypes = options.separateLinksToImageTypes
var aLocalLinkElements = [ONOXMLElement]()
var aExternalLinkElements = [ONOXMLElement]()
var uniqueLocalPageURLs = UniqueURLArray()
var uniqueExternalPageURLs = UniqueURLArray()
var imageElements = [ONOXMLElement]()
var imageURLs = Set<NSURL>()
document.enumerateElementsWithCSS("a[href]") { (aLinkElement, index, stop) in
if
let linkURLString = aLinkElement["href"] as? String,
let linkURL = NSURL(string: linkURLString, relativeToURL: localURL)
{
if separateLinksToImageTypes {
let hasImageType = [".jpg", ".jpeg", ".png", ".gif"].reduce(false, combine: { (hasSoFar, suffix) -> Bool in
return hasSoFar || linkURLString.hasSuffix(suffix)
})
if hasImageType {
imageElements.append(aLinkElement)
imageURLs.insert(linkURL)
return
}
}
let isExternal = URLIsExternal(linkURL, localHost: localHost)
if isExternal {
aExternalLinkElements.append(aLinkElement)
uniqueExternalPageURLs.insertReturningConformedURLIfNew(linkURL)
}
else {
aLocalLinkElements.append(aLinkElement)
uniqueLocalPageURLs.insertReturningConformedURLIfNew(linkURL)
}
}
}
self.aLocalLinkElements = aLocalLinkElements
self.aExternalLinkElements = aExternalLinkElements
self.uniqueLocalPageURLs = uniqueLocalPageURLs
self.uniqueExternalPageURLs = uniqueExternalPageURLs
document.enumerateElementsWithCSS("img[src]") { (imgElement, index, stop) in
if
let imageURLString = imgElement["src"] as? String,
let imageURL = NSURL(string: imageURLString, relativeToURL: localURL)
{
//let isExternal = URLIsExternal(linkURL, localHost: localHost)
imageElements.append(imgElement)
imageURLs.insert(imageURL)
}
}
self.imageElements = imageElements
self.imageURLs = imageURLs
h1Elements = document.allElementsWithCSS("h1")
richSnippetElements = [] //TODO:
}
else {
document = nil
stringEncoding = nil
pageTitleElements = []
metaDescriptionElements = []
openGraphElements = []
uniqueFeedURLs = UniqueURLArray()
feedLinkElements = []
uniqueExternalPageURLs = UniqueURLArray()
aExternalLinkElements = []
uniqueLocalPageURLs = UniqueURLArray()
aLocalLinkElements = []
imageURLs = Set<NSURL>()
imageElements = []
h1Elements = []
richSnippetElements = []
preBodyByteCount = nil
}
}
public var HTMLHeadData: NSData? {
if let preBodyByteCount = preBodyByteCount {
return data.subdataWithRange(NSMakeRange(0, preBodyByteCount))
}
return nil
}
public var HTMLBodyData: NSData? {
if let preBodyByteCount = preBodyByteCount {
return data.subdataWithRange(NSMakeRange(preBodyByteCount, data.length - preBodyByteCount))
}
return nil
}
public var stringContent: String? {
return NSString(data: data, encoding: stringEncoding) as? String
//return data.stringRepresentationUsingONOXMLDocumentHints(document)
}
public var HTMLHeadStringContent: String? {
if let data = HTMLHeadData {
return NSString(data: data, encoding: stringEncoding) as? String
}
else {
return nil
}
//return HTMLHeadData?.stringRepresentationUsingONOXMLDocumentHints(document)
}
public var HTMLBodyStringContent: String? {
if let data = HTMLBodyData {
return NSString(data: data, encoding: stringEncoding) as? String
}
else {
return nil
}
//return HTMLBodyData?.stringRepresentationUsingONOXMLDocumentHints(document)
}
}
public struct PageInfo {
public let requestedURL: NSURL
public let finalURL: NSURL?
public let statusCode: Int
public let baseContentType: BaseContentType
public let MIMEType: MIMETypeString?
public let byteCount: Int?
public let contentInfo: PageContentInfo?
}
public struct RequestRedirectionInfo {
let sourceRequest: NSURLRequest
let nextRequest: NSURLRequest
public let statusCode: Int
public let MIMEType: MIMETypeString?
}
| apache-2.0 | 6e6ade893ccd44bd5859d0f304c28613 | 23.519451 | 167 | 0.713206 | 3.712751 | false | false | false | false |
eoger/firefox-ios | Client/Frontend/AuthenticationManager/RequirePasscodeIntervalViewController.swift | 4 | 3168 | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import Foundation
import Shared
import SwiftKeychainWrapper
/// Screen presented to the user when selecting the time interval before requiring a passcode
class RequirePasscodeIntervalViewController: UITableViewController {
let intervalOptions: [PasscodeInterval] = [
.immediately,
.oneMinute,
.fiveMinutes,
.tenMinutes,
.fifteenMinutes,
.oneHour
]
fileprivate let BasicCheckmarkCell = "BasicCheckmarkCell"
fileprivate var authenticationInfo: AuthenticationKeychainInfo?
init() {
super.init(nibName: nil, bundle: nil)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func viewDidLoad() {
super.viewDidLoad()
title = AuthenticationStrings.requirePasscode
tableView.accessibilityIdentifier = "AuthenticationManager.passcodeIntervalTableView"
tableView.register(UITableViewCell.self, forCellReuseIdentifier: BasicCheckmarkCell)
tableView.backgroundColor = UIColor.theme.tableView.headerBackground
let headerFooterFrame = CGRect(width: self.view.frame.width, height: SettingsUX.TableViewHeaderFooterHeight)
let headerView = ThemedTableSectionHeaderFooterView(frame: headerFooterFrame)
headerView.showTopBorder = false
headerView.showBottomBorder = true
let footerView = ThemedTableSectionHeaderFooterView(frame: headerFooterFrame)
footerView.showTopBorder = true
footerView.showBottomBorder = false
tableView.tableHeaderView = headerView
tableView.tableFooterView = footerView
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
self.authenticationInfo = KeychainWrapper.sharedAppContainerKeychain.authenticationInfo()
tableView.reloadData()
}
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: BasicCheckmarkCell, for: indexPath)
let option = intervalOptions[indexPath.row]
let intervalTitle = NSAttributedString.tableRowTitle(option.settingTitle, enabled: true)
cell.textLabel?.attributedText = intervalTitle
cell.accessoryType = authenticationInfo?.requiredPasscodeInterval == option ? .checkmark : .none
cell.backgroundColor = UIColor.theme.tableView.rowBackground
return cell
}
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return intervalOptions.count
}
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
authenticationInfo?.updateRequiredPasscodeInterval(intervalOptions[indexPath.row])
KeychainWrapper.sharedAppContainerKeychain.setAuthenticationInfo(authenticationInfo)
tableView.reloadData()
}
}
| mpl-2.0 | 4dcf8ab2ee3eda52f1ab46f70e7988dd | 39.615385 | 116 | 0.734217 | 5.781022 | false | false | false | false |
hoobaa/nkbd | Keyboard/cForwardingView.swift | 6 | 7709 | //
// ForwardingView.swift
// TransliteratingKeyboard
//
// Created by Alexei Baboulevitch on 7/19/14.
// Copyright (c) 2014 Apple. All rights reserved.
//
import UIKit
class ForwardingView: UIView {
var touchToView: [UITouch:UIView]
override init(frame: CGRect) {
self.touchToView = [:]
super.init(frame: frame)
self.contentMode = UIViewContentMode.Redraw
self.multipleTouchEnabled = true
self.userInteractionEnabled = true
self.opaque = false
}
required init(coder: NSCoder) {
fatalError("NSCoding not supported")
}
// Why have this useless drawRect? Well, if we just set the backgroundColor to clearColor,
// then some weird optimization happens on UIKit's side where tapping down on a transparent pixel will
// not actually recognize the touch. Having a manual drawRect fixes this behavior, even though it doesn't
// actually do anything.
override func drawRect(rect: CGRect) {}
override func hitTest(point: CGPoint, withEvent event: UIEvent!) -> UIView? {
if self.hidden || self.alpha == 0 || !self.userInteractionEnabled {
return nil
}
else {
return (CGRectContainsPoint(self.bounds, point) ? self : nil)
}
}
func handleControl(view: UIView?, controlEvent: UIControlEvents) {
if let control = view as? UIControl {
let targets = control.allTargets()
for target in targets {
if var actions = control.actionsForTarget(target, forControlEvent: controlEvent) {
for action in actions {
if let selectorString = action as? String {
let selector = Selector(selectorString)
control.sendAction(selector, to: target, forEvent: nil)
}
}
}
}
}
}
// TODO: there's a bit of "stickiness" to Apple's implementation
func findNearestView(position: CGPoint) -> UIView? {
if !self.bounds.contains(position) {
return nil
}
var closest: (UIView, CGFloat)? = nil
for anyView in self.subviews {
if let view = anyView as? UIView {
if view.hidden {
continue
}
view.alpha = 1
let distance = distanceBetween(view.frame, point: position)
if closest != nil {
if distance < closest!.1 {
closest = (view, distance)
}
}
else {
closest = (view, distance)
}
}
}
if closest != nil {
return closest!.0
}
else {
return nil
}
}
// http://stackoverflow.com/questions/3552108/finding-closest-object-to-cgpoint b/c I'm lazy
func distanceBetween(rect: CGRect, point: CGPoint) -> CGFloat {
if CGRectContainsPoint(rect, point) {
return 0
}
var closest = rect.origin
if (rect.origin.x + rect.size.width < point.x) {
closest.x += rect.size.width
}
else if (point.x > rect.origin.x) {
closest.x = point.x
}
if (rect.origin.y + rect.size.height < point.y) {
closest.y += rect.size.height
}
else if (point.y > rect.origin.y) {
closest.y = point.y
}
let a = pow(Double(closest.y - point.y), 2)
let b = pow(Double(closest.x - point.x), 2)
return CGFloat(sqrt(a + b));
}
// reset tracked views without cancelling current touch
func resetTrackedViews() {
for view in self.touchToView.values {
self.handleControl(view, controlEvent: .TouchCancel)
}
self.touchToView.removeAll(keepCapacity: true)
}
func ownView(newTouch: UITouch, viewToOwn: UIView?) -> Bool {
var foundView = false
if viewToOwn != nil {
for (touch, view) in self.touchToView {
if viewToOwn == view {
if touch == newTouch {
break
}
else {
self.touchToView[touch] = nil
foundView = true
}
break
}
}
}
self.touchToView[newTouch] = viewToOwn
return foundView
}
override func touchesBegan(touches: Set<NSObject>, withEvent event: UIEvent) {
for obj in touches {
if let touch = obj as? UITouch {
let position = touch.locationInView(self)
var view = findNearestView(position)
var viewChangedOwnership = self.ownView(touch, viewToOwn: view)
if !viewChangedOwnership {
self.handleControl(view, controlEvent: .TouchDown)
if touch.tapCount > 1 {
// two events, I think this is the correct behavior but I have not tested with an actual UIControl
self.handleControl(view, controlEvent: .TouchDownRepeat)
}
}
}
}
}
override func touchesMoved(touches: Set<NSObject>, withEvent event: UIEvent) {
for obj in touches {
if let touch = obj as? UITouch {
let position = touch.locationInView(self)
var oldView = self.touchToView[touch]
var newView = findNearestView(position)
if oldView != newView {
self.handleControl(oldView, controlEvent: .TouchDragExit)
var viewChangedOwnership = self.ownView(touch, viewToOwn: newView)
if !viewChangedOwnership {
self.handleControl(newView, controlEvent: .TouchDragEnter)
}
else {
self.handleControl(newView, controlEvent: .TouchDragInside)
}
}
else {
self.handleControl(oldView, controlEvent: .TouchDragInside)
}
}
}
}
override func touchesEnded(touches: Set<NSObject>, withEvent event: UIEvent) {
for obj in touches {
if let touch = obj as? UITouch {
var view = self.touchToView[touch]
let touchPosition = touch.locationInView(self)
if self.bounds.contains(touchPosition) {
self.handleControl(view, controlEvent: .TouchUpInside)
}
else {
self.handleControl(view, controlEvent: .TouchCancel)
}
self.touchToView[touch] = nil
}
}
}
override func touchesCancelled(touches: Set<NSObject>, withEvent event: UIEvent!) {
for obj in touches {
if let touch = obj as? UITouch {
var view = self.touchToView[touch]
self.handleControl(view, controlEvent: .TouchCancel)
self.touchToView[touch] = nil
}
}
}
}
| bsd-3-clause | 1fa935392ac27c7f996fbe22f937c032 | 32.372294 | 122 | 0.498249 | 5.417428 | false | false | false | false |
google/GTMAppAuth | GTMAppAuthSwift/Sources/GTMKeychain.swift | 1 | 13732 | /*
* Copyright 2022 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import Foundation
import Security
/// An internal utility for saving and loading data to the keychain.
final class GTMKeychain {
private var keychainHelper: KeychainHelper
/// An initializer for testing to create an instance of this keychain wrapper with a given helper.
///
/// - Parameter keychainHelper: An instance conforming to `KeychainHelper`.
init(keychainHelper: KeychainHelper? = nil) {
if let helper = keychainHelper {
self.keychainHelper = helper
} else {
self.keychainHelper = KeychainWrapper()
}
}
/// Saves the password `String` to the keychain with the given identifier.
///
/// - Parameters:
/// - password: The `String` password.
/// - itemName: The name for the Keychain item.
/// - Throws: An instance of `KeychainWrapper.Error`.
func save(password: String, forItemName itemName: String) throws {
try savePasswordToKeychain(password, forItemName: itemName)
}
/// Saves the password `String` to the keychain with the given identifier.
///
/// - Parameters:
/// - password: The `String` password.
/// - itemName: The name for the Keychain item.
/// - usingDataProtectionKeychain: A `Bool` indicating whether to use the data
/// protection keychain on macOS 10.15.
/// - Throws: An instance of `KeychainWrapper.Error`.
@available(macOS 10.15, *)
func save(
password: String,
forItemName itemName: String,
usingDataProtectionKeychain: Bool
) throws {
try savePasswordToKeychain(
password,
forItemName: itemName,
usingDataProtectionKeychain: usingDataProtectionKeychain
)
}
private func savePasswordToKeychain(
_ password: String,
forItemName name: String,
usingDataProtectionKeychain: Bool = false
) throws {
keychainHelper.useDataProtectionKeychain = usingDataProtectionKeychain
try keychainHelper.setPassword(
password,
forService: name,
accessibility: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
)
}
/// Retrieves the `String` password for the given `String` identifier.
///
/// - Parameter itemName: A `String` identifier for the Keychain item.
/// - Returns: A `String` password if found.
/// - Throws: An instance of `KeychainWrapper.Error`.
func password(forItemName itemName: String) throws -> String {
try passwordFromKeychain(withKeychainItemName: itemName)
}
/// Retrieves the `String` password for the given `String` identifier.
///
/// - Parameters:
/// - itemName: A `String` identifier for the Keychain item.
/// - usingDataProtectionKeychain: A `Bool` indicating whether to use the data protection
/// keychain on macOS 10.15.
/// - Returns: A `String` password if found.
/// - Throws: An instance of `KeychainWrapper.Error`.
@available(macOS 10.15, *)
func password(forItemName itemName: String, usingDataProtectionKeychain: Bool) throws -> String {
try passwordFromKeychain(
withKeychainItemName: itemName,
usingDataProtectionKeychain: usingDataProtectionKeychain
)
}
private func passwordFromKeychain(
withKeychainItemName itemName: String,
usingDataProtectionKeychain: Bool = false
) throws -> String {
keychainHelper.useDataProtectionKeychain = usingDataProtectionKeychain
return try keychainHelper.password(forService: itemName)
}
/// Saves the password `Data` to the keychain with the given identifier.
///
/// - Parameters:
/// - passwordData: The password `Data`.
/// - itemName: The name for the Keychain item.
/// - Throws: An instance of `KeychainWrapper.Error`.
func save(passwordData: Data, forItemName itemName: String) throws {
try savePasswordDataToKeychain(passwordData, forItemName: itemName)
}
/// Saves the password `Data` to the keychain with the given identifier.
///
/// - Parameters:
/// - password: The password `Data`.
/// - itemName: The name for the Keychain item.
/// - usingDataProtectionKeychain: A `Bool` indicating whether to use the data protection
/// keychain on macOS 10.15.
/// - Throws: An instance of `KeychainWrapper.Error`.
@available(macOS 10.15, *)
func save(
passwordData: Data,
forItemName itemName: String,
usingDataProtectionKeychain: Bool
) throws {
try savePasswordDataToKeychain(
passwordData,
forItemName: itemName,
usingDataProtectionKeychain: usingDataProtectionKeychain
)
}
private func savePasswordDataToKeychain(
_ passwordData: Data,
forItemName itemName: String,
usingDataProtectionKeychain: Bool = false
) throws {
keychainHelper.useDataProtectionKeychain = usingDataProtectionKeychain
try keychainHelper.setPassword(
data: passwordData,
forService: itemName,
accessibility: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
)
}
/// Retrieves the password `Data` for the given `String` identifier.
///
/// - Parameter itemName: A `String` identifier for the Keychain item.
/// - Returns: The password `Data` if found.
/// - Throws: An instance of `KeychainWrapper.Error`.
func passwordData(forItemName itemName: String) throws -> Data {
try passwordDataFromKeychain(withItemName: itemName)
}
/// Retrieves the password `Data` for the given `String` identifier.
///
/// - Parameters:
/// - itemName: A `String` identifier for the Keychain item.
/// - usingDataProtectionKeychain: A `Bool` indicating whether to use the data protection
/// keychain on macOS 10.15.
/// - Returns: The password `Data` if found.
/// - Throws: An instance of `KeychainWrapper.Error`.
@available(macOS 10.15, *)
func passwordData(
forItemName itemName: String,
usingDataProtectionKeychain: Bool
) throws -> Data {
try passwordDataFromKeychain(
withItemName: itemName,
usingDataProtectionKeychain: usingDataProtectionKeychain
)
}
private func passwordDataFromKeychain(
withItemName itemName: String,
usingDataProtectionKeychain: Bool = false
) throws -> Data {
keychainHelper.useDataProtectionKeychain = usingDataProtectionKeychain
return try keychainHelper.passwordData(forService: itemName)
}
/// Removes stored password string, such as when the user signs out.
///
/// - Parameter itemName: The Keychain name for the item.
/// - Throws: An instance of `KeychainWrapper.Error`.
func removePasswordFromKeychain(withItemName itemName: String) throws {
try removePasswordFromKeychain(keychainItemName: itemName)
}
/// Removes stored password string, such as when the user signs out. Note that if you choose to
/// start using the data protection keychain on macOS, any items previously created will not be
/// accessible without migration.
///
/// - Parameters:
/// - itemName: The Keychain name for the item.
/// - usingDataProtectionKeychain: A Boolean value that indicates whether to use the data
/// protection keychain on macOS 10.15+.
/// - Throws: An instance of `KeychainWrapper.Error`.
@available(macOS 10.15, *)
func removePasswordFromKeychain(forName name: String, usingDataProtectionKeychain: Bool) throws {
try removePasswordFromKeychain(
keychainItemName: name,
usingDataProtectionKeychain: usingDataProtectionKeychain
)
}
private func removePasswordFromKeychain(
keychainItemName: String,
usingDataProtectionKeychain: Bool = false
) throws {
keychainHelper.useDataProtectionKeychain = usingDataProtectionKeychain
try keychainHelper.removePassword(forService: keychainItemName)
}
}
// MARK: - Keychain helper
/// A protocol defining the helper API for interacting with the Keychain.
protocol KeychainHelper {
var accountName: String { get }
var useDataProtectionKeychain: Bool { get set }
func password(forService service: String) throws -> String
func passwordData(forService service: String) throws -> Data
func removePassword(forService service: String) throws
func setPassword(_ password: String, forService service: String, accessibility: CFTypeRef) throws
func setPassword(data: Data, forService service: String, accessibility: CFTypeRef?) throws
}
/// An internally scoped keychain helper.
private struct KeychainWrapper: KeychainHelper {
let accountName = "OAuth"
var useDataProtectionKeychain = false
@available(macOS 10.15, *)
private var isMaxMacOSVersionGreaterThanTenOneFive: Bool {
let tenOneFive = OperatingSystemVersion(majorVersion: 10, minorVersion: 15, patchVersion: 0)
return ProcessInfo().isOperatingSystemAtLeast(tenOneFive)
}
func keychainQuery(forService service: String) -> [String: Any] {
var query: [String: Any] = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String : accountName,
kSecAttrService as String: service,
]
#if os(macOS) && isMaxMacOSVersionGreaterThanTenOneFive
if #available(macOS 10.15, *), useDataProtectionKeychain {
query[kSecUseDataProtectionKeychain as String] = kCFBooleanTrue
}
#endif
return query
}
func password(forService service: String) throws -> String {
let passwordData = try passwordData(forService: service)
guard let result = String(data: passwordData, encoding: .utf8) else {
throw GTMKeychainError.unexpectedPasswordData(forItemName: service)
}
return result
}
func passwordData(forService service: String) throws -> Data {
guard !service.isEmpty else { throw GTMKeychainError.noService }
var passwordItem: AnyObject?
var keychainQuery = keychainQuery(forService: service)
keychainQuery[kSecReturnData as String] = true
keychainQuery[kSecMatchLimit as String] = kSecMatchLimitOne
let status = SecItemCopyMatching(keychainQuery as CFDictionary, &passwordItem)
guard status != errSecItemNotFound else {
throw GTMKeychainError.passwordNotFound(forItemName: service)
}
guard status == errSecSuccess else { throw GTMKeychainError.unhandled(status: status) }
guard let result = passwordItem as? Data else {
throw GTMKeychainError.unexpectedPasswordData(forItemName: service)
}
return result
}
func removePassword(forService service: String) throws {
guard !service.isEmpty else { throw GTMKeychainError.noService }
let keychainQuery = keychainQuery(forService: service)
let status = SecItemDelete(keychainQuery as CFDictionary)
guard status != errSecItemNotFound else {
throw GTMKeychainError.failedToDeletePasswordBecauseItemNotFound(itemName: service)
}
guard status == noErr else { throw GTMKeychainError.failedToDeletePassword(forItemName: service) }
}
func setPassword(
_ password: String,
forService service: String,
accessibility: CFTypeRef
) throws {
let passwordData = Data(password.utf8)
try setPassword(data: passwordData, forService: service, accessibility: accessibility)
}
func setPassword(data: Data, forService service: String, accessibility: CFTypeRef?) throws {
guard !service.isEmpty else { throw GTMKeychainError.noService }
do {
try removePassword(forService: service)
} catch GTMKeychainError.failedToDeletePasswordBecauseItemNotFound {
// Don't throw; password doesn't exist since the password is being saved for the first time
} catch {
// throw here since this is some other error
throw error
}
guard !data.isEmpty else { return }
var keychainQuery = keychainQuery(forService: service)
keychainQuery[kSecValueData as String] = data
if let accessibility = accessibility {
keychainQuery[kSecAttrAccessible as String] = accessibility
}
let status = SecItemAdd(keychainQuery as CFDictionary, nil)
guard status == noErr else { throw GTMKeychainError.failedToSetPassword(forItemName: service) }
}
}
// MARK: - Keychain Errors
/// Errors that may arise while saving, reading, and removing passwords from the Keychain.
public enum GTMKeychainError: Error, Equatable, CustomNSError {
case unhandled(status: OSStatus)
case passwordNotFound(forItemName: String)
/// Error thrown when there is no name for the item in the keychain.
case noService
case unexpectedPasswordData(forItemName: String)
case failedToDeletePassword(forItemName: String)
case failedToDeletePasswordBecauseItemNotFound(itemName: String)
case failedToSetPassword(forItemName: String)
public static var errorDomain: String {
"GTMAppAuthKeychainErrorDomain"
}
public var errorUserInfo: [String : Any] {
switch self {
case .unhandled(status: let status):
return ["status": status]
case .passwordNotFound(let itemName):
return ["itemName": itemName]
case .noService:
return [:]
case .unexpectedPasswordData(let itemName):
return ["itemName": itemName]
case .failedToDeletePassword(let itemName):
return ["itemName": itemName]
case .failedToDeletePasswordBecauseItemNotFound(itemName: let itemName):
return ["itemName": itemName]
case .failedToSetPassword(forItemName: let itemName):
return ["itemName": itemName]
}
}
}
| apache-2.0 | f1df3cf05785a404be25c4103438ebaa | 35.815013 | 102 | 0.726333 | 4.70113 | false | false | false | false |
BenYeh16/SoundMapiOS | SoundMap/RecordInfoViewController.swift | 1 | 12335 | //
// RecordInfoViewController.swift
// SoundMap
//
// Created by 胡采思 on 12/06/2017.
// Copyright © 2017 cnl4. All rights reserved.
//
import UIKit
import AVFoundation
import CoreLocation
class RecordInfoViewController: UIViewController, UITextViewDelegate, UITextFieldDelegate {
@IBOutlet weak var recordInfoView: UIView!
@IBOutlet weak var closeButton: UIButton!
@IBOutlet weak var saveButton: UIButton!
@IBOutlet weak var soundInfoLabel: UILabel!
@IBOutlet weak var descriptionText: UITextView!
@IBOutlet weak var titleText: UITextField!
@IBOutlet weak var scrollView: UIScrollView!
@IBOutlet weak var audioCurrent: UILabel!
@IBOutlet weak var audioTime: UILabel!
@IBOutlet weak var audioSlider: UISlider!
@IBOutlet weak var playButton: UIButton!
var player:AVAudioPlayer = AVAudioPlayer();
var remotePlayer:AVPlayer = AVPlayer();
var isPaused:BooleanLiteralType = false;
var timer: Timer!
var soundFileURL: URL?
override func viewDidLoad() {
super.viewDidLoad()
// Set design attributes
recordInfoView.layer.cornerRadius = 10
recordInfoView.layer.masksToBounds = true
soundInfoLabel.font = UIFont.boldSystemFont(ofSize: 20.0)
titleText.layer.borderColor = UIColor.init(red: 203/255, green: 203/255, blue: 203/255, alpha: 1).cgColor
descriptionText.layer.borderColor = UIColor.init(red: 204/255, green: 204/255, blue: 204/255, alpha: 1).cgColor
saveButton.layer.borderColor = UIColor.init(red: 7/255, green: 55/255, blue: 99/255, alpha: 1).cgColor
// Keyboard
//NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
//NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
// Text delegate
descriptionText.delegate = self
titleText.delegate = self
// Initialize audio
let documentsDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
soundFileURL = documentsDirectory.appendingPathComponent("recording-123.m4a")
self.isPaused = false;
do {
//let audioPath = Bundle.main.path(forResource: "audiofile", ofType: "mp3")
//try player = AVAudioPlayer(contentsOf: NSURL(fileURLWithPath: audioPath!) as URL)
try player = AVAudioPlayer(contentsOf: soundFileURL!)
player.volume = 1.0
audioSlider.maximumValue = Float(player.duration)
audioSlider.value = 0.0
audioTime.text = stringFromTimeInterval(interval: player.duration)
audioCurrent.text = stringFromTimeInterval(interval: player.currentTime)
//try player = AVAudioPlayer(contentsOf: url)
//let playerItem = AVPlayerItem(url: self.url)
//try self.remotePlayer = AVPlayer(playerItem: playerItem)
//self.remotePlayer.volume = 1.0
} catch {
}
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
/****** TextView related ******/
/*func keyboardWillShow(notification: NSNotification) {
/*let keyboardSize: CGSize = ((notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue.size)!
let offset: CGSize = ((notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue.size)!
if keyboardSize.height == offset.height {
UIView.animate(withDuration: 0.1, animations: { () -> Void in
self.view.frame.origin.y -= keyboardSize.height
})
} else {
UIView.animate(withDuration: 0.1, animations: { () -> Void in
self.view.frame.origin.y += keyboardSize.height - offset.height
})
}*/
if let keyboardFrame = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue) {
let rect = keyboardFrame.cgRectValue
UIView.animate(withDuration: 0.25, delay: 0, options: .curveEaseInOut, animations: {
self.descriptionText.contentInset = UIEdgeInsetsMake(0, 0, rect.size.height, 0)
}, completion: nil)
}
}
func keyboardWillHide(notification: NSNotification) {
/*if let keyboardFrame = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue) {
let rect = keyboardFrame.cgRectValue
self.view.frame.origin.y += rect.size.height
}*/
UIView.animate(withDuration: 0.25, delay: 0, options: .curveEaseInOut, animations: {
self.descriptionText.contentInset = UIEdgeInsets.zero
}, completion: nil)
}*/
func textViewDidBeginEditing(_ textView: UITextView) {
animateViewMoving(up: true, moveValue: 50)
}
func textViewDidEndEditing(_ textView: UITextView) {
animateViewMoving(up: true, moveValue: -50)
}
func animateViewMoving (up: Bool, moveValue: CGFloat){
let movementDuration:TimeInterval = 0.3
let movement:CGFloat = ( up ? -moveValue : moveValue)
UIView.beginAnimations( "animateView", context: nil)
UIView.setAnimationBeginsFromCurrentState(true)
UIView.setAnimationDuration(movementDuration )
self.view.frame = self.view.frame.offsetBy(dx: 0, dy: movement)
UIView.commitAnimations()
}
// Allow RETURN to hide keyboard for textField
func textFieldShouldReturn(_ textField: UITextField) -> Bool {
textField.resignFirstResponder()
return true
}
// Allow RETURN to hide keyboard for textView
func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
if (text == "\n")
{
textView.resignFirstResponder()
return false
}
return true
}
/****** Button action ******/
@IBAction func saveSound(_ sender: Any) {
let data = SharedData()
//let documentsDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
//let soundFileURL: URL = documentsDirectory.appendingPathComponent("recording-123.m4a")
//self.parentView.pinFromOutside()
print("soundfile url: '\(soundFileURL)'")
print("title: " + titleText.text!)
print ("descripText: " + descriptionText.text)
if ( titleText.text != "" && descriptionText.text != ""){
print("ready to upload")
NotificationCenter.default.post(name: NSNotification.Name(rawValue: "stopSoundNotification"), object: nil)
let locationManager = CLLocationManager()
var currentLocation = locationManager.location!
/*upload with
user id
titleText.text
descriptionText.text
\(currentLocation.coordinate.latitude)
\(currentLocation.coordinate.longitude)
\(soundFileURL)
*/
var storeUrl = data.storeSound(latitude: "25.033331",
longitude: "121.534831",
id: data.getUserId(),
title: titleText.text!,
descript: descriptionText.text
)
print("!@#!@#!# storeUrl" + storeUrl)
var request = URLRequest(url: URL(string: storeUrl)!) // link removed
//var request = URLRequest(url : URL(string: "http://140.112.90.203:4000/setUserVoice/1")!)
request.httpMethod = "POST"
/* create body*/
let body = NSMutableData()
//let file = "\(soundFileURL)" // :String
let bundlefile = Bundle.main.path(forResource: "audiofile", ofType: "mp3")
print("!!!!!! " + bundlefile!)
let url = URL(string: bundlefile!) // :URL
let data = try! Data(contentsOf: url!)
body.append(data)
request.httpBody = body as Data
/* body create complete*/
let atask = URLSession.shared.dataTask(with: request) { data, response, error in
if error != nil{
print("error in dataTask")
return
}
do {
let json = try JSONSerialization.jsonObject(with: data!, options: .mutableContainers) as? NSDictionary
if let parseJSON = json {
let resultValue:String = parseJSON["success"] as! String;
print("result: \(resultValue)")
print(parseJSON)
}
} catch let error as NSError {
print(error)
}
}
atask.resume()
// Close modal
dismiss(animated: true, completion: nil)
}else {
let alertController = UIAlertController(
title: "Don't leave Blank",
message: "Title or description missing",
preferredStyle: .alert)
// 建立[確認]按鈕
let okAction = UIAlertAction(
title: "確認",
style: .default,
handler: {
(action: UIAlertAction!) -> Void in
print("按下確認後，閉包裡的動作")
})
alertController.addAction(okAction)
// 顯示提示框
self.present(
alertController,
animated: true,
completion: nil)
}
//
}
@IBAction func closePopup(_ sender: Any) {
dismiss(animated: true, completion: nil)
}
/****** Audio ******/
@IBAction func playAudioPressed(_ sender: Any) {
if ( self.isPaused == false ) {
player.play()
playButton.setImage(UIImage(named: "music-pause"), for: .normal)
self.isPaused = true
//audioSlider.value = Float(player.currentTime)
timer = Timer(timeInterval: 1.0, target: self, selector: #selector(self.updateSlider), userInfo: nil, repeats: true)
RunLoop.main.add(timer, forMode: .commonModes)
} else {
player.pause()
playButton.setImage(UIImage(named: "music-play"), for: .normal)
self.isPaused = false
timer.invalidate()
}
}
@IBAction func slide(_ sender: Any) {
player.currentTime = TimeInterval(audioSlider.value)
}
func stringFromTimeInterval(interval: TimeInterval) -> String {
let interval = Int(interval)
let seconds = interval % 60
let minutes = (interval / 60) % 60
return String(format: "%02d:%02d", minutes, seconds)
}
func updateSlider(_ timer: Timer) {
audioSlider.value = Float(player.currentTime)
audioCurrent.text = stringFromTimeInterval(interval: player.currentTime)
audioTime.text = stringFromTimeInterval(interval: player.duration - player.currentTime)
if audioTime.text == "00:00" { // done
playButton.setImage(UIImage(named: "music-play"), for: .normal)
}
}
func stringFromFloatCMTime(time: Double) -> String {
let intTime = Int(time)
let seconds = intTime % 60
let minutes = ( intTime / 60 ) % 60
return String(format: "%02d:%02d", minutes, seconds)
}
/*
// MARK: - Navigation
// In a storyboard-based application, you will often want to do a little preparation before navigation
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
// Get the new view controller using segue.destinationViewController.
// Pass the selected object to the new view controller.
}
*/
}
| gpl-3.0 | 53c54b4bf80f23dbb48a23e2ec663c2d | 37.249221 | 152 | 0.588207 | 5.0423 | false | false | false | false |
wordpress-mobile/WordPress-iOS | WordPress/WordPressTest/MediaHostTests.swift | 2 | 4086 | import XCTest
@testable import WordPress
class MediaHostTests: XCTestCase {
func testInitializationWithPublicSite() {
let host = MediaHost(
isAccessibleThroughWPCom: false,
isPrivate: false,
isAtomic: false,
siteID: nil,
username: nil,
authToken: nil) { error in
XCTFail("This should not be called.")
}
XCTAssertEqual(host, .publicSite)
}
func testInitializationWithPublicWPComSite() {
let host = MediaHost(
isAccessibleThroughWPCom: true,
isPrivate: false,
isAtomic: false,
siteID: nil,
username: nil,
authToken: nil) { error in
XCTFail("This should not be called.")
}
XCTAssertEqual(host, .publicWPComSite)
}
func testInitializationWithPrivateSelfHostedSite() {
let host = MediaHost(
isAccessibleThroughWPCom: false,
isPrivate: true,
isAtomic: false,
siteID: nil,
username: nil,
authToken: nil) { error in
XCTFail("This should not be called.")
}
XCTAssertEqual(host, .privateSelfHostedSite)
}
func testInitializationWithPrivateWPComSite() {
let authToken = "letMeIn!"
let host = MediaHost(
isAccessibleThroughWPCom: true,
isPrivate: true,
isAtomic: false,
siteID: nil,
username: nil,
authToken: authToken) { error in
XCTFail("This should not be called.")
}
XCTAssertEqual(host, .privateWPComSite(authToken: authToken))
}
func testInitializationWithPrivateAtomicWPComSite() {
let siteID = 16557
let username = "demouser"
let authToken = "letMeIn!"
let host = MediaHost(
isAccessibleThroughWPCom: true,
isPrivate: true,
isAtomic: true,
siteID: siteID,
username: username,
authToken: authToken) { error in
XCTFail("This should not be called.")
}
XCTAssertEqual(host, .privateAtomicWPComSite(siteID: siteID, username: username, authToken: authToken))
}
func testInitializationWithPrivateAtomicWPComSiteWithoutAuthTokenFails() {
let siteID = 16557
let username = "demouser"
let expectation = self.expectation(description: "We're expecting an error to be triggered.")
let _ = MediaHost(
isAccessibleThroughWPCom: true,
isPrivate: true,
isAtomic: true,
siteID: siteID,
username: username,
authToken: nil) { error in
if error == .wpComPrivateSiteWithoutAuthToken {
expectation.fulfill()
}
}
waitForExpectations(timeout: 0.05)
}
func testInitializationWithPrivateAtomicWPComSiteWithoutUsernameFails() {
let siteID = 16557
let authToken = "letMeIn!"
let expectation = self.expectation(description: "We're expecting an error to be triggered.")
let _ = MediaHost(
isAccessibleThroughWPCom: true,
isPrivate: true,
isAtomic: true,
siteID: siteID,
username: nil,
authToken: authToken) { error in
if error == .wpComPrivateSiteWithoutUsername {
expectation.fulfill()
}
}
waitForExpectations(timeout: 0.05)
}
func testInitializationWithPrivateAtomicWPComSiteWithoutSiteIDFails() {
let expectation = self.expectation(description: "The error closure will be called")
let _ = MediaHost(
isAccessibleThroughWPCom: true,
isPrivate: true,
isAtomic: true,
siteID: nil,
username: nil,
authToken: nil) { error in
expectation.fulfill()
}
waitForExpectations(timeout: 0.05)
}
}
| gpl-2.0 | eb4adc154ea8a7f159e56fc18c99fc04 | 28.608696 | 111 | 0.568771 | 5.27907 | false | true | false | false |
fawadsuhail/weather-app | WeatherAppTests/RealmDataProviderTests.swift | 1 | 1677 | //
// RealmDataProviderTests.swift
// WeatherApp
//
// Created by Fawad Suhail on 4/3/17.
// Copyright © 2017 Fawad Suhail. All rights reserved.
//
import XCTest
@testable import WeatherApp
@testable import RealmSwift
class RealmDataProviderTests: XCTestCase {
override func setUp() {
super.setUp()
// Put setup code here. This method is called before the invocation of each test method in the class.
// setup in memory Identifier
RealmDataProvider.shared.setupWithMemoryIdentifier(identifier: "testRealm1")
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class
super.tearDown()
}
func testInsertion() {
let city = City(name: "singapore")
RealmDataProvider.shared.addCity(city: city)
let cities: [City] = RealmDataProvider.shared.getCities()
XCTAssert(cities.count == 1, "")
}
func testDuplicates() {
// all the following insertions should result in only
// one result in the database "singapore"
let city1 = City(name: "Singapore")
let city2 = City(name: " singapore")
let city3 = City(name: "SiNgApOrE")
// insert 1
RealmDataProvider.shared.addCity(city: city1)
// insert 2
RealmDataProvider.shared.addCity(city: city2)
// insert 3
RealmDataProvider.shared.addCity(city: city3)
guard let realm = try? Realm() else {
XCTFail("Failed to initialize realm")
return
}
let cities = realm.objects(CityRealmObject.self).filter("name = 'singapore'")
XCTAssert(cities.count == 1, "Cities are not one")
}
}
| mit | e955e11865d35ef83a70c2b29bad1e1c | 24.014925 | 106 | 0.667064 | 4.067961 | false | true | false | false |
avito-tech/Paparazzo | Paparazzo/Core/VIPER/InfoMessage/InfoMessageAnimator.swift | 1 | 5198 | import UIKit
public enum InfoMessageViewDismissType {
case interactive
case timeout
case force
}
struct InfoMessageAnimatorData {
let animation: InfoMessageAnimatorBehavior
let timeout: TimeInterval
let onDismiss: ((InfoMessageViewDismissType) -> ())?
init(
animation: InfoMessageAnimatorBehavior,
timeout: TimeInterval = 0.0,
onDismiss: ((InfoMessageViewDismissType) -> ())?)
{
self.animation = animation
self.timeout = timeout
self.onDismiss = onDismiss
}
}
private enum AnimatorState {
case initial
case appearing
case appeared
case dismissingByTimer
case dismissingByDismissFunction
case dismissed
}
final class InfoMessageAnimator: InfoMessageViewInput {
private weak var container: UIView?
private weak var messageView: InfoMessageView?
private var dismissingByTimerDebouncer: Debouncer
// Constant settings
private let behavior: InfoMessageAnimatorBehavior
private let onDismiss: ((InfoMessageViewDismissType) -> ())?
// Updatable settings
private var timeout: TimeInterval
// Other state
private var state = AnimatorState.initial
init(_ data: InfoMessageAnimatorData)
{
behavior = data.animation
onDismiss = data.onDismiss
timeout = data.timeout
dismissingByTimerDebouncer = Debouncer(delay: timeout)
}
// MARK: - Interface
func appear(messageView: InfoMessageView, in container: UIView) {
self.container = container
self.messageView = messageView
messageView.size = messageView.sizeThatFits(container.size)
behavior.configure(messageView: messageView, in: container)
container.addSubview(messageView)
container.bringSubviewToFront(messageView)
changeState(to: .appearing)
}
func dismiss() {
changeState(to: .dismissingByDismissFunction)
}
func update(timeout: TimeInterval) {
self.timeout = timeout
dismissingByTimerDebouncer.cancel()
dismissingByTimerDebouncer = Debouncer(delay: timeout)
switch state {
case .initial, .appearing:
// dismissing is not scheduled
break
case .appeared:
scheduleDismissing()
case .dismissingByTimer, .dismissingByDismissFunction, .dismissed:
// scheduling is not needed
break
}
}
// MARK: - States
private func changeState(to newState: AnimatorState) {
guard allowedTransitions().contains(newState) else { return }
state = newState
switch newState {
case .initial:
break
case .appearing:
animateAppearing()
case .appeared:
scheduleDismissing()
case .dismissingByTimer:
animateDismissing(dismissType: .timeout)
case .dismissingByDismissFunction:
animateDismissing(dismissType: .force)
case .dismissed:
messageView?.removeFromSuperview()
}
}
private func allowedTransitions() -> [AnimatorState] {
switch state {
case .initial:
return [.appearing, .dismissingByDismissFunction]
case .appearing:
return [.appeared, .dismissingByDismissFunction]
case .appeared:
return [.dismissingByTimer, .dismissingByDismissFunction]
case .dismissingByTimer, .dismissingByDismissFunction:
return [.dismissed]
case .dismissed:
return []
}
}
private func scheduleDismissing() {
if timeout.isZero {
dismissingByTimerDebouncer.cancel()
} else {
dismissingByTimerDebouncer.debounce { [weak self] in
self?.changeState(to: .dismissingByTimer)
}
}
}
// MARK: - Animations
private func animateAppearing() {
guard
let messageView = self.messageView,
let container = self.container
else { return }
UIView.animate(
withDuration: 0.5,
delay: 0,
usingSpringWithDamping: 0.75,
initialSpringVelocity: 0.1,
options: .curveEaseIn,
animations: {
self.behavior.present(messageView: messageView, in: container)
},
completion: {_ in
self.changeState(to: .appeared)
}
)
}
private func animateDismissing(dismissType: InfoMessageViewDismissType) {
guard
let messageView = self.messageView,
let container = self.container
else { return }
UIView.animate(
withDuration: 0.3,
delay: 0,
options: .curveEaseOut,
animations: {
self.behavior.dismiss(messageView: messageView, in: container)
},
completion: {_ in
self.changeState(to: .dismissed)
self.onDismiss?(dismissType)
}
)
}
}
| mit | bcac1fe824244e9c0880b04afd141290 | 27.404372 | 78 | 0.595806 | 5.375388 | false | false | false | false |
khizkhiz/swift | test/SILGen/generic_closures.swift | 2 | 6087 | // RUN: %target-swift-frontend -parse-stdlib -emit-silgen %s | FileCheck %s
import Swift
var zero: Int
// CHECK-LABEL: sil hidden @_TF16generic_closures28generic_nondependent_context{{.*}}
func generic_nondependent_context<T>(x: T, y: Int) -> Int {
func foo() -> Int { return y }
// CHECK: [[FOO:%.*]] = function_ref @_TFF16generic_closures28generic_nondependent_context{{.*}} : $@convention(thin) (Int) -> Int
// CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]
return foo()
}
// CHECK-LABEL: sil hidden @_TF16generic_closures15generic_capture{{.*}}
func generic_capture<T>(x: T) -> Any.Type {
func foo() -> Any.Type { return T.self }
// CHECK: [[FOO:%.*]] = function_ref @_TFF16generic_closures15generic_capture{{.*}} : $@convention(thin) <τ_0_0> () -> @thick protocol<>.Type
// CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]
return foo()
}
// CHECK-LABEL: sil hidden @_TF16generic_closures20generic_capture_cast{{.*}}
func generic_capture_cast<T>(x: T, y: Any) -> Bool {
func foo(a: Any) -> Bool { return a is T }
// CHECK: [[FOO:%.*]] = function_ref @_TFF16generic_closures20generic_capture_cast{{.*}} : $@convention(thin) <τ_0_0> (@in protocol<>) -> Bool
// CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]
return foo(y)
}
protocol Concept {
var sensical: Bool { get }
}
// CHECK-LABEL: sil hidden @_TF16generic_closures29generic_nocapture_existential{{.*}}
func generic_nocapture_existential<T>(x: T, y: Concept) -> Bool {
func foo(a: Concept) -> Bool { return a.sensical }
// CHECK: [[FOO:%.*]] = function_ref @_TFF16generic_closures29generic_nocapture_existential{{.*}} : $@convention(thin) (@in Concept) -> Bool
// CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]
return foo(y)
}
// CHECK-LABEL: sil hidden @_TF16generic_closures25generic_dependent_context{{.*}}
func generic_dependent_context<T>(x: T, y: Int) -> T {
func foo() -> T { return x }
// CHECK: [[FOO:%.*]] = function_ref @_TFF16generic_closures25generic_dependent_context{{.*}} : $@convention(thin) <τ_0_0> (@owned @box τ_0_0) -> @out τ_0_0
// CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]<T>
return foo()
}
enum Optionable<Wrapped> {
case none
case some(Wrapped)
}
class NestedGeneric<U> {
class func generic_nondependent_context<T>(x: T, y: Int, z: U) -> Int {
func foo() -> Int { return y }
return foo()
}
class func generic_dependent_inner_context<T>(x: T, y: Int, z: U) -> T {
func foo() -> T { return x }
return foo()
}
class func generic_dependent_outer_context<T>(x: T, y: Int, z: U) -> U {
func foo() -> U { return z }
return foo()
}
class func generic_dependent_both_contexts<T>(x: T, y: Int, z: U) -> (T, U) {
func foo() -> (T, U) { return (x, z) }
return foo()
}
// CHECK-LABEL: sil hidden @_TFC16generic_closures13NestedGeneric20nested_reabstraction{{.*}}
// CHECK: [[REABSTRACT:%.*]] = function_ref @_TTRG__rXFo___XFo_iT__iT__
// CHECK: partial_apply [[REABSTRACT]]<U, T>
func nested_reabstraction<T>(x: T) -> Optionable<() -> ()> {
return .some({})
}
}
// <rdar://problem/15417773>
// Ensure that nested closures capture the generic parameters of their nested
// context.
// CHECK: sil hidden @_TF16generic_closures25nested_closure_in_generic{{.*}} : $@convention(thin) <T> (@in T) -> @out T
// CHECK: function_ref [[OUTER_CLOSURE:@_TFF16generic_closures25nested_closure_in_genericurFxxU_FT_Q_]]
// CHECK: sil shared [[OUTER_CLOSURE]] : $@convention(thin) <T> (@inout_aliasable T) -> @out T
// CHECK: function_ref [[INNER_CLOSURE:@_TFFF16generic_closures25nested_closure_in_genericurFxxU_FT_Q_U_FT_Q_]]
// CHECK: sil shared [[INNER_CLOSURE]] : $@convention(thin) <T> (@inout_aliasable T) -> @out T {
func nested_closure_in_generic<T>(x:T) -> T {
return { { x }() }()
}
// CHECK-LABEL: sil hidden @_TF16generic_closures16local_properties
func local_properties<T>(t: inout T) {
// CHECK: [[TBOX:%[0-9]+]] = alloc_box $T
var prop: T {
get {
return t
}
set {
t = newValue
}
}
// CHECK: [[GETTER_REF:%[0-9]+]] = function_ref [[GETTER_CLOSURE:@_TFF16generic_closures16local_properties.*]] : $@convention(thin) <τ_0_0> (@owned @box τ_0_0) -> @out τ_0_0
// CHECK: apply [[GETTER_REF]]
t = prop
// CHECK: [[SETTER_REF:%[0-9]+]] = function_ref [[SETTER_CLOSURE:@_TFF16generic_closures16local_properties.*]] : $@convention(thin) <τ_0_0> (@in τ_0_0, @owned @box τ_0_0) -> ()
// CHECK: apply [[SETTER_REF]]
prop = t
var prop2: T {
get {
return t
}
set {
// doesn't capture anything
}
}
// CHECK: [[GETTER2_REF:%[0-9]+]] = function_ref [[GETTER2_CLOSURE:@_TFF16generic_closures16local_properties.*]] : $@convention(thin) <τ_0_0> (@owned @box τ_0_0) -> @out τ_0_0
// CHECK: apply [[GETTER2_REF]]
t = prop2
// CHECK: [[SETTER2_REF:%[0-9]+]] = function_ref [[SETTER2_CLOSURE:@_TFF16generic_closures16local_properties.*]] : $@convention(thin) <τ_0_0> (@in τ_0_0) -> ()
// CHECK: apply [[SETTER2_REF]]
prop2 = t
}
protocol Fooable {
static func foo() -> Bool
}
// <rdar://problem/16399018>
func shmassert(@autoclosure f: () -> Bool) {}
// CHECK-LABEL: sil hidden @_TF16generic_closures21capture_generic_param
func capture_generic_param<A: Fooable>(x: A) {
shmassert(A.foo())
}
// Make sure we use the correct convention when capturing class-constrained
// member types: <rdar://problem/24470533>
class Class {}
protocol HasClassAssoc { associatedtype Assoc : Class }
// CHECK-LABEL: sil hidden @_TF16generic_closures34captures_class_constrained_genericuRxS_13HasClassAssocrFTx1fFwx5AssocwxS1__T_
// CHECK: bb0(%0 : $*T, %1 : $@callee_owned (@owned T.Assoc) -> @owned T.Assoc):
// CHECK: [[GENERIC_FN:%.*]] = function_ref @_TFF16generic_closures34captures_class_constrained_genericuRxS_13HasClassAssocrFTx1fFwx5AssocwxS1__T_U_FT_FQQ_5AssocS2_
// CHECK: [[CONCRETE_FN:%.*]] = partial_apply [[GENERIC_FN]]<T, T.Assoc>(%1)
func captures_class_constrained_generic<T : HasClassAssoc>(x: T, f: T.Assoc -> T.Assoc) {
let _: () -> T.Assoc -> T.Assoc = { f }
}
| apache-2.0 | ab2ee994e8c26abe4b44d40f31d3538c | 36.708075 | 178 | 0.629715 | 3.11813 | false | false | false | false |
slavapestov/swift | test/decl/subscript/subscripting.swift | 1 | 7538 | // RUN: %target-parse-verify-swift
struct X { }
// Simple examples
struct X1 {
var stored : Int
subscript (i : Int) -> Int {
get {
return stored
}
mutating
set {
stored = newValue
}
}
}
struct X2 {
var stored : Int
subscript (i : Int) -> Int {
get {
return stored + i
}
set(v) {
stored = v - i
}
}
}
struct X3 {
var stored : Int
subscript (_ : Int) -> Int {
get {
return stored
}
set(v) {
stored = v
}
}
}
struct X4 {
var stored : Int
subscript (i : Int, j : Int) -> Int {
get {
return stored + i + j
}
set(v) {
stored = v + i - j
}
}
}
// Semantic errors
struct Y1 {
var x : X
subscript(i: Int) -> Int {
get {
return x // expected-error{{cannot convert return expression of type 'X' to return type 'Int'}}
}
set {
x = newValue // expected-error{{cannot assign value of type 'Int' to type 'X'}}
}
}
}
struct Y2 {
subscript(idx: Int) -> TypoType { // expected-error 3{{use of undeclared type 'TypoType'}}
get { repeat {} while true }
set {}
}
}
class Y3 {
subscript(idx: Int) -> TypoType { // expected-error 3{{use of undeclared type 'TypoType'}}
get { repeat {} while true }
set {}
}
}
protocol ProtocolGetSet0 {
subscript(i: Int) -> Int {} // expected-error {{subscript declarations must have a getter}}
}
protocol ProtocolGetSet1 {
subscript(i: Int) -> Int { get }
}
protocol ProtocolGetSet2 {
subscript(i: Int) -> Int { set } // expected-error {{subscript declarations must have a getter}}
}
protocol ProtocolGetSet3 {
subscript(i: Int) -> Int { get set }
}
protocol ProtocolGetSet4 {
subscript(i: Int) -> Int { set get }
}
protocol ProtocolWillSetDidSet1 {
subscript(i: Int) -> Int { willSet } // expected-error {{expected get or set in a protocol property}}
}
protocol ProtocolWillSetDidSet2 {
subscript(i: Int) -> Int { didSet } // expected-error {{expected get or set in a protocol property}}
}
protocol ProtocolWillSetDidSet3 {
subscript(i: Int) -> Int { willSet didSet } // expected-error {{expected get or set in a protocol property}}
}
protocol ProtocolWillSetDidSet4 {
subscript(i: Int) -> Int { didSet willSet } // expected-error {{expected get or set in a protocol property}}
}
class DidSetInSubscript {
subscript(_: Int) -> Int {
didSet { // expected-error {{didSet is not allowed in subscripts}}
print("eek")
}
get {}
}
}
class WillSetInSubscript {
subscript(_: Int) -> Int {
willSet { // expected-error {{willSet is not allowed in subscripts}}
print("eek")
}
get {}
}
}
subscript(i: Int) -> Int { // expected-error{{'subscript' functions may only be declared within a type}}
get {}
}
func f() {
subscript (i: Int) -> Int { // expected-error{{'subscript' functions may only be declared within a type}}
get {}
}
}
struct NoSubscript { }
struct OverloadedSubscript {
subscript(i: Int) -> Int {
get {
return i
}
set {}
}
subscript(i: Int, j: Int) -> Int {
get { return i }
set {}
}
}
struct RetOverloadedSubscript {
subscript(i: Int) -> Int { // expected-note {{found this candidate}}
get { return i }
set {}
}
subscript(i: Int) -> Float { // expected-note {{found this candidate}}
get { return Float(i) }
set {}
}
}
struct MissingGetterSubscript1 {
subscript (i : Int) -> Int {
} // expected-error {{computed property must have accessors specified}}
}
struct MissingGetterSubscript2 {
subscript (i : Int, j : Int) -> Int { // expected-error{{subscript declarations must have a getter}}
set {}
}
}
func test_subscript(inout x2: X2, i: Int, j: Int, inout value: Int, no: NoSubscript,
inout ovl: OverloadedSubscript, inout ret: RetOverloadedSubscript) {
no[i] = value // expected-error{{type 'NoSubscript' has no subscript members}}
value = x2[i]
x2[i] = value
value = ovl[i]
ovl[i] = value
value = ovl[(i, j)]
ovl[(i, j)] = value
value = ovl[(i, j, i)] // expected-error{{cannot subscript a value of type 'OverloadedSubscript' with an index of type '(Int, Int, Int)'}}
// expected-note @-1 {{expected an argument list of type '(Int)'}}
ret[i] // expected-error{{ambiguous use of 'subscript'}}
value = ret[i]
ret[i] = value
}
func subscript_rvalue_materialize(inout i: Int) {
i = X1(stored: 0)[i]
}
func subscript_coerce(fn: ([UnicodeScalar], [UnicodeScalar]) -> Bool) {}
func test_subscript_coerce() {
subscript_coerce({ $0[$0.count-1] < $1[$1.count-1] })
}
struct no_index {
subscript () -> Int { return 42 }
func test() -> Int {
return self[]
}
}
struct tuple_index {
subscript (x : Int, y : Int) -> (Int, Int) { return (x, y) }
func test() -> (Int, Int) {
return self[123, 456]
}
}
struct SubscriptTest1 {
subscript(keyword:String) -> Bool { return true } // expected-note 2 {{found this candidate}}
subscript(keyword:String) -> String? {return nil } // expected-note 2 {{found this candidate}}
}
func testSubscript1(s1 : SubscriptTest1) {
let _ : Int = s1["hello"] // expected-error {{ambiguous subscript with base type 'SubscriptTest1' and index type 'String'}}
if s1["hello"] {}
let _ = s1["hello"] // expected-error {{ambiguous use of 'subscript'}}
}
struct SubscriptTest2 {
subscript(a : String, b : Int) -> Int { return 0 }
subscript(a : String, b : String) -> Int { return 0 }
}
func testSubscript1(s2 : SubscriptTest2) {
_ = s2["foo"] // expected-error {{cannot subscript a value of type 'SubscriptTest2' with an index of type 'String'}}
// expected-note @-1 {{overloads for 'subscript' exist with these partially matching parameter lists: (String, Int), (String, String)}}
let a = s2["foo", 1.0] // expected-error {{cannot subscript a value of type 'SubscriptTest2' with an index of type '(String, Double)'}}
// expected-note @-1 {{overloads for 'subscript' exist with these partially matching parameter lists: (String, Int), (String, String)}}
let b = s2[1, "foo"] // expected-error {{cannot subscript a value of type 'SubscriptTest2' with an index of type '(Int, String)'}}
// expected-note @-1 {{expected an argument list of type '(String, String)'}}
}
// sr-114 & rdar://22007370
class Foo {
subscript(key: String) -> String { // expected-note {{'subscript' previously declared here}}
get { a } // expected-error {{use of unresolved identifier 'a'}}
set { b } // expected-error {{use of unresolved identifier 'b'}}
}
subscript(key: String) -> String { // expected-error {{invalid redeclaration of 'subscript'}}
get { a } // expected-error {{use of unresolved identifier 'a'}}
set { b } // expected-error {{use of unresolved identifier 'b'}}
}
}
// <rdar://problem/23952125> QoI: Subscript in protocol with missing {}, better diagnostic please
protocol r23952125 {
associatedtype ItemType
var count: Int { get }
subscript(index: Int) -> ItemType // expected-error {{subscript in protocol must have explicit { get } or { get set } specifier}} {{36-36= { get set \}}}
var c : Int // expected-error {{property in protocol must have explicit { get } or { get set } specifier}}
}
// <rdar://problem/16812341> QoI: Poor error message when providing a default value for a subscript parameter
struct S4 {
subscript(subs: Int = 0) -> Int { // expected-error {{default arguments are not allowed in subscripts}}
get {
return 1
}
}
}
| apache-2.0 | fca854ff819a3625b9ccf6de801efe38 | 24.90378 | 156 | 0.625232 | 3.591234 | false | false | false | false |
CrazyZhangSanFeng/BanTang | BanTang/BanTang/Classes/Home/Model/BTHomeTopic.swift | 1 | 768 | //
// BTHomeTopic.swift
// BanTang
//
// Created by 张灿 on 16/6/6.
// Copyright © 2016年 张灿. All rights reserved.
//
import UIKit
import MJExtension
class BTHomeTopic: NSObject {
/** id */
var ID: String = ""
/** 标题 */
var title: String = ""
/** 类型 */
var type: String = ""
/** 图片 */
var pic: String = ""
/** 是否显示喜欢 */
var is_show_like: Bool = false
/** 是否喜欢 */
var islike:Bool = false
/** 喜欢的人数 */
var likes: String = ""
/** 用户模型 */
var user : BTTopicUserItem?
override static func mj_replacedKeyFromPropertyName() -> [NSObject : AnyObject]! {
return ["ID": "id"]
}
}
| apache-2.0 | ef0af67955d7d6531c08ef2b02bd668f | 15.068182 | 86 | 0.497878 | 3.570707 | false | false | false | false |
themonki/onebusaway-iphone | Carthage/Checkouts/swift-protobuf/Sources/SwiftProtobuf/TextFormatScanner.swift | 1 | 35871 | // Sources/SwiftProtobuf/TextFormatScanner.swift - Text format decoding
//
// Copyright (c) 2014 - 2016 Apple Inc. and the project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See LICENSE.txt for license information:
// https://github.com/apple/swift-protobuf/blob/master/LICENSE.txt
//
// -----------------------------------------------------------------------------
///
/// Test format decoding engine.
///
// -----------------------------------------------------------------------------
import Foundation
private let asciiBell = UInt8(7)
private let asciiBackspace = UInt8(8)
private let asciiTab = UInt8(9)
private let asciiNewLine = UInt8(10)
private let asciiVerticalTab = UInt8(11)
private let asciiFormFeed = UInt8(12)
private let asciiCarriageReturn = UInt8(13)
private let asciiZero = UInt8(ascii: "0")
private let asciiOne = UInt8(ascii: "1")
private let asciiThree = UInt8(ascii: "3")
private let asciiSeven = UInt8(ascii: "7")
private let asciiNine = UInt8(ascii: "9")
private let asciiColon = UInt8(ascii: ":")
private let asciiPeriod = UInt8(ascii: ".")
private let asciiPlus = UInt8(ascii: "+")
private let asciiComma = UInt8(ascii: ",")
private let asciiSemicolon = UInt8(ascii: ";")
private let asciiDoubleQuote = UInt8(ascii: "\"")
private let asciiSingleQuote = UInt8(ascii: "\'")
private let asciiBackslash = UInt8(ascii: "\\")
private let asciiForwardSlash = UInt8(ascii: "/")
private let asciiHash = UInt8(ascii: "#")
private let asciiUnderscore = UInt8(ascii: "_")
private let asciiQuestionMark = UInt8(ascii: "?")
private let asciiSpace = UInt8(ascii: " ")
private let asciiOpenSquareBracket = UInt8(ascii: "[")
private let asciiCloseSquareBracket = UInt8(ascii: "]")
private let asciiOpenCurlyBracket = UInt8(ascii: "{")
private let asciiCloseCurlyBracket = UInt8(ascii: "}")
private let asciiOpenAngleBracket = UInt8(ascii: "<")
private let asciiCloseAngleBracket = UInt8(ascii: ">")
private let asciiMinus = UInt8(ascii: "-")
private let asciiLowerA = UInt8(ascii: "a")
private let asciiUpperA = UInt8(ascii: "A")
private let asciiLowerB = UInt8(ascii: "b")
private let asciiLowerE = UInt8(ascii: "e")
private let asciiUpperE = UInt8(ascii: "E")
private let asciiLowerF = UInt8(ascii: "f")
private let asciiUpperF = UInt8(ascii: "F")
private let asciiLowerI = UInt8(ascii: "i")
private let asciiLowerL = UInt8(ascii: "l")
private let asciiLowerN = UInt8(ascii: "n")
private let asciiLowerR = UInt8(ascii: "r")
private let asciiLowerS = UInt8(ascii: "s")
private let asciiLowerT = UInt8(ascii: "t")
private let asciiUpperT = UInt8(ascii: "T")
private let asciiLowerU = UInt8(ascii: "u")
private let asciiLowerV = UInt8(ascii: "v")
private let asciiLowerX = UInt8(ascii: "x")
private let asciiLowerY = UInt8(ascii: "y")
private let asciiLowerZ = UInt8(ascii: "z")
private let asciiUpperZ = UInt8(ascii: "Z")
private func fromHexDigit(_ c: UInt8) -> UInt8? {
if c >= asciiZero && c <= asciiNine {
return c - asciiZero
}
if c >= asciiUpperA && c <= asciiUpperF {
return c - asciiUpperA + UInt8(10)
}
if c >= asciiLowerA && c <= asciiLowerF {
return c - asciiLowerA + UInt8(10)
}
return nil
}
// Protobuf Text encoding assumes that you're working directly
// in UTF-8. So this implementation converts the string to UTF8,
// then decodes it into a sequence of bytes, then converts
// it back into a string.
private func decodeString(_ s: String) -> String? {
var out = [UInt8]()
var bytes = s.utf8.makeIterator()
while let byte = bytes.next() {
switch byte {
case asciiBackslash: // backslash
if let escaped = bytes.next() {
switch escaped {
case asciiZero...asciiSeven: // 0...7
// C standard allows 1, 2, or 3 octal digits.
let savedPosition = bytes
let digit1 = escaped
let digit1Value = digit1 - asciiZero
if let digit2 = bytes.next(),
digit2 >= asciiZero && digit2 <= asciiSeven {
let digit2Value = digit2 - asciiZero
let innerSavedPosition = bytes
if let digit3 = bytes.next(),
digit3 >= asciiZero && digit3 <= asciiSeven {
let digit3Value = digit3 - asciiZero
let n = digit1Value * 64 + digit2Value * 8 + digit3Value
out.append(n)
} else {
let n = digit1Value * 8 + digit2Value
out.append(n)
bytes = innerSavedPosition
}
} else {
let n = digit1Value
out.append(n)
bytes = savedPosition
}
case asciiLowerX: // "x"
// Unlike C/C++, protobuf only allows 1 or 2 digits here:
if let byte = bytes.next(), let digit = fromHexDigit(byte) {
var n = digit
let savedPosition = bytes
if let byte = bytes.next(), let digit = fromHexDigit(byte) {
n = n &* 16 + digit
} else {
// No second digit; reset the iterator
bytes = savedPosition
}
out.append(n)
} else {
return nil // Hex escape must have at least 1 digit
}
case asciiLowerA: // \a
out.append(asciiBell)
case asciiLowerB: // \b
out.append(asciiBackspace)
case asciiLowerF: // \f
out.append(asciiFormFeed)
case asciiLowerN: // \n
out.append(asciiNewLine)
case asciiLowerR: // \r
out.append(asciiCarriageReturn)
case asciiLowerT: // \t
out.append(asciiTab)
case asciiLowerV: // \v
out.append(asciiVerticalTab)
case asciiDoubleQuote,
asciiSingleQuote,
asciiQuestionMark,
asciiBackslash: // " ' ? \
out.append(escaped)
default:
return nil // Unrecognized escape
}
} else {
return nil // Input ends with backslash
}
default:
out.append(byte)
}
}
// There has got to be an easier way to convert a [UInt8] into a String.
return out.withUnsafeBufferPointer { ptr in
if let addr = ptr.baseAddress {
return utf8ToString(bytes: addr, count: ptr.count)
} else {
return String()
}
}
}
///
/// TextFormatScanner has no public members.
///
internal struct TextFormatScanner {
internal var extensions: ExtensionMap?
private var p: UnsafePointer<UInt8>
private var end: UnsafePointer<UInt8>
private var doubleFormatter = DoubleFormatter()
internal var complete: Bool {
mutating get {
return p == end
}
}
internal init(utf8Pointer: UnsafePointer<UInt8>, count: Int, extensions: ExtensionMap? = nil) {
p = utf8Pointer
end = p + count
self.extensions = extensions
skipWhitespace()
}
/// Skip whitespace
private mutating func skipWhitespace() {
while p != end {
let u = p[0]
switch u {
case asciiSpace,
asciiTab,
asciiNewLine,
asciiCarriageReturn: // space, tab, NL, CR
p += 1
case asciiHash: // # comment
p += 1
while p != end {
// Skip until end of line
let c = p[0]
p += 1
if c == asciiNewLine || c == asciiCarriageReturn {
break
}
}
default:
return
}
}
}
/// Return a buffer containing the raw UTF8 for an identifier.
/// Assumes that you already know the current byte is a valid
/// start of identifier.
private mutating func parseUTF8Identifier() -> UnsafeBufferPointer<UInt8> {
let start = p
loop: while p != end {
let c = p[0]
switch c {
case asciiLowerA...asciiLowerZ,
asciiUpperA...asciiUpperZ,
asciiZero...asciiNine,
asciiUnderscore:
p += 1
default:
break loop
}
}
let s = UnsafeBufferPointer(start: start, count: p - start)
skipWhitespace()
return s
}
/// Return a String containing the next identifier.
private mutating func parseIdentifier() -> String {
let buff = parseUTF8Identifier()
let s = utf8ToString(bytes: buff.baseAddress!, count: buff.count)
// Force-unwrap is OK: we never have invalid UTF8 at this point.
return s!
}
/// Parse the rest of an [extension_field_name] in the input, assuming the
/// initial "[" character has already been read (and is in the prefix)
/// This is also used for AnyURL, so we include "/", "."
private mutating func parseExtensionKey() -> String? {
let start = p
if p == end {
return nil
}
let c = p[0]
switch c {
case asciiLowerA...asciiLowerZ, asciiUpperA...asciiUpperZ:
p += 1
default:
return nil
}
while p != end {
let c = p[0]
switch c {
case asciiLowerA...asciiLowerZ,
asciiUpperA...asciiUpperZ,
asciiZero...asciiNine,
asciiUnderscore,
asciiPeriod,
asciiForwardSlash:
p += 1
case asciiCloseSquareBracket: // ]
return utf8ToString(bytes: start, count: p - start)
default:
return nil
}
}
return nil
}
/// Scan a string that encodes a byte field, return a count of
/// the number of bytes that should be decoded from it
private mutating func validateAndCountBytesFromString(terminator: UInt8, sawBackslash: inout Bool) throws -> Int {
var count = 0
let start = p
sawBackslash = false
while p != end {
let byte = p[0]
p += 1
if byte == terminator {
p = start
return count
}
switch byte {
case asciiBackslash: // "\\"
sawBackslash = true
if p != end {
let escaped = p[0]
p += 1
switch escaped {
case asciiZero...asciiSeven: // '0'...'7'
// C standard allows 1, 2, or 3 octal digits.
if p != end, p[0] >= asciiZero, p[0] <= asciiSeven {
p += 1
if p != end, p[0] >= asciiZero, p[0] <= asciiSeven {
if escaped > asciiThree {
// Out of range octal: three digits and first digit is greater than 3
throw TextFormatDecodingError.malformedText
}
p += 1
}
}
count += 1
case asciiLowerX: // 'x' hexadecimal escape
if p != end && fromHexDigit(p[0]) != nil {
p += 1
if p != end && fromHexDigit(p[0]) != nil {
p += 1
}
} else {
throw TextFormatDecodingError.malformedText // Hex escape must have at least 1 digit
}
count += 1
case asciiLowerA, // \a ("alert")
asciiLowerB, // \b
asciiLowerF, // \f
asciiLowerN, // \n
asciiLowerR, // \r
asciiLowerT, // \t
asciiLowerV, // \v
asciiSingleQuote, // \'
asciiDoubleQuote, // \"
asciiQuestionMark, // \?
asciiBackslash: // \\
count += 1
default:
throw TextFormatDecodingError.malformedText // Unrecognized escape
}
}
default:
count += 1
}
}
throw TextFormatDecodingError.malformedText
}
/// Protobuf Text format uses C ASCII conventions for
/// encoding byte sequences, including the use of octal
/// and hexadecimal escapes.
///
/// Assumes that validateAndCountBytesFromString() has already
/// verified the correctness. So we get to avoid error checks here.
private mutating func parseBytesFromString(terminator: UInt8, into data: inout Data) {
data.withUnsafeMutableBytes {
(dataPointer: UnsafeMutablePointer<UInt8>) in
var out = dataPointer
while p[0] != terminator {
let byte = p[0]
p += 1
switch byte {
case asciiBackslash: // "\\"
let escaped = p[0]
p += 1
switch escaped {
case asciiZero...asciiSeven: // '0'...'7'
// C standard allows 1, 2, or 3 octal digits.
let digit1Value = escaped - asciiZero
let digit2 = p[0]
if digit2 >= asciiZero, digit2 <= asciiSeven {
p += 1
let digit2Value = digit2 - asciiZero
let digit3 = p[0]
if digit3 >= asciiZero, digit3 <= asciiSeven {
p += 1
let digit3Value = digit3 - asciiZero
out[0] = digit1Value &* 64 + digit2Value * 8 + digit3Value
out += 1
} else {
out[0] = digit1Value * 8 + digit2Value
out += 1
}
} else {
out[0] = digit1Value
out += 1
}
case asciiLowerX: // 'x' hexadecimal escape
// We already validated, so we know there's at least one digit:
var n = fromHexDigit(p[0])!
p += 1
if let digit = fromHexDigit(p[0]) {
n = n &* 16 &+ digit
p += 1
}
out[0] = n
out += 1
case asciiLowerA: // \a ("alert")
out[0] = asciiBell
out += 1
case asciiLowerB: // \b
out[0] = asciiBackspace
out += 1
case asciiLowerF: // \f
out[0] = asciiFormFeed
out += 1
case asciiLowerN: // \n
out[0] = asciiNewLine
out += 1
case asciiLowerR: // \r
out[0] = asciiCarriageReturn
out += 1
case asciiLowerT: // \t
out[0] = asciiTab
out += 1
case asciiLowerV: // \v
out[0] = asciiVerticalTab
out += 1
default:
out[0] = escaped
out += 1
}
default:
out[0] = byte
out += 1
}
}
p += 1 // Consume terminator
}
}
/// Assumes the leading quote has already been consumed
private mutating func parseStringSegment(terminator: UInt8) -> String? {
let start = p
var sawBackslash = false
while p != end {
let c = p[0]
if c == terminator {
let s = utf8ToString(bytes: start, count: p - start)
p += 1
skipWhitespace()
if let s = s, sawBackslash {
return decodeString(s)
} else {
return s
}
}
p += 1
if c == asciiBackslash { // \
if p == end {
return nil
}
sawBackslash = true
p += 1
}
}
return nil // Unterminated quoted string
}
internal mutating func nextUInt() throws -> UInt64 {
if p == end {
throw TextFormatDecodingError.malformedNumber
}
let c = p[0]
p += 1
if c == asciiZero { // leading '0' precedes octal or hex
if p[0] == asciiLowerX { // 'x' => hex
p += 1
var n: UInt64 = 0
while p != end {
let digit = p[0]
let val: UInt64
switch digit {
case asciiZero...asciiNine: // 0...9
val = UInt64(digit - asciiZero)
case asciiLowerA...asciiLowerF: // a...f
val = UInt64(digit - asciiLowerA + 10)
case asciiUpperA...asciiUpperF:
val = UInt64(digit - asciiUpperA + 10)
case asciiLowerU: // trailing 'u'
p += 1
skipWhitespace()
return n
default:
skipWhitespace()
return n
}
if n > UInt64.max / 16 {
throw TextFormatDecodingError.malformedNumber
}
p += 1
n = n * 16 + val
}
skipWhitespace()
return n
} else { // octal
var n: UInt64 = 0
while p != end {
let digit = p[0]
if digit == asciiLowerU { // trailing 'u'
p += 1
skipWhitespace()
return n
}
if digit < asciiZero || digit > asciiSeven {
skipWhitespace()
return n // not octal digit
}
let val = UInt64(digit - asciiZero)
if n > UInt64.max / 8 {
throw TextFormatDecodingError.malformedNumber
}
p += 1
n = n * 8 + val
}
skipWhitespace()
return n
}
} else if c > asciiZero && c <= asciiNine { // 1...9
var n = UInt64(c - asciiZero)
while p != end {
let digit = p[0]
if digit == asciiLowerU { // trailing 'u'
p += 1
skipWhitespace()
return n
}
if digit < asciiZero || digit > asciiNine {
skipWhitespace()
return n // not a digit
}
let val = UInt64(digit - asciiZero)
if n > UInt64.max / 10 || n * 10 > UInt64.max - val {
throw TextFormatDecodingError.malformedNumber
}
p += 1
n = n * 10 + val
}
skipWhitespace()
return n
}
throw TextFormatDecodingError.malformedNumber
}
internal mutating func nextSInt() throws -> Int64 {
if p == end {
throw TextFormatDecodingError.malformedNumber
}
let c = p[0]
if c == asciiMinus { // -
p += 1
// character after '-' must be digit
let digit = p[0]
if digit < asciiZero || digit > asciiNine {
throw TextFormatDecodingError.malformedNumber
}
let n = try nextUInt()
let limit: UInt64 = 0x8000000000000000 // -Int64.min
if n >= limit {
if n > limit {
// Too large negative number
throw TextFormatDecodingError.malformedNumber
} else {
return Int64.min // Special case for Int64.min
}
}
return -Int64(bitPattern: n)
} else {
let n = try nextUInt()
if n > UInt64(bitPattern: Int64.max) {
throw TextFormatDecodingError.malformedNumber
}
return Int64(bitPattern: n)
}
}
internal mutating func nextStringValue() throws -> String {
var result: String
skipWhitespace()
if p == end {
throw TextFormatDecodingError.malformedText
}
let c = p[0]
if c != asciiSingleQuote && c != asciiDoubleQuote {
throw TextFormatDecodingError.malformedText
}
p += 1
if let s = parseStringSegment(terminator: c) {
result = s
} else {
throw TextFormatDecodingError.malformedText
}
while true {
if p == end {
return result
}
let c = p[0]
if c != asciiSingleQuote && c != asciiDoubleQuote {
return result
}
p += 1
if let s = parseStringSegment(terminator: c) {
result.append(s)
} else {
throw TextFormatDecodingError.malformedText
}
}
}
/// Protobuf Text Format allows a single bytes field to
/// contain multiple quoted strings. The values
/// are separately decoded and then concatenated:
/// field1: "bytes" 'more bytes'
/// "and even more bytes"
internal mutating func nextBytesValue() throws -> Data {
// Get the first string's contents
var result: Data
skipWhitespace()
if p == end {
throw TextFormatDecodingError.malformedText
}
let c = p[0]
if c != asciiSingleQuote && c != asciiDoubleQuote {
throw TextFormatDecodingError.malformedText
}
p += 1
var sawBackslash = false
let n = try validateAndCountBytesFromString(terminator: c, sawBackslash: &sawBackslash)
if sawBackslash {
result = Data(count: n)
parseBytesFromString(terminator: c, into: &result)
} else {
result = Data(bytes: p, count: n)
p += n + 1 // Skip string body + close quote
}
// If there are more strings, decode them
// and append to the result:
while true {
skipWhitespace()
if p == end {
return result
}
let c = p[0]
if c != asciiSingleQuote && c != asciiDoubleQuote {
return result
}
p += 1
var sawBackslash = false
let n = try validateAndCountBytesFromString(terminator: c, sawBackslash: &sawBackslash)
if sawBackslash {
var b = Data(count: n)
parseBytesFromString(terminator: c, into: &b)
result.append(b)
} else {
result.append(p, count: n)
p += n + 1 // Skip string body + close quote
}
}
}
// Tries to identify a sequence of UTF8 characters
// that represent a numeric floating-point value.
private mutating func tryParseFloatString() -> Double? {
guard p != end else {return nil}
let start = p
var c = p[0]
if c == asciiMinus {
p += 1
guard p != end else {p = start; return nil}
c = p[0]
}
switch c {
case asciiZero: // '0' as first character is not allowed followed by digit
p += 1
guard p != end else {break}
c = p[0]
if c >= asciiZero && c <= asciiNine {
p = start
return nil
}
case asciiPeriod: // '.' as first char only if followed by digit
p += 1
guard p != end else {p = start; return nil}
c = p[0]
if c < asciiZero || c > asciiNine {
p = start
return nil
}
case asciiOne...asciiNine:
break
default:
p = start
return nil
}
loop: while p != end {
let c = p[0]
switch c {
case asciiZero...asciiNine,
asciiPeriod,
asciiPlus,
asciiMinus,
asciiLowerE,
asciiUpperE: // 0...9, ., +, -, e, E
p += 1
case asciiLowerF: // f
// proto1 allowed floats to be suffixed with 'f'
let d = doubleFormatter.utf8ToDouble(bytes: start, count: p - start)
// Just skip the 'f'
p += 1
skipWhitespace()
return d
default:
break loop
}
}
let d = doubleFormatter.utf8ToDouble(bytes: start, count: p - start)
skipWhitespace()
return d
}
// Skip specified characters if they all match
private mutating func skipOptionalCharacters(bytes: [UInt8]) {
let start = p
for b in bytes {
if p == end || p[0] != b {
p = start
return
}
p += 1
}
}
// Skip following keyword if it matches (case-insensitively)
// the given keyword (specified as a series of bytes).
private mutating func skipOptionalKeyword(bytes: [UInt8]) -> Bool {
let start = p
for b in bytes {
if p == end {
p = start
return false
}
var c = p[0]
if c >= asciiUpperA && c <= asciiUpperZ {
// Convert to lower case
// (Protobuf text keywords are case insensitive)
c += asciiLowerA - asciiUpperA
}
if c != b {
p = start
return false
}
p += 1
}
if p == end {
return true
}
let c = p[0]
if ((c >= asciiUpperA && c <= asciiUpperZ)
|| (c >= asciiLowerA && c <= asciiLowerZ)) {
p = start
return false
}
skipWhitespace()
return true
}
// If the next token is the identifier "nan", return true.
private mutating func skipOptionalNaN() -> Bool {
return skipOptionalKeyword(bytes:
[asciiLowerN, asciiLowerA, asciiLowerN])
}
// If the next token is a recognized spelling of "infinity",
// return Float.infinity or -Float.infinity
private mutating func skipOptionalInfinity() -> Float? {
if p == end {
return nil
}
let c = p[0]
let negated: Bool
if c == asciiMinus {
negated = true
p += 1
} else {
negated = false
}
let inf = [asciiLowerI, asciiLowerN, asciiLowerF]
let infinity = [asciiLowerI, asciiLowerN, asciiLowerF, asciiLowerI,
asciiLowerN, asciiLowerI, asciiLowerT, asciiLowerY]
if (skipOptionalKeyword(bytes: inf)
|| skipOptionalKeyword(bytes: infinity)) {
return negated ? -Float.infinity : Float.infinity
}
return nil
}
internal mutating func nextFloat() throws -> Float {
if let d = tryParseFloatString() {
return Float(d)
}
if skipOptionalNaN() {
return Float.nan
}
if let inf = skipOptionalInfinity() {
return inf
}
throw TextFormatDecodingError.malformedNumber
}
internal mutating func nextDouble() throws -> Double {
if let d = tryParseFloatString() {
return d
}
if skipOptionalNaN() {
return Double.nan
}
if let inf = skipOptionalInfinity() {
return Double(inf)
}
throw TextFormatDecodingError.malformedNumber
}
internal mutating func nextBool() throws -> Bool {
skipWhitespace()
if p == end {
throw TextFormatDecodingError.malformedText
}
let c = p[0]
p += 1
let result: Bool
switch c {
case asciiZero:
result = false
case asciiOne:
result = true
case asciiLowerF, asciiUpperF:
if p != end {
let alse = [asciiLowerA, asciiLowerL, asciiLowerS, asciiLowerE]
skipOptionalCharacters(bytes: alse)
}
result = false
case asciiLowerT, asciiUpperT:
if p != end {
let rue = [asciiLowerR, asciiLowerU, asciiLowerE]
skipOptionalCharacters(bytes: rue)
}
result = true
default:
throw TextFormatDecodingError.malformedText
}
if p == end {
return result
}
switch p[0] {
case asciiSpace,
asciiTab,
asciiNewLine,
asciiCarriageReturn,
asciiHash,
asciiComma,
asciiSemicolon,
asciiCloseSquareBracket,
asciiCloseCurlyBracket,
asciiCloseAngleBracket:
skipWhitespace()
return result
default:
throw TextFormatDecodingError.malformedText
}
}
internal mutating func nextOptionalEnumName() throws -> UnsafeBufferPointer<UInt8>? {
skipWhitespace()
if p == end {
throw TextFormatDecodingError.malformedText
}
switch p[0] {
case asciiLowerA...asciiLowerZ, asciiUpperA...asciiUpperZ:
return parseUTF8Identifier()
default:
return nil
}
}
/// Any URLs are syntactically (almost) identical to extension
/// keys, so we share the code for those.
internal mutating func nextOptionalAnyURL() throws -> String? {
return try nextOptionalExtensionKey()
}
/// Returns next extension key or nil if end-of-input or
/// if next token is not an extension key.
///
/// Throws an error if the next token starts with '[' but
/// cannot be parsed as an extension key.
///
/// Note: This accepts / characters to support Any URL parsing.
/// Technically, Any URLs can contain / characters and extension
/// key names cannot. But in practice, accepting / chracters for
/// extension keys works fine, since the result just gets rejected
/// when the key is looked up.
internal mutating func nextOptionalExtensionKey() throws -> String? {
skipWhitespace()
if p == end {
return nil
}
if p[0] == asciiOpenSquareBracket { // [
p += 1
if let s = parseExtensionKey() {
if p == end || p[0] != asciiCloseSquareBracket {
throw TextFormatDecodingError.malformedText
}
// Skip ]
p += 1
skipWhitespace()
return s
} else {
throw TextFormatDecodingError.malformedText
}
}
return nil
}
/// Returns text of next regular key or nil if end-of-input.
/// This considers an extension key [keyname] to be an
/// error, so call nextOptionalExtensionKey first if you
/// want to handle extension keys.
///
/// This is only used by map parsing; we should be able to
/// rework that to use nextFieldNumber instead.
internal mutating func nextKey() throws -> String? {
skipWhitespace()
if p == end {
return nil
}
let c = p[0]
switch c {
case asciiOpenSquareBracket: // [
throw TextFormatDecodingError.malformedText
case asciiLowerA...asciiLowerZ,
asciiUpperA...asciiUpperZ,
asciiOne...asciiNine: // a...z, A...Z, 1...9
return parseIdentifier()
default:
throw TextFormatDecodingError.malformedText
}
}
/// Parse a field name, look it up, and return the corresponding
/// field number.
///
/// returns nil at end-of-input
///
/// Throws if field name cannot be parsed or if field name is
/// unknown.
///
/// This function accounts for as much as 2/3 of the total run
/// time of the entire parse.
internal mutating func nextFieldNumber(names: _NameMap) throws -> Int? {
if p == end {
return nil
}
let c = p[0]
switch c {
case asciiLowerA...asciiLowerZ,
asciiUpperA...asciiUpperZ: // a...z, A...Z
let key = parseUTF8Identifier()
if let fieldNumber = names.number(forProtoName: key) {
return fieldNumber
} else {
throw TextFormatDecodingError.unknownField
}
case asciiOne...asciiNine: // 1-9 (field numbers are 123, not 0123)
var fieldNum = Int(c) - Int(asciiZero)
p += 1
while p != end {
let c = p[0]
if c >= asciiZero && c <= asciiNine {
fieldNum = fieldNum &* 10 &+ (Int(c) - Int(asciiZero))
} else {
break
}
p += 1
}
skipWhitespace()
if names.names(for: fieldNum) != nil {
return fieldNum
} else {
// It was a number that isn't a known field.
// The C++ version (TextFormat::Parser::ParserImpl::ConsumeField()),
// supports an option to file or skip the field's value (this is true
// of unknown names or numbers).
throw TextFormatDecodingError.unknownField
}
default:
break
}
throw TextFormatDecodingError.malformedText
}
private mutating func skipRequiredCharacter(_ c: UInt8) throws {
skipWhitespace()
if p != end && p[0] == c {
p += 1
skipWhitespace()
} else {
throw TextFormatDecodingError.malformedText
}
}
internal mutating func skipRequiredComma() throws {
try skipRequiredCharacter(asciiComma)
}
internal mutating func skipRequiredColon() throws {
try skipRequiredCharacter(asciiColon)
}
private mutating func skipOptionalCharacter(_ c: UInt8) -> Bool {
if p != end && p[0] == c {
p += 1
skipWhitespace()
return true
}
return false
}
internal mutating func skipOptionalColon() -> Bool {
return skipOptionalCharacter(asciiColon)
}
internal mutating func skipOptionalEndArray() -> Bool {
return skipOptionalCharacter(asciiCloseSquareBracket)
}
internal mutating func skipOptionalBeginArray() -> Bool {
return skipOptionalCharacter(asciiOpenSquareBracket)
}
internal mutating func skipOptionalObjectEnd(_ c: UInt8) -> Bool {
return skipOptionalCharacter(c)
}
internal mutating func skipOptionalSeparator() {
if p != end {
let c = p[0]
if c == asciiComma || c == asciiSemicolon { // comma or semicolon
p += 1
skipWhitespace()
}
}
}
/// Returns the character that should end this field.
/// E.g., if object starts with "{", returns "}"
internal mutating func skipObjectStart() throws -> UInt8 {
if p != end {
let c = p[0]
p += 1
skipWhitespace()
switch c {
case asciiOpenCurlyBracket: // {
return asciiCloseCurlyBracket // }
case asciiOpenAngleBracket: // <
return asciiCloseAngleBracket // >
default:
break
}
}
throw TextFormatDecodingError.malformedText
}
}
| apache-2.0 | e9d8527feccde471a8b034880f64f8ee | 32.337361 | 118 | 0.502244 | 5.197189 | false | false | false | false |
anirudh24seven/wikipedia-ios | Pods/SWStepSlider/Pod/Classes/SWStepSlider.swift | 1 | 9625 | //
// SWStepSlider.swift
// Pods
//
// Created by Sarun Wongpatcharapakorn on 2/4/16.
//
//
import UIKit
public class SWStepSliderAccessibilityElement: UIAccessibilityElement {
var minimumValue: Int = 0
var maximumValue: Int = 4
var value: Int = 2
weak var slider: SWStepSlider?
public init(accessibilityContainer container: AnyObject, slider: SWStepSlider) {
self.slider = slider
super.init(accessibilityContainer: container)
}
override public func accessibilityActivate() -> Bool {
return true
}
override public func accessibilityIncrement() {
let new = value + 1
self.slider?.setValueAndUpdateView(new)
}
override public func accessibilityDecrement() {
let new = value - 1
self.slider?.setValueAndUpdateView(new)
}
}
@IBDesignable
public class SWStepSlider: UIControl {
@IBInspectable public var minimumValue: Int = 0 {
didSet {
if self.minimumValue != oldValue {
if let e = self.thumbAccessabilityElement {
e.minimumValue = self.minimumValue
self.accessibilityElements = [e]
}
}
}
}
@IBInspectable public var maximumValue: Int = 4 {
didSet {
if self.maximumValue != oldValue {
if let e = self.thumbAccessabilityElement {
e.minimumValue = self.maximumValue
self.accessibilityElements = [e]
}
}
}
}
@IBInspectable public var value: Int = 2 {
didSet {
if self.value != oldValue {
if let e = self.thumbAccessabilityElement {
e.accessibilityValue = String(self.value)
e.value = self.value
self.accessibilityElements = [e]
}
if self.continuous {
self.sendActionsForControlEvents(.ValueChanged)
}
}
}
}
@IBInspectable public var continuous: Bool = true // if set, value change events are generated any time the value changes due to dragging. default = YES
let trackLayer = CALayer()
public var trackHeight: CGFloat = 2
public var trackColor = UIColor(red: 152.0/255.0, green: 152.0/255.0, blue: 152.0/255.0, alpha: 1)
public var tickHeight: CGFloat = 8
public var tickWidth: CGFloat = 2
public var tickColor = UIColor(red: 152.0/255.0, green: 152.0/255.0, blue: 152.0/255.0, alpha: 1)
let thumbLayer = CAShapeLayer()
var thumbFillColor = UIColor.whiteColor()
var thumbStrokeColor = UIColor(red: 222.0/255.0, green: 222.0/255.0, blue: 222.0/255.0, alpha: 1)
var thumbDimension: CGFloat = 28
private var thumbAccessabilityElement: SWStepSliderAccessibilityElement?
var stepWidth: CGFloat {
return self.trackWidth / CGFloat(self.maximumValue)
}
var trackWidth: CGFloat {
return self.bounds.size.width - self.thumbDimension
}
var trackOffset: CGFloat {
return (self.bounds.size.width - self.trackWidth) / 2
}
var numberOfSteps: Int {
return self.maximumValue - self.minimumValue + 1
}
required public init?(coder: NSCoder) {
super.init(coder: coder)
self.commonInit()
}
override init(frame: CGRect) {
super.init(frame: frame)
self.commonInit()
}
private func commonInit() {
self.trackLayer.backgroundColor = self.trackColor.CGColor
self.layer.addSublayer(trackLayer)
self.thumbLayer.backgroundColor = UIColor.clearColor().CGColor
self.thumbLayer.fillColor = self.thumbFillColor.CGColor
self.thumbLayer.strokeColor = self.thumbStrokeColor.CGColor
self.thumbLayer.lineWidth = 0.5
self.thumbLayer.frame = CGRect(x: 0, y: 0, width: self.thumbDimension, height: self.thumbDimension)
self.thumbLayer.path = UIBezierPath(ovalInRect: self.thumbLayer.bounds).CGPath
// Shadow
self.thumbLayer.shadowOffset = CGSize(width: 0, height: 2)
self.thumbLayer.shadowColor = UIColor.blackColor().CGColor
self.thumbLayer.shadowOpacity = 0.3
self.thumbLayer.shadowRadius = 2
self.thumbLayer.contentsScale = UIScreen.mainScreen().scale
self.layer.addSublayer(self.thumbLayer)
self.thumbAccessabilityElement = SWStepSliderAccessibilityElement(accessibilityContainer: self, slider: self)
if let e = self.thumbAccessabilityElement {
e.accessibilityLabel = "Text Slider"
e.accessibilityHint = "Increment of decrement to adjust the text size"
e.accessibilityTraits = UIAccessibilityTraitAdjustable
self.accessibilityElements = [e]
}
}
public override func layoutSubviews() {
super.layoutSubviews()
var rect = self.bounds
rect.origin.x = self.trackOffset
rect.origin.y = (rect.size.height - self.trackHeight) / 2
rect.size.height = self.trackHeight
rect.size.width = self.trackWidth
self.trackLayer.frame = rect
let center = CGPoint(x: self.trackOffset + CGFloat(self.value) * self.stepWidth, y: self.bounds.midY)
let thumbRect = CGRect(x: center.x - self.thumbDimension / 2, y: center.y - self.thumbDimension / 2, width: self.thumbDimension, height: self.thumbDimension)
self.thumbLayer.frame = thumbRect
if let e = self.thumbAccessabilityElement {
e.accessibilityFrame = self.convertRect(thumbRect, toView: nil)
self.accessibilityElements = [e]
}
}
public override func drawRect(rect: CGRect) {
super.drawRect(rect)
let ctx = UIGraphicsGetCurrentContext()
CGContextSaveGState(ctx!)
// Draw ticks
CGContextSetFillColorWithColor(ctx!, self.tickColor.CGColor)
for index in 0..<self.numberOfSteps {
let x = self.trackOffset + CGFloat(index) * self.stepWidth - 0.5 * self.tickWidth
let y = self.bounds.midY - 0.5 * self.tickHeight
// Clip the tick
let tickPath = UIBezierPath(rect: CGRect(x: x , y: y, width: self.tickWidth, height: self.tickHeight))
// Fill the tick
CGContextAddPath(ctx!, tickPath.CGPath)
CGContextFillPath(ctx!)
}
CGContextRestoreGState(ctx!)
}
public override func intrinsicContentSize() -> CGSize {
return CGSize(width: self.thumbDimension * CGFloat(self.numberOfSteps), height: self.thumbDimension)
}
public func setValueAndUpdateView(value: Int) {
self.value = self.clipValue(value)
CATransaction.begin()
CATransaction.setDisableActions(true)
// Update UI without animation
self.setNeedsLayout()
CATransaction.commit()
}
// MARK: - Touch
var previousLocation: CGPoint!
var dragging = false
var originalValue: Int!
public override func beginTrackingWithTouch(touch: UITouch, withEvent event: UIEvent?) -> Bool {
let location = touch.locationInView(self)
self.originalValue = self.value
print("touch \(location)")
if self.thumbLayer.frame.contains(location) {
self.dragging = true
} else {
self.dragging = false
}
self.previousLocation = location
return self.dragging
}
public override func continueTrackingWithTouch(touch: UITouch, withEvent event: UIEvent?) -> Bool {
let location = touch.locationInView(self)
let deltaLocation = location.x - self.previousLocation.x
let deltaValue = self.deltaValue(deltaLocation)
if deltaLocation < 0 {
// minus
self.value = self.clipValue(self.originalValue - deltaValue)
} else {
self.value = self.clipValue(self.originalValue + deltaValue)
}
CATransaction.begin()
CATransaction.setDisableActions(true)
// Update UI without animation
self.setNeedsLayout()
CATransaction.commit()
return true
}
public override func endTrackingWithTouch(touch: UITouch?, withEvent event: UIEvent?) {
self.previousLocation = nil
self.originalValue = nil
self.dragging = false
if self.continuous == false {
self.sendActionsForControlEvents(.ValueChanged)
}
}
// MARK: - Helper
func deltaValue(deltaLocation: CGFloat) -> Int {
return Int(round(fabs(deltaLocation) / self.stepWidth))
}
func clipValue(value: Int) -> Int {
return min(max(value, self.minimumValue), self.maximumValue)
}
// MARK: - Accessibility
override public var isAccessibilityElement: Bool {
get {
return false //return NO to be a container
}
set {
super.isAccessibilityElement = newValue
}
}
override public func accessibilityElementCount() -> Int {
return 1
}
override public func accessibilityElementAtIndex(index: Int) -> AnyObject? {
return self.thumbAccessabilityElement
}
override public func indexOfAccessibilityElement(element: AnyObject) -> Int {
return 0
}
}
| mit | d69c7d8be261d52772c273f01fdc5f32 | 31.627119 | 165 | 0.609662 | 4.810095 | false | false | false | false |
rodrigok/wwdc-2016-shcolarship | Rodrigo Nascimento/PageViewController.swift | 1 | 3084 | //
// PageViewController.swift
// Rodrigo Nascimento
//
// Created by Rodrigo Nascimento on 25/04/16.
// Copyright (c) 2016 Rodrigo Nascimento. All rights reserved.
//
import UIKit
class PageViewController: UIPageViewController, UIPageViewControllerDataSource, UIPageViewControllerDelegate {
let pages = 4
var pageControl: UIPageControl!
override func viewDidLoad() {
super.viewDidLoad()
pageControl = UIPageControl(frame: CGRectMake(0.0, 0.0, self.view.frame.width, 30.0))
pageControl.pageIndicatorTintColor = UIColor(white: 0.9, alpha: 1)
pageControl.currentPageIndicatorTintColor = UIColor(red: 0.6745, green: 0.5765, blue: 0.3333, alpha: 0.5)
pageControl.numberOfPages = pages
self.view.addSubview(pageControl)
self.view.bringSubviewToFront(pageControl)
self.delegate = self
self.dataSource = self
self.view.backgroundColor = UIColor(rgba: "#292b36")
let pageContentViewController = self.viewControllerAtIndex(0)
self.setViewControllers([pageContentViewController!], direction: UIPageViewControllerNavigationDirection.Forward, animated: true, completion: nil)
}
func pageViewController(pageViewController: UIPageViewController, didFinishAnimating finished: Bool, previousViewControllers: [UIViewController], transitionCompleted completed: Bool) {
self.pageControl.currentPage = (pageViewController.viewControllers![0] as! PageContentViewController).pageIndex!
}
func pageViewController(pageViewController: UIPageViewController, viewControllerAfterViewController viewController: UIViewController) -> UIViewController? {
var index = (viewController as! PageContentViewController).pageIndex!
index += 1
if(index >= pages){
return nil
}
return self.viewControllerAtIndex(index)
}
func pageViewController(pageViewController: UIPageViewController, viewControllerBeforeViewController viewController: UIViewController) -> UIViewController? {
var index = (viewController as! PageContentViewController).pageIndex!
if(index <= 0){
return nil
}
index -= 1
return self.viewControllerAtIndex(index)
}
func viewControllerAtIndex(index : Int) -> UIViewController? {
if((pages == 0) || (index >= pages)) {
return nil
}
let identifier = NSString(format: "PageContentViewController%d", index) as String
let pageContentViewController = self.storyboard?.instantiateViewControllerWithIdentifier(identifier) as! PageContentViewController
pageContentViewController.pageIndex = index
pageContentViewController.pageViewController = self
return pageContentViewController
}
override func prefersStatusBarHidden() -> Bool {
return true
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
| mit | b7077d7fa62957b35f72a43a6dfa96f8 | 37.55 | 188 | 0.700065 | 5.721707 | false | false | false | false |
chris-wood/reveiller | reveiller/Pods/SwiftCharts/SwiftCharts/Layers/ChartPointsBubbleLayer.swift | 6 | 1803 | //
// ChartPointsBubbleLayer.swift
// Examples
//
// Created by ischuetz on 16/05/15.
// Copyright (c) 2015 ivanschuetz. All rights reserved.
//
import UIKit
public class ChartPointsBubbleLayer<T: ChartPointBubble>: ChartPointsLayer<T> {
private let diameterFactor: Double
public init(xAxis: ChartAxisLayer, yAxis: ChartAxisLayer, innerFrame: CGRect, chartPoints: [T], displayDelay: Float = 0, maxBubbleDiameter: Double = 30, minBubbleDiameter: Double = 2) {
let (minDiameterScalar, maxDiameterScalar): (Double, Double) = chartPoints.reduce((min: 0, max: 0)) {tuple, chartPoint in
(min: min(tuple.min, chartPoint.diameterScalar), max: max(tuple.max, chartPoint.diameterScalar))
}
self.diameterFactor = (maxBubbleDiameter - minBubbleDiameter) / (maxDiameterScalar - minDiameterScalar)
super.init(xAxis: xAxis, yAxis: yAxis, innerFrame: innerFrame, chartPoints: chartPoints, displayDelay: displayDelay)
}
override public func chartViewDrawing(context context: CGContextRef, chart: Chart) {
for chartPointModel in self.chartPointsModels {
CGContextSetLineWidth(context, 1.0)
CGContextSetStrokeColorWithColor(context, chartPointModel.chartPoint.borderColor.CGColor)
CGContextSetFillColorWithColor(context, chartPointModel.chartPoint.bgColor.CGColor)
let diameter = CGFloat(chartPointModel.chartPoint.diameterScalar * diameterFactor)
let circleRect = (CGRectMake(chartPointModel.screenLoc.x - diameter / 2, chartPointModel.screenLoc.y - diameter / 2, diameter, diameter))
CGContextFillEllipseInRect(context, circleRect)
CGContextStrokeEllipseInRect(context, circleRect)
}
}
}
| mit | 033f1ee763a10dd05e8e03ee28863438 | 42.97561 | 189 | 0.702163 | 4.899457 | false | false | false | false |
Estimote/iOS-SDK | Examples/swift/LoyaltyStore/LoyaltyStore/Views/Customer/CustomerCell.swift | 1 | 1004 | //
// Please report any problems with this app template to [email protected]
//
import UIKit
/// Customer cell used in StoreViewController to display customers
class CustomerCell: UITableViewCell {
@IBOutlet weak var cardView : CardView!
@IBOutlet weak var avatarImageView : AvatarImageView!
@IBOutlet weak var nameLabel : UILabel!
@IBOutlet weak var pointsLabel : UILabel!
override func awakeFromNib() {
}
override func setSelected(_ selected: Bool, animated: Bool) {
switch selected {
case true :
cardView.backgroundColor = UIColor.white
cardView.shadowVisible()
nameLabel.textColor = UIColor.black
pointsLabel.textColor = UIColor.black
case false :
cardView.backgroundColor = UIColor.init(red: 148/256, green: 106/256, blue: 207/256, alpha: 1)
cardView.shadowHidden()
nameLabel.textColor = UIColor.white
pointsLabel.textColor = UIColor.white
}
}
}
| mit | a1e93da4e8cd33fc566d15203eb17397 | 29.424242 | 102 | 0.669323 | 4.691589 | false | false | false | false |
MakeAWishFoundation/SwiftyMocky | Sources/Shared/Count.swift | 1 | 3546 | import Foundation
/// Count enum. Use it for all Verify features, when checking how many times something happened.
///
/// There are three ways of using it:
/// 1. Explicit literal - you can pass 0, 1, 2 ... to verify exact number
/// 2. Using predefined .custom, to specify custom matching rule.
/// 3. Using one of predefined rules, for example:
/// - .atLeastOnce
/// - .exactly(1)
/// - .from(2, to: 4)
/// - .less(than: 2)
/// - .lessOrEqual(to: 1)
/// - .more(than: 2)
/// - .moreOrEqual(to: 3)
/// - .never
public enum Count: ExpressibleByIntegerLiteral {
/// Count matching closure
public typealias CustomMatchingClosure = ( _ value: Int ) -> Bool
/// [Internal] Count is represented by integer literals, with type Int
public typealias IntegerLiteralType = Int
/// Called at least once
case atLeastOnce
/// Called exactly once
case once
/// Custom count resolving closure
case custom(CustomMatchingClosure)
/// Called exactly n times
case exactly(Int)
/// Called in a...b range
case from(Int, to: Int)
/// Called less than n times
case less(than: Int)
/// Called less than ot equal to n times
case lessOrEqual(to: Int)
/// Called more than n times
case more(than: Int)
/// Called more than ot equal to n times
case moreOrEqual(to: Int)
/// Never called
case never
/// Creates new count instance, matching specific count
///
/// - Parameter value: Exact count value
public init(integerLiteral value: IntegerLiteralType) {
self = .exactly(value)
}
}
// MARK: - CustomStringConvertible
extension Count: CustomStringConvertible {
/// Human readable description
public var description: String {
switch self {
case .atLeastOnce:
return "at least 1"
case .once:
return "once"
case .custom:
return "custom"
case .exactly(let value):
return "exactly \(value)"
case .from(let lowerBound, let upperBound):
return "from \(lowerBound) to \(upperBound)"
case .less(let value):
return "less than \(value)"
case .lessOrEqual(let value):
return "less than or equal to \(value)"
case .more(let value):
return "more than \(value)"
case .moreOrEqual(let value):
return "more than or equal to \(value)"
case .never:
return "none"
}
}
}
// MARK: - Countable
extension Count: Countable {
/// Returns whether given count matches countable case.
///
/// - Parameter count: Given count
/// - Returns: true, if it is within boundaries, false otherwise
public func matches(_ count: Int) -> Bool {
switch self {
case .atLeastOnce:
return count >= 1
case .once:
return count == 1
case .custom(let matchingRule):
return matchingRule(count)
case .exactly(let value):
return count == value
case .from(let lowerBound, to: let upperBound):
return count >= lowerBound && count <= upperBound
case .less(let value):
return count < value
case .lessOrEqual(let value):
return count <= value
case .more(let value):
return count > value
case .moreOrEqual(let value):
return count >= value
case .never:
return count == 0
}
}
}
| mit | 2915989f5851390e984e240f486ca0d4 | 30.105263 | 96 | 0.584602 | 4.465995 | false | false | false | false |
natecook1000/swift | test/IDE/complete_exception.swift | 3 | 11278 | // RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=CATCH1 | %FileCheck %s -check-prefix=CATCH1
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=THROW1 > %t.throw1
// RUN: %FileCheck %s -check-prefix=THROW1 < %t.throw1
// RUN: %FileCheck %s -check-prefix=THROW1-LOCAL < %t.throw1
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=CATCH2 | %FileCheck %s -check-prefix=CATCH2
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=THROW2 | %FileCheck %s -check-prefix=THROW2
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=CATCH3 | %FileCheck %s -check-prefix=CATCH3
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=TOP_LEVEL_CATCH1 | %FileCheck %s -check-prefix=CATCH1
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=TOP_LEVEL_THROW1 | %FileCheck %s -check-prefix=THROW1
// FIXME: <rdar://problem/21001526> No dot code completion results in switch case or catch stmt at top-level
// RUNdisabled: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=TOP_LEVEL_CATCH2 | %FileCheck %s -check-prefix=CATCH2
// RUNdisabled: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=TOP_LEVEL_THROW2 | %FileCheck %s -check-prefix=THROW2
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH1 > %t.inside_catch1
// RUN: %FileCheck %s -check-prefix=STMT < %t.inside_catch1
// RUN: %FileCheck %s -check-prefix=IMPLICIT_ERROR < %t.inside_catch1
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH2 > %t.inside_catch2
// RUN: %FileCheck %s -check-prefix=STMT < %t.inside_catch2
// RUN: %FileCheck %s -check-prefix=EXPLICIT_ERROR_E < %t.inside_catch2
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH3 > %t.inside_catch3
// RUN: %FileCheck %s -check-prefix=STMT < %t.inside_catch3
// RUN: %FileCheck %s -check-prefix=EXPLICIT_NSERROR_E < %t.inside_catch3
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH4 > %t.inside_catch4
// RUN: %FileCheck %s -check-prefix=STMT < %t.inside_catch4
// RUN: %FileCheck %s -check-prefix=EXPLICIT_ERROR_PAYLOAD_I < %t.inside_catch4
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH5 > %t.inside_catch5
// RUN: %FileCheck %s -check-prefix=STMT < %t.inside_catch5
// RUN: %FileCheck %s -check-prefix=EXPLICIT_ERROR_E < %t.inside_catch5
// RUN: %FileCheck %s -check-prefix=NO_ERROR_AND_A < %t.inside_catch5
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH6 > %t.inside_catch6
// RUN: %FileCheck %s -check-prefix=STMT < %t.inside_catch6
// RUN: %FileCheck %s -check-prefix=NO_E < %t.inside_catch6
// RUN: %FileCheck %s -check-prefix=NO_ERROR_AND_A < %t.inside_catch6
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH_ERR_DOT1 | %FileCheck %s -check-prefix=ERROR_DOT
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH_ERR_DOT2 | %FileCheck %s -check-prefix=ERROR_DOT
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH_ERR_DOT3 | %FileCheck %s -check-prefix=NSERROR_DOT
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=INSIDE_CATCH_ERR_DOT4 | %FileCheck %s -check-prefix=INT_DOT
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=TOP_LEVEL_INSIDE_CATCH1 > %t.top_level_inside_catch1
// RUN: %FileCheck %s -check-prefix=STMT < %t.top_level_inside_catch1
// RUN: %FileCheck %s -check-prefix=IMPLICIT_ERROR < %t.top_level_inside_catch1
// RUN: %target-swift-ide-test(mock-sdk: %clang-importer-sdk) -code-completion -source-filename %s -code-completion-token=TOP_LEVEL_INSIDE_CATCH_ERR_DOT1 | %FileCheck %s -check-prefix=ERROR_DOT
// REQUIRES: objc_interop
import Foundation // importer SDK
protocol ErrorPro1 : Error {}
class Error1 : Error {}
class Error2 : Error {}
class Error3 {}
extension Error3 : Error{}
enum Error4 : Error {
case E1
case E2(Int32)
}
class NoneError1 {}
func getError1() -> Error1 { return Error1() }
func getNSError() -> NSError { return NSError(domain: "", code: 1, userInfo: [:]) }
func test001() {
do {} catch #^CATCH1^#
// CATCH1: Begin completions
// CATCH1-DAG: Decl[Enum]/CurrModule: Error4[#Error4#]; name=Error4{{$}}
// CATCH1-DAG: Decl[Class]/CurrModule: Error3[#Error3#]; name=Error3{{$}}
// CATCH1-DAG: Decl[Class]/CurrModule: Error2[#Error2#]; name=Error2{{$}}
// CATCH1-DAG: Decl[Class]/CurrModule: Error1[#Error1#]; name=Error1{{$}}
// CATCH1-DAG: Keyword[let]/None: let{{; name=.+$}}
// CATCH1-DAG: Decl[Class]/CurrModule: NoneError1[#NoneError1#]; name=NoneError1{{$}}
// CATCH1-DAG: Decl[Class]/OtherModule[Foundation]: NSError[#NSError#]{{; name=.+$}}
}
func test002() {
let text = "NonError"
let e1 = Error1()
let e2 = Error2()
throw #^THROW1^#
// THROW1: Begin completions
// THROW1-DAG: Decl[Enum]/CurrModule: Error4[#Error4#]; name=Error4{{$}}
// THROW1-DAG: Decl[Class]/CurrModule: Error3[#Error3#]; name=Error3{{$}}
// THROW1-DAG: Decl[Class]/CurrModule: Error2[#Error2#]; name=Error2{{$}}
// THROW1-DAG: Decl[Class]/CurrModule: Error1[#Error1#]; name=Error1{{$}}
// THROW1-DAG: Decl[Protocol]/CurrModule: ErrorPro1[#ErrorPro1#]; name=ErrorPro1{{$}}
// THROW1-DAG: Decl[FreeFunction]/CurrModule: getError1()[#Error1#]{{; name=.+$}}
// THROW1-DAG: Decl[FreeFunction]/CurrModule: getNSError()[#NSError#]{{; name=.+$}}
// If we could prove that there is no way to get to an Error value by
// starting from these, we could remove them. But that may be infeasible in
// the presence of overloaded operators.
// THROW1-DAG: Decl[Class]/CurrModule: NoneError1[#NoneError1#]; name=NoneError1{{$}}
// THROW1-LOCAL: Decl[LocalVar]/Local: text[#String#]; name=text{{$}}
// THROW1-LOCAL: Decl[LocalVar]/Local: e1[#Error1#]; name=e1{{$}}
// THROW1-LOCAL: Decl[LocalVar]/Local: e2[#Error2#]; name=e2{{$}}
}
func test003() {
do {} catch Error4.#^CATCH2^#
// CATCH2: Begin completions
// CATCH2: Decl[EnumElement]/CurrNominal: E1[#Error4#]{{; name=.+$}}
// CATCH2: Decl[EnumElement]/CurrNominal: E2({#Int32#})[#(Int32) -> Error4#]{{; name=.+$}}
// CATCH2: End completions
}
func test004() {
throw Error4.#^THROW2^#
// THROW2: Begin completions
// THROW2: Decl[EnumElement]/CurrNominal: E1[#Error4#]{{; name=.+$}}
// THROW2: Decl[EnumElement]/CurrNominal: E2({#Int32#})[#(Int32) -> Error4#]{{; name=.+$}}
// THROW2: End completions
}
func test005() {
do {} catch Error4.E2#^CATCH3^#
// CATCH3: Begin completions
// CATCH3: Pattern/CurrModule: ({#Int32#})[#Error4#]{{; name=.+$}}
// CATCH3: End completions
}
//===--- Top-level throw/catch
do {} catch #^TOP_LEVEL_CATCH1^# {}
throw #^TOP_LEVEL_THROW1^#
do {} catch Error4.#^TOP_LEVEL_CATCH2^# {}
throw Error4.#^TOP_LEVEL_THROW2^#
//===--- Inside catch body
// Statement-level code completions. This isn't exhaustive.
// STMT: Begin completions
// STMT-DAG: Keyword[if]/None: if; name=if
// STMT-DAG: Decl[Class]/CurrModule: Error1[#Error1#]; name=Error1
// STMT-DAG: Decl[Class]/CurrModule: Error2[#Error2#]; name=Error2
// STMT-DAG: Decl[FreeFunction]/CurrModule: getError1()[#Error1#]; name=getError1()
// STMT-DAG: Decl[FreeFunction]/CurrModule: getNSError()[#NSError#]; name=getNSError()
// STMT: End completions
func test006() {
do {
} catch {
#^INSIDE_CATCH1^#
}
// IMPLICIT_ERROR: Decl[LocalVar]/Local: error[#Error#]; name=error
}
func test007() {
do {
} catch let e {
#^INSIDE_CATCH2^#
}
// EXPLICIT_ERROR_E: Decl[LocalVar]/Local: e[#Error#]; name=e
}
func test008() {
do {
} catch let e as NSError {
#^INSIDE_CATCH3^#
}
// EXPLICIT_NSERROR_E: Decl[LocalVar]/Local: e[#NSError#]; name=e
}
func test009() {
do {
} catch Error4.E2(let i) {
#^INSIDE_CATCH4^#
}
// FIXME: we're getting parentheses around the type when it's unnamed...
// EXPLICIT_ERROR_PAYLOAD_I: Decl[LocalVar]/Local: i[#(Int32)#]; name=i
}
func test010() {
do {
} catch let awesomeError {
} catch let e {
#^INSIDE_CATCH5^#
} catch {}
// NO_ERROR_AND_A-NOT: awesomeError
// NO_ERROR_AND_A-NOT: Decl[LocalVar]/Local: error
}
func test011() {
do {
} catch let awesomeError {
} catch let excellentError {
} catch {}
#^INSIDE_CATCH6^#
// NO_E-NOT: excellentError
}
func test012() {
do {
} catch {
error.#^INSIDE_CATCH_ERR_DOT1^#
}
}
// ERROR_DOT: Begin completions
// ERROR_DOT: Keyword[self]/CurrNominal: self[#Error#]; name=self
func test013() {
do {
} catch let e {
e.#^INSIDE_CATCH_ERR_DOT2^#
}
}
func test014() {
do {
} catch let e as NSError {
e.#^INSIDE_CATCH_ERR_DOT3^#
}
// NSERROR_DOT: Begin completions
// NSERROR_DOT-DAG: Decl[InstanceVar]/CurrNominal: domain[#String#]; name=domain
// NSERROR_DOT-DAG: Decl[InstanceVar]/CurrNominal: code[#Int#]; name=code
// NSERROR_DOT-DAG: Decl[InstanceVar]/Super: hashValue[#Int#]; name=hashValue
// NSERROR_DOT-DAG: Decl[InstanceMethod]/Super: myClass()[#AnyClass!#]; name=myClass()
// NSERROR_DOT-DAG: Decl[InstanceMethod]/Super: isEqual({#(other): NSObject!#})[#Bool#]; name=isEqual(other: NSObject!)
// NSERROR_DOT-DAG: Decl[InstanceVar]/Super: hash[#Int#]; name=hash
// NSERROR_DOT-DAG: Decl[InstanceVar]/Super: description[#String#]; name=description
// NSERROR_DOT: End completions
}
func test015() {
do {
} catch Error4.E2(let i) where i == 2 {
i.#^INSIDE_CATCH_ERR_DOT4^#
}
}
// Check that we can complete on the bound value; Not exhaustive..
// INT_DOT: Begin completions
// INT_DOT-DAG: Decl[InstanceVar]/Super: bigEndian[#(Int32)#]; name=bigEndian
// INT_DOT-DAG: Decl[InstanceVar]/Super: littleEndian[#(Int32)#]; name=littleEndian
// INT_DOT: End completions
//===--- Inside catch body top-level
do {
} catch {
#^TOP_LEVEL_INSIDE_CATCH1^#
}
do {
} catch {
error.#^TOP_LEVEL_INSIDE_CATCH_ERR_DOT1^#
}
| apache-2.0 | d2e764dafd51b89e7f87497d24c1d1db | 45.411523 | 193 | 0.673524 | 3.0958 | false | true | false | false |
esttorhe/RxSwift | RxCocoa/RxCocoa/Common/DelegateProxy.swift | 1 | 3082 | //
// DelegateProxy.swift
// RxCocoa
//
// Created by Krunoslav Zaher on 6/14/15.
// Copyright (c) 2015 Krunoslav Zaher. All rights reserved.
//
import Foundation
import RxSwift
var delegateAssociatedTag: UInt8 = 0
var dataSourceAssociatedTag: UInt8 = 0
// This should be only used from `MainScheduler`
//
// Also, please take a look at `DelegateProxyType` protocol implementation
public class DelegateProxy : _RXDelegateProxy {
private var subjectsForSelector = [Selector: PublishSubject<[AnyObject]>]()
unowned let parentObject: AnyObject
public required init(parentObject: AnyObject) {
self.parentObject = parentObject
MainScheduler.ensureExecutingOnScheduler()
#if TRACE_RESOURCES
OSAtomicIncrement32(&resourceCount)
#endif
super.init()
}
public func observe(selector: Selector) -> Observable<[AnyObject]> {
if hasWiredImplementationForSelector(selector) {
print("Delegate proxy is already implementing `\(selector)`, a more performant way of registering might exist.")
}
if !self.respondsToSelector(selector) {
rxFatalError("This class doesn't respond to selector \(selector)")
}
let subject = subjectsForSelector[selector]
if let subject = subject {
return subject
}
else {
let subject = PublishSubject<[AnyObject]>()
subjectsForSelector[selector] = subject
return subject
}
}
// proxy
public override func interceptedSelector(selector: Selector, withArguments arguments: [AnyObject]!) {
trySendNext(subjectsForSelector[selector], arguments)
}
class func _pointer(p: UnsafePointer<Void>) -> UnsafePointer<Void> {
return p
}
public class func delegateAssociatedObjectTag() -> UnsafePointer<Void> {
return _pointer(&delegateAssociatedTag)
}
public class func createProxyForObject(object: AnyObject) -> AnyObject {
return self.init(parentObject: object)
}
public class func assignedProxyFor(object: AnyObject) -> AnyObject? {
let maybeDelegate: AnyObject? = objc_getAssociatedObject(object, self.delegateAssociatedObjectTag())
return castOptionalOrFatalError(maybeDelegate)
}
public class func assignProxy(proxy: AnyObject, toObject object: AnyObject) {
precondition(proxy.isKindOfClass(self.classForCoder()))
objc_setAssociatedObject(object, self.delegateAssociatedObjectTag(), proxy, .OBJC_ASSOCIATION_RETAIN)
}
public func setForwardToDelegate(delegate: AnyObject?, retainDelegate: Bool) {
self._setForwardToDelegate(delegate, retainDelegate: retainDelegate)
}
public func forwardToDelegate() -> AnyObject? {
return self._forwardToDelegate
}
deinit {
for v in subjectsForSelector.values {
sendCompleted(v)
}
#if TRACE_RESOURCES
OSAtomicDecrement32(&resourceCount)
#endif
}
} | mit | 8adacc894ab79442b49a38442e9941c0 | 29.83 | 124 | 0.666775 | 5.36 | false | false | false | false |
ello/ello-ios | Sources/Controllers/Following/FollowingViewController.swift | 1 | 5751 | ////
/// FollowingViewController.swift
//
import PromiseKit
class FollowingViewController: StreamableViewController {
override func trackerName() -> String? { return "Stream" }
override func trackerProps() -> [String: Any]? {
return ["kind": "Following"]
}
override func trackerStreamInfo() -> (String, String?)? {
return ("following", nil)
}
private var reloadFollowingContentObserver: NotificationObserver?
private var appBackgroundObserver: NotificationObserver?
private var appForegroundObserver: NotificationObserver?
private var newFollowingContentObserver: NotificationObserver?
private var _mockScreen: FollowingScreenProtocol?
var screen: FollowingScreenProtocol {
set(screen) { _mockScreen = screen }
get { return fetchScreen(_mockScreen) }
}
var generator: FollowingGenerator!
required init() {
super.init(nibName: nil, bundle: nil)
self.title = ""
generator = FollowingGenerator(destination: self)
}
required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
deinit {
removeNotificationObservers()
}
override func loadView() {
let screen = FollowingScreen()
screen.delegate = self
view = screen
viewContainer = screen.streamContainer
}
override func viewDidLoad() {
super.viewDidLoad()
streamViewController.initialLoadClosure = { [weak self] in self?.loadFollowing() }
streamViewController.streamKind = .following
setupNavigationItems(streamKind: .following)
streamViewController.showLoadingSpinner()
streamViewController.loadInitialPage()
addNotificationObservers()
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
addTemporaryNotificationObservers()
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
removeTemporaryNotificationObservers()
}
private func updateInsets() {
updateInsets(maxY: max(screen.navigationBar.frame.maxY - 14, 0))
}
override func showNavBars(animated: Bool) {
super.showNavBars(animated: animated)
positionNavBar(screen.navigationBar, visible: true, animated: animated)
updateInsets()
}
override func hideNavBars(animated: Bool) {
super.hideNavBars(animated: animated)
positionNavBar(screen.navigationBar, visible: false, animated: animated)
updateInsets()
}
override func streamWillPullToRefresh() {
super.streamWillPullToRefresh()
screen.newPostsButtonVisible = false
}
override func streamViewInfiniteScroll() -> Promise<[Model]>? {
return generator.loadNextPage()
}
}
extension FollowingViewController {
private func setupNavigationItems(streamKind: StreamKind) {
screen.navigationBar.leftItems = [.burger]
screen.navigationBar.rightItems = [.gridList(isGrid: streamKind.isGridView)]
}
private func addTemporaryNotificationObservers() {
reloadFollowingContentObserver = NotificationObserver(
notification: NewContentNotifications.reloadFollowingContent
) { [weak self] in
guard let `self` = self else { return }
self.streamViewController.showLoadingSpinner()
self.screen.newPostsButtonVisible = false
self.streamViewController.loadInitialPage(reload: true)
}
}
private func removeTemporaryNotificationObservers() {
reloadFollowingContentObserver?.removeObserver()
}
private func addNotificationObservers() {
newFollowingContentObserver = NotificationObserver(
notification: NewContentNotifications.newFollowingContent
) { [weak self] in
guard let `self` = self else { return }
self.screen.newPostsButtonVisible = true
}
}
private func removeNotificationObservers() {
newFollowingContentObserver?.removeObserver()
appBackgroundObserver?.removeObserver()
}
}
extension FollowingViewController: StreamDestination {
var isPagingEnabled: Bool {
get { return streamViewController.isPagingEnabled }
set { streamViewController.isPagingEnabled = newValue }
}
func loadFollowing() {
streamViewController.isPagingEnabled = false
generator.load()
}
func replacePlaceholder(
type: StreamCellType.PlaceholderType,
items: [StreamCellItem],
completion: @escaping Block
) {
streamViewController.replacePlaceholder(type: type, items: items, completion: completion)
if type == .streamItems {
streamViewController.doneLoading()
}
}
func setPlaceholders(items: [StreamCellItem]) {
streamViewController.clearForInitialLoad(newItems: items)
}
func setPrimary(jsonable: Model) {
}
func setPagingConfig(responseConfig: ResponseConfig) {
streamViewController.responseConfig = responseConfig
}
func primaryModelNotFound() {
self.showGenericLoadFailure()
self.streamViewController.doneLoading()
}
}
extension FollowingViewController: FollowingScreenDelegate {
func scrollToTop() {
streamViewController.scrollToTop(animated: true)
}
func loadNewPosts() {
let scrollView = streamViewController.collectionView
scrollView.setContentOffset(CGPoint(x: 0, y: -scrollView.contentInset.top), animated: true)
postNotification(NewContentNotifications.reloadFollowingContent, value: ())
screen.newPostsButtonVisible = false
}
}
| mit | 1dc51b3d36684ceee33b8a2daf8da943 | 28.953125 | 99 | 0.682838 | 5.359739 | false | false | false | false |
huangboju/Moots | Examples/UIScrollViewDemo/UIScrollViewDemo/Account/Views/MyCoRightsRecommendView.swift | 1 | 5494 | //
// File.swift
// UIScrollViewDemo
//
// Created by 黄伯驹 on 2017/11/9.
// Copyright © 2017年 伯驹 黄. All rights reserved.
//
class MyCoRightsRecommendViewCell: UICollectionViewCell, Reusable {
private lazy var imageView: UIImageView = {
let imageView = UIImageView()
imageView.backgroundColor = UIColor(white: 0.95, alpha: 1)
return imageView
}()
private lazy var titleLabel: UILabel = {
let titleLabel = generatLabel(with: UIFontMake(14))
titleLabel.backgroundColor = UIColor.blue
return titleLabel
}()
private lazy var pormtLabel: UILabel = {
let pormtLabel = generatLabel(with: UIFontMake(12))
pormtLabel.textColor = UIColor(hex: 0x4A4A4A)
pormtLabel.backgroundColor = UIColor.red
return pormtLabel
}()
override init(frame: CGRect) {
super.init(frame: frame)
backgroundColor = UIColor(white: 0.9, alpha: 1)
contentView.addSubview(imageView)
contentView.addSubview(titleLabel)
contentView.addSubview(pormtLabel)
}
override func layoutSubviews() {
super.layoutSubviews()
let width = bounds.width
imageView.frame = CGSize(width: width, height: 125).rect
titleLabel.frame = CGRect(x: 11, y: imageView.frame.maxY + 6, width: width - 22, height: 20)
pormtLabel.frame = CGRect(x: titleLabel.frame.minX, y: titleLabel.frame.maxY + 2, width: width - 22, height: 17)
}
private func generatLabel(with font: UIFont) -> UILabel {
let label = UILabel()
label.font = font
return label
}
public func updateCell() {}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
}
class MyCoRightsRecommendView: UIView {
public var data: [String] = []
private let layout = MyCollectionViewLayout()
private(set) var collectionView: UICollectionView!
override func layoutSubviews() {
super.layoutSubviews()
collectionView.frame = bounds
layout.itemSize = CGSize(width: (bounds.width - 3) / 2, height: 181)
}
override init(frame: CGRect) {
super.init(frame: frame)
collectionView = {
self.layout.minimumLineSpacing = 11
self.layout.minimumInteritemSpacing = 3
let collectionView = UICollectionView(frame: .zero, collectionViewLayout: self.layout)
collectionView.dataSource = self
collectionView.delegate = self
collectionView.backgroundColor = .white
collectionView.register(cellType: MyCoRightsRecommendViewCell.self)
collectionView.register(MyCollectionHeaderView.self, forSupplementaryViewOfKind: UICollectionView.elementKindSectionHeader, withReuseIdentifier: "header")
return collectionView
}()
addSubview(collectionView)
}
private weak var headerView: FormView?
public func addHeaderView(_ headerView: FormView) {
self.headerView = headerView
collectionView.addSubview(headerView)
}
public func freshView() {
collectionView.reloadData()
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
}
extension MyCoRightsRecommendView: UICollectionViewDataSource {
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return data.count
}
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
let cell: MyCoRightsRecommendViewCell = collectionView.dequeueReusableCell(for: indexPath)
cell.updateCell()
return cell
}
func collectionView(_ collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, at indexPath: IndexPath) -> UICollectionReusableView {
return collectionView.dequeueReusableSupplementaryView(ofKind: kind, withReuseIdentifier: "header", for: indexPath)
}
}
extension MyCoRightsRecommendView: UICollectionViewDelegateFlowLayout {
func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, referenceSizeForHeaderInSection section: Int) -> CGSize {
headerView?.layoutIfNeeded()
// 导航栏似乎有影响
guard var size = headerView?.contentSize else {
return .zero
}
size.height -= 64
return CGSize(width: SCREEN_WIDTH, height: size.height)
}
}
class MyCollectionHeaderView: UICollectionReusableView {
override init(frame: CGRect) {
super.init(frame: frame)
backgroundColor = .red
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
}
class MyCollectionViewLayout: UICollectionViewFlowLayout {
override func prepare() {
super.prepare()
}
override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
let attrs = super.layoutAttributesForElements(in: rect)
if let aaa = attrs {
for attr in aaa {
if attr.representedElementKind == UICollectionView.elementKindSectionHeader {
print(attr)
}
}
}
return attrs
}
}
| mit | e7881a02a68b47ef8e7e501692b3a94f | 30.039773 | 170 | 0.659711 | 5.148916 | false | false | false | false |
banxi1988/BXLoadMoreControl | Example/Pods/PinAuto/Pod/Classes/UIView+PinAuto.swift | 4 | 14358 | //
// UIView+PinAuto.swift
// Pods
//
// Created by Haizhen Lee on 16/1/14.
//
//
import UIKit
// PinAuto Chian Style Method Value Container
open class LayoutConstraintParams{
open var priority:UILayoutPriority = UILayoutPriorityRequired
open var relation: NSLayoutRelation = NSLayoutRelation.equal
open var firstItemAttribute:NSLayoutAttribute = NSLayoutAttribute.notAnAttribute
open var secondItemAttribute:NSLayoutAttribute = NSLayoutAttribute.notAnAttribute
open var multiplier:CGFloat = 1.0
open var constant:CGFloat = 0
open let firstItem:UIView
open var secondItem:AnyObject?
open var identifier:String? = LayoutConstraintParams.constraintIdentifier
open static let constraintIdentifier = "pin_auto"
fileprivate let attributesOfOpposite: [NSLayoutAttribute] = [.right,.rightMargin,.trailing,.trailingMargin,.bottom,.bottomMargin]
fileprivate var shouldReverseValue:Bool{
if firstItemAttribute == secondItemAttribute{
return attributesOfOpposite.contains(firstItemAttribute)
}
return false
}
public init(firstItem:UIView){
self.firstItem = firstItem
}
open var required:LayoutConstraintParams{
priority = UILayoutPriorityRequired
return self
}
open func withPriority(_ value:UILayoutPriority) -> LayoutConstraintParams{
priority = value
return self
}
open var withLowPriority:LayoutConstraintParams{
priority = UILayoutPriorityDefaultLow
return self
}
open var withHighPriority:LayoutConstraintParams{
priority = UILayoutPriorityDefaultHigh
return self
}
open func decrPriorityBy(_ value:UILayoutPriority) -> LayoutConstraintParams{
priority = priority - value
return self
}
open func incrPriorityBy(_ value:UILayoutPriority) -> LayoutConstraintParams{
priority = priority - value
return self
}
open func withRelation(_ relation:NSLayoutRelation){
self.relation = relation
}
open var withGteRelation:LayoutConstraintParams{
self.relation = .greaterThanOrEqual
return self
}
open var withLteRelation:LayoutConstraintParams{
self.relation = .lessThanOrEqual
return self
}
open var withEqRelation:LayoutConstraintParams{
self.relation = .equal
return self
}
open func multiplyBy(_ multiplier:CGFloat) -> LayoutConstraintParams{
self.multiplier = multiplier
return self
}
open func to(_ value:CGFloat) -> LayoutConstraintParams{
constant = value
relation = .equal
return self
}
open func equal(_ value:CGFloat) -> LayoutConstraintParams{
constant = value
relation = .equal
return self
}
open func equalTo(_ value:CGFloat) -> LayoutConstraintParams{
constant = value
relation = .equal
return self
}
open func eq(_ value:CGFloat) -> LayoutConstraintParams{
constant = value
relation = .equal
return self
}
open func lte(_ value:CGFloat) -> LayoutConstraintParams{
constant = value
relation = .lessThanOrEqual
return self
}
open func gte(_ value:CGFloat) -> LayoutConstraintParams{
constant = value
relation = .greaterThanOrEqual
return self
}
open func to(_ item:UIView) -> LayoutConstraintParams{
secondItem = item
return self
}
open func to(_ item:UILayoutSupport) -> LayoutConstraintParams{
secondItem = item
return self
}
open func equalTo(_ item:UIView) -> LayoutConstraintParams{
secondItem = item
relation = .equal
secondItemAttribute = firstItemAttribute
return self
}
open func eqTo(_ item:UIView) -> LayoutConstraintParams{
secondItem = item
relation = .equal
secondItemAttribute = firstItemAttribute
return self
}
open func offset(_ value:CGFloat) -> LayoutConstraintParams{
constant = value
return self
}
open func lteTo(_ item:UIView) -> LayoutConstraintParams{
secondItem = item
relation = .lessThanOrEqual
secondItemAttribute = firstItemAttribute
return self
}
open func gteTo(_ item:UIView) -> LayoutConstraintParams{
secondItem = item
relation = .greaterThanOrEqual
secondItemAttribute = firstItemAttribute
return self
}
open func lessThanOrEqualTo(_ item:UIView) -> LayoutConstraintParams{
secondItem = item
relation = .lessThanOrEqual
secondItemAttribute = firstItemAttribute
return self
}
open func greaterThanOrEqualTo(_ item:UIView) -> LayoutConstraintParams{
secondItem = item
relation = .greaterThanOrEqual
secondItemAttribute = firstItemAttribute
return self
}
open func identifier(_ id:String?) -> LayoutConstraintParams{
self.identifier = id
return self
}
open func equalTo(_ itemAttribute:NSLayoutAttribute,ofView view:UIView) -> LayoutConstraintParams{
self.secondItem = view
self.relation = .equal
self.secondItemAttribute = itemAttribute
return self
}
open var inSuperview: LayoutConstraintParams{
secondItem = firstItem.superview
return self
}
open var toSuperview: LayoutConstraintParams{
secondItem = firstItem.superview
return self
}
open func autoadd() -> NSLayoutConstraint{
return install()
}
@discardableResult
open func install() -> NSLayoutConstraint{
let finalConstanValue = shouldReverseValue ? -constant : constant
let constraint = NSLayoutConstraint(item: firstItem,
attribute: firstItemAttribute,
relatedBy: relation,
toItem: secondItem,
attribute: secondItemAttribute,
multiplier: multiplier,
constant: finalConstanValue)
constraint.identifier = identifier
firstItem.translatesAutoresizingMaskIntoConstraints = false
if let secondItem = secondItem{
firstItem.assertHasSuperview()
let containerView:UIView
if let secondItemView = secondItem as? UIView{
if firstItem.superview == secondItemView{
containerView = secondItemView
}else if firstItem.superview == secondItemView.superview{
containerView = firstItem.superview!
}else{
fatalError("Second Item Should be First Item 's superview or sibling view")
}
}else if secondItem is UILayoutSupport{
containerView = firstItem.superview!
}else{
fatalError("Second Item Should be UIView or UILayoutSupport")
}
containerView.addConstraint(constraint)
}else{
firstItem.addConstraint(constraint)
}
return constraint
}
}
// PinAuto Core Method
public extension UIView{
fileprivate var pa_makeConstraint:LayoutConstraintParams{
assertHasSuperview()
return LayoutConstraintParams(firstItem: self)
}
public var pa_width:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.firstItemAttribute = .width
pa.secondItem = nil
pa.secondItemAttribute = .notAnAttribute
return pa
}
public var pa_height:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.firstItemAttribute = .height
pa.secondItem = nil
pa.secondItemAttribute = .notAnAttribute
return pa
}
@available(*,introduced: 1.2)
public func pa_aspectRatio(_ ratio:CGFloat) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.firstItemAttribute = .height
pa.secondItemAttribute = .width
pa.secondItem = self
pa.multiplier = ratio // height = width * ratio
// ratio = width:height
return pa
}
public var pa_leading:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.firstItemAttribute = .leading
pa.secondItem = superview
pa.secondItemAttribute = .leading
return pa
}
public var pa_trailing:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .trailing
pa.secondItemAttribute = .trailing
return pa
}
public var pa_top:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .top
pa.secondItemAttribute = .top
return pa
}
public var pa_bottom:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .bottom
pa.secondItemAttribute = .bottom
return pa
}
public var pa_centerX:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .centerX
pa.secondItemAttribute = .centerX
return pa
}
public var pa_centerY:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .centerY
pa.secondItemAttribute = .centerY
return pa
}
public var pa_left:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .left
pa.secondItemAttribute = .left
return pa
}
public var pa_right:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .right
pa.secondItemAttribute = .right
return pa
}
public var pa_leadingMargin:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .leadingMargin
pa.secondItemAttribute = .leadingMargin
return pa
}
public var pa_trailingMargin:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .trailingMargin
pa.secondItemAttribute = .trailingMargin
return pa
}
public var pa_topMargin:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .topMargin
pa.secondItemAttribute = .topMargin
return pa
}
public var pa_bottomMargin:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .bottomMargin
pa.secondItemAttribute = .bottomMargin
return pa
}
public var pa_leftMargin:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .leftMargin
pa.secondItemAttribute = .leadingMargin
return pa
}
public var pa_rightMargin:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .rightMargin
pa.secondItemAttribute = .rightMargin
return pa
}
public var pa_centerXWithinMargins:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .centerXWithinMargins
pa.secondItemAttribute = .centerXWithinMargins
return pa
}
public var pa_centerYWithinMargins:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = superview
pa.firstItemAttribute = .centerYWithinMargins
pa.secondItemAttribute = .centerYWithinMargins
return pa
}
public var pa_baseline:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.firstItemAttribute = .lastBaseline
return pa
}
public var pa_firstBaseline:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.firstItemAttribute = .firstBaseline
return pa
}
public var pa_lastBaseline:LayoutConstraintParams{
let pa = pa_makeConstraint
pa.firstItemAttribute = NSLayoutAttribute.lastBaseline
return pa
}
public func pa_below(_ item:UILayoutSupport,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .top
pa.relation = .equal
pa.secondItemAttribute = .bottom
pa.constant = offset
return pa
}
public func pa_below(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .top
pa.relation = .equal
pa.secondItemAttribute = .bottom
pa.constant = offset
return pa
}
public func pa_above(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .bottom
pa.relation = .equal
pa.secondItemAttribute = .top
pa.constant = -offset
return pa
}
public func pa_above(_ item:UILayoutSupport,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .bottom
pa.relation = .equal
pa.secondItemAttribute = .top
pa.constant = -offset
return pa
}
public func pa_toLeadingOf(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .trailing
pa.relation = .equal
pa.secondItemAttribute = .leading
pa.constant = -offset
return pa
}
public func pa_before(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .trailing
pa.relation = .equal
pa.secondItemAttribute = .leading
pa.constant = -offset
return pa
}
public func pa_toLeftOf(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .right
pa.relation = .equal
pa.secondItemAttribute = .left
pa.constant = -offset
return pa
}
public func pa_toTrailingOf(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .leading
pa.relation = .equal
pa.secondItemAttribute = .trailing
pa.constant = offset
return pa
}
public func pa_after(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .leading
pa.relation = .equal
pa.secondItemAttribute = .trailing
pa.constant = offset
return pa
}
public func pa_toRightOf(_ item:UIView,offset:CGFloat = 0) -> LayoutConstraintParams{
let pa = pa_makeConstraint
pa.secondItem = item
pa.firstItemAttribute = .left
pa.relation = .equal
pa.secondItemAttribute = .right
pa.constant = offset
return pa
}
}
| mit | d5f85bd188679ae31b8e66c28be2727c | 23.755172 | 131 | 0.699262 | 5.122369 | false | false | false | false |
SmallElephant/FEAlgorithm-Swift | 4-ListNode/4-ListNode/main.swift | 1 | 4745 | //
// main.swift
// 4-ListNode
//
// Created by FlyElephant on 16/6/12.
// Copyright © 2016年 FlyElephant. All rights reserved.
//
import Foundation
var node1=ListNode()
node1.value=10
var node2=ListNode()
node2.value=20
node1.next=node2
var node3=ListNode()
node3.value=30
node2.next=node3
var node4 = ListNode()
node4.value=40
node3.next=node4
var node5 = ListNode()
node5.value=50
node4.next=node5
//var listManager:ListNodeManager = ListNodeManager()
//var head:ListNode?
//var firstNode:ListNode?
//var deleteNode:ListNode?
//listManager.createList(&head, data: 11)
//firstNode = head
//
//listManager.createList(&head, data: 12)
//listManager.createList(&head, data: 13)
//deleteNode = head
//listManager.createList(&head, data: 14)
//listManager.createList(&head, data: 15)
//
//listManager.deleteNode(head: &firstNode, toBeDeleted: &deleteNode)
//print("FlyElephant")
//listManager.printList(firstNode)
var searchManager:ListNodeManager = ListNodeManager()
var headNode:ListNode?
var searchHeadNode:ListNode?
searchManager.createList(&headNode, data: 1)
searchHeadNode = headNode
searchManager.createList(&headNode, data: 2)
searchManager.createList(&headNode, data: 3)
searchManager.createList(&headNode, data: 4)
searchManager.createList(&headNode, data: 5)
searchManager.createList(&headNode, data: 6)
searchManager.createList(&headNode, data: 7)
searchManager.createList(&headNode, data: 8)
searchManager.createList(&headNode, data: 9)
var searchNode:SearchNode = SearchNode()
var reverseNode:ListNode? = searchNode.reverseNodeList(head: searchHeadNode)
//searchNode.printList(reverseNode)
var mergeHeadNode:ListNode?
var mergeHead1:ListNode?
searchNode.createList(&mergeHeadNode, data: 1)
mergeHead1 = mergeHeadNode
searchNode.createList(&mergeHeadNode, data: 3)
searchNode.createList(&mergeHeadNode, data: 5)
searchNode.createList(&mergeHeadNode, data: 7)
var mergeHeadNode2:ListNode?
var mergeHead2:ListNode?
searchNode.createList(&mergeHeadNode2, data: 2)
mergeHead2 = mergeHeadNode2
searchNode.createList(&mergeHeadNode2, data: 4)
searchNode.createList(&mergeHeadNode2, data: 6)
searchNode.createList(&mergeHeadNode2, data: 8)
searchNode.printList(mergeHead1)
searchNode.printList(mergeHead2)
var mergeResultNode:ListNode? = searchNode.mergeSortList(head: mergeHead1, nextHead: mergeHead2)
searchNode.printList(mergeResultNode)
//var resultNode:ListNode? = searchNode.findNodeByDescendIndex(head: searchHeadNode, index: 3)
//if resultNode != nil {
// print("FlyElephant-节点的Value--\(resultNode!.value!)")
//} else {
// print("节点没有值")
//}
//
//var centerNode:ListNode? = searchNode.findCenterNode(head: searchHeadNode)
//if centerNode != nil {
// print("FlyElephant-中点的Value--\(centerNode!.value!)")
//} else {
// print("中点没有值")
//}
var randomHead:RandomListNode = RandomListNode()
randomHead.data = "A"
var randomNode1:RandomListNode = RandomListNode()
randomNode1.data = "B"
randomHead.next = randomNode1
var randomNode2:RandomListNode = RandomListNode()
randomNode2.data = "C"
randomNode1.next = randomNode2
var randomNode3:RandomListNode = RandomListNode()
randomNode3.data = "D"
randomNode2.next = randomNode3
var randomNode4:RandomListNode = RandomListNode()
randomNode4.data = "E"
randomNode3.next = randomNode4
randomHead.sibling = randomNode2
randomNode1.sibling = randomNode4
randomNode3.sibling = randomNode1
var pHead:RandomListNode? = randomHead
var clone:RandomListClone = RandomListClone()
clone.randomListNodeClone(headNode: &pHead)
while pHead != nil {
print("随机节点--\(pHead!.data)---👬--\(pHead!.sibling?.data)")
pHead = pHead?.next
}
var firstSearchNode:ListNode?
var firstSearchHead:ListNode?
searchNode.createList(&firstSearchNode, data: 1)
firstSearchHead = firstSearchNode
searchNode.createList(&firstSearchNode, data: 2)
searchNode.createList(&firstSearchNode, data: 3)
searchNode.createList(&firstSearchNode, data: 6)
searchNode.createList(&firstSearchNode, data: 7)
var nextSearchNode:ListNode?
var nextSearchHead:ListNode?
searchNode.createList(&nextSearchNode, data: 4)
nextSearchHead = nextSearchNode
searchNode.createList(&nextSearchNode, data: 5)
searchNode.createList(&nextSearchNode, data: 6)
searchNode.createList(&nextSearchNode, data: 7)
searchNode.printList(nextSearchHead)
var commonNode:ListNode? = searchNode.findFirstCommon(firstHead: firstSearchHead, nextHead: nextSearchHead)
if commonNode == nil {
print("没有公共节点")
} else {
print("第一个公共节点的值-\(commonNode!.value!)")
}
var josephList:JosephList = JosephList()
var josephHeadNode:ListNode? = josephList.createList(number: 5)
josephList.printList(headNode: josephHeadNode!, number: 5)
| mit | 66df963df4b7352109896d15c8630ed6 | 24.237838 | 107 | 0.774898 | 3.165424 | false | false | false | false |
zhangjk4859/MyWeiBoProject | sinaWeibo/sinaWeibo/Classes/Compose/表情选择器/EmoticonTextAttachment.swift | 1 | 845 | //
// EmoticonTextAttachment.swift
// sinaWeibo
//
// Created by 张俊凯 on 16/7/27.
// Copyright © 2016年 张俊凯. All rights reserved.
//
import UIKit
class EmoticonTextAttachment: NSTextAttachment {
// 保存对应表情的文字
var chs: String?
/// 根据表情模型, 创建表情字符串
class func imageText(emoticon: Emoticon, font: UIFont) -> NSAttributedString{
// 1.创建附件
let attachment = EmoticonTextAttachment()
attachment.chs = emoticon.chs
attachment.image = UIImage(contentsOfFile: emoticon.imagePath!)
// 设置了附件的大小
let s = font.lineHeight
attachment.bounds = CGRectMake(0, -4, s, s)
// 2. 根据附件创建属性字符串
return NSAttributedString(attachment: attachment)
}
}
| mit | 7111fa6d32d5f8e88d661d4804558a0e | 24.517241 | 81 | 0.632432 | 4.228571 | false | false | false | false |
microeditionbiz/ML-client | ML-client/View Controllers/InstallmentsViewController.swift | 1 | 3728 | //
// InstallmentsViewController.swift
// ML-client
//
// Created by Pablo Romero on 8/13/17.
// Copyright © 2017 Pablo Romero. All rights reserved.
//
import UIKit
class InstallmentsViewController: UIViewController {
@IBOutlet weak var tableView: UITableView!
@IBOutlet weak var activityIndicatorView: UIActivityIndicatorView!
var paymentInfo: PaymentInfo!
var installments: Installments?
var selectedPayerCost: Installments.PayerCost?
override func viewDidLoad() {
super.viewDidLoad()
setupTableView()
loadData()
}
// MARK: - Setup
private func setupTableView() {
// This is to don't have empty cells
tableView.tableFooterView = UIView()
tableView.backgroundColor = UIColor.clear
tableView.estimatedRowHeight = 44
tableView.rowHeight = UITableViewAutomaticDimension
}
// MARK: - Content
private func setLoadingMode(on: Bool) {
if on {
activityIndicatorView.startAnimating()
} else {
activityIndicatorView.stopAnimating()
}
activityIndicatorView.isHidden = !on
tableView.isHidden = on
}
// MARK: - Networking
private func loadData() {
guard let paymentMethodId = paymentInfo?.paymentMethod?.id, let cardIssuerId = paymentInfo?.cardIssuer?.id, let amount = paymentInfo?.amount else {
assertionFailure("Missing required info")
return
}
setLoadingMode(on: true)
MPAPI.sharedInstance.installments(paymentMethodId: paymentMethodId, issuerId: cardIssuerId, amount: amount) { (installments, error) in
self.setLoadingMode(on: false)
if let error = error {
UIAlertController.presentAlert(withError: error, overViewController: self)
} else {
self.installments = installments
self.tableView.reloadData()
}
}
}
// MARK: - Actions
@IBAction func payAction(_ sender: UIBarButtonItem) {
if selectedPayerCost == nil {
UIAlertController.presentAlert(message: "Primero debe seleccionar un plan de pagos.", overViewController: self)
} else {
completePaymentFlow()
}
}
// MARK: - Navigation
fileprivate func completePaymentFlow() {
UIAlertController.presentQuestion(text: "Proceder con el pago?", okTitle: "Ok", cancelTitle: "Cancelar", overViewController: self) { (pay) in
if pay {
self.paymentInfo?.payerCost = self.selectedPayerCost
self.paymentInfo?.completePaymentFlow()
}
}
}
}
// MARK: - Extensions
extension InstallmentsViewController: UITableViewDelegate, UITableViewDataSource {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return installments?.payerCosts?.count ?? 0
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let payerCost = installments!.payerCosts![indexPath.row]
let cell = tableView.dequeueReusableCell(withIdentifier: "PayerCostCell", for: indexPath) as! PayerCostCell
cell.update(withPayerCost: payerCost)
return cell
}
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
selectedPayerCost = installments?.payerCosts![indexPath.row]
}
func tableView(_ tableView: UITableView, didDeselectRowAt indexPath: IndexPath) {
selectedPayerCost = nil
}
}
| mit | 64608eeadada694c7f986c7367803ef5 | 29.54918 | 155 | 0.629461 | 5.44883 | false | false | false | false |
RoRoche/iOSSwiftStarter | iOSSwiftStarter/Pods/Nimble/Sources/Nimble/Matchers/BeginWith.swift | 111 | 2446 | import Foundation
/// A Nimble matcher that succeeds when the actual sequence's first element
/// is equal to the expected value.
public func beginWith<S: SequenceType, T: Equatable where S.Generator.Element == T>(startingElement: T) -> NonNilMatcherFunc<S> {
return NonNilMatcherFunc { actualExpression, failureMessage in
failureMessage.postfixMessage = "begin with <\(startingElement)>"
if let actualValue = try actualExpression.evaluate() {
var actualGenerator = actualValue.generate()
return actualGenerator.next() == startingElement
}
return false
}
}
/// A Nimble matcher that succeeds when the actual collection's first element
/// is equal to the expected object.
public func beginWith(startingElement: AnyObject) -> NonNilMatcherFunc<NMBOrderedCollection> {
return NonNilMatcherFunc { actualExpression, failureMessage in
failureMessage.postfixMessage = "begin with <\(startingElement)>"
let collection = try actualExpression.evaluate()
return collection != nil && collection!.indexOfObject(startingElement) == 0
}
}
/// A Nimble matcher that succeeds when the actual string contains expected substring
/// where the expected substring's location is zero.
public func beginWith(startingSubstring: String) -> NonNilMatcherFunc<String> {
return NonNilMatcherFunc { actualExpression, failureMessage in
failureMessage.postfixMessage = "begin with <\(startingSubstring)>"
if let actual = try actualExpression.evaluate() {
let range = actual.rangeOfString(startingSubstring)
return range != nil && range!.startIndex == actual.startIndex
}
return false
}
}
#if _runtime(_ObjC)
extension NMBObjCMatcher {
public class func beginWithMatcher(expected: AnyObject) -> NMBObjCMatcher {
return NMBObjCMatcher(canMatchNil: false) { actualExpression, failureMessage in
let actual = try! actualExpression.evaluate()
if let _ = actual as? String {
let expr = actualExpression.cast { $0 as? String }
return try! beginWith(expected as! String).matches(expr, failureMessage: failureMessage)
} else {
let expr = actualExpression.cast { $0 as? NMBOrderedCollection }
return try! beginWith(expected).matches(expr, failureMessage: failureMessage)
}
}
}
}
#endif
| apache-2.0 | 149a43369dff44bf326aa698769846ee | 43.472727 | 129 | 0.689697 | 5.328976 | false | false | false | false |
apple/swift-package-manager | Sources/PackageModel/Toolchain.swift | 2 | 2738 | //===----------------------------------------------------------------------===//
//
// This source file is part of the Swift 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 the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import TSCBasic
public protocol Toolchain {
/// Path of the librarian.
var librarianPath: AbsolutePath { get }
/// Path of the `swiftc` compiler.
var swiftCompilerPath: AbsolutePath { get }
/// Path containing the macOS Swift stdlib.
var macosSwiftStdlib: AbsolutePath { get throws }
/// Path of the `clang` compiler.
func getClangCompiler() throws -> AbsolutePath
// FIXME: This is a temporary API until index store is widely available in
// the OSS clang compiler. This API should not used for any other purpose.
/// Returns true if clang compiler's vendor is Apple and nil if unknown.
func _isClangCompilerVendorApple() throws -> Bool?
/// Additional flags to be passed to the build tools.
var extraFlags: BuildFlags { get }
/// Additional flags to be passed to the C compiler.
@available(*, deprecated, message: "use extraFlags.cCompilerFlags instead")
var extraCCFlags: [String] { get }
/// Additional flags to be passed to the Swift compiler.
@available(*, deprecated, message: "use extraFlags.swiftCompilerFlags instead")
var extraSwiftCFlags: [String] { get }
/// Additional flags to be passed to the C++ compiler.
@available(*, deprecated, message: "use extraFlags.cxxCompilerFlags instead")
var extraCPPFlags: [String] { get }
}
extension Toolchain {
public func _isClangCompilerVendorApple() throws -> Bool? {
return nil
}
public var macosSwiftStdlib: AbsolutePath {
get throws {
return try AbsolutePath(validating: "../../lib/swift/macosx", relativeTo: resolveSymlinks(swiftCompilerPath))
}
}
public var toolchainLibDir: AbsolutePath {
get throws {
// FIXME: Not sure if it's better to base this off of Swift compiler or our own binary.
return try AbsolutePath(validating: "../../lib", relativeTo: resolveSymlinks(swiftCompilerPath))
}
}
public var extraCCFlags: [String] {
extraFlags.cCompilerFlags
}
public var extraCPPFlags: [String] {
extraFlags.cxxCompilerFlags
}
public var extraSwiftCFlags: [String] {
extraFlags.swiftCompilerFlags
}
}
| apache-2.0 | fe8d750710572dc41e5d80183232b7e4 | 34.102564 | 121 | 0.640614 | 4.942238 | false | false | false | false |
apple/swift-nio-http2 | Sources/NIOHPACK/HPACKHeader.swift | 1 | 25458 | //===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftNIO open source project
//
// Copyright (c) 2017-2021 Apple Inc. and the SwiftNIO project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import NIOCore
import NIOHTTP1
/// Very similar to `NIOHTTP1.HTTPHeaders`, but with extra data for storing indexing
/// information.
public struct HPACKHeaders: ExpressibleByDictionaryLiteral, Sendable {
/// The maximum size of the canonical connection header value array to use when removing
/// connection headers during `HTTPHeaders` normalisation. When using an array the removal
/// is O(H·C) where H is the length of headers to noramlize and C is the length of the
/// connection header value array.
///
/// Beyond this limit we construct a set of the connection header values to reduce the
/// complexity to O(H).
///
/// We use an array for small connection header lists as it is cheaper (values don't need to be
/// hashed and constructing a set incurs an additional allocation). The value of 32 was picked
/// as the crossover point where using an array became more expensive than using a set when
/// running the `hpackheaders_normalize_httpheaders_removing_10k_conn_headers` performance test
/// with varying input sizes.
@usableFromInline
static let connectionHeaderValueArraySizeLimit = 32
@usableFromInline
internal var headers: [HPACKHeader]
// see 8.1.2.2. Connection-Specific Header Fields in RFC 7540
@usableFromInline
static let illegalHeaders: [String] = ["connection", "keep-alive", "proxy-connection",
"transfer-encoding", "upgrade"]
/// Constructor that can be used to map between `HTTPHeaders` and `HPACKHeaders` types.
@inlinable
public init(httpHeaders: HTTPHeaders, normalizeHTTPHeaders: Bool) {
if normalizeHTTPHeaders {
self.headers = httpHeaders.map { HPACKHeader(name: $0.name.lowercased(), value: $0.value) }
let connectionHeaderValue = httpHeaders[canonicalForm: "connection"]
// Above a limit we use a set rather than scanning the connection header value array.
// See `Self.connectionHeaderValueArraySizeLimit`.
if connectionHeaderValue.count > Self.connectionHeaderValueArraySizeLimit {
var headersToRemove = Set(connectionHeaderValue)
// Since we have a set we can just merge in the illegal headers.
headersToRemove.formUnion(Self.illegalHeaders.lazy.map { $0[...] })
self.headers.removeAll { header in
headersToRemove.contains(header.name[...])
}
} else {
self.headers.removeAll { header in
connectionHeaderValue.contains(header.name[...]) ||
HPACKHeaders.illegalHeaders.contains(header.name)
}
}
} else {
self.headers = httpHeaders.map { HPACKHeader(name: $0.name, value: $0.value) }
}
}
/// Constructor that can be used to map between `HTTPHeaders` and `HPACKHeaders` types.
@inlinable
public init(httpHeaders: HTTPHeaders) {
self.init(httpHeaders: httpHeaders, normalizeHTTPHeaders: true)
}
/// Construct a `HPACKHeaders` structure.
///
/// The indexability of all headers is assumed to be the default, i.e. indexable and
/// rewritable by proxies.
///
/// - parameters
/// - headers: An initial set of headers to use to populate the header block.
@inlinable
public init(_ headers: [(String, String)] = []) {
self.headers = headers.map { HPACKHeader(name: $0.0, value: $0.1) }
}
/// Construct a `HPACKHeaders` structure.
///
/// The indexability of all headers is assumed to be the default, i.e. indexable and
/// rewritable by proxies.
///
/// - Parameter elements: name, value pairs provided by a dictionary literal.
@inlinable
public init(dictionaryLiteral elements: (String, String)...) {
self.init(elements)
}
/// Construct a `HPACKHeaders` structure.
///
/// The indexability of all headers is assumed to be the default, i.e. indexable and
/// rewritable by proxies.
///
/// - parameters
/// - headers: An initial set of headers to use to populate the header block.
/// - allocator: The allocator to use to allocate the underlying storage.
@available(*, deprecated, renamed: "init(_:)")
public init(_ headers: [(String, String)] = [], allocator: ByteBufferAllocator) {
// We no longer use an allocator so we don't need this method anymore.
self.init(headers)
}
/// Internal initializer to make things easier for unit tests.
@inlinable
init(fullHeaders: [(HPACKIndexing, String, String)]) {
self.headers = fullHeaders.map { HPACKHeader(name: $0.1, value: $0.2, indexing: $0.0) }
}
/// Internal initializer for use in HPACK decoding.
@inlinable
init(headers: [HPACKHeader]) {
self.headers = headers
}
/// Add a header name/value pair to the block.
///
/// This method is strictly additive: if there are other values for the given header name
/// already in the block, this will add a new entry. `add` performs case-insensitive
/// comparisons on the header field name.
///
/// - Parameter name: The header field name. This must be an ASCII string. For HTTP/2 lowercase
/// header names are strongly encouraged.
/// - Parameter value: The header field value to add for the given name.
@inlinable
public mutating func add(name: String, value: String, indexing: HPACKIndexing = .indexable) {
precondition(!name.utf8.contains(where: { !$0.isASCII }), "name must be ASCII")
self.headers.append(HPACKHeader(name: name, value: value, indexing: indexing))
}
/// Add a sequence of header name/value pairs to the block.
///
/// This method is strictly additive: if there are other entries with the same header
/// name already in the block, this will add new entries.
///
/// - Parameter contentsOf: The sequence of header name/value pairs. Header names must be ASCII
/// strings. For HTTP/2 lowercase header names are strongly recommended.
@inlinable
public mutating func add<S: Sequence>(contentsOf other: S, indexing: HPACKIndexing = .indexable) where S.Element == (String, String) {
self.reserveCapacity(self.headers.count + other.underestimatedCount)
for (name, value) in other {
self.add(name: name, value: value, indexing: indexing)
}
}
/// Add a sequence of header name/value/indexing triplet to the block.
///
/// This method is strictly additive: if there are other entries with the same header
/// name already in the block, this will add new entries.
///
/// - Parameter contentsOf: The sequence of header name/value/indexing triplets. Header names
/// must be ASCII strings. For HTTP/2 lowercase header names are strongly recommended.
@inlinable
public mutating func add<S: Sequence>(contentsOf other: S) where S.Element == HPACKHeaders.Element {
self.reserveCapacity(self.headers.count + other.underestimatedCount)
for (name, value, indexing) in other {
self.add(name: name, value: value, indexing: indexing)
}
}
/// Add a header name/value pair to the block, replacing any previous values for the
/// same header name that are already in the block.
///
/// This is a supplemental method to `add` that essentially combines `remove` and `add`
/// in a single function. It can be used to ensure that a header block is in a
/// well-defined form without having to check whether the value was previously there.
/// Like `add`, this method performs case-insensitive comparisons of the header field
/// names.
///
/// - Parameter name: The header field name. For maximum compatibility this should be an
/// ASCII string. For future-proofing with HTTP/2 lowercase header names are strongly
/// recommended.
/// - Parameter value: The header field value to add for the given name.
@inlinable
public mutating func replaceOrAdd(name: String, value: String, indexing: HPACKIndexing = .indexable) {
self.remove(name: name)
self.add(name: name, value: value, indexing: indexing)
}
/// Remove all values for a given header name from the block.
///
/// This method uses case-insensitive comparisons for the header field name.
///
/// - Parameter name: The name of the header field to remove from the block.
@inlinable
public mutating func remove(name nameToRemove: String) {
self.headers.removeAll { header in
return nameToRemove.isEqualCaseInsensitiveASCIIBytes(to: header.name)
}
}
/// Retrieve all of the values for a given header field name from the block.
///
/// This method uses case-insensitive comparisons for the header field name. It
/// does not return a maximally-decomposed list of the header fields, but instead
/// returns them in their original representation: that means that a comma-separated
/// header field list may contain more than one entry, some of which contain commas
/// and some do not. If you want a representation of the header fields suitable for
/// performing computation on, consider `getCanonicalForm`.
///
/// - Parameter name: The header field name whose values are to be retrieved.
/// - Returns: A list of the values for that header field name.
@inlinable
public subscript(name: String) -> [String] {
guard !self.headers.isEmpty else {
return []
}
var array: [String] = []
for header in self.headers {
if header.name.isEqualCaseInsensitiveASCIIBytes(to: name) {
array.append(header.value)
}
}
return array
}
/// Retrieves the first value for a given header field name from the block.
///
/// This method uses case-insensitive comparisons for the header field name. It
/// does not return the first value from a maximally-decomposed list of the header fields,
/// but instead returns the first value from the original representation: that means
/// that a comma-separated header field list may contain more than one entry, some of
/// which contain commas and some do not. If you want a representation of the header fields
/// suitable for performing computation on, consider `getCanonicalForm`.
///
/// - Parameter name: The header field name whose first value should be retrieved.
/// - Returns: The first value for the header field name.
@inlinable
public func first(name: String) -> String? {
guard !self.headers.isEmpty else {
return nil
}
return self.headers.first { $0.name.isEqualCaseInsensitiveASCIIBytes(to: name) }?.value
}
/// Checks if a header is present.
///
/// - parameters:
/// - name: The name of the header
/// - returns: `true` if a header with the name (and value) exists, `false` otherwise.
@inlinable
public func contains(name: String) -> Bool {
guard !self.headers.isEmpty else {
return false
}
for header in self.headers {
if header.name.isEqualCaseInsensitiveASCIIBytes(to: name) {
return true
}
}
return false
}
/// Retrieves the header values for the given header field in "canonical form": that is,
/// splitting them on commas as extensively as possible such that multiple values received on the
/// one line are returned as separate entries. Also respects the fact that Set-Cookie should not
/// be split in this way.
///
/// - Parameter name: The header field name whose values are to be retrieved.
/// - Returns: A list of the values for that header field name.
@inlinable
public subscript(canonicalForm name: String) -> [String] {
let result = self[name]
guard result.count > 0 else {
return []
}
// It's not safe to split Set-Cookie on comma.
if name.isEqualCaseInsensitiveASCIIBytes(to: "set-cookie") {
return result
}
// We slightly overcommit here to try to reduce the amount of resizing we do.
var trimmedResults: [String] = []
trimmedResults.reserveCapacity(result.count * 4)
// This loop operates entirely on the UTF-8 views. This vastly reduces the cost of this slicing and dicing.
for field in result {
for entry in field.utf8._lazySplit(separator: UInt8(ascii: ",")) {
let trimmed = entry._trimWhitespace()
if trimmed.isEmpty {
continue
}
// This constructor pair kinda sucks, but you can't create a String from a slice of UTF8View as
// cheaply as you can with a Substring, so we go through that initializer instead.
trimmedResults.append(String(Substring(trimmed)))
}
}
return trimmedResults
}
/// Special internal function for use by tests.
internal subscript(position: Int) -> (String, String) {
precondition(position < self.headers.endIndex, "Position \(position) is beyond bounds of \(self.headers.endIndex)")
let header = self.headers[position]
return (header.name, header.value)
}
}
extension HPACKHeaders {
/// The total number of headers that can be contained without allocating new storage.
@inlinable
public var capacity: Int {
return self.headers.capacity
}
/// Reserves enough space to store the specified number of headers.
///
/// - Parameter minimumCapacity: The requested number of headers to store.
@inlinable
public mutating func reserveCapacity(_ minimumCapacity: Int) {
self.headers.reserveCapacity(minimumCapacity)
}
}
extension HPACKHeaders: RandomAccessCollection {
public typealias Element = (name: String, value: String, indexable: HPACKIndexing)
public struct Index: Comparable {
@usableFromInline
let _base: Array<HPACKHeaders>.Index
@inlinable
init(_base: Array<HPACKHeaders>.Index) {
self._base = _base
}
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
return lhs._base < rhs._base
}
}
@inlinable
public var startIndex: HPACKHeaders.Index {
return .init(_base: self.headers.startIndex)
}
@inlinable
public var endIndex: HPACKHeaders.Index {
return .init(_base: self.headers.endIndex)
}
@inlinable
public func index(before i: HPACKHeaders.Index) -> HPACKHeaders.Index {
return .init(_base: self.headers.index(before: i._base))
}
@inlinable
public func index(after i: HPACKHeaders.Index) -> HPACKHeaders.Index {
return .init(_base: self.headers.index(after: i._base))
}
@inlinable
public subscript(position: HPACKHeaders.Index) -> Element {
let element = self.headers[position._base]
return (name: element.name, value: element.value, indexable: element.indexing)
}
// Why are we providing an `Iterator` when we could just use the default one?
// The answer is that we changed from Sequence to RandomAccessCollection in a SemVer minor release. The
// previous code had a special-case Iterator, and so to avoid breaking that abstraction we need to provide one
// here too. Happily, however, we can simply delegate to the underlying Iterator type.
/// An iterator of HTTP header fields.
///
/// This iterator will return each value for a given header name separately. That
/// means that `name` is not guaranteed to be unique in a given block of headers.
public struct Iterator: IteratorProtocol {
@usableFromInline
var _base: Array<HPACKHeader>.Iterator
@inlinable
init(_ base: HPACKHeaders) {
self._base = base.headers.makeIterator()
}
@inlinable
public mutating func next() -> Element? {
guard let element = self._base.next() else {
return nil
}
return (name: element.name, value: element.value, indexable: element.indexing)
}
}
@inlinable
public func makeIterator() -> HPACKHeaders.Iterator {
return Iterator(self)
}
}
extension HPACKHeaders: CustomStringConvertible {
public var description: String {
var headersArray: [(HPACKIndexing, String, String)] = []
headersArray.reserveCapacity(self.headers.count)
for h in self.headers {
headersArray.append((h.indexing, h.name, h.value))
}
return headersArray.description
}
}
// NOTE: This is a bad definition of equatable and hashable. In particular, both order and
// indexability are ignored. We should change it, but we should be careful when we do so.
// More discussion at https://github.com/apple/swift-nio-http2/issues/342.
extension HPACKHeaders: Equatable {
@inlinable
public static func ==(lhs: HPACKHeaders, rhs: HPACKHeaders) -> Bool {
guard lhs.headers.count == rhs.headers.count else {
return false
}
let lhsNames = Set(lhs.headers.map { $0.name })
let rhsNames = Set(rhs.headers.map { $0.name })
guard lhsNames == rhsNames else {
return false
}
for name in lhsNames {
guard lhs[name].sorted() == rhs[name].sorted() else {
return false
}
}
return true
}
}
extension HPACKHeaders: Hashable {
@inlinable
public func hash(into hasher: inout Hasher) {
// Discriminator, to indicate that this is a collection. This improves the performance
// of Sets and Dictionaries that include collections of HPACKHeaders by reducing hash collisions.
hasher.combine(self.count)
// This emulates the logic used in equatability, but we sort it to ensure that
// we hash equivalently.
let names = Set(self.headers.lazy.map { $0.name }).sorted()
for name in names {
hasher.combine(self[name].sorted())
}
}
}
/// Defines the types of indexing and rewriting operations a decoder may take with
/// regard to this header.
public enum HPACKIndexing: CustomStringConvertible, Sendable {
/// Header may be written into the dynamic index table or may be rewritten by
/// proxy servers.
case indexable
/// Header is not written to the dynamic index table, but proxies may rewrite
/// it en-route, as long as they preserve its non-indexable attribute.
case nonIndexable
/// Header may not be written to the dynamic index table, and proxies must
/// pass it on as-is without rewriting.
case neverIndexed
public var description: String {
switch self {
case .indexable:
return "[]"
case .nonIndexable:
return "[non-indexable]"
case .neverIndexed:
return "[neverIndexed]"
}
}
}
@usableFromInline
internal struct HPACKHeader: Sendable {
@usableFromInline
var indexing: HPACKIndexing
@usableFromInline
var name: String
@usableFromInline
var value: String
@inlinable
internal init(name: String, value: String, indexing: HPACKIndexing = .indexable) {
self.indexing = indexing
self.name = name
self.value = value
}
}
extension HPACKHeader {
@inlinable
internal var size: Int {
// RFC 7541 § 4.1:
//
// The size of an entry is the sum of its name's length in octets (as defined in
// Section 5.2), its value's length in octets, and 32.
//
// The size of an entry is calculated using the length of its name and value
// without any Huffman encoding applied.
return name.utf8.count + value.utf8.count + 32
}
}
internal extension UInt8 {
@inlinable
var isASCII: Bool {
return self <= 127
}
}
/* private but inlinable */
internal extension UTF8.CodeUnit {
@inlinable
var isASCIIWhitespace: Bool {
switch self {
case UInt8(ascii: " "),
UInt8(ascii: "\t"):
return true
default:
return false
}
}
}
extension Substring.UTF8View {
@inlinable
func _trimWhitespace() -> Substring.UTF8View {
guard let firstNonWhitespace = self.firstIndex(where: { !$0.isASCIIWhitespace }) else {
// The whole substring is ASCII whitespace.
return Substring().utf8
}
// There must be at least one non-ascii whitespace character, so banging here is safe.
let lastNonWhitespace = self.lastIndex(where: { !$0.isASCIIWhitespace })!
return self[firstNonWhitespace...lastNonWhitespace]
}
}
extension String.UTF8View {
@inlinable
func _lazySplit(separator: UTF8.CodeUnit) -> LazyUTF8ViewSplitSequence {
return LazyUTF8ViewSplitSequence(self, separator: separator)
}
@usableFromInline
struct LazyUTF8ViewSplitSequence: Sequence {
@usableFromInline typealias Element = Substring.UTF8View
@usableFromInline var _baseView: String.UTF8View
@usableFromInline var _separator: UTF8.CodeUnit
@inlinable
init(_ baseView: String.UTF8View, separator: UTF8.CodeUnit) {
self._baseView = baseView
self._separator = separator
}
@inlinable
func makeIterator() -> Iterator {
return Iterator(self)
}
@usableFromInline
struct Iterator: IteratorProtocol {
@usableFromInline var _base: LazyUTF8ViewSplitSequence
@usableFromInline var _lastSplitIndex: Substring.UTF8View.Index
@inlinable
init(_ base: LazyUTF8ViewSplitSequence) {
self._base = base
self._lastSplitIndex = base._baseView.startIndex
}
@inlinable
mutating func next() -> Substring.UTF8View? {
let endIndex = self._base._baseView.endIndex
guard self._lastSplitIndex != endIndex else {
return nil
}
let restSlice = self._base._baseView[self._lastSplitIndex...]
if let nextSplitIndex = restSlice.firstIndex(of: self._base._separator) {
// The separator is present. We want to drop the separator, so we need to advance the index past this point.
self._lastSplitIndex = self._base._baseView.index(after: nextSplitIndex)
return restSlice[..<nextSplitIndex]
} else {
// The separator isn't present, so we want the entire rest of the slice.
self._lastSplitIndex = self._base._baseView.endIndex
return restSlice
}
}
}
}
}
extension String.UTF8View {
/// Compares two UTF8 strings as case insensitive ASCII bytes.
///
/// - Parameter bytes: The string constant in the form of a collection of `UInt8`
/// - Returns: Whether the collection contains **EXACTLY** this array or no, but by ignoring case.
@inlinable
func compareCaseInsensitiveASCIIBytes(to other: String.UTF8View) -> Bool {
// fast path: we can get the underlying bytes of both
let maybeMaybeResult = self.withContiguousStorageIfAvailable { lhsBuffer -> Bool? in
other.withContiguousStorageIfAvailable { rhsBuffer in
if lhsBuffer.count != rhsBuffer.count {
return false
}
for idx in 0 ..< lhsBuffer.count {
// let's hope this gets vectorised ;)
if lhsBuffer[idx] & 0xdf != rhsBuffer[idx] & 0xdf && lhsBuffer[idx].isASCII {
return false
}
}
return true
}
}
if let maybeResult = maybeMaybeResult, let result = maybeResult {
return result
} else {
return self._compareCaseInsensitiveASCIIBytesSlowPath(to: other)
}
}
@inlinable
@inline(never)
func _compareCaseInsensitiveASCIIBytesSlowPath(to other: String.UTF8View) -> Bool {
return self.elementsEqual(other, by: { return (($0 & 0xdf) == ($1 & 0xdf) && $0.isASCII) })
}
}
extension String {
@inlinable
internal func isEqualCaseInsensitiveASCIIBytes(to: String) -> Bool {
return self.utf8.compareCaseInsensitiveASCIIBytes(to: to.utf8)
}
}
| apache-2.0 | 3c65373ec175b9bb84cd73c63d484a2c | 37.279699 | 138 | 0.631128 | 4.704491 | false | false | false | false |
DimaKorol/CollectionViewAdapter | CollectionViewAdapter/DelegeteCellManager+CollectionViewDelegates.swift | 1 | 15555 | //
// DefaultCollectionViewDelegate.swift
// CollectionViewAdapter
//
// Created by dimakorol on 4/6/16.
// Copyright © 2016 dimakorol. All rights reserved.
//
import UIKit
extension DelegateCellManager: UICollectionViewDataSource, UICollectionViewDelegateFlowLayout {
public func collectionView(collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return getCount()
}
public func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
guard let (cellData, cellBinder) = getAllForIndex(indexPath.row) else {
if let cell = ownDataSourceDelegate?.collectionView(collectionView, cellForItemAtIndexPath: indexPath){
return cell
}
return UICollectionViewCell()
}
let cell = collectionView.dequeueReusableCellWithReuseIdentifier(cellBinder.cellId, forIndexPath: indexPath)
bindData(cell, cellBinder: cellBinder, data: cellData.data)
return cell
}
public func numberOfSectionsInCollectionView(collectionView: UICollectionView) -> Int{
if let numberOfSections = ownDataSourceDelegate?.numberOfSectionsInCollectionView?(collectionView){
return numberOfSections
}
return 1
}
// // The view that is returned must be retrieved from a call to -dequeueReusableSupplementaryViewOfKind:withReuseIdentifier:forIndexPath:
// public func collectionView(collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, atIndexPath indexPath: NSIndexPath) -> UICollectionReusableView{
// if let reusableView = ownDataSourceDelegate?.collectionView?(collectionView, viewForSupplementaryElementOfKind: kind, atIndexPath: indexPath){
// return reusableView
// }
// return UICollectionReusableView()
// }
@available(iOS 9.0, *)
public func collectionView(collectionView: UICollectionView, canMoveItemAtIndexPath indexPath: NSIndexPath) -> Bool{
if let canMoveItemAtIndexPath = ownDataSourceDelegate?.collectionView?(collectionView, canMoveItemAtIndexPath: indexPath){
return canMoveItemAtIndexPath
}
return false
}
@available(iOS 9.0, *)
public func collectionView(collectionView: UICollectionView, moveItemAtIndexPath sourceIndexPath: NSIndexPath, toIndexPath destinationIndexPath: NSIndexPath){
ownDataSourceDelegate?.collectionView?(collectionView, moveItemAtIndexPath: sourceIndexPath, toIndexPath : destinationIndexPath)
}
public func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAtIndexPath indexPath: NSIndexPath) -> CGSize{
guard let (cellData, cellBinder) = getAllForIndex(indexPath.row) else {
return defaultSize(collectionView, layout: collectionViewLayout, defaultSizeForItemAtIndexPath: indexPath)
}
var size : CGSize?
if let autolayout = cellBinder.cellAutoSize where autolayout{
let cell = templateCell(cellBinder)
bindData(cell, cellBinder: cellBinder, data: cellData.data)
size = cell.estimateSizeWith(cellBinder, collectionViewSize: collectionView.frame.size)
if let correctedSize = cellBinder.cellSize?(collectionView, estimatedSize: size!){
size = correctedSize
}
} else{
if let newSize = cellBinder.collectionView?(collectionView, layout: collectionViewLayout, sizeForItemAtIndexPath: indexPath){
size = newSize
}
}
guard let resultSize = size else{
return defaultSize(collectionView, layout: collectionViewLayout, defaultSizeForItemAtIndexPath: indexPath)
}
return resultSize
}
func defaultSize(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, defaultSizeForItemAtIndexPath indexPath: NSIndexPath) -> CGSize{
if let size = ownViewDelegateFlowLayout?.collectionView?(collectionView, layout: collectionViewLayout, sizeForItemAtIndexPath: indexPath){
return size
}
return (collectionViewLayout as! UICollectionViewFlowLayout).itemSize
}
public func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, insetForSectionAtIndex section: Int) -> UIEdgeInsets{
if let edge = ownViewDelegateFlowLayout?.collectionView?(collectionView, layout: collectionViewLayout, insetForSectionAtIndex: section){
return edge
}
return (collectionViewLayout as! UICollectionViewFlowLayout).sectionInset
}
public func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, minimumLineSpacingForSectionAtIndex section: Int) -> CGFloat{
if let minimumLineSpacing = ownViewDelegateFlowLayout?.collectionView?(collectionView, layout: collectionViewLayout, minimumLineSpacingForSectionAtIndex: section){
return minimumLineSpacing
}
return (collectionViewLayout as! UICollectionViewFlowLayout).minimumLineSpacing
}
public func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, minimumInteritemSpacingForSectionAtIndex section: Int) -> CGFloat{
if let minimumInteritemSpacing = ownViewDelegateFlowLayout?.collectionView?(collectionView, layout: collectionViewLayout, minimumInteritemSpacingForSectionAtIndex: section){
return minimumInteritemSpacing
}
return (collectionViewLayout as! UICollectionViewFlowLayout).minimumInteritemSpacing
}
public func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, referenceSizeForHeaderInSection section: Int) -> CGSize{
if let headerReferenceSize = ownViewDelegateFlowLayout?.collectionView?(collectionView, layout: collectionViewLayout, referenceSizeForHeaderInSection: section){
return headerReferenceSize
}
return (collectionViewLayout as! UICollectionViewFlowLayout).headerReferenceSize
}
public func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, referenceSizeForFooterInSection section: Int) -> CGSize{
if let footerReferenceSize = ownViewDelegateFlowLayout?.collectionView?(collectionView, layout: collectionViewLayout, referenceSizeForFooterInSection: section){
return footerReferenceSize
}
return (collectionViewLayout as! UICollectionViewFlowLayout).footerReferenceSize
}
public func collectionView(collectionView: UICollectionView, shouldHighlightItemAtIndexPath indexPath: NSIndexPath) -> Bool{
guard let cellBinder = getAllForIndex(indexPath.row)?.1,
shouldHighlightItemAtIndexPath = cellBinder.collectionView?(collectionView, shouldHighlightItemAtIndexPath: indexPath) else {
if let shouldHighlightItemAtIndexPath = ownViewDelegateFlowLayout?.collectionView?(collectionView, shouldHighlightItemAtIndexPath: indexPath){
return shouldHighlightItemAtIndexPath
}
return true
}
return shouldHighlightItemAtIndexPath
}
public func collectionView(collectionView: UICollectionView, didHighlightItemAtIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, didHighlightItemAtIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, didHighlightItemAtIndexPath: indexPath)
}
}
public func collectionView(collectionView: UICollectionView, didUnhighlightItemAtIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, didUnhighlightItemAtIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, didUnhighlightItemAtIndexPath: indexPath)
}
}
public func collectionView(collectionView: UICollectionView, shouldSelectItemAtIndexPath indexPath: NSIndexPath) -> Bool{
guard let cellBinder = getAllForIndex(indexPath.row)?.1,
shouldSelectItemAtIndexPath = cellBinder.collectionView?(collectionView, shouldSelectItemAtIndexPath: indexPath) else {
if let shouldSelectItemAtIndexPath = ownViewDelegateFlowLayout?.collectionView?(collectionView, shouldSelectItemAtIndexPath: indexPath){
return shouldSelectItemAtIndexPath
}
return true
}
return shouldSelectItemAtIndexPath
}
public func collectionView(collectionView: UICollectionView, shouldDeselectItemAtIndexPath indexPath: NSIndexPath) -> Bool{
guard let cellBinder = getAllForIndex(indexPath.row)?.1,
shouldDeselectItemAtIndexPath = cellBinder.collectionView?(collectionView, shouldSelectItemAtIndexPath: indexPath) else {
if let shouldDeselectItemAtIndexPath = ownViewDelegateFlowLayout?.collectionView?(collectionView, shouldSelectItemAtIndexPath: indexPath){
return shouldDeselectItemAtIndexPath
}
return true
}
return shouldDeselectItemAtIndexPath
}// called when the user taps on an already-selected item in multi-select mode
public func collectionView(collectionView: UICollectionView, didSelectItemAtIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, didSelectItemAtIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, didSelectItemAtIndexPath: indexPath)
}
}
public func collectionView(collectionView: UICollectionView, didDeselectItemAtIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, didDeselectItemAtIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, didDeselectItemAtIndexPath: indexPath)
}
}
public func collectionView(collectionView: UICollectionView, willDisplayCell cell: UICollectionViewCell, forItemAtIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, willDisplayCell: cell, forItemAtIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, willDisplayCell: cell, forItemAtIndexPath: indexPath)
}
}
public func collectionView(collectionView: UICollectionView, willDisplaySupplementaryView view: UICollectionReusableView, forElementKind elementKind: String, atIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, willDisplaySupplementaryView: view, forElementKind: elementKind, atIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, willDisplaySupplementaryView: view, forElementKind: elementKind, atIndexPath: indexPath)
}
}
public func collectionView(collectionView: UICollectionView, didEndDisplayingCell cell: UICollectionViewCell, forItemAtIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, didEndDisplayingCell: cell, forItemAtIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, didEndDisplayingCell: cell, forItemAtIndexPath: indexPath)
}
}
public func collectionView(collectionView: UICollectionView, didEndDisplayingSupplementaryView view: UICollectionReusableView, forElementOfKind elementKind: String, atIndexPath indexPath: NSIndexPath){
ownViewDelegateFlowLayout?.collectionView?(collectionView, didEndDisplayingSupplementaryView: view, forElementOfKind: elementKind, atIndexPath: indexPath)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, didEndDisplayingSupplementaryView: view, forElementOfKind: elementKind, atIndexPath: indexPath)
}
}
// These methods provide support for copy/paste actions on cells.
// All three should be implemented if any are.
public func collectionView(collectionView: UICollectionView, shouldShowMenuForItemAtIndexPath indexPath: NSIndexPath) -> Bool{
guard let cellBinder = getAllForIndex(indexPath.row)?.1,
shouldShowMenuForItemAtIndexPath = cellBinder.collectionView?(collectionView, shouldShowMenuForItemAtIndexPath: indexPath) else {
if let shouldShowMenuForItemAtIndexPath = ownViewDelegateFlowLayout?.collectionView?(collectionView, shouldShowMenuForItemAtIndexPath: indexPath){
return shouldShowMenuForItemAtIndexPath
}
return false
}
return shouldShowMenuForItemAtIndexPath
}
public func collectionView(collectionView: UICollectionView, canPerformAction action: Selector, forItemAtIndexPath indexPath: NSIndexPath, withSender sender: AnyObject?) -> Bool{
guard let cellBinder = getAllForIndex(indexPath.row)?.1,
canPerformAction = cellBinder.collectionView?(collectionView, canPerformAction:action, forItemAtIndexPath: indexPath, withSender: sender) else {
if let canPerformAction = ownViewDelegateFlowLayout?.collectionView?(collectionView, canPerformAction:action, forItemAtIndexPath: indexPath, withSender: sender){
return canPerformAction
}
return false
}
return canPerformAction
}
public func collectionView(collectionView: UICollectionView, performAction action: Selector, forItemAtIndexPath indexPath: NSIndexPath, withSender sender: AnyObject?){
ownViewDelegateFlowLayout?.collectionView?(collectionView, performAction: action, forItemAtIndexPath: indexPath, withSender: sender)
if let cellBinder = getAllForIndex(indexPath.row)?.1 {
cellBinder.collectionView?(collectionView, performAction: action, forItemAtIndexPath: indexPath, withSender: sender)
}
}
// Focus
@available(iOS 9.0, *)
public func collectionView(collectionView: UICollectionView, canFocusItemAtIndexPath indexPath: NSIndexPath) -> Bool{
guard let cellBinder = getAllForIndex(indexPath.row)?.1,
canFocusItemAtIndexPath = cellBinder.collectionView?(collectionView, canFocusItemAtIndexPath: indexPath) else {
if let canFocusItemAtIndexPath = ownViewDelegateFlowLayout?.collectionView?(collectionView, canFocusItemAtIndexPath: indexPath){
return canFocusItemAtIndexPath
}
return true
}
return canFocusItemAtIndexPath
}
}
| mit | 778069ca8b1b8a960ec787616dff0ea3 | 53.575439 | 205 | 0.72798 | 7.034826 | false | false | false | false |
lemberg/obd2-swift-lib | OBD2-Swift/Classes/Parser/Descriptor01.swift | 1 | 7673 | //
// Descriptor.swift
// OBD2Swift
//
// Created by Max Vitruk on 5/25/17.
// Copyright © 2017 Lemberg. All rights reserved.
//
import Foundation
public class Mode01Descriptor : DescriptorProtocol {
public var response : Response
var descriptor : SensorDescriptor
required public init(describe response : Response) {
self.response = response
let pid = response.pid
self.mode = response.mode
guard pid >= 0x0 && pid <= 0x4E else {
assertionFailure("Unsuported pid group")
self.descriptor = SensorDescriptorTable[0]
return
}
self.descriptor = SensorDescriptorTable[Int(pid)]
}
public var mode : Mode
public var pid : UInt8 {
return response.pid
}
public var valueMetrics : Float? {
guard let data = response.data else {return nil}
guard !isAsciiEncoded else {return nil}
guard let exec = descriptor.calcFunction else {return nil}
return exec(data)
}
public var valueImperial : Float? {
guard let value = valueMetrics else {return nil}
guard let exec = descriptor.convertFunction else {return nil}
return exec(value)
}
public var unitsImperial : Float? {
guard let value = valueMetrics else {return nil}
guard let exec = descriptor.convertFunction else {return nil}
return exec(value)
}
public var asciValue : String? {
guard let data = response.data else {return nil}
guard isAsciiEncoded else {return nil}
return calculateStringForData(data: data)
}
public var description : String {
return descriptor.description
}
public var shortDescription :String {
return descriptor.shortDescription
}
public var unitImperial : String {
return descriptor.imperialUnit
}
public var unitMetric : String {
return descriptor.metricUnit
}
public var isAsciiEncoded : Bool {
return IS_ALPHA_VALUE(pid: pid)
}
public func stringRepresentation(metric : Bool, rounded : Bool = false) -> String {
if isAsciiEncoded {
return asciValue ?? ""
}else{
guard let value = self.value(metric: metric) else {return ""}
let units = self.units(metric: metric)
if rounded {
return "\(Int.init(value)) \(units)"
}else{
return "\(value) \(units)"
}
}
}
public func units(metric : Bool) -> String {
return metric ? descriptor.metricUnit : descriptor.imperialUnit
}
public func value(metric : Bool) -> Float? {
return metric ? valueMetrics : valueImperial
}
public func minValue(metric : Bool) -> Int {
if isAsciiEncoded {
return Int.min
}
return metric ? descriptor.minMetricValue : descriptor.minImperialValue
}
public func maxValue(metric : Bool) -> Int {
if isAsciiEncoded {
return Int.max
}
return metric ? descriptor.maxMetricValue : descriptor.maxImperialValue
}
//TODO: - Add multidescriptor to descriptor tables
// public func isMultiValue() -> Bool {
// return IS_MULTI_VALUE_SENSOR(pid: pid)
// }
//MARK: - String Calculation Methods
private func calculateStringForData(data : Data) -> String? {
switch pid {
case 0x03:
return calculateFuelSystemStatus(data)
case 0x12:
return calculateSecondaryAirStatus(data)
case 0x13:
return calculateOxygenSensorsPresent(data)
case 0x1C:
return calculateDesignRequirements(data)
case 0x1D:
return "" //TODO: pid 29 - Oxygen Sensor
case 0x1E:
return calculateAuxiliaryInputStatus(data)
default:
return nil
}
}
private func calculateAuxiliaryInputStatus(_ data : Data) -> String? {
var dataA = data[0]
dataA = dataA & ~0x7F // only bit 0 is valid
if dataA & 0x01 != 0 {
return "PTO_STATE: ON"
}else if dataA & 0x02 != 0 {
return "PTO_STATE: OFF"
}else {
return nil
}
}
private func calculateDesignRequirements(_ data : Data) -> String? {
var returnString : String?
let dataA = data[0]
switch dataA {
case 0x01:
returnString = "OBD II"
break
case 0x02:
returnString = "OBD"
break
case 0x03:
returnString = "OBD I and OBD II"
break
case 0x04:
returnString = "OBD I"
break
case 0x05:
returnString = "NO OBD"
break
case 0x06:
returnString = "EOBD"
break
case 0x07:
returnString = "EOBD and OBD II"
break
case 0x08:
returnString = "EOBD and OBD"
break
case 0x09:
returnString = "EOBD, OBD and OBD II"
break
case 0x0A:
returnString = "JOBD";
break
case 0x0B:
returnString = "JOBD and OBD II"
break
case 0x0C:
returnString = "JOBD and EOBD"
break
case 0x0D:
returnString = "JOBD, EOBD, and OBD II"
break
default:
returnString = "N/A"
break
}
return returnString
}
private func calculateOxygenSensorsPresent(_ data : Data) -> String {
var returnString : String = ""
let dataA = data[0]
if dataA & 0x01 != 0 {
returnString = "O2S11"
}
if dataA & 0x02 != 0 {
returnString = "\(returnString), O2S12"
}
if dataA & 0x04 != 0 {
returnString = "\(returnString), O2S13"
}
if dataA & 0x08 != 0 {
returnString = "\(returnString), O2S14"
}
if dataA & 0x10 != 0 {
returnString = "\(returnString), O2S21"
}
if dataA & 0x20 != 0 {
returnString = "\(returnString), O2S22"
}
if dataA & 0x40 != 0 {
returnString = "\(returnString), O2S23"
}
if dataA & 0x80 != 0 {
returnString = "\(returnString), O2S24"
}
return returnString
}
private func calculateOxygenSensorsPresentB(_ data : Data) -> String {
var returnString : String = ""
let dataA = data[0]
if(dataA & 0x01 != 0){
returnString = "O2S11"
}
if dataA & 0x02 != 0 {
returnString = "\(returnString), O2S12"
}
if dataA & 0x04 != 0 {
returnString = "\(returnString), O2S21"
}
if(dataA & 0x08 != 0) {
returnString = "\(returnString), O2S22"
}
if dataA & 0x10 != 0 {
returnString = "\(returnString), O2S31"
}
if dataA & 0x20 != 0 {
returnString = "\(returnString), O2S32"
}
if dataA & 0x40 != 0 {
returnString = "\(returnString), O2S41"
}
if dataA & 0x80 != 0 {
returnString = "\(returnString), O2S42"
}
return returnString
}
private func calculateFuelSystemStatus(_ data : Data) -> String {
var rvString : String = ""
let dataA = data[0]
switch dataA {
case 0x01:
rvString = "Open Loop"
break
case 0x02:
rvString = "Closed Loop"
break
case 0x04:
rvString = "OL-Drive"
break;
case 0x08:
rvString = "OL-Fault"
break
case 0x10:
rvString = "CL-Fault"
break
default:
break
}
return rvString
}
private func calculateSecondaryAirStatus(_ data : Data) -> String {
var rvString : String = ""
let dataA = data[0]
switch dataA {
case 0x01:
rvString = "AIR_STAT: UPS"
break
case 0x02:
rvString = "AIR_STAT: DNS"
break
case 0x04:
rvString = "AIR_STAT: OFF"
break
default:
break
}
return rvString
}
}
| mit | c1f92f3ad9b0aa1146ed9779d02cccd3 | 21.97006 | 85 | 0.579901 | 3.886525 | false | false | false | false |
akolov/FlingChallenge | FlingChallenge/FlingChallenge/CircularProgressIndicator.swift | 1 | 1965 | //
// CircularProgressIndicator.swift
// FlingChallenge
//
// Created by Alexander Kolov on 9/5/16.
// Copyright © 2016 Alexander Kolov. All rights reserved.
//
import UIKit
@IBDesignable
class CircularProgressIndicator: UIView {
override init(frame: CGRect) {
super.init(frame: frame)
initialize()
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
initialize()
}
var progress: Float = 0 {
didSet {
shapeLayer.path = path.CGPath
if progress >= 1.0 && hideWhenFinished {
hidden = true
}
}
}
@IBInspectable
var hideWhenFinished: Bool = true
private func initialize() {
backgroundShapeLayer.fillColor = nil
backgroundShapeLayer.strokeColor = UIColor(white: 0, alpha: 0.5).CGColor
backgroundShapeLayer.lineWidth = 10
backgroundShapeLayer.addSublayer(shapeLayer)
}
override func layoutSubviews() {
super.layoutSubviews()
backgroundShapeLayer.path = UIBezierPath(ovalInRect: bounds).CGPath
}
override class func layerClass() -> AnyClass {
return CAShapeLayer.self
}
var backgroundShapeLayer: CAShapeLayer {
return layer as! CAShapeLayer
}
private(set) lazy var shapeLayer: CAShapeLayer = {
let layer = CAShapeLayer()
layer.fillColor = nil
layer.strokeColor = UIColor.whiteColor().CGColor
layer.lineWidth = 10
return layer
}()
override func intrinsicContentSize() -> CGSize {
return CGSize(width: 60, height: 60)
}
private var path: UIBezierPath {
let start = M_PI * 1.5
let end = start + M_PI * 2.0
let center = CGPoint(x: bounds.width / 2, y: bounds.height / 2)
let radius = bounds.width / 2
let startAngle = CGFloat(start)
let endAngle = CGFloat(Float(end - start) * progress) + startAngle
let path = UIBezierPath()
path.addArcWithCenter(center, radius: radius, startAngle: startAngle, endAngle: endAngle, clockwise: true)
return path
}
}
| mit | 444d54229103c6e4b6832fbb2f6b40e7 | 22.662651 | 110 | 0.680754 | 4.28821 | false | false | false | false |
hooman/swift | test/Concurrency/Runtime/async_task_cancellation_early.swift | 2 | 1231 | // RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking %import-libdispatch -parse-as-library) | %FileCheck %s --dump-input=always
// REQUIRES: executable_test
// REQUIRES: concurrency
// REQUIRES: libdispatch
// Temporarily disabled to unblock PR testing:
// REQUIRES: rdar80745964
// rdar://76038845
// UNSUPPORTED: use_os_stdlib
// UNSUPPORTED: back_deployment_runtime
import Dispatch
@available(SwiftStdlib 5.5, *)
func test_detach_cancel_child_early() async {
print(#function) // CHECK: test_detach_cancel_child_early
let h: Task<Bool, Error> = Task.detached {
async let childCancelled: Bool = { () -> Bool in
await Task.sleep(2_000_000_000)
return Task.isCancelled
}()
let xx = await childCancelled
print("child, cancelled: \(xx)") // CHECK: child, cancelled: true
let cancelled = Task.isCancelled
print("self, cancelled: \(cancelled)") // CHECK: self, cancelled: true
return cancelled
}
h.cancel()
print("handle cancel")
let got = try! await h.value
print("was cancelled: \(got)") // CHECK: was cancelled: true
}
@available(SwiftStdlib 5.5, *)
@main struct Main {
static func main() async {
await test_detach_cancel_child_early()
}
}
| apache-2.0 | 7a4c1c5e4d7317792e78a8f81f86054a | 27.627907 | 150 | 0.689683 | 3.674627 | false | true | false | false |
wltrup/Swift-WTCoreGraphicsExtensions | Example/Tests/WTCoreGraphicsExtensionsTestsBase.swift | 1 | 2652 | //
// WTCoreGraphicsExtensionsTestsBase.swift
// WTCoreGraphicsExtensions
//
// Created by Wagner Truppel on 2016.12.03.
//
// Copyright (c) 2016 Wagner Truppel. All rights reserved.
//
import XCTest
import Foundation
import WTCoreGraphicsExtensions
class WTCoreGraphicsExtensionsTestsBase: XCTestCase
{
var tolerance: CGFloat = 0
var N: Int = 0
var rangeMin: CGFloat = 0
var rangeMax: CGFloat = 0
// MARK: -
var expectedValue: CGFloat = 0
var resultedValue: CGFloat = 0
var expectedPoint = CGPoint.zero
var resultedPoint = CGPoint.zero
var expectedVector = CGVector.zero
var resultedVector = CGVector.zero
var expectedError: WTCoreGraphicsExtensionsError!
var resultedError: Error!
// MARK: -
final func assertAbsoluteDifferenceWithinTolerance()
{ XCTAssertTrue(abs(resultedValue - expectedValue) <= tolerance) }
/// Tests that uniformly generated pseudo-random values in the range [0, 1]
/// satisfy the properties that their average approaches 1/2 and their
/// variance approaches 1/12.
final func testRandomness(_ values: [CGFloat])
{
let n = CGFloat(values.count)
let average = values.reduce(0, +) / n
let variance = values
.map { ($0 - average)*($0 - average) }
.reduce(0, +) / n
expectedValue = 1.0/2.0
resultedValue = average
assertAbsoluteDifferenceWithinTolerance()
expectedValue = 1.0/12.0
resultedValue = variance
assertAbsoluteDifferenceWithinTolerance()
}
final func assertEqualPointsWithinTolerance()
{
expectedValue = expectedPoint.x
resultedValue = resultedPoint.x
assertAbsoluteDifferenceWithinTolerance()
expectedValue = expectedPoint.y
resultedValue = resultedPoint.y
assertAbsoluteDifferenceWithinTolerance()
}
final func assertEqualVectorsWithinTolerance()
{
expectedValue = expectedVector.dx
resultedValue = resultedVector.dx
assertAbsoluteDifferenceWithinTolerance()
expectedValue = expectedVector.dy
resultedValue = resultedVector.dy
assertAbsoluteDifferenceWithinTolerance()
}
final func assertEqualErrors()
{
XCTAssertTrue(resultedError is WTCoreGraphicsExtensionsError)
if let resultedError = resultedError as? WTCoreGraphicsExtensionsError
{ XCTAssertEqual(resultedError, expectedError) }
}
// MARK: -
override func setUp()
{
super.setUp()
tolerance = 1e-10
N = 100
rangeMin = -10
rangeMax = 10
}
}
| mit | 5c73383ef783144edb543780b4a50ee9 | 25 | 79 | 0.668552 | 5.179688 | false | true | false | false |
baquiax/SimpleTwitterClient | SimpleTwitterClient/Pods/OAuthSwift/OAuthSwift/String+OAuthSwift.swift | 5 | 3960 | //
// String+OAuthSwift.swift
// OAuthSwift
//
// Created by Dongri Jin on 6/21/14.
// Copyright (c) 2014 Dongri Jin. All rights reserved.
//
import Foundation
extension String {
internal func indexOf(sub: String) -> Int? {
var pos: Int?
if let range = self.rangeOfString(sub) {
if !range.isEmpty {
pos = self.startIndex.distanceTo(range.startIndex)
}
}
return pos
}
internal subscript (r: Range<Int>) -> String {
get {
let startIndex = self.startIndex.advancedBy(r.startIndex)
let endIndex = startIndex.advancedBy(r.endIndex - r.startIndex)
return self[startIndex..<endIndex]
}
}
func urlEncodedStringWithEncoding(encoding: NSStringEncoding) -> String {
let originalString: NSString = self
let customAllowedSet = NSCharacterSet(charactersInString:"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~")
let escapedString = originalString.stringByAddingPercentEncodingWithAllowedCharacters(customAllowedSet)
return escapedString! as String
}
func parametersFromQueryString() -> Dictionary<String, String> {
return dictionaryBySplitting("&", keyValueSeparator: "=")
}
var urlQueryEncoded: String? {
return self.stringByAddingPercentEncodingWithAllowedCharacters(NSCharacterSet.URLQueryAllowedCharacterSet())
}
func dictionaryBySplitting(elementSeparator: String, keyValueSeparator: String) -> Dictionary<String, String> {
var string = self
if(hasPrefix(elementSeparator)) {
string = String(characters.dropFirst(1))
}
var parameters = Dictionary<String, String>()
let scanner = NSScanner(string: string)
var key: NSString?
var value: NSString?
while !scanner.atEnd {
key = nil
scanner.scanUpToString(keyValueSeparator, intoString: &key)
scanner.scanString(keyValueSeparator, intoString: nil)
value = nil
scanner.scanUpToString(elementSeparator, intoString: &value)
scanner.scanString(elementSeparator, intoString: nil)
if (key != nil && value != nil) {
parameters.updateValue(value! as String, forKey: key! as String)
}
}
return parameters
}
public var headerDictionary: Dictionary<String, String> {
return dictionaryBySplitting(",", keyValueSeparator: "=")
}
var safeStringByRemovingPercentEncoding: String {
return self.stringByRemovingPercentEncoding ?? self
}
func split(s:String)->[String]{
if s.isEmpty{
var x=[String]()
for y in self.characters{
x.append(String(y))
}
return x
}
return self.componentsSeparatedByString(s)
}
func trim()->String{
return self.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
}
func has(s:String)->Bool{
if (self.rangeOfString(s) != nil) {
return true
}else{
return false
}
}
func hasBegin(s:String)->Bool{
if self.hasPrefix(s) {
return true
}else{
return false
}
}
func hasEnd(s:String)->Bool{
if self.hasSuffix(s) {
return true
}else{
return false
}
}
func length()->Int{
return self.utf16.count
}
func size()->Int{
return self.utf16.count
}
func `repeat`(times: Int) -> String{
var result = ""
for _ in 0..<times {
result += self
}
return result
}
func reverse()-> String{
let s=Array(self.split("").reverse())
var x=""
for y in s{
x+=y
}
return x
}
}
| mit | a2e5a73ba3347e271d282652fdd17947 | 26.692308 | 135 | 0.585101 | 5.109677 | false | false | false | false |
OpenKitten/MongoKitten | Sources/MongoClient/InternalCommands/IsMaster.swift | 2 | 2039 | import MongoCore
public struct MongoClientDetails: Encodable {
public struct ApplicationDetails: Encodable {
public var name: String
}
public struct DriverDetails: Encodable {
public let name = "SwiftMongoClient"
public let version = "1"
}
public struct OSDetails: Encodable {
#if os(Linux)
public let type = "Linux"
public let name: String? = nil // TODO: see if we can fill this in
#elseif os(macOS)
public let type = "Darwin"
public let name: String? = "macOS"
#elseif os(iOS)
public let type = "Darwin"
public let name: String? = "iOS"
#elseif os(Windows)
public let type = "Windows"
public let name: String? = nil
#else
public let type = "unknown"
public let name: String? = nil
#endif
#if arch(x86_64)
public let architecture: String? = "x86_64"
#else
public let architecture: String? = nil
#endif
public let version: String? = nil
}
public var application: ApplicationDetails?
public var driver = DriverDetails()
public var os = OSDetails()
#if swift(>=5.2)
public let platform: String? = "Swift 5.2"
#elseif swift(>=5.1)
public let platform: String? = "Swift 5.1"
#elseif swift(>=5.0)
public let platform: String? = "Swift 5.0"
#elseif swift(>=4.2)
public let platform: String? = "Swift 4.2"
#elseif swift(>=4.1)
public let platform: String? = "Swift 4.1"
#else
public let platform: String?
#endif
public init(application: ApplicationDetails?) {
self.application = application
}
}
internal struct IsMaster: Encodable {
private let isMaster: Int32 = 1
internal var saslSupportedMechs: String?
internal var client: MongoClientDetails?
internal init(clientDetails: MongoClientDetails?, userNamespace: String?) {
self.client = clientDetails
self.saslSupportedMechs = userNamespace
}
}
| mit | 99faf2632e1ccd4f60b84edaac9a3d6f | 27.319444 | 79 | 0.616479 | 4.094378 | false | false | false | false |
Arthraim/ARTagger | ARTagger/ViewController.swift | 1 | 8075 | //
// ViewController.swift
// ARTagger
//
// Created by Arthur Wang on 7/7/17.
// Copyright © 2017 YANGAPP. All rights reserved.
//
import UIKit
import SceneKit
import ARKit
import CoreML
import Vision
class ViewController: UIViewController, ARSCNViewDelegate, ARSessionDelegate {
// var session: ARSession!
var text: String?
private var requests = [VNRequest]()
var screenCenter: CGPoint?
@IBOutlet var sceneView: ARSCNView!
override func viewDidLoad() {
super.viewDidLoad()
// Set the view's delegate
sceneView.delegate = self
// Show statistics such as fps and timing information
sceneView.showsStatistics = true
sceneView.preferredFramesPerSecond = 60
DispatchQueue.main.async {
self.screenCenter = self.sceneView.bounds.mid
}
// Create a new scene
let scene = SCNScene(named: "art.scnassets/empty.scn")!
// Set the scene to the view
sceneView.scene = scene
sceneView.session.delegate = self
// coreML vision
setupVision()
sceneView.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.handleTag(gestureRecognizer:))))
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
// Create a session configuration
let configuration = ARWorldTrackingSessionConfiguration()
// configuration.planeDetection = .horizontal
// Run the view's session
sceneView.session.run(configuration)
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
// Pause the view's session
sceneView.session.pause()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Release any cached data, images, etc that aren't in use.
}
// func addText(text: String) {
@objc
func handleTag(gestureRecognizer: UITapGestureRecognizer) {
guard let currentFrame = sceneView.session.currentFrame else { return }
let scnText = SCNText(string: String(text ?? "ERROR"), extrusionDepth: 1)
scnText.firstMaterial?.lightingModel = .constant
let textScale = 0.02 / Float(scnText.font.pointSize)
let textNode = SCNNode(geometry: scnText)
textNode.scale = SCNVector3Make(textScale, textScale, textScale)
sceneView.scene.rootNode.addChildNode(textNode)
// Set transform of node to be 10cm in front of camera
var translation = textNode.simdTransform
translation.columns.3.z = -0.2
textNode.simdTransform = matrix_multiply(currentFrame.camera.transform, translation)
addHomeTags(currentFrame: currentFrame)
}
func addHomeTags(currentFrame: ARFrame) {
if (text == "mouse") {
addHomeTag(imageName: "razer", currentFrame: currentFrame)
} else if (text == "iPod") {
addHomeTag(imageName: "nokia", currentFrame: currentFrame)
}
}
func addHomeTag(imageName: String, currentFrame: ARFrame) {
let image = UIImage(named: imageName)
// Create an image plane using a snapshot of the view
let imagePlain = SCNPlane(width: sceneView.bounds.width / 6000,
height: sceneView.bounds.height / 6000)
imagePlain.firstMaterial?.diffuse.contents = image
imagePlain.firstMaterial?.lightingModel = .constant
let plainNode = SCNNode(geometry: imagePlain)
sceneView.scene.rootNode.addChildNode(plainNode)
// Set transform of node to be 10cm in front of camera
var translation = matrix_identity_float4x4
translation.columns.3.z = -0.22
translation.columns.3.y = 0.05
plainNode.simdTransform = matrix_multiply(currentFrame.camera.transform, translation)
}
// MARK: - coreML vision logic
func setupVision() {
//guard let visionModel = try? VNCoreMLModel(for: Inceptionv3().model)
guard let visionModel = try? VNCoreMLModel(for: Resnet50().model)
else { fatalError("Can't load VisionML model") }
let classificationRequest = VNCoreMLRequest(model: visionModel, completionHandler: handleClassifications)
classificationRequest.imageCropAndScaleOption = VNImageCropAndScaleOptionCenterCrop
self.requests = [classificationRequest]
}
func handleClassifications(request: VNRequest, error: Error?) {
guard let observations = request.results
else { print("no results: \(error!)"); return }
let classifications = observations[0...4]
.flatMap({ $0 as? VNClassificationObservation })
// .filter({ $0.confidence > 0.3 })
.sorted(by: { $0.confidence > $1.confidence })
DispatchQueue.main.async {
let text = classifications.map {
(prediction: VNClassificationObservation) -> String in
return "\(round(prediction.confidence * 100 * 100)/100)%: \(prediction.identifier)"
}
print(text.joined(separator: " | "))
// add 3d text
if let firstPrediction = classifications.first {
if firstPrediction.confidence > 0.1 {
// self.addText(text: firstPrediction.identifier)
if let t = firstPrediction.identifier.split(separator: ",").first {
self.text = String(t)
}
}
}
}
}
// MARK: - ARSCNViewDelegate
// Override to create and configure nodes for anchors added to the view's session.
// func renderer(_ renderer: SCNSceneRenderer, nodeFor anchor: ARAnchor) -> SCNNode? {
// if let textNote = textNode {
// updateText()
// return textNode
// }
// let node = SCNNode()
// return node
// }
// func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
// // This visualization covers only detected planes.
// guard let planeAnchor = anchor as? ARPlaneAnchor else { return }
//
// // Create a SceneKit plane to visualize the node using its position and extent.
// let plane = SCNPlane(width: CGFloat(planeAnchor.extent.x), height: CGFloat(planeAnchor.extent.z))
// let planeNode = SCNNode(geometry: plane)
// planeNode.position = SCNVector3Make(planeAnchor.center.x, 0, planeAnchor.center.z)
//
// // SCNPlanes are vertically oriented in their local coordinate space.
// // Rotate it to match the horizontal orientation of the ARPlaneAnchor.
// planeNode.transform = SCNMatrix4MakeRotation(-Float.pi / 2, 1, 0, 0)
//
// // ARKit owns the node corresponding to the anchor, so make the plane a child node.
// node.addChildNode(planeNode)
// }
func session(_ session: ARSession, didFailWithError error: Error) {
// Present an error message to the user
}
func sessionWasInterrupted(_ session: ARSession) {
// Inform the user that the session has been interrupted, for example, by presenting an overlay
}
func sessionInterruptionEnded(_ session: ARSession) {
// Reset tracking and/or remove existing anchors if consistent tracking is required
}
var i = 0
func session(_ session: ARSession, didUpdate frame: ARFrame) {
i = i + 1
if (i % 10 == 0) {
// if (i <= 10) {
DispatchQueue.global(qos: .background).async {
var requestOptions:[VNImageOption : Any] = [:]
let imageRequestHandler = VNImageRequestHandler(cvPixelBuffer: frame.capturedImage, orientation: 1, options: requestOptions)
do {
try imageRequestHandler.perform(self.requests)
} catch {
print(error)
}
}
}
}
}
| mit | af70a9897cd53b644dc3f481c674348c | 35.369369 | 140 | 0.626084 | 4.757808 | false | false | false | false |
russbishop/swift | test/Generics/invalid.swift | 1 | 2479 | // RUN: %target-parse-verify-swift -enable-experimental-nested-generic-types
func bet() where A : B {} // expected-error {{'where' clause cannot be attached to a non-generic declaration}}
typealias gimel where A : B // expected-error {{'where' clause cannot be attached to a non-generic declaration}}
// expected-error@-1 {{expected '=' in typealias declaration}}
class dalet where A : B {} // expected-error {{'where' clause cannot be attached to a non-generic declaration}}
protocol he where A : B { // expected-error {{'where' clause cannot be attached to a protocol declaration}}
associatedtype vav where A : B // expected-error {{'where' clause cannot be attached to an associated type declaration}}
}
struct Lunch<T> {
struct Dinner<U> {
var leftovers: T
var transformation: (T) -> U
}
}
class Deli<Spices> {
class Pepperoni {}
struct Sausage {}
}
struct Pizzas<Spices> {
class NewYork {
}
class DeepDish {
}
}
class HotDog {
}
struct Pepper {}
struct ChiliFlakes {}
func eatDinnerConcrete(d: Pizzas<ChiliFlakes>.NewYork,
t: Deli<ChiliFlakes>.Pepperoni) {
}
func eatDinnerConcrete(d: Pizzas<Pepper>.DeepDish,
t: Deli<Pepper>.Pepperoni) {
}
func badDiagnostic1() {
_ = Lunch<Pizzas<Pepper>.NewYork>.Dinner<HotDog>( // expected-error {{expression type 'Lunch<Pizzas<Pepper>.NewYork>.Dinner<HotDog>' is ambiguous without more context}}
leftovers: Pizzas<ChiliFlakes>.NewYork(),
transformation: { _ in HotDog() })
}
func badDiagnostic2() {
let firstCourse = Pizzas<ChiliFlakes>.NewYork()
var dinner = Lunch<Pizzas<ChiliFlakes>.NewYork>.Dinner<HotDog>(
leftovers: firstCourse,
transformation: { _ in HotDog() })
let topping = Deli<Pepper>.Pepperoni()
eatDinnerConcrete(d: firstCourse, t: topping)
// expected-error@-1 {{cannot invoke 'eatDinnerConcrete' with an argument list of type '(d: Pizzas<ChiliFlakes>.NewYork, t: Deli<Pepper>.Pepperoni)'}}
// expected-note@-2 {{overloads for 'eatDinnerConcrete' exist with these partially matching parameter lists: (d: Pizzas<ChiliFlakes>.NewYork, t: Deli<ChiliFlakes>.Pepperoni), (d: Pizzas<Pepper>.DeepDish, t: Deli<Pepper>.Pepperoni)}}
}
// Real error is that we cannot infer the generic parameter from context
func takesAny(_ a: Any) {}
func badDiagnostic3() {
takesAny(Deli.self) // expected-error {{argument type 'Deli<_>.Type' does not conform to expected type 'Any' (aka 'protocol<>')}}
}
| apache-2.0 | a5c179d2682508b25d32d55f418ee1b9 | 29.604938 | 234 | 0.695442 | 3.88558 | false | false | false | false |
TongCui/LearningCrptography | CryptographyDemo/ViewControllers/CryptographyViewController.swift | 1 | 3238 | //
// CryptographyViewController.swift
// CryptographyDemo
//
// Created by tcui on 14/8/2017.
// Copyright © 2017 LuckyTR. All rights reserved.
//
import UIKit
import RxSwift
import RxCocoa
class CryptographyViewController: BaseViewController {
var cryptography: Cryptography?
@IBOutlet weak var segmentedControl: UISegmentedControl!
@IBOutlet weak var topLabel: UILabel!
@IBOutlet weak var topTextField: UITextField!
@IBOutlet weak var bottomLabel: UILabel!
@IBOutlet weak var bottomTextField: UITextField!
@IBOutlet weak var keyTextField: UITextField!
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
// Do any additional setup after loading the view.
}
private func setupUI() {
// Default Key
keyTextField.text = cryptography?.defaultKey
// Upper Case
topTextField.rx.text
.map { $0?.uppercased() }
.bind(to: topTextField.rx.text)
.disposed(by: disposeBag)
bottomTextField.rx.text
.map { $0?.uppercased() }
.bind(to: bottomTextField.rx.text)
.disposed(by: disposeBag)
// Bind Top and Bottom Textfields
let topTextObservable = topTextField.rx.text.orEmpty.throttle(0.5, scheduler: MainScheduler.instance)
let keyTextObservable = keyTextField.rx.text.orEmpty.throttle(0.5, scheduler: MainScheduler.instance)
let segmentedControlObservable = segmentedControl.rx.value
Observable.combineLatest(topTextObservable, keyTextObservable, segmentedControlObservable) { [weak self] topText, keyText, segmentedIndex in
let bottomText: String?
switch segmentedIndex {
case 0: bottomText = self?.cryptography?.encrypt(from: topText, key: keyText)
case 1: bottomText = self?.cryptography?.decrypt(from: topText, key: keyText)
default: bottomText = "Error"
}
return bottomText ?? ""
}
.bind(to: bottomTextField.rx.text)
.disposed(by: disposeBag)
// Segmented Control
segmentedControl.rx.value
.map { $0 == 0 ? "Plaintext" : "Chipertext" }
.bind(to: topLabel.rx.text)
.disposed(by: disposeBag)
segmentedControl.rx.value
.map { $0 == 1 ? "Plaintext" : "Chipertext" }
.bind(to: bottomLabel.rx.text)
.disposed(by: disposeBag)
// Tap View to hide keyboard
let tapBackground = UITapGestureRecognizer()
tapBackground.rx.event
.subscribe(onNext: { [weak self] _ in
self?.view.endEditing(true)
})
.disposed(by: disposeBag)
view.addGestureRecognizer(tapBackground)
}
private func getPlaintext(from chiperText: String) -> String {
return "plaintext \(chiperText)"
}
private func getChipertext(from plainText: String) -> String {
return "chipertext \(plainText)"
}
private func changeKey() {
print("TODO: Change Key")
}
}
| mit | a126f1a6aece3ca3bdc801378f3695fb | 29.537736 | 148 | 0.599011 | 4.760294 | false | false | false | false |
IBM-MIL/IBM-Ready-App-for-Retail | iOS/ReadyAppRetail/ReadyAppRetail/Controllers/ProductDetailViewController.swift | 1 | 16891 | /*
Licensed Materials - Property of IBM
© Copyright IBM Corporation 2015. All Rights Reserved.
*/
import UIKit
class ProductDetailViewController: MILWebViewController, MILWebViewDelegate, UIAlertViewDelegate {
@IBOutlet weak var addToListContainerView: UIView!
@IBOutlet weak var addToListContainerViewBottomSpace: NSLayoutConstraint!
@IBOutlet weak var backBarButton: UIBarButtonItem!
@IBOutlet weak var addedToListPopupLabel: UILabel!
@IBOutlet weak var addedToListPopup: UIView!
@IBOutlet weak var dimViewButton: UIButton!
var addToListContainerViewDestinationBottomSpace: CGFloat!
var containerViewController: AddToListContainerViewController!
var productId : NSString = ""
var currentProduct : Product!
var webViewReady : Bool = false
var jsonDataReady : Bool = false
var jsonString : NSString!
var json : JSON?
var addToListVisible : Bool = false
override func viewDidLoad() {
self.startPage = "index.html/"
super.viewDidLoad()
self.saveInstanceToAppDelegate()
self.setUpAddToListPopup()
self.setUpAddToListContainer()
self.setupWebView()
self.showDimViewButton()
//query for product information
self.getProductById()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
}
override func viewWillAppear(animated: Bool) {
setUpNavigationBar()
}
/**
When the view disappears it hides the progress hud
- parameter animated:
*/
override func viewWillDisappear(animated: Bool) {
Utils.dismissProgressHud()
}
/**
This method is called by viewDidLoad. It calls MILWLHelper's getProductById method and then shows the progressHud
*/
private func getProductById(){
MILWLHelper.getProductById(self.productId, callBack: self.productRetrievalResult)
Utils.showProgressHud()
}
func productRetrievalResult(success: Bool, jsonResult: JSON?) {
if success {
if let result = jsonResult {
self.receiveProductDetailJSON(result)
}
} else {
self.failureGettingProductById()
}
}
/**
This method is called by the GetProductByIdDataManager when the onFailure is called by Worklight. It first dismisses the progress hud and then if the view is visible it shows the error alert
*/
func failureGettingProductById(){
Utils.dismissProgressHud()
if (self.isViewLoaded() == true && self.view.window != nil ) { //check if the view is currently visible
Utils.showServerErrorAlertWithCancel(self, tag: 1) //only show error alert if the view is visible
}
}
/**
This method is called by ProductIsAvailableDataManager when the onFailure is called by the Worklight. It first dismisses the progress hud and then if the view is visible it shows the error alert
*/
func failureGettingProductAvailability(){
Utils.dismissProgressHud()
if (self.isViewLoaded() == true && self.view.window != nil) {
Utils.showServerErrorAlertWithCancel(self, tag: 2)
}
}
/**
This method is called when the user clicks a button on the alert view. If the user clicks a button with index 1 then it shows the progress hud and then retries either the getProductById method or the queryProductIsAvailable method. If the butten clicked is index 0 then it pops the view controller to go back to the browseViewController.
- parameter alertView:
- parameter buttonIndex:
*/
func alertView(alertView: UIAlertView, clickedButtonAtIndex buttonIndex: Int) {
if(alertView.tag == 1){
if(buttonIndex == 1){
Utils.showProgressHud()
self.getProductById()
}
else{
self.navigationController?.popViewControllerAnimated(true)
}
}
else if(alertView.tag == 2){
if(buttonIndex == 1){
Utils.showProgressHud()
self.queryProductIsAvailable()
}
else{
self.navigationController?.popViewControllerAnimated(true)
}
}
}
/**
This method saves the current instance of ProductDetailViewController to the app delegate's instance variable "productDetailViewController"
*/
private func saveInstanceToAppDelegate(){
let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
appDelegate.productDetailViewController = self
}
/**
This method sets up the the navigation bar with various properties
*/
private func setUpNavigationBar(){
//customize back arrow
//set the back button to be just an arrow, nothing in right button space (nil)
self.navigationItem.leftBarButtonItem = self.backBarButton
self.navigationItem.rightBarButtonItem = nil
self.navigationController?.navigationBar.titleTextAttributes = [ NSFontAttributeName: UIFont(name: "Oswald-Regular", size: 22)!, NSForegroundColorAttributeName: UIColor.whiteColor()]
}
/**
This method sets up the webview
*/
private func setupWebView(){
self.view.bringSubviewToFront(self.webView)
self.delegate = self
self.setupWebViewConstraints()
}
/**
This method sets up the addToListPopup
*/
private func setUpAddToListPopup(){
self.addedToListPopup.alpha = 0
self.addedToListPopup.layer.cornerRadius = 10
}
/**
This method sets ups the AddToListContainer
*/
private func setUpAddToListContainer(){
self.addToListContainerViewDestinationBottomSpace = self.addToListContainerViewBottomSpace.constant
self.addToListContainerViewBottomSpace.constant = -(self.addToListContainerView.frame.size.height + self.tabBarController!.tabBar.bounds.size.height)
self.providesPresentationContextTransitionStyle = true;
self.definesPresentationContext = true;
}
/**
This method shows the dimViewButton by making it not hidden, changing its alpha and bringing it up to the front
*/
private func showDimViewButton(){
self.dimViewButton.alpha = 0.0
self.dimViewButton.hidden = false
self.dimViewButton.alpha = 0.6
self.view.bringSubviewToFront(self.dimViewButton)
}
/**
This method hides the dimViewbutton by changing it to hidden and making its alpha set to 0.0
*/
private func hideDimViewButton(){
if (self.addToListVisible == false) {
self.dimViewButton.hidden = true
}
}
/**
This method is called if the callback changes. If pathComponents[2] is set to "Ready
then it sets the webViewReady instance variable to true and it then calls the tryToInjectData method. If both the webView and data are ready then it will inject the data.
- parameter pathComponents:
*/
func callBackHasChanged(pathComponents: Array<String>) {
if (pathComponents[2] == "Ready") {
self.webViewReady = true
self.tryToInjectData()
}
}
/**
This method takes care of if the addToList Button was pressed on the hybrid side. It calls the addToListTapped method to show the modal popup of the addToListContainer
- parameter pathComponents:
*/
func nativeViewHasChanged(pathComponents: Array<String>) {
if (pathComponents[2] == "AddToList") {
self.addToListTapped()
}
}
/**
This method first checks if data can be injected by calling the canInjectData method. If this is true, then it calls the injectData method and then hides the dimViewButton
*/
private func tryToInjectData(){
if(self.canInjectData() == true){
self.injectData()
self.hideDimViewButton()
}
}
/**
This method checks if data can be injected. It does this by checking if the jsonDataReady and webViewReady are both set to true. If it is set to true, then it returns true, else false.
- returns: A Bool representing if data can be injected
*/
private func canInjectData() -> Bool{
if(self.jsonDataReady == true && self.webViewReady == true){
return true
}
else{
return false
}
}
/**
This method injects data into the web view by injecting the jsonString instance variable.
*/
private func injectData(){
let injectData : String = "injectData(\(self.jsonString))";
let inject : String = Utils.prepareCodeInjectionString(injectData);
self.webView.stringByEvaluatingJavaScriptFromString(inject);
Utils.dismissProgressHud()
}
/**
This method is called by the GetProductByIdDataManager when it has finished massaging the product detail json. It sets the json instance variable to the json parameter. It then calls parseProduct of JSONParseHelper and sets the currentProduct instance variable to the return value of this method. After it calls the queryProductIsAvailable method to query for product availabilty.
- parameter json: the massaged product detail json the webview expects
*/
func receiveProductDetailJSON(json : JSON){
self.json = json
self.currentProduct = JSONParseHelper.parseProduct(json)
self.updateTitle()
self.queryProductIsAvailable()
}
/**
This method updates the title of the navigation bar
*/
private func updateTitle(){
if let name = self.currentProduct?.name {
self.navigationItem.title = name.uppercaseString
}
}
/**
This method is called by the receiveProductDetailJSON method. It first calls MILWLHelper's productIsAvailable method. If this method returns false, then this means the user isn't logged in and it will procede to inject data without product availability since getting product availability is a protected call and a user needs to be logged in to make this call.
*/
func queryProductIsAvailable(){
if(MILWLHelper.productIsAvailable(self.currentProduct.id, callback: self) != true){
self.jsonString = "\(self.json!)"
self.jsonDataReady = true
self.tryToInjectData()
}
}
/**
This method is called by the ProductIsAvailableDataManager when it is ready to send the product availability information to the ProductDetailViewController. It will recieve a 1 for In Stock, 0 for out of stock, or a 2 for no information available. When this method receives this information, it adds it to the json instance variable and then updates to the jsonString instance variable and sets the jsonDataReady instance variable to true. After it trys to inject data by calling the tryToInjectData method.
- parameter availability: 1 for In Stock, 0 for out of stock, or a 2 for no information available
*/
func recieveProductAvailability(availability : Int){
if(availability == 1){
self.json!["availability"] = "In Stock"
}
else if (availability == 0){
self.json!["availability"] = "Out of Stock"
}
else if (availability == 2){
self.json!["availability"] = ""
}
self.jsonString = "\(self.json!)"
self.jsonDataReady = true
self.tryToInjectData()
}
/**
This method is called by the ReadyAppsChallengeHandler when the user authentication has timed out thus not allowing us to do productIsAvailable procedure call to Worklight since this call is protected. Thus, this method injects data to the webview without the product availability.
*/
func injectWithoutProductAvailability(){
self.jsonString = "\(self.json!)"
self.jsonDataReady = true
self.tryToInjectData()
}
/**
calls the UserAuthHelper's checkIfLoggedIn method, and shows login view if not logged in. If logged in, shows choose list view
*/
func addToListTapped(){
if (UserAuthHelper.checkIfLoggedIn(self)) {
self.addToListVisible = true
self.dimViewButton.hidden = false
self.view.bringSubviewToFront(self.dimViewButton)
self.view.bringSubviewToFront(self.addToListContainerView)
UIView.animateWithDuration(0.4, animations: {
//
self.dimViewButton.alpha = 0.6
self.addToListContainerViewBottomSpace.constant = self.addToListContainerViewDestinationBottomSpace
self.view.layoutIfNeeded()
})
}
}
/**
dismisses the add to list view from the screen if user touches outside or presses cancel/X button
*/
func dismissAddToListContainer() {
UIView.animateWithDuration(0.4, animations: {
//
self.dimViewButton.alpha = 0
self.addToListContainerViewBottomSpace.constant = -(self.addToListContainerView.frame.size.height + self.tabBarController!.tabBar.bounds.size.height)
self.view.layoutIfNeeded()
}, completion: { finished in
if (self.containerViewController.currentSegueIdentifier == "createAList") {
self.containerViewController.swapViewControllers()
}
})
self.dimViewButton.hidden = true
self.view.endEditing(true)
self.addToListVisible = false
}
/**
dismiss add to list container if user taps outside of it
- parameter sender:
*/
@IBAction func tappedOutsideOfListContainer(sender: AnyObject) {
if(self.canInjectData() == true){
self.dismissAddToListContainer()
}
}
/**
added to list popup fade out
*/
func fadeOutAddedToListPopup() {
UIView.animateWithDuration(1, animations: {
//
self.addedToListPopup.alpha = 0
})
}
/**
added to list popup fade in
*/
func fadeInAddedToListPopup() {
UIView.animateWithDuration(1, animations: {
//
self.addedToListPopup.alpha = 0.95
}, completion: { finished in
})
}
/**
function to show grey popup on bottom of screen saying that the item was added to a particular list after tapping that list. includes fade in/out
- parameter listName: - name of the list the item was added to
*/
func showPopup(listName: String) {
// create attributed string
let localizedString = NSLocalizedString("Product added to \(listName)!", comment: "")
let string = localizedString as NSString
let attributedString = NSMutableAttributedString(string: string as String)
//Add attributes to two parts of the string
attributedString.addAttributes([NSFontAttributeName: UIFont(name: "OpenSans", size: 14)!, NSForegroundColorAttributeName: UIColor.whiteColor()], range: string.rangeOfString("Product added to "))
attributedString.addAttributes([NSFontAttributeName: UIFont(name: "OpenSans-Semibold", size: 14)!, NSForegroundColorAttributeName: UIColor.whiteColor()], range: string.rangeOfString("\(listName)!"))
//set label to be attributed string and present popup
self.addedToListPopupLabel.attributedText = attributedString
self.fadeInAddedToListPopup()
_ = NSTimer.scheduledTimerWithTimeInterval(2, target: self, selector: Selector("fadeOutAddedToListPopup"), userInfo: nil, repeats: 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.
if (segue.identifier == "addToListContainer") {
self.containerViewController = segue.destinationViewController as! AddToListContainerViewController
}
}
/**
This method is called when the tappedBackButton is pressed.
- parameter sender:
*/
@IBAction func tappedBackButton(sender: AnyObject) {
self.navigationController?.popViewControllerAnimated(true)
}
}
| epl-1.0 | fa9c79eb444ec74571cc214270c9391f | 34.557895 | 511 | 0.651983 | 5.289696 | false | false | false | false |
Incipia/Elemental | Elemental/Classes/ViewControllers/ElementalPageViewController.swift | 1 | 16981 | //
// ElementalPageViewController.swift
// Pods
//
// Created by Leif Meyer on 7/3/17.
//
//
import UIKit
public protocol ElementalPageViewControllerDelegate: class {
func elementalPageTransitionCompleted(index: Int, destinationIndex: Int, in viewController: ElementalPageViewController)
}
public protocol ElementalPage {
func willAppear(inPageViewController pageViewController: ElementalPageViewController)
func cancelAppear(inPageViewController pageViewController: ElementalPageViewController)
func didAppear(inPageViewController pageViewController: ElementalPageViewController)
func willDisappear(fromPageViewController pageViewController: ElementalPageViewController)
func cancelDisappear(fromPageViewController pageViewController: ElementalPageViewController)
func didDisappear(fromPageViewController pageViewController: ElementalPageViewController)
}
public extension ElementalPage {
func willAppear(inPageViewController pageViewController: ElementalPageViewController) {}
func cancelAppear(inPageViewController pageViewController: ElementalPageViewController) {}
func didAppear(inPageViewController pageViewController: ElementalPageViewController) {}
func willDisappear(fromPageViewController pageViewController: ElementalPageViewController) {}
func cancelDisappear(fromPageViewController pageViewController: ElementalPageViewController) {}
func didDisappear(fromPageViewController pageViewController: ElementalPageViewController) {}
}
open class ElementalPageViewController: UIPageViewController {
// MARK: - Nested Types
private class DataSource: NSObject, UIPageViewControllerDataSource {
// MARK: - Private Properties
fileprivate unowned let _owner: ElementalPageViewController
// MARK: - Init
init(owner: ElementalPageViewController) {
_owner = owner
}
// MARK: - UIPageViewControllerDataSource
public func pageViewController(_ pageViewController: UIPageViewController, viewControllerAfter viewController: UIViewController) -> UIViewController? {
guard let index = _owner.pages.index(of: viewController), index < _owner.pages.count - 1 else { return nil }
return _owner.pages[index + 1]
}
public func pageViewController(_ pageViewController: UIPageViewController, viewControllerBefore viewController: UIViewController) -> UIViewController? {
guard let index = _owner.pages.index(of: viewController), index > 0 else { return nil }
return _owner.pages[index - 1]
}
}
private class PageIndicatorDataSource: DataSource {
// MARK: - UIPageViewControllerDataSource
public func presentationCount(for pageViewController: UIPageViewController) -> Int {
return _owner.pages.count
}
public func presentationIndex(for pageViewController: UIPageViewController) -> Int {
return _owner.currentIndex
}
}
fileprivate struct TransitionState {
var nextViewController: UIViewController?
var direction: UIPageViewControllerNavigationDirection = .forward
}
// MARK: - Private Properties
private var _dataSource: DataSource! = nil
fileprivate var _transitionState: TransitionState = TransitionState()
// MARK: - Public Properties
public fileprivate(set) var pages: [UIViewController] = [] {
didSet {
for (index, vc) in pages.enumerated() { vc.view.tag = index }
}
}
public func setPages(_ pages: [UIViewController], currentIndex: Int, direction: UIPageViewControllerNavigationDirection, animated: Bool, completion: (() -> Void)? = nil) {
self.pages = pages
setCurrentIndex(currentIndex, direction: direction, animated: animated, completion: completion)
}
public private(set) var currentIndex: Int = 0
public func setCurrentIndex(_ currentIndex: Int, direction: UIPageViewControllerNavigationDirection, animated: Bool, completion: (() -> Void)? = nil) {
self.currentIndex = currentIndex
_transition(from: viewControllers?.first, to: pages.count > currentIndex ? pages[currentIndex] : nil, direction: direction, animated: animated, notifyDelegate: true, completion: completion)
}
public var showsPageIndicator: Bool = false {
didSet {
guard showsPageIndicator != oldValue else { return }
_dataSource = showsPageIndicator ? PageIndicatorDataSource(owner: self) : DataSource(owner: self)
dataSource = _dataSource
}
}
public weak var elementalDelegate: ElementalPageViewControllerDelegate?
public var pageCount: Int {
return pages.count
}
// Subclass Hooks
open func prepareForTransition(from currentPage: UIViewController?, to nextPage: UIViewController?, direction: UIPageViewControllerNavigationDirection, animated: Bool) {
(currentPage as? ElementalPage)?.willDisappear(fromPageViewController: self)
(nextPage as? ElementalPage)?.willAppear(inPageViewController: self)
}
open func cancelTransition(from currentPage: UIViewController?, to nextPage: UIViewController?, direction: UIPageViewControllerNavigationDirection, animated: Bool) {
(currentPage as? ElementalPage)?.cancelDisappear(fromPageViewController: self)
(nextPage as? ElementalPage)?.cancelAppear(inPageViewController: self)
}
open func recoverAfterTransition(from previousPage: UIViewController?, to currentPage: UIViewController?, direction: UIPageViewControllerNavigationDirection, animated: Bool) {
(previousPage as? ElementalPage)?.didDisappear(fromPageViewController: self)
(currentPage as? ElementalPage)?.didAppear(inPageViewController: self)
}
// MARK: - Init
public convenience init(viewControllers: [UIViewController]) {
self.init(transitionStyle: .scroll, navigationOrientation: .horizontal)
// didSet will not be triggered if pages is set directly in an init method
_setPages(viewControllers)
}
public required init?(coder: NSCoder) {
super.init(coder: coder)
_commonInit()
}
public override init(transitionStyle style: UIPageViewControllerTransitionStyle, navigationOrientation: UIPageViewControllerNavigationOrientation, options: [String : Any]? = nil) {
super.init(transitionStyle: style, navigationOrientation: navigationOrientation, options: options)
_commonInit()
}
private func _commonInit() {
showsPageIndicator = true
delegate = self
dataSource = _dataSource
}
// MARK: - Life Cycle
open override func viewDidLoad() {
super.viewDidLoad()
view.subviews.forEach { ($0 as? UIScrollView)?.delaysContentTouches = false }
_transition(from: nil, to: pages.first, direction: .forward, animated: false, notifyDelegate: false, completion: nil)
}
// MARK: - Public
public func navigate(_ direction: UIPageViewControllerNavigationDirection, completion: (() -> Void)? = nil) {
guard let current = viewControllers?.first else { completion?(); return }
var next: UIViewController?
switch direction {
case .forward: next = dataSource?.pageViewController(self, viewControllerAfter: current)
case .reverse: next = dataSource?.pageViewController(self, viewControllerBefore: current)
}
guard let target = next else { completion?(); return }
switch direction {
case .forward: currentIndex = currentIndex + 1
case .reverse: currentIndex = currentIndex - 1
}
_transition(from: current, to: next, direction: direction, animated: true, notifyDelegate: true, completion: completion)
}
public func navigate(to index: Int) {
guard !pages.isEmpty, index != currentIndex else { return }
let index = min(index, pages.count - 1)
switch index {
case 0..<currentIndex:
let count = currentIndex - index
for _ in 0..<count { navigate(.reverse) }
case currentIndex+1..<pages.count:
let count = index - currentIndex
for _ in 0..<count { navigate(.forward) }
default: break
}
}
public func navigateToFirst() {
navigate(to: 0)
}
// MARK: - Private
private func _transition(from current: UIViewController?, to next: UIViewController?, direction: UIPageViewControllerNavigationDirection, animated: Bool, notifyDelegate: Bool, completion: (() -> Void)?) {
guard current != next else { return }
prepareForTransition(from: current, to: next, direction: direction, animated: true)
let nextViewControllers = next == nil ? nil : [next!]
setViewControllers(nextViewControllers, direction: direction, animated: true) { finished in
self.recoverAfterTransition(from: current, to: next, direction: direction, animated: true)
if let next = next, let index = self.pages.index(of: next) {
// calling setViewControllers(direction:animated:) doesn't trigger the UIPageViewControllerDelegate method
// didFinishAnimating, so we have to tell our elementalDelegate that a transition was just completed
self.elementalDelegate?.elementalPageTransitionCompleted(index: index, destinationIndex: self.currentIndex, in: self)
}
completion?()
}
}
fileprivate func _setPages(_ pages: [UIViewController]) {
self.pages = pages
}
fileprivate func _setCurrentIndex(_ index: Int) {
currentIndex = index
}
}
extension ElementalPageViewController: UIPageViewControllerDelegate {
public func pageViewController(_ pageViewController: UIPageViewController, willTransitionTo pendingViewControllers: [UIViewController]) {
let nextViewController = pendingViewControllers.first
let direction: UIPageViewControllerNavigationDirection = {
guard let nextIndex = nextViewController?.view.tag else { return .forward }
return nextIndex < currentIndex ? .reverse : .forward
}()
if let transitionViewController = _transitionState.nextViewController {
cancelTransition(from: pageViewController.viewControllers?.first, to: transitionViewController, direction: _transitionState.direction, animated: true)
}
_transitionState.nextViewController = nextViewController
_transitionState.direction = direction
prepareForTransition(from: pageViewController.viewControllers?.first, to: nextViewController, direction: direction, animated: true)
}
public func pageViewController(_ pageViewController: UIPageViewController, didFinishAnimating finished: Bool, previousViewControllers: [UIViewController], transitionCompleted completed: Bool) {
guard let index = pageViewController.viewControllers?.first?.view.tag else { return }
_setCurrentIndex(index)
let previousViewController = previousViewControllers.first
if previousViewController == pageViewController.viewControllers?.first, let transitionViewController = _transitionState.nextViewController {
cancelTransition(from: previousViewController, to: transitionViewController, direction: _transitionState.direction, animated: true)
} else {
let direction: UIPageViewControllerNavigationDirection = {
guard let previousIndex = previousViewController?.view.tag else { return .forward }
return currentIndex < previousIndex ? .reverse : .forward
}()
recoverAfterTransition(from: previousViewController, to: pageViewController.viewControllers?.first, direction: direction, animated: true)
}
_transitionState.nextViewController = nil
guard completed else { return }
elementalDelegate?.elementalPageTransitionCompleted(index: index, destinationIndex: currentIndex, in: self)
}
}
public protocol ElementalContextual {
func enter(context: Any)
func leave(context: Any)
func changeContext(from oldContext: Any, to context: Any)
}
public extension ElementalContextual {
func enter(context: Any) {}
func leave(context: Any) {}
func changeContext(from oldContext: Any, to context: Any) {}
}
open class ElementalContextPage<PageContext>: ElementalViewController, ElementalPage, ElementalContextual {
// MARK: - Subclass Hooks
open func enterOwn(context: PageContext) {}
open func leaveOwn(context: PageContext) {}
open func changeOwnContext(from oldContext: PageContext, to context: PageContext) {}
// MARK: - ElementalContextual
open func enter(context: Any) {
guard let pageContext = context as? PageContext else { return }
enterOwn(context: pageContext)
}
open func leave(context: Any) {
guard let pageContext = context as? PageContext else { return }
leaveOwn(context: pageContext)
}
open func changeContext(from oldContext: Any, to context: Any) {
if let oldPageContext = oldContext as? PageContext, let pageContext = context as? PageContext {
changeOwnContext(from: oldPageContext, to: pageContext)
} else if let oldPageContext = oldContext as? PageContext {
leaveOwn(context: oldPageContext)
} else if let pageContext = context as? PageContext {
enterOwn(context: pageContext)
}
}
}
open class ElementalContextPageViewController<Context>: ElementalPageViewController {
// MARK: - Nested Types
public typealias Page = ElementalContextPage<Context>
// MARK: - Private Properties
private var _transitionContexts: [UIViewController : (countDown: Int, context: Context?)] = [:]
private var _transitionStateContext: Context?
// MARK: - Public Properties
public var context: Context? {
didSet {
if let oldContext = oldValue, let context = context {
viewControllers?.forEach { ($0 as? ElementalContextual)?.changeContext(from: oldValue, to: oldContext) }
} else if let oldContext = oldValue {
viewControllers?.forEach { ($0 as? ElementalContextual)?.leave(context: oldContext) }
} else if let context = context {
viewControllers?.forEach { ($0 as? ElementalContextual)?.enter(context: context) }
}
}
}
// Subclass Hooks
override open func prepareForTransition(from currentPage: UIViewController?, to nextPage: UIViewController?, direction: UIPageViewControllerNavigationDirection, animated: Bool) {
super.prepareForTransition(from: currentPage, to: nextPage, direction: direction, animated: animated)
if let currentPage = currentPage, currentPage is ElementalContextual {
var transitionContext = _transitionContexts[currentPage] ?? (countDown: 0, context: context)
transitionContext.countDown += 1
_transitionContexts[currentPage] = transitionContext
}
if let contextualNextPage = nextPage as? ElementalContextual, let nextPage = nextPage {
if _transitionState.nextViewController == nextPage {
_transitionStateContext = context
}
if let oldContext = _transitionContexts[nextPage]?.context, let context = context {
contextualNextPage.changeContext(from: oldContext, to: context)
} else if let oldContext = _transitionContexts[nextPage]?.context {
contextualNextPage.leave(context: oldContext)
} else if let context = context {
contextualNextPage.enter(context: context)
}
_transitionContexts[nextPage]?.context = nil
}
}
open override func cancelTransition(from currentPage: UIViewController?, to nextPage: UIViewController?, direction: UIPageViewControllerNavigationDirection, animated: Bool) {
super.cancelTransition(from: currentPage, to: nextPage, direction: direction, animated: animated)
guard let nextPage = nextPage as? ElementalContextual else { return }
nextPage.leave(context: _transitionStateContext)
_transitionStateContext = nil
}
override open func recoverAfterTransition(from previousPage: UIViewController?, to currentPage: UIViewController?, direction: UIPageViewControllerNavigationDirection, animated: Bool) {
super.recoverAfterTransition(from: previousPage, to: currentPage, direction: direction, animated: animated)
guard let previousPage = previousPage, var transitionContext = _transitionContexts[previousPage] else { return }
transitionContext.countDown -= 1
if transitionContext.countDown == 0 {
if let oldContext = transitionContext.context {
(previousPage as? ElementalContextual)?.leave(context: oldContext)
}
_transitionContexts[previousPage] = nil
} else {
_transitionContexts[previousPage] = transitionContext
}
_transitionStateContext = nil
}
// MARK: - Init
public convenience init(context: Context, viewControllers: [UIViewController]) {
self.init(viewControllers: viewControllers)
self.context = context
}
}
| mit | aa3f58b50201b0d5895b6dbb23e8ba81 | 44.647849 | 207 | 0.718214 | 5.336581 | false | false | false | false |
laurentVeliscek/AudioKit | AudioKit/macOS/AudioKit for macOS/User Interface/AKResourceAudioFileLoaderView.swift | 2 | 6411 | //
// AKResourceAudioFileLoaderView.swift
// AudioKit for macOS
//
// Created by Aurelius Prochazka on 7/30/16.
// Copyright © 2016 AudioKit. All rights reserved.
//
import Cocoa
public class AKResourcesAudioFileLoaderView: NSView {
var player: AKAudioPlayer?
var stopOuterPath = NSBezierPath()
var playOuterPath = NSBezierPath()
var upOuterPath = NSBezierPath()
var downOuterPath = NSBezierPath()
var currentIndex = 0
var titles = [String]()
override public func mouseDown(theEvent: NSEvent) {
var isFileChanged = false
let isPlayerPlaying = player!.isPlaying
let touchLocation = convertPoint(theEvent.locationInWindow, fromView: nil)
if stopOuterPath.containsPoint(touchLocation) {
player?.stop()
}
if playOuterPath.containsPoint(touchLocation) {
player?.play()
}
if upOuterPath.containsPoint(touchLocation) {
currentIndex -= 1
isFileChanged = true
}
if downOuterPath.containsPoint(touchLocation) {
currentIndex += 1
isFileChanged = true
}
if currentIndex < 0 { currentIndex = titles.count - 1 }
if currentIndex >= titles.count { currentIndex = 0 }
if isFileChanged {
player?.stop()
let filename = titles[currentIndex]
let file = try? AKAudioFile(readFileName: "\(filename)", baseDir: .Resources)
do {
try player?.replaceFile(file!)
} catch {
Swift.print("Could not replace file")
}
if isPlayerPlaying { player?.play() }
}
needsDisplay = true
}
public convenience init(player: AKAudioPlayer,
filenames: [String],
frame: CGRect = CGRect(x: 0, y: 0, width: 440, height: 60)) {
self.init(frame: frame)
self.player = player
self.titles = filenames
}
func drawAudioFileLoader(sliderColor sliderColor: NSColor = NSColor(calibratedRed: 1, green: 0, blue: 0.062, alpha: 1), fileName: String = "None") {
//// General Declarations
let _ = unsafeBitCast(NSGraphicsContext.currentContext()!.graphicsPort, CGContext.self)
//// Color Declarations
let backgroundColor = NSColor(calibratedRed: 0.835, green: 0.842, blue: 0.836, alpha: 0.925)
let color = NSColor(calibratedRed: 0.029, green: 1, blue: 0, alpha: 1)
let dark = NSColor(calibratedRed: 0, green: 0, blue: 0, alpha: 1)
//// background Drawing
let backgroundPath = NSBezierPath(rect: NSMakeRect(0, 0, 440, 60))
backgroundColor.setFill()
backgroundPath.fill()
//// stopButton
//// stopOuter Drawing
stopOuterPath = NSBezierPath(rect: NSMakeRect(0, 0, 60, 60))
sliderColor.setFill()
stopOuterPath.fill()
//// stopInner Drawing
let stopInnerPath = NSBezierPath(rect: NSMakeRect(15, 15, 30, 30))
dark.setFill()
stopInnerPath.fill()
//// playButton
//// playOuter Drawing
playOuterPath = NSBezierPath(rect: NSMakeRect(60, 0, 60, 60))
color.setFill()
playOuterPath.fill()
//// playInner Drawing
let playInnerPath = NSBezierPath()
playInnerPath.moveToPoint(NSMakePoint(76.5, 45))
playInnerPath.lineToPoint(NSMakePoint(76.5, 15))
playInnerPath.lineToPoint(NSMakePoint(106.5, 30))
dark.setFill()
playInnerPath.fill()
//// upButton
//// upOuter Drawing
upOuterPath = NSBezierPath(rect: NSMakeRect(381, 30, 59, 30))
backgroundColor.setFill()
upOuterPath.fill()
//// upInner Drawing
let upInnerPath = NSBezierPath()
upInnerPath.moveToPoint(NSMakePoint(395.75, 37.5))
upInnerPath.lineToPoint(NSMakePoint(425.25, 37.5))
upInnerPath.lineToPoint(NSMakePoint(410.5, 52.5))
upInnerPath.lineToPoint(NSMakePoint(410.5, 52.5))
upInnerPath.lineToPoint(NSMakePoint(395.75, 37.5))
upInnerPath.closePath()
dark.setFill()
upInnerPath.fill()
//// downButton
//// downOuter Drawing
downOuterPath = NSBezierPath(rect: NSMakeRect(381, 0, 59, 30))
backgroundColor.setFill()
downOuterPath.fill()
//// downInner Drawing
let downInnerPath = NSBezierPath()
downInnerPath.moveToPoint(NSMakePoint(410.5, 7.5))
downInnerPath.lineToPoint(NSMakePoint(410.5, 7.5))
downInnerPath.lineToPoint(NSMakePoint(425.25, 22.5))
downInnerPath.lineToPoint(NSMakePoint(395.75, 22.5))
downInnerPath.lineToPoint(NSMakePoint(410.5, 7.5))
downInnerPath.closePath()
dark.setFill()
downInnerPath.fill()
//// nameLabel Drawing
let nameLabelRect = NSMakeRect(120, 0, 320, 60)
let nameLabelStyle = NSMutableParagraphStyle()
nameLabelStyle.alignment = .Left
let nameLabelFontAttributes = [NSFontAttributeName: NSFont(name: "HelveticaNeue", size: 24)!, NSForegroundColorAttributeName: NSColor.blackColor(), NSParagraphStyleAttributeName: nameLabelStyle]
let nameLabelInset: CGRect = NSInsetRect(nameLabelRect, 10, 0)
let nameLabelTextHeight: CGFloat = NSString(string: fileName).boundingRectWithSize(NSMakeSize(nameLabelInset.width, CGFloat.infinity), options: NSStringDrawingOptions.UsesLineFragmentOrigin, attributes: nameLabelFontAttributes).size.height
let nameLabelTextRect: NSRect = NSMakeRect(nameLabelInset.minX, nameLabelInset.minY + (nameLabelInset.height - nameLabelTextHeight) / 2, nameLabelInset.width, nameLabelTextHeight)
NSGraphicsContext.saveGraphicsState()
NSRectClip(nameLabelInset)
NSString(string: fileName).drawInRect(NSOffsetRect(nameLabelTextRect, 0, 0), withAttributes: nameLabelFontAttributes)
NSGraphicsContext.restoreGraphicsState()
}
override public func drawRect(rect: CGRect) {
drawAudioFileLoader(fileName: titles[currentIndex])
}
} | mit | 49775b3f9648d7d273108dc53d9facb3 | 35.634286 | 247 | 0.614197 | 5.019577 | false | false | false | false |
wireapp/wire-ios | Wire-iOS/Sources/UserInterface/Conversation/Content/Cells/Utility/MessageToolboxDataSource.swift | 1 | 12273 | //
// Wire
// Copyright (C) 2018 Wire Swiss GmbH
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see http://www.gnu.org/licenses/.
//
import Foundation
import UIKit
import WireDataModel
import WireCommonComponents
/// The different contents that can be displayed inside the message toolbox.
enum MessageToolboxContent: Equatable {
/// Display buttons to let the user resend the message.
case sendFailure(NSAttributedString)
/// Display the list of reactions.
case reactions(NSAttributedString)
/// Display list of calls
case callList(NSAttributedString)
/// Display the message details (timestamp and/or status and/or countdown).
case details(timestamp: NSAttributedString?, status: NSAttributedString?, countdown: NSAttributedString?)
}
extension MessageToolboxContent: Comparable {
/// Returns whether one content is located above or below the other.
/// This is used to determine from which direction to slide, so that we can keep
/// the animations logical.
static func < (lhs: MessageToolboxContent, rhs: MessageToolboxContent) -> Bool {
switch (lhs, rhs) {
case (.sendFailure, _):
return true
case (.details, .reactions):
return true
default:
return false
}
}
}
// MARK: - Data Source
/**
* An object that determines what content to display for the given message.
*/
class MessageToolboxDataSource {
/// The displayed message.
let message: ZMConversationMessage
/// The content to display for the message.
private(set) var content: MessageToolboxContent
// MARK: - Formatting Properties
private let statusTextColor = SemanticColors.Label.textMessageDetails
private let statusFont = FontSpec.smallRegularFont.font!
private static let ephemeralTimeFormatter = EphemeralTimeoutFormatter()
private var attributes: [NSAttributedString.Key: AnyObject] {
return [.font: statusFont, .foregroundColor: statusTextColor]
}
private static let separator = " " + String.MessageToolbox.middleDot + " "
// MARK: - Initialization
/// Creates a toolbox data source for the given message.
init(message: ZMConversationMessage) {
self.message = message
self.content = .details(timestamp: nil, status: nil, countdown: nil)
}
// MARK: - Content
/**
* Updates the contents of the message toolbox.
* - parameter forceShowTimestamp: Whether the timestamp should be shown, even if a state
* with a higher priority has been calculated (ex: likes).
* - parameter widthConstraint: The width available to rend the toolbox contents.
*/
func updateContent(forceShowTimestamp: Bool, widthConstraint: CGFloat) -> SlideDirection? {
// Compute the state
let likers = message.likers
let isSentBySelfUser = message.senderUser?.isSelfUser == true
let failedToSend = message.deliveryState == .failedToSend && isSentBySelfUser
let showTimestamp = forceShowTimestamp || likers.isEmpty
let previousContent = self.content
// Determine the content by priority
// 1) Call list
if message.systemMessageData?.systemMessageType == .performedCall ||
message.systemMessageData?.systemMessageType == .missedCall {
content = .callList(makeCallList())
}
// 2) Failed to send
else if failedToSend && isSentBySelfUser {
let detailsString = "content.system.failedtosend_message_timestamp".localized && attributes
content = .sendFailure(detailsString)
}
// 3) Likers
else if !showTimestamp {
let text = makeReactionsLabel(with: message.likers, widthConstraint: widthConstraint)
content = .reactions(text)
}
// 4) Timestamp
else {
let (timestamp, status, countdown) = makeDetailsString()
content = .details(timestamp: timestamp, status: status, countdown: countdown)
}
// Only perform the changes if the content did change.
guard previousContent != content else {
return nil
}
return previousContent < content ? .up : .down
}
// MARK: - Reactions
/// Creates a label that display the likers of the message.
private func makeReactionsLabel(with likers: [UserType], widthConstraint: CGFloat) -> NSAttributedString {
let likers = message.likers
// If there is only one liker, always display the name, even if the width doesn't fit
if likers.count == 1 {
return (likers[0].name ?? "") && attributes
}
// Create the list of likers
let likersNames = likers.compactMap(\.name).joined(separator: ", ")
let likersNamesAttributedString = likersNames && attributes
// Check if the list of likers fits on the screen. Otheriwse, show the summary
let constrainedSize = CGSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude)
let labelSize = likersNamesAttributedString.boundingRect(with: constrainedSize, options: [.usesFontLeading, .usesLineFragmentOrigin], context: nil)
if likers.count >= 3 || labelSize.width > widthConstraint {
let likersCount = String(format: "participants.people.count".localized, likers.count)
return likersCount && attributes
} else {
return likersNamesAttributedString
}
}
// MARK: - Details Text
/// Create a timestamp list for all calls associated with a call system message
private func makeCallList() -> NSAttributedString {
if let childMessages = message.systemMessageData?.childMessages, !childMessages.isEmpty, let timestamp = timestampString(message) {
let childrenTimestamps = childMessages.compactMap {
$0 as? ZMConversationMessage
}.sorted { left, right in
left.serverTimestamp < right.serverTimestamp
}.compactMap(timestampString)
let finalText = childrenTimestamps.reduce(timestamp) { (text, current) in
return "\(text)\n\(current)"
}
return finalText && attributes
} else {
return timestampString(message) ?? "-" && attributes
}
}
/// Creates a label that display the status of the message.
private func makeDetailsString() -> (NSAttributedString?, NSAttributedString?, NSAttributedString?) {
let deliveryStateString: NSAttributedString? = selfStatus(for: message)
let countdownStatus = makeEphemeralCountdown()
if let timestampString = self.timestampString(message), message.isSent {
if let deliveryStateString = deliveryStateString, message.shouldShowDeliveryState {
return (timestampString && attributes, deliveryStateString, countdownStatus)
} else {
return (timestampString && attributes, nil, countdownStatus)
}
} else {
return (nil, deliveryStateString, countdownStatus)
}
}
private func makeEphemeralCountdown() -> NSAttributedString? {
let showDestructionTimer = message.isEphemeral &&
!message.isObfuscated &&
nil != message.destructionDate &&
message.deliveryState != .pending
if let destructionDate = message.destructionDate, showDestructionTimer {
let remaining = destructionDate.timeIntervalSinceNow + 1 // We need to add one second to start with the correct value
if remaining > 0 {
if let string = MessageToolboxDataSource.ephemeralTimeFormatter.string(from: remaining) {
return string && attributes
}
} else if message.isAudio {
// do nothing, audio messages are allowed to extend the timer
// past the destruction date.
}
}
return nil
}
/// Returns the status for the sender of the message.
fileprivate func selfStatus(for message: ZMConversationMessage) -> NSAttributedString? {
guard let sender = message.senderUser,
sender.isSelfUser else { return nil }
var deliveryStateString: String
switch message.deliveryState {
case .pending:
deliveryStateString = "content.system.pending_message_timestamp".localized
case .read:
return selfStatusForReadDeliveryState(for: message)
case .delivered:
deliveryStateString = "content.system.message_delivered_timestamp".localized
case .sent:
deliveryStateString = "content.system.message_sent_timestamp".localized
case .invalid, .failedToSend:
return nil
}
return NSAttributedString(string: deliveryStateString) && attributes
}
private func seenTextAttachment() -> NSTextAttachment {
let imageIcon = NSTextAttachment.textAttachment(for: .eye, with: statusTextColor, verticalCorrection: -1)
imageIcon.accessibilityLabel = "seen"
return imageIcon
}
/// Creates the status for the read receipts.
fileprivate func selfStatusForReadDeliveryState(for message: ZMConversationMessage) -> NSAttributedString? {
guard let conversationType = message.conversationLike?.conversationType else {return nil}
switch conversationType {
case .group:
let attributes: [NSAttributedString.Key: AnyObject] = [
.font: UIFont.monospacedDigitSystemFont(ofSize: 10, weight: .semibold),
.foregroundColor: statusTextColor
]
let imageIcon = seenTextAttachment()
let attributedString = NSAttributedString(attachment: imageIcon) + " \(message.readReceipts.count)" && attributes
attributedString.accessibilityLabel = (imageIcon.accessibilityLabel ?? "") + " \(message.readReceipts.count)"
return attributedString
case .oneOnOne:
guard let timestamp = message.readReceipts.first?.serverTimestamp else {
return nil
}
let imageIcon = seenTextAttachment()
let timestampString = message.formattedDate(timestamp)
let attributedString = NSAttributedString(attachment: imageIcon) + " " + timestampString && attributes
attributedString.accessibilityLabel = (imageIcon.accessibilityLabel ?? "") + " " + timestampString
return attributedString
default:
return nil
}
}
/// Creates the timestamp text.
fileprivate func timestampString(_ message: ZMConversationMessage) -> String? {
let timestampString: String?
if let editedTimeString = message.formattedEditedDate() {
timestampString = String(format: "content.system.edited_message_prefix_timestamp".localized, editedTimeString)
} else if let dateTimeString = message.formattedReceivedDate() {
if let systemMessage = message as? ZMSystemMessage, systemMessage.systemMessageType == .messageDeletedForEveryone {
timestampString = String(format: "content.system.deleted_message_prefix_timestamp".localized, dateTimeString)
} else if let durationString = message.systemMessageData?.callDurationString() {
timestampString = dateTimeString + MessageToolboxDataSource.separator + durationString
} else {
timestampString = dateTimeString
}
} else {
timestampString = .none
}
return timestampString
}
}
| gpl-3.0 | 4f056ca083e96601ddd79c47ea37c55f | 38.590323 | 155 | 0.662022 | 5.271907 | false | false | false | false |
gregomni/swift | test/AutoDiff/Sema/derivative_attr_type_checking.swift | 7 | 47023 | // RUN: %target-swift-frontend-typecheck -verify -disable-availability-checking %s
// RUN: %target-swift-frontend-typecheck -enable-testing -verify -disable-availability-checking %s
// Swift.AdditiveArithmetic:3:17: note: cannot yet register derivative default implementation for protocol requirements
import _Differentiation
// Dummy `Differentiable`-conforming type.
struct DummyTangentVector: Differentiable & AdditiveArithmetic {
static var zero: Self { Self() }
static func + (_: Self, _: Self) -> Self { Self() }
static func - (_: Self, _: Self) -> Self { Self() }
typealias TangentVector = Self
}
// Test top-level functions.
func id(_ x: Float) -> Float {
return x
}
@derivative(of: id)
func jvpId(x: Float) -> (value: Float, differential: (Float) -> (Float)) {
return (x, { $0 })
}
@derivative(of: id, wrt: x)
func vjpIdExplicitWrt(x: Float) -> (value: Float, pullback: (Float) -> Float) {
return (x, { $0 })
}
func generic<T: Differentiable>(_ x: T, _ y: T) -> T {
return x
}
@derivative(of: generic)
func jvpGeneric<T: Differentiable>(x: T, y: T) -> (
value: T, differential: (T.TangentVector, T.TangentVector) -> T.TangentVector
) {
return (x, { $0 + $1 })
}
@derivative(of: generic)
func vjpGenericExtraGenericRequirements<T: Differentiable & FloatingPoint>(
x: T, y: T
) -> (value: T, pullback: (T) -> (T, T)) where T == T.TangentVector {
return (x, { ($0, $0) })
}
// Test `wrt` parameter clauses.
func add(x: Float, y: Float) -> Float {
return x + y
}
@derivative(of: add, wrt: x) // ok
func vjpAddWrtX(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float)) {
return (x + y, { $0 })
}
@derivative(of: add, wrt: (x, y)) // ok
func vjpAddWrtXY(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float, Float)) {
return (x + y, { ($0, $0) })
}
// Test index-based `wrt` parameters.
func subtract(x: Float, y: Float) -> Float {
return x - y
}
@derivative(of: subtract, wrt: (0, y)) // ok
func vjpSubtractWrt0Y(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float, Float)) {
return (x - y, { ($0, $0) })
}
@derivative(of: subtract, wrt: (1)) // ok
func vjpSubtractWrt1(x: Float, y: Float) -> (value: Float, pullback: (Float) -> Float) {
return (x - y, { $0 })
}
// Test invalid original function.
// expected-error @+1 {{cannot find 'nonexistentFunction' in scope}}
@derivative(of: nonexistentFunction)
func vjpOriginalFunctionNotFound(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
struct Q { }
@derivative(of: remainder(_:_:)) // expected-error {{cannot find 'remainder' in scope}}
// expected-error @+1 {{generic parameter 'T' is not used in function signature}}
func _vjpRemainder<T: FloatingPoint>(_ x: Q, _ y: Q) -> (
value: Q, pullback: (Q) -> (Q, Q)
) {
fatalError()
}
// Test `@derivative` attribute where `value:` result does not conform to `Differentiable`.
// Invalid original function should be diagnosed first.
// expected-error @+1 {{cannot find 'nonexistentFunction' in scope}}
@derivative(of: nonexistentFunction)
func vjpOriginalFunctionNotFound2(_ x: Float) -> (value: Int, pullback: (Float) -> Float) {
fatalError()
}
// Test incorrect `@derivative` declaration type.
// expected-note @+2 {{'incorrectDerivativeType' defined here}}
// expected-note @+1 {{candidate global function does not have expected type '(Int) -> Int'}}
func incorrectDerivativeType(_ x: Float) -> Float {
return x
}
// expected-error @+1 {{'@derivative(of:)' attribute requires function to return a two-element tuple; first element must have label 'value:' and second element must have label 'pullback:' or 'differential:'}}
@derivative(of: incorrectDerivativeType)
func jvpResultIncorrect(x: Float) -> Float {
return x
}
// expected-error @+1 {{'@derivative(of:)' attribute requires function to return a two-element tuple; first element must have label 'value:'}}
@derivative(of: incorrectDerivativeType)
func vjpResultIncorrectFirstLabel(x: Float) -> (Float, (Float) -> Float) {
return (x, { $0 })
}
// expected-error @+1 {{'@derivative(of:)' attribute requires function to return a two-element tuple; second element must have label 'pullback:' or 'differential:'}}
@derivative(of: incorrectDerivativeType)
func vjpResultIncorrectSecondLabel(x: Float) -> (value: Float, (Float) -> Float) {
return (x, { $0 })
}
// expected-error @+1 {{referenced declaration 'incorrectDerivativeType' could not be resolved}}
@derivative(of: incorrectDerivativeType)
func vjpResultNotDifferentiable(x: Int) -> (
value: Int, pullback: (Int) -> Int
) {
return (x, { $0 })
}
// expected-error @+2 {{function result's 'pullback' type does not match 'incorrectDerivativeType'}}
// expected-note @+3 {{'pullback' does not have expected type '(Float.TangentVector) -> Float.TangentVector' (aka '(Float) -> Float')}}
@derivative(of: incorrectDerivativeType)
func vjpResultIncorrectPullbackType(x: Float) -> (
value: Float, pullback: (Double) -> Double
) {
return (x, { $0 })
}
// Test invalid `wrt:` differentiation parameters.
func invalidWrtParam(_ x: Float, _ y: Float) -> Float {
return x
}
// expected-error @+1 {{unknown parameter name 'z'}}
@derivative(of: add, wrt: z)
func vjpUnknownParam(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float)) {
return (x + y, { $0 })
}
// expected-error @+1 {{parameters must be specified in original order}}
@derivative(of: invalidWrtParam, wrt: (y, x))
func vjpParamOrderNotIncreasing(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float, Float)) {
return (x + y, { ($0, $0) })
}
// expected-error @+1 {{'self' parameter is only applicable to instance methods}}
@derivative(of: invalidWrtParam, wrt: self)
func vjpInvalidSelfParam(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float, Float)) {
return (x + y, { ($0, $0) })
}
// expected-error @+1 {{parameter index is larger than total number of parameters}}
@derivative(of: invalidWrtParam, wrt: 2)
func vjpSubtractWrt2(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float, Float)) {
return (x - y, { ($0, $0) })
}
// expected-error @+1 {{parameters must be specified in original order}}
@derivative(of: invalidWrtParam, wrt: (1, x))
func vjpSubtractWrt1x(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float, Float)) {
return (x - y, { ($0, $0) })
}
// expected-error @+1 {{parameters must be specified in original order}}
@derivative(of: invalidWrtParam, wrt: (1, 0))
func vjpSubtractWrt10(x: Float, y: Float) -> (value: Float, pullback: (Float) -> (Float, Float)) {
return (x - y, { ($0, $0) })
}
func noParameters() -> Float {
return 1
}
// expected-error @+1 {{'vjpNoParameters()' has no parameters to differentiate with respect to}}
@derivative(of: noParameters)
func vjpNoParameters() -> (value: Float, pullback: (Float) -> Float) {
return (1, { $0 })
}
func noDifferentiableParameters(x: Int) -> Float {
return 1
}
// expected-error @+1 {{no differentiation parameters could be inferred; must differentiate with respect to at least one parameter conforming to 'Differentiable'}}
@derivative(of: noDifferentiableParameters)
func vjpNoDifferentiableParameters(x: Int) -> (
value: Float, pullback: (Float) -> Int
) {
return (1, { _ in 0 })
}
func functionParameter(_ fn: (Float) -> Float) -> Float {
return fn(1)
}
// expected-error @+1 {{can only differentiate with respect to parameters that conform to 'Differentiable', but '(Float) -> Float' does not conform to 'Differentiable'}}
@derivative(of: functionParameter, wrt: fn)
func vjpFunctionParameter(_ fn: (Float) -> Float) -> (
value: Float, pullback: (Float) -> Float
) {
return (functionParameter(fn), { $0 })
}
// Test static methods.
protocol StaticMethod: Differentiable {
static func foo(_ x: Float) -> Float
static func generic<T: Differentiable>(_ x: T) -> T
}
extension StaticMethod {
static func foo(_ x: Float) -> Float { x }
static func generic<T: Differentiable>(_ x: T) -> T { x }
}
extension StaticMethod {
@derivative(of: foo)
static func jvpFoo(x: Float) -> (value: Float, differential: (Float) -> Float)
{
return (x, { $0 })
}
// Test qualified declaration name.
@derivative(of: StaticMethod.foo)
static func vjpFoo(x: Float) -> (value: Float, pullback: (Float) -> Float) {
return (x, { $0 })
}
@derivative(of: generic)
static func vjpGeneric<T: Differentiable>(_ x: T) -> (
value: T, pullback: (T.TangentVector) -> (T.TangentVector)
) {
return (x, { $0 })
}
// expected-error @+1 {{'self' parameter is only applicable to instance methods}}
@derivative(of: foo, wrt: (self, x))
static func vjpFooWrtSelf(x: Float) -> (value: Float, pullback: (Float) -> Float) {
return (x, { $0 })
}
}
// Test instance methods.
protocol InstanceMethod: Differentiable {
func foo(_ x: Self) -> Self
func generic<T: Differentiable>(_ x: T) -> Self
}
extension InstanceMethod {
// expected-note @+1 {{'foo' defined here}}
func foo(_ x: Self) -> Self { x }
// expected-note @+1 {{'generic' defined here}}
func generic<T: Differentiable>(_ x: T) -> Self { self }
}
extension InstanceMethod {
@derivative(of: foo)
func jvpFoo(x: Self) -> (
value: Self, differential: (TangentVector, TangentVector) -> (TangentVector)
) {
return (x, { $0 + $1 })
}
// Test qualified declaration name.
@derivative(of: InstanceMethod.foo, wrt: x)
func jvpFooWrtX(x: Self) -> (
value: Self, differential: (TangentVector) -> (TangentVector)
) {
return (x, { $0 })
}
@derivative(of: generic)
func vjpGeneric<T: Differentiable>(_ x: T) -> (
value: Self, pullback: (TangentVector) -> (TangentVector, T.TangentVector)
) {
return (self, { ($0, .zero) })
}
@derivative(of: generic, wrt: (self, x))
func jvpGenericWrt<T: Differentiable>(_ x: T) -> (value: Self, differential: (TangentVector, T.TangentVector) -> TangentVector) {
return (self, { dself, dx in dself })
}
// expected-error @+1 {{'self' parameter must come first in the parameter list}}
@derivative(of: generic, wrt: (x, self))
func jvpGenericWrtSelf<T: Differentiable>(_ x: T) -> (value: Self, differential: (TangentVector, T.TangentVector) -> TangentVector) {
return (self, { dself, dx in dself })
}
}
extension InstanceMethod {
// If `Self` conforms to `Differentiable`, then `Self` is inferred to be a differentiation parameter.
// expected-error @+2 {{function result's 'pullback' type does not match 'foo'}}
// expected-note @+3 {{'pullback' does not have expected type '(Self.TangentVector) -> (Self.TangentVector, Self.TangentVector)'}}
@derivative(of: foo)
func vjpFoo(x: Self) -> (
value: Self, pullback: (TangentVector) -> TangentVector
) {
return (x, { $0 })
}
// If `Self` conforms to `Differentiable`, then `Self` is inferred to be a differentiation parameter.
// expected-error @+2 {{function result's 'pullback' type does not match 'generic'}}
// expected-note @+3 {{'pullback' does not have expected type '(Self.TangentVector) -> (Self.TangentVector, T.TangentVector)'}}
@derivative(of: generic)
func vjpGeneric<T: Differentiable>(_ x: T) -> (
value: Self, pullback: (TangentVector) -> T.TangentVector
) {
return (self, { _ in .zero })
}
}
// Test `@derivative` declaration with more constrained generic signature.
func req1<T>(_ x: T) -> T {
return x
}
@derivative(of: req1)
func vjpExtraConformanceConstraint<T: Differentiable>(_ x: T) -> (
value: T, pullback: (T.TangentVector) -> T.TangentVector
) {
return (x, { $0 })
}
func req2<T, U>(_ x: T, _ y: U) -> T {
return x
}
@derivative(of: req2)
func vjpExtraConformanceConstraints<T: Differentiable, U: Differentiable>( _ x: T, _ y: U) -> (
value: T, pullback: (T) -> (T, U)
) where T == T.TangentVector, U == U.TangentVector, T: CustomStringConvertible {
return (x, { ($0, .zero) })
}
// Test `@derivative` declaration with extra same-type requirements.
func req3<T>(_ x: T) -> T {
return x
}
@derivative(of: req3)
func vjpSameTypeRequirementsGenericParametersAllConcrete<T>(_ x: T) -> (
value: T, pullback: (T.TangentVector) -> T.TangentVector
) where T: Differentiable, T.TangentVector == Float {
return (x, { $0 })
}
struct Wrapper<T: Equatable>: Equatable {
var x: T
init(_ x: T) { self.x = x }
}
extension Wrapper: AdditiveArithmetic where T: AdditiveArithmetic {
static var zero: Self { .init(.zero) }
static func + (lhs: Self, rhs: Self) -> Self { .init(lhs.x + rhs.x) }
static func - (lhs: Self, rhs: Self) -> Self { .init(lhs.x - rhs.x) }
}
extension Wrapper: Differentiable where T: Differentiable, T == T.TangentVector {
typealias TangentVector = Wrapper<T.TangentVector>
}
extension Wrapper where T: Differentiable, T == T.TangentVector {
@derivative(of: init(_:))
static func vjpInit(_ x: T) -> (value: Self, pullback: (Wrapper<T>.TangentVector) -> (T)) {
fatalError()
}
}
// Test class methods.
class Super {
@differentiable(reverse)
// expected-note @+1 {{candidate instance method is not defined in the current type context}}
func foo(_ x: Float) -> Float {
return x
}
@derivative(of: foo)
func vjpFoo(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
return (foo(x), { v in v })
}
}
class Sub: Super {
// TODO(TF-649): Enable `@derivative` to override derivatives for original
// declaration defined in superclass.
// expected-error @+1 {{referenced declaration 'foo' could not be resolved}}
@derivative(of: foo)
override func vjpFoo(_ x: Float) -> (value: Float, pullback: (Float) -> Float)
{
return (foo(x), { v in v })
}
}
// Test non-`func` original declarations.
struct Struct<T> {
var x: T
}
extension Struct: Equatable where T: Equatable {}
extension Struct: Differentiable & AdditiveArithmetic
where T: Differentiable & AdditiveArithmetic {
static var zero: Self {
fatalError()
}
static func + (lhs: Self, rhs: Self) -> Self {
fatalError()
}
static func - (lhs: Self, rhs: Self) -> Self {
fatalError()
}
typealias TangentVector = Struct<T.TangentVector>
mutating func move(by offset: TangentVector) {
x.move(by: offset.x)
}
}
class Class<T> {
var x: T
init(_ x: T) {
self.x = x
}
}
extension Class: Differentiable where T: Differentiable {}
// Test computed properties.
extension Struct {
var computedProperty: T {
get { x }
set { x = newValue }
_modify { yield &x }
}
}
extension Struct where T: Differentiable & AdditiveArithmetic {
@derivative(of: computedProperty)
func vjpProperty() -> (value: T, pullback: (T.TangentVector) -> TangentVector) {
return (x, { v in .init(x: v) })
}
@derivative(of: computedProperty.get)
func jvpProperty() -> (value: T, differential: (TangentVector) -> T.TangentVector) {
fatalError()
}
@derivative(of: computedProperty.set)
mutating func vjpPropertySetter(_ newValue: T) -> (
value: (), pullback: (inout TangentVector) -> T.TangentVector
) {
fatalError()
}
// expected-error @+1 {{cannot register derivative for _modify accessor}}
@derivative(of: computedProperty._modify)
mutating func vjpPropertyModify(_ newValue: T) -> (
value: (), pullback: (inout TangentVector) -> T.TangentVector
) {
fatalError()
}
}
// Test initializers.
extension Struct {
init(_ x: Float) {}
init(_ x: T, y: Float) {}
}
extension Struct where T: Differentiable & AdditiveArithmetic {
@derivative(of: init)
static func vjpInit(_ x: Float) -> (
value: Struct, pullback: (TangentVector) -> Float
) {
return (.init(x), { _ in .zero })
}
@derivative(of: init(_:y:))
static func vjpInit2(_ x: T, _ y: Float) -> (
value: Struct, pullback: (TangentVector) -> (T.TangentVector, Float)
) {
return (.init(x, y: y), { _ in (.zero, .zero) })
}
}
// Test subscripts.
extension Struct {
subscript() -> Float {
get { 1 }
set {}
}
subscript(float float: Float) -> Float {
get { 1 }
set {}
}
// expected-note @+1 {{candidate subscript does not have a setter}}
subscript<T: Differentiable>(x: T) -> T { x }
}
extension Struct where T: Differentiable & AdditiveArithmetic {
@derivative(of: subscript.get)
func vjpSubscriptGetter() -> (value: Float, pullback: (Float) -> TangentVector) {
return (1, { _ in .zero })
}
// expected-error @+2 {{a derivative already exists for '_'}}
// expected-note @-6 {{other attribute declared here}}
@derivative(of: subscript)
func vjpSubscript() -> (value: Float, pullback: (Float) -> TangentVector) {
return (1, { _ in .zero })
}
@derivative(of: subscript().get)
func jvpSubscriptGetter() -> (value: Float, differential: (TangentVector) -> Float) {
return (1, { _ in .zero })
}
@derivative(of: subscript(float:).get, wrt: self)
func vjpSubscriptLabeledGetter(float: Float) -> (value: Float, pullback: (Float) -> TangentVector) {
return (1, { _ in .zero })
}
// expected-error @+2 {{a derivative already exists for '_'}}
// expected-note @-6 {{other attribute declared here}}
@derivative(of: subscript(float:), wrt: self)
func vjpSubscriptLabeled(float: Float) -> (value: Float, pullback: (Float) -> TangentVector) {
return (1, { _ in .zero })
}
@derivative(of: subscript(float:).get)
func jvpSubscriptLabeledGetter(float: Float) -> (value: Float, differential: (TangentVector, Float) -> Float) {
return (1, { (_,_) in 1})
}
@derivative(of: subscript(_:).get, wrt: self)
func vjpSubscriptGenericGetter<T: Differentiable>(x: T) -> (value: T, pullback: (T.TangentVector) -> TangentVector) {
return (x, { _ in .zero })
}
// expected-error @+2 {{a derivative already exists for '_'}}
// expected-note @-6 {{other attribute declared here}}
@derivative(of: subscript(_:), wrt: self)
func vjpSubscriptGeneric<T: Differentiable>(x: T) -> (value: T, pullback: (T.TangentVector) -> TangentVector) {
return (x, { _ in .zero })
}
@derivative(of: subscript.set)
mutating func vjpSubscriptSetter(_ newValue: Float) -> (
value: (), pullback: (inout TangentVector) -> Float
) {
fatalError()
}
@derivative(of: subscript().set)
mutating func jvpSubscriptSetter(_ newValue: Float) -> (
value: (), differential: (inout TangentVector, Float) -> ()
) {
fatalError()
}
@derivative(of: subscript(float:).set)
mutating func vjpSubscriptLabeledSetter(float: Float, newValue: Float) -> (
value: (), pullback: (inout TangentVector) -> (Float, Float)
) {
fatalError()
}
@derivative(of: subscript(float:).set)
mutating func jvpSubscriptLabeledSetter(float: Float, _ newValue: Float) -> (
value: (), differential: (inout TangentVector, Float, Float) -> Void
) {
fatalError()
}
// Error: original subscript has no setter.
// expected-error @+1 {{referenced declaration 'subscript(_:)' could not be resolved}}
@derivative(of: subscript(_:).set, wrt: self)
mutating func vjpSubscriptGeneric_NoSetter<T: Differentiable>(x: T) -> (
value: T, pullback: (T.TangentVector) -> TangentVector
) {
return (x, { _ in .zero })
}
}
struct SR15530_Struct<T> {}
extension SR15530_Struct: Differentiable where T: Differentiable {}
extension SR15530_Struct {
// expected-note @+1 {{candidate instance method does not have type equal to or less constrained than '<T where T : Differentiable> (inout SR15530_Struct<T>) -> (Int, @differentiable(reverse) (inout T) -> Void) -> Void'}}
mutating func sr15530_update<D>(at index: Int, byCalling closure: (inout T, D) -> Void, withArgument: D) {
fatalError("Stop")
}
}
extension SR15530_Struct where T: Differentiable {
// expected-error @+1 {{referenced declaration 'sr15530_update' could not be resolved}}
@derivative(of: sr15530_update)
mutating func vjp_sr15530_update(
at index: Int,
byCalling closure: @differentiable(reverse) (inout T) -> Void
) -> (value: Void, pullback: (inout Self.TangentVector) -> Void) {
fatalError("Stop")
}
}
extension Class {
subscript() -> Float {
get { 1 }
// expected-note @+1 {{'subscript()' declared here}}
set {}
}
}
extension Class where T: Differentiable {
@derivative(of: subscript.get)
func vjpSubscriptGetter() -> (value: Float, pullback: (Float) -> TangentVector) {
return (1, { _ in .zero })
}
// expected-error @+2 {{a derivative already exists for '_'}}
// expected-note @-6 {{other attribute declared here}}
@derivative(of: subscript)
func vjpSubscript() -> (value: Float, pullback: (Float) -> TangentVector) {
return (1, { _ in .zero })
}
// FIXME(SR-13096): Enable derivative registration for class property/subscript setters.
// This requires changing derivative type calculation rules for functions with
// class-typed parameters. We need to assume that all functions taking
// class-typed operands may mutate those operands.
// expected-error @+1 {{cannot yet register derivative for class property or subscript setters}}
@derivative(of: subscript.set)
func vjpSubscriptSetter(_ newValue: Float) -> (
value: (), pullback: (inout TangentVector) -> Float
) {
fatalError()
}
}
// Test duplicate `@derivative` attribute.
func duplicate(_ x: Float) -> Float { x }
// expected-note @+1 {{other attribute declared here}}
@derivative(of: duplicate)
func jvpDuplicate1(_ x: Float) -> (value: Float, differential: (Float) -> Float) {
return (duplicate(x), { $0 })
}
// expected-error @+1 {{a derivative already exists for 'duplicate'}}
@derivative(of: duplicate)
func jvpDuplicate2(_ x: Float) -> (value: Float, differential: (Float) -> Float) {
return (duplicate(x), { $0 })
}
// Test invalid original declaration kind.
// expected-note @+1 {{candidate var does not have a getter}}
var globalVariable: Float
// expected-error @+1 {{referenced declaration 'globalVariable' could not be resolved}}
@derivative(of: globalVariable)
func invalidOriginalDeclaration(x: Float) -> (
value: Float, differential: (Float) -> (Float)
) {
return (x, { $0 })
}
// Test ambiguous original declaration.
protocol P1 {}
protocol P2 {}
// expected-note @+1 {{candidate global function found here}}
func ambiguous<T: P1>(_ x: T) -> T { x }
// expected-note @+1 {{candidate global function found here}}
func ambiguous<T: P2>(_ x: T) -> T { x }
// expected-error @+1 {{referenced declaration 'ambiguous' is ambiguous}}
@derivative(of: ambiguous)
func jvpAmbiguous<T: P1 & P2 & Differentiable>(x: T)
-> (value: T, differential: (T.TangentVector) -> (T.TangentVector))
{
return (x, { $0 })
}
// Test no valid original declaration.
// Original declarations are invalid because they have extra generic
// requirements unsatisfied by the `@derivative` function.
// expected-note @+1 {{candidate global function does not have type equal to or less constrained than '<T where T : Differentiable> (x: T) -> T'}}
func invalid<T: BinaryFloatingPoint>(x: T) -> T { x }
// expected-note @+1 {{candidate global function does not have type equal to or less constrained than '<T where T : Differentiable> (x: T) -> T'}}
func invalid<T: CustomStringConvertible>(x: T) -> T { x }
// expected-note @+1 {{candidate global function does not have type equal to or less constrained than '<T where T : Differentiable> (x: T) -> T'}}
func invalid<T: FloatingPoint>(x: T) -> T { x }
// expected-error @+1 {{referenced declaration 'invalid' could not be resolved}}
@derivative(of: invalid)
func jvpInvalid<T: Differentiable>(x: T) -> (
value: T, differential: (T.TangentVector) -> T.TangentVector
) {
return (x, { $0 })
}
// Test stored property original declaration.
struct HasStoredProperty {
// expected-note @+1 {{'stored' declared here}}
var stored: Float
}
extension HasStoredProperty: Differentiable & AdditiveArithmetic {
static var zero: Self {
fatalError()
}
static func + (lhs: Self, rhs: Self) -> Self {
fatalError()
}
static func - (lhs: Self, rhs: Self) -> Self {
fatalError()
}
typealias TangentVector = Self
}
extension HasStoredProperty {
// expected-error @+1 {{cannot register derivative for stored property 'stored'}}
@derivative(of: stored)
func vjpStored() -> (value: Float, pullback: (Float) -> TangentVector) {
return (stored, { _ in .zero })
}
}
// Test derivative registration for protocol requirements. Currently unsupported.
// TODO(TF-982): Lift this restriction and add proper support.
protocol ProtocolRequirementDerivative {
// expected-note @+1 {{cannot yet register derivative default implementation for protocol requirements}}
func requirement(_ x: Float) -> Float
}
extension ProtocolRequirementDerivative {
// expected-error @+1 {{referenced declaration 'requirement' could not be resolved}}
@derivative(of: requirement)
func vjpRequirement(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
}
// Test `inout` parameters.
func multipleSemanticResults(_ x: inout Float) -> Float {
return x
}
// expected-error @+1 {{cannot differentiate functions with both an 'inout' parameter and a result}}
@derivative(of: multipleSemanticResults)
func vjpMultipleSemanticResults(x: inout Float) -> (
value: Float, pullback: (Float) -> Float
) {
return (multipleSemanticResults(&x), { $0 })
}
struct InoutParameters: Differentiable {
typealias TangentVector = DummyTangentVector
mutating func move(by _: TangentVector) {}
}
extension InoutParameters {
// expected-note @+1 4 {{'staticMethod(_:rhs:)' defined here}}
static func staticMethod(_ lhs: inout Self, rhs: Self) {}
// Test wrt `inout` parameter.
@derivative(of: staticMethod)
static func vjpWrtInout(_ lhs: inout Self, _ rhs: Self) -> (
value: Void, pullback: (inout TangentVector) -> TangentVector
) { fatalError() }
// expected-error @+1 {{function result's 'pullback' type does not match 'staticMethod(_:rhs:)'}}
@derivative(of: staticMethod)
static func vjpWrtInoutMismatch(_ lhs: inout Self, _ rhs: Self) -> (
// expected-note @+1 {{'pullback' does not have expected type '(inout InoutParameters.TangentVector) -> InoutParameters.TangentVector' (aka '(inout DummyTangentVector) -> DummyTangentVector')}}
value: Void, pullback: (TangentVector) -> TangentVector
) { fatalError() }
@derivative(of: staticMethod)
static func jvpWrtInout(_ lhs: inout Self, _ rhs: Self) -> (
value: Void, differential: (inout TangentVector, TangentVector) -> Void
) { fatalError() }
// expected-error @+1 {{function result's 'differential' type does not match 'staticMethod(_:rhs:)'}}
@derivative(of: staticMethod)
static func jvpWrtInoutMismatch(_ lhs: inout Self, _ rhs: Self) -> (
// expected-note @+1 {{'differential' does not have expected type '(inout InoutParameters.TangentVector, InoutParameters.TangentVector) -> ()' (aka '(inout DummyTangentVector, DummyTangentVector) -> ()')}}
value: Void, differential: (TangentVector, TangentVector) -> Void
) { fatalError() }
// Test non-wrt `inout` parameter.
@derivative(of: staticMethod, wrt: rhs)
static func vjpNotWrtInout(_ lhs: inout Self, _ rhs: Self) -> (
value: Void, pullback: (TangentVector) -> TangentVector
) { fatalError() }
// expected-error @+1 {{function result's 'pullback' type does not match 'staticMethod(_:rhs:)'}}
@derivative(of: staticMethod, wrt: rhs)
static func vjpNotWrtInoutMismatch(_ lhs: inout Self, _ rhs: Self) -> (
// expected-note @+1 {{'pullback' does not have expected type '(InoutParameters.TangentVector) -> InoutParameters.TangentVector' (aka '(DummyTangentVector) -> DummyTangentVector')}}
value: Void, pullback: (inout TangentVector) -> TangentVector
) { fatalError() }
@derivative(of: staticMethod, wrt: rhs)
static func jvpNotWrtInout(_ lhs: inout Self, _ rhs: Self) -> (
value: Void, differential: (TangentVector) -> TangentVector
) { fatalError() }
// expected-error @+1 {{function result's 'differential' type does not match 'staticMethod(_:rhs:)'}}
@derivative(of: staticMethod, wrt: rhs)
static func jvpNotWrtInout(_ lhs: inout Self, _ rhs: Self) -> (
// expected-note @+1 {{'differential' does not have expected type '(InoutParameters.TangentVector) -> InoutParameters.TangentVector' (aka '(DummyTangentVector) -> DummyTangentVector')}}
value: Void, differential: (inout TangentVector) -> TangentVector
) { fatalError() }
}
extension InoutParameters {
// expected-note @+1 4 {{'mutatingMethod' defined here}}
mutating func mutatingMethod(_ other: Self) {}
// Test wrt `inout` `self` parameter.
@derivative(of: mutatingMethod)
mutating func vjpWrtInout(_ other: Self) -> (
value: Void, pullback: (inout TangentVector) -> TangentVector
) { fatalError() }
// expected-error @+1 {{function result's 'pullback' type does not match 'mutatingMethod'}}
@derivative(of: mutatingMethod)
mutating func vjpWrtInoutMismatch(_ other: Self) -> (
// expected-note @+1 {{'pullback' does not have expected type '(inout InoutParameters.TangentVector) -> InoutParameters.TangentVector' (aka '(inout DummyTangentVector) -> DummyTangentVector')}}
value: Void, pullback: (TangentVector) -> TangentVector
) { fatalError() }
@derivative(of: mutatingMethod)
mutating func jvpWrtInout(_ other: Self) -> (
value: Void, differential: (inout TangentVector, TangentVector) -> Void
) { fatalError() }
// expected-error @+1 {{function result's 'differential' type does not match 'mutatingMethod'}}
@derivative(of: mutatingMethod)
mutating func jvpWrtInoutMismatch(_ other: Self) -> (
// expected-note @+1 {{'differential' does not have expected type '(inout InoutParameters.TangentVector, InoutParameters.TangentVector) -> ()' (aka '(inout DummyTangentVector, DummyTangentVector) -> ()')}}
value: Void, differential: (TangentVector, TangentVector) -> Void
) { fatalError() }
// Test non-wrt `inout` `self` parameter.
@derivative(of: mutatingMethod, wrt: other)
mutating func vjpNotWrtInout(_ other: Self) -> (
value: Void, pullback: (TangentVector) -> TangentVector
) { fatalError() }
// expected-error @+1 {{function result's 'pullback' type does not match 'mutatingMethod'}}
@derivative(of: mutatingMethod, wrt: other)
mutating func vjpNotWrtInoutMismatch(_ other: Self) -> (
// expected-note @+1 {{'pullback' does not have expected type '(InoutParameters.TangentVector) -> InoutParameters.TangentVector' (aka '(DummyTangentVector) -> DummyTangentVector')}}
value: Void, pullback: (inout TangentVector) -> TangentVector
) { fatalError() }
@derivative(of: mutatingMethod, wrt: other)
mutating func jvpNotWrtInout(_ other: Self) -> (
value: Void, differential: (TangentVector) -> TangentVector
) { fatalError() }
// expected-error @+1 {{function result's 'differential' type does not match 'mutatingMethod'}}
@derivative(of: mutatingMethod, wrt: other)
mutating func jvpNotWrtInoutMismatch(_ other: Self) -> (
// expected-note @+1 {{'differential' does not have expected type '(InoutParameters.TangentVector) -> InoutParameters.TangentVector' (aka '(DummyTangentVector) -> DummyTangentVector')}}
value: Void, differential: (TangentVector, TangentVector) -> Void
) { fatalError() }
}
// Test no semantic results.
func noSemanticResults(_ x: Float) {}
// expected-error @+1 {{cannot differentiate void function 'noSemanticResults'}}
@derivative(of: noSemanticResults)
func vjpNoSemanticResults(_ x: Float) -> (value: Void, pullback: Void) {}
// Test multiple semantic results.
extension InoutParameters {
func multipleSemanticResults(_ x: inout Float) -> Float { x }
// expected-error @+1 {{cannot differentiate functions with both an 'inout' parameter and a result}}
@derivative(of: multipleSemanticResults)
func vjpMultipleSemanticResults(_ x: inout Float) -> (
value: Float, pullback: (inout Float) -> Void
) { fatalError() }
func inoutVoid(_ x: Float, _ void: inout Void) -> Float {}
// expected-error @+1 {{cannot differentiate functions with both an 'inout' parameter and a result}}
@derivative(of: inoutVoid)
func vjpInoutVoidParameter(_ x: Float, _ void: inout Void) -> (
value: Float, pullback: (inout Float) -> Void
) { fatalError() }
}
// Test original/derivative function `inout` parameter mismatches.
extension InoutParameters {
// expected-note @+1 {{candidate instance method does not have expected type '(InoutParameters) -> (inout Float) -> Void'}}
func inoutParameterMismatch(_ x: Float) {}
// expected-error @+1 {{referenced declaration 'inoutParameterMismatch' could not be resolved}}
@derivative(of: inoutParameterMismatch)
func vjpInoutParameterMismatch(_ x: inout Float) -> (value: Void, pullback: (inout Float) -> Void) {
fatalError()
}
// expected-note @+1 {{candidate instance method does not have expected type '(inout InoutParameters) -> (Float) -> Void'}}
func mutatingMismatch(_ x: Float) {}
// expected-error @+1 {{referenced declaration 'mutatingMismatch' could not be resolved}}
@derivative(of: mutatingMismatch)
mutating func vjpMutatingMismatch(_ x: Float) -> (value: Void, pullback: (inout Float) -> Void) {
fatalError()
}
}
// Test cross-file derivative registration.
extension FloatingPoint where Self: Differentiable {
@usableFromInline
@derivative(of: rounded)
func vjpRounded() -> (
value: Self,
pullback: (Self.TangentVector) -> (Self.TangentVector)
) {
fatalError()
}
}
extension Differentiable where Self: AdditiveArithmetic {
// expected-error @+1 {{referenced declaration '+' could not be resolved}}
@derivative(of: +)
static func vjpPlus(x: Self, y: Self) -> (
value: Self,
pullback: (Self.TangentVector) -> (Self.TangentVector, Self.TangentVector)
) {
return (x + y, { v in (v, v) })
}
}
extension AdditiveArithmetic
where Self: Differentiable, Self == Self.TangentVector {
// expected-error @+1 {{referenced declaration '+' could not be resolved}}
@derivative(of: +)
func vjpPlusInstanceMethod(x: Self, y: Self) -> (
value: Self, pullback: (Self) -> (Self, Self)
) {
return (x + y, { v in (v, v) })
}
}
// Test derivatives of default implementations.
protocol HasADefaultImplementation {
func req(_ x: Float) -> Float
}
extension HasADefaultImplementation {
func req(_ x: Float) -> Float { x }
// ok
@derivative(of: req)
func req(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
(x, { 10 * $0 })
}
}
// Test default derivatives of requirements.
protocol HasADefaultDerivative {
// expected-note @+1 {{cannot yet register derivative default implementation for protocol requirements}}
func req(_ x: Float) -> Float
}
extension HasADefaultDerivative {
// TODO(TF-982): Support default derivatives for protocol requirements.
// expected-error @+1 {{referenced declaration 'req' could not be resolved}}
@derivative(of: req)
func vjpReq(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
(x, { 10 * $0 })
}
}
// MARK: - Original function visibility = derivative function visibility
public func public_original_public_derivative(_ x: Float) -> Float { x }
@derivative(of: public_original_public_derivative)
public func _public_original_public_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
public func public_original_usablefrominline_derivative(_ x: Float) -> Float { x }
@usableFromInline
@derivative(of: public_original_usablefrominline_derivative)
func _public_original_usablefrominline_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
func internal_original_internal_derivative(_ x: Float) -> Float { x }
@derivative(of: internal_original_internal_derivative)
func _internal_original_internal_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
private func private_original_private_derivative(_ x: Float) -> Float { x }
@derivative(of: private_original_private_derivative)
private func _private_original_private_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
fileprivate func fileprivate_original_fileprivate_derivative(_ x: Float) -> Float { x }
@derivative(of: fileprivate_original_fileprivate_derivative)
fileprivate func _fileprivate_original_fileprivate_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
func internal_original_usablefrominline_derivative(_ x: Float) -> Float { x }
@usableFromInline
@derivative(of: internal_original_usablefrominline_derivative)
func _internal_original_usablefrominline_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
func internal_original_inlinable_derivative(_ x: Float) -> Float { x }
@inlinable
@derivative(of: internal_original_inlinable_derivative)
func _internal_original_inlinable_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
func internal_original_alwaysemitintoclient_derivative(_ x: Float) -> Float { x }
@_alwaysEmitIntoClient
@derivative(of: internal_original_alwaysemitintoclient_derivative)
func _internal_original_alwaysemitintoclient_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
// MARK: - Original function visibility < derivative function visibility
@usableFromInline
func usablefrominline_original_public_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_usablefrominline_original_public_derivative' is public, but original function 'usablefrominline_original_public_derivative' is internal}}
@derivative(of: usablefrominline_original_public_derivative)
// expected-note @+1 {{mark the derivative function as 'internal' to match the original function}} {{1-7=internal}}
public func _usablefrominline_original_public_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
func internal_original_public_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_internal_original_public_derivative' is public, but original function 'internal_original_public_derivative' is internal}}
@derivative(of: internal_original_public_derivative)
// expected-note @+1 {{mark the derivative function as 'internal' to match the original function}} {{1-7=internal}}
public func _internal_original_public_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
private func private_original_usablefrominline_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_private_original_usablefrominline_derivative' is internal, but original function 'private_original_usablefrominline_derivative' is private}}
@derivative(of: private_original_usablefrominline_derivative)
@usableFromInline
// expected-note @+1 {{mark the derivative function as 'private' to match the original function}} {{1-1=private }}
func _private_original_usablefrominline_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
private func private_original_public_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_private_original_public_derivative' is public, but original function 'private_original_public_derivative' is private}}
@derivative(of: private_original_public_derivative)
// expected-note @+1 {{mark the derivative function as 'private' to match the original function}} {{1-7=private}}
public func _private_original_public_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
private func private_original_internal_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_private_original_internal_derivative' is internal, but original function 'private_original_internal_derivative' is private}}
@derivative(of: private_original_internal_derivative)
// expected-note @+1 {{mark the derivative function as 'private' to match the original function}}
func _private_original_internal_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
fileprivate func fileprivate_original_private_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_fileprivate_original_private_derivative' is private, but original function 'fileprivate_original_private_derivative' is fileprivate}}
@derivative(of: fileprivate_original_private_derivative)
// expected-note @+1 {{mark the derivative function as 'fileprivate' to match the original function}} {{1-8=fileprivate}}
private func _fileprivate_original_private_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
private func private_original_fileprivate_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_private_original_fileprivate_derivative' is fileprivate, but original function 'private_original_fileprivate_derivative' is private}}
@derivative(of: private_original_fileprivate_derivative)
// expected-note @+1 {{mark the derivative function as 'private' to match the original function}} {{1-12=private}}
fileprivate func _private_original_fileprivate_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
// MARK: - Original function visibility > derivative function visibility
public func public_original_private_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_public_original_private_derivative' is fileprivate, but original function 'public_original_private_derivative' is public}}
@derivative(of: public_original_private_derivative)
// expected-note @+1 {{mark the derivative function as '@usableFromInline' to match the original function}} {{1-1=@usableFromInline }}
fileprivate func _public_original_private_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
public func public_original_internal_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_public_original_internal_derivative' is internal, but original function 'public_original_internal_derivative' is public}}
@derivative(of: public_original_internal_derivative)
// expected-note @+1 {{mark the derivative function as '@usableFromInline' to match the original function}} {{1-1=@usableFromInline }}
func _public_original_internal_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
func internal_original_fileprivate_derivative(_ x: Float) -> Float { x }
// expected-error @+1 {{derivative function must have same access level as original function; derivative function '_internal_original_fileprivate_derivative' is fileprivate, but original function 'internal_original_fileprivate_derivative' is internal}}
@derivative(of: internal_original_fileprivate_derivative)
// expected-note @+1 {{mark the derivative function as 'internal' to match the original function}} {{1-12=internal}}
fileprivate func _internal_original_fileprivate_derivative(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
// Test invalid reference to an accessor of a non-storage declaration.
// expected-note @+1 {{candidate global function does not have a getter}}
func function(_ x: Float) -> Float {
x
}
// expected-error @+1 {{referenced declaration 'function' could not be resolved}}
@derivative(of: function(_:).get)
func vjpFunction(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
// Test ambiguity that exists when Type function name is the same
// as an accessor label.
extension Float {
// Original function name conflicts with an accessor name ("set").
func set() -> Float {
self
}
// Original function name does not conflict with an accessor name.
func method() -> Float {
self
}
// Test ambiguous parse.
// Expected:
// - Base type: `Float`
// - Declaration name: `set`
// - Accessor kind: <none>
// Actual:
// - Base type: <none>
// - Declaration name: `Float`
// - Accessor kind: `set`
// expected-error @+1 {{cannot find 'Float' in scope}}
@derivative(of: Float.set)
func jvpSet() -> (value: Float, differential: (Float) -> Float) {
fatalError()
}
@derivative(of: Float.method)
func jvpMethod() -> (value: Float, differential: (Float) -> Float) {
fatalError()
}
}
// Test original function with opaque result type.
// expected-note @+1 {{candidate global function does not have expected type '(Float) -> Float'}}
func opaqueResult(_ x: Float) -> some Differentiable { x }
// expected-error @+1 {{referenced declaration 'opaqueResult' could not be resolved}}
@derivative(of: opaqueResult)
func vjpOpaqueResult(_ x: Float) -> (value: Float, pullback: (Float) -> Float) {
fatalError()
}
// Test instance vs static method mismatch.
struct StaticMismatch<T: Differentiable> {
// expected-note @+1 {{original function 'init(_:)' is a 'static' method}}
init(_ x: T) {}
// expected-note @+1 {{original function 'instanceMethod' is an instance method}}
func instanceMethod(_ x: T) -> T { x }
// expected-note @+1 {{original function 'staticMethod' is a 'static' method}}
static func staticMethod(_ x: T) -> T { x }
// expected-error @+1 {{unexpected derivative function declaration; 'init(_:)' requires the derivative function 'vjpInit' to be a 'static' method}}
@derivative(of: init)
// expected-note @+1 {{make derivative function 'vjpInit' a 'static' method}}{{3-3=static }}
func vjpInit(_ x: T) -> (value: Self, pullback: (T.TangentVector) -> T.TangentVector) {
fatalError()
}
// expected-error @+1 {{unexpected derivative function declaration; 'instanceMethod' requires the derivative function 'jvpInstance' to be an instance method}}
@derivative(of: instanceMethod)
// expected-note @+1 {{make derivative function 'jvpInstance' an instance method}}{{3-10=}}
static func jvpInstance(_ x: T) -> (
value: T, differential: (T.TangentVector) -> (T.TangentVector)
) {
return (x, { $0 })
}
// expected-error @+1 {{unexpected derivative function declaration; 'staticMethod' requires the derivative function 'jvpStatic' to be a 'static' method}}
@derivative(of: staticMethod)
// expected-note @+1 {{make derivative function 'jvpStatic' a 'static' method}}{{3-3=static }}
func jvpStatic(_ x: T) -> (
value: T, differential: (T.TangentVector) -> (T.TangentVector)
) {
return (x, { $0 })
}
}
| apache-2.0 | 434ce0bda7fe2d2c34e8723a002a4c90 | 37.511876 | 256 | 0.688216 | 3.853397 | false | false | false | false |
Sage-Bionetworks/BridgeAppSDK | BridgeAppSDK/SBAGenericStepDataSource.swift | 1 | 22186 | //
// SBAGenericStepDataSource.swift
// BridgeAppSDK
//
// Created by Josh Bruhin on 6/5/17.
// Copyright © 2017 Sage Bionetworks. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation and/or
// other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder(s) nor the names of any contributors
// may be used to endorse or promote products derived from this software without
// specific prior written permission. No license is granted to the trademarks of
// the copyright holders even if such marks are included in this software.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
import UIKit
/**
SBAGenericStepDataSource: the internal model for SBAGenericStepViewController. It provides the UITableViewDataSource,
manages and stores answers provided thru user input, and provides an ORKResult with those anwers upon request.
It also provides several convenience methods for saving or selecting answers, checking if all answers are valid,
and retrieving specific model objects that may be needed by the ViewController.
The tableView data source is comprised of 3 objects:
1) SBAGenericStepTableSection - An object representing a section in the tableView. It has one or more SBAGenericStepTableItemGroups.
2) SBAGenericStepTableItemGroup - An object representing a specific question supplied by ORKStep in the form of ORKFormItem.
An ORKFormItem can have multiple answer options, such as a boolean question or text choice
question. Or, it can have just one answer option, in the case of alpha/numeric questions.
Upon init(), the ItemGroup will create one or more SBAGenericStepTableItem representing the answer
options for the ORKFormItem. The ItemGroup is responsible for storing/computing the answers
for its ORKFormItem.
3) SBAGenericStepTableItem - An object representing a specific answer option from the ItemGroup (ORKFormItem), such as a Yes or No
choice in a boolean question or a string or number that's entered thru a text field. There will be
one TableItem for each indexPath in the tableView.
*/
public protocol SBAGenericStepDataSourceDelegate {
func answersDidChange()
}
open class SBAGenericStepDataSource: NSObject {
open var delegate: SBAGenericStepDataSourceDelegate?
open var sections: Array<SBAGenericStepTableSection> = Array()
open var step: ORKStep?
/**
Initialize a new SBAGenericStepDataSource.
@param step The ORKStep
@param result The previous ORKResult, if any
*/
public init(step: ORKStep?, result: ORKResult?) {
super.init()
self.step = step
populate()
if result != nil {
updateAnswers(from: result!)
}
}
func updateAnswers(from result: ORKResult) {
guard let taskResult = result as? ORKTaskResult else { return }
// find the existing result for this step, if any
if let stepResult = taskResult.result(forIdentifier: step!.identifier) as? ORKStepResult,
let stepResults = stepResult.results as? [ORKQuestionResult] {
// for each form item result, save the existing answer to our model
for result in stepResults {
let answer = result.answer ?? ORKNullAnswerValue()
if let group = itemGroup(with: result.identifier) {
group.answer = answer as AnyObject
}
}
}
}
public func updateDefaults(_ defaults: NSMutableDictionary) {
// TODO: Josh Bruhin, 6/12/17 - implement. this may require access to a HealthKit source.
for section in sections {
section.itemGroups.forEach({
if let newAnswer = defaults[$0.formItem.identifier] {
$0.defaultAnswer = newAnswer as AnyObject
}
})
}
// notify our delegate that the result changed
if let delegate = delegate {
delegate.answersDidChange()
}
}
/**
Determine if all answers are valid. Also checks the case where answers are required but one has not been provided.
@return A Bool indicating if all answers are valid
*/
open func allAnswersValid() -> Bool {
for section in sections {
for itemGroup in section.itemGroups {
if !itemGroup.isAnswerValid {
return false
}
}
}
return true
}
/**
Retrieve the 'SBAGenericStepTableItemGroup' with a specific ORKFormItem identifier.
@param identifier The identifier of the ORKFormItem assigned to the ItemGroup
@return The requested SBAGenericStepTableItemGroup, or nil if it cannot be found
*/
open func itemGroup(with identifier: String) -> SBAGenericStepTableItemGroup? {
for section in sections {
for itemGroup in section.itemGroups {
if itemGroup.formItem.identifier == identifier {
return itemGroup
}
}
}
return nil
}
/**
Retrieve the 'SBAGenericStepTableItemGroup' for a specific IndexPath.
@param indexPath The IndexPath that represents the ItemGroup in the tableView
@return The requested SBAGenericStepTableItemGroup, or nil if it cannot be found
*/
open func itemGroup(at indexPath: IndexPath) -> SBAGenericStepTableItemGroup? {
let section = sections[indexPath.section]
for itemGroup in section.itemGroups {
if itemGroup.beginningRowIndex ... itemGroup.beginningRowIndex + (itemGroup.items.count - 1) ~= indexPath.row {
return itemGroup
}
}
return nil
}
/**
Retrieve the 'SBAGenericStepTableItem' for a specific IndexPath.
@param indexPath The IndexPath that represents the TableItem in the tableView
@return The requested SBAGenericStepTableItem, or nil if it cannot be found
*/
open func tableItem(at indexPath: IndexPath) -> SBAGenericStepTableItem? {
if let itemGroup = itemGroup(at: indexPath) {
let index = indexPath.row - itemGroup.beginningRowIndex
return itemGroup.items[index]
}
return nil
}
/**
Save an answer for a specific IndexPath.
@param answer The object to be save as the answer
@param indexPath The IndexPath that represents the TableItemGroup in the tableView
*/
open func saveAnswer(_ answer: AnyObject, at indexPath: IndexPath) {
let itemGroup = self.itemGroup(at: indexPath)
itemGroup?.answer = answer
// inform delegate that answers have changed
if let delegate = delegate {
delegate.answersDidChange()
}
}
/**
Select or deselect the answer option for a specific IndexPath.
@param indexPath The IndexPath that represents the TableItemGroup in the tableView
*/
open func selectAnswer(selected: Bool, at indexPath: IndexPath) {
let itemGroup = self.itemGroup(at: indexPath)
itemGroup?.select(selected, indexPath: indexPath)
// inform delegate that answers have changed
if let delegate = delegate {
delegate.answersDidChange()
}
}
/**
Retrieve the current ORKStepResult.
@return An ORKStepResult object with the current answers for all of its ORKFormItems
*/
open func results(parentResult: ORKStepResult) -> ORKStepResult {
guard let formItems = formItemsWithAnswerFormat() else { return parentResult }
// "Now" is the end time of the result, which is either actually now,
// or the last time we were in the responder chain.
let now = parentResult.endDate
for formItem: ORKFormItem in formItems {
var answer = ORKNullAnswerValue()
var answerDate = now
var systemCalendar = Calendar.current
var systemTimeZone = NSTimeZone.system
if let itemGroup = itemGroup(with: formItem.identifier) {
answer = itemGroup.answer
// check that answer is not NSNull (ORKNullAnswerValue)
// Skipped forms report a "null" value for every item -- by skipping, the user has explicitly said they don't want
// to report any values from this form.
if !(answer is NSNull) {
answerDate = itemGroup.answerDate ?? now
systemCalendar = itemGroup.calendar
systemTimeZone = itemGroup.timezone
}
}
guard let result = formItem.answerFormat?.result(withIdentifier: formItem.identifier, answer: answer) else {
continue
}
let impliedAnswerFormat = formItem.answerFormat?.implied()
if let dateAnswerFormat = impliedAnswerFormat as? ORKDateAnswerFormat,
let dateQuestionResult = result as? ORKDateQuestionResult,
let _ = dateQuestionResult.dateAnswer {
let usedCalendar = dateAnswerFormat.calendar ?? systemCalendar
dateQuestionResult.calendar = usedCalendar
dateQuestionResult.timeZone = systemTimeZone
}
else if let numericAnswerFormat = impliedAnswerFormat as? ORKNumericAnswerFormat,
let numericQuestionFormat = result as? ORKNumericQuestionResult,
numericQuestionFormat.unit == nil {
numericQuestionFormat.unit = numericAnswerFormat.unit
}
result.startDate = answerDate
result.endDate = answerDate
parentResult.addResult(result)
}
return parentResult
}
fileprivate func formItemsWithAnswerFormat() -> Array<ORKFormItem>? {
return self.formItems()?.filter { $0.answerFormat != nil }
}
fileprivate func formItems() -> [ORKFormItem]? {
guard let formStep = self.step as? SBAFormStepProtocol else { return nil }
return formStep.formItems
}
fileprivate func populate() {
guard let items = formItems(), items.count > 0 else {
return
}
let singleSelectionTypes: [ORKQuestionType] = [.boolean, .singleChoice, .multipleChoice, .location]
for item in items {
// some form items need to be in their own section
var needExclusiveSection = false
if let answerFormat = item.answerFormat?.implied() {
let multiCellChoice = singleSelectionTypes.contains(answerFormat.questionType) && !(answerFormat is ORKValuePickerAnswerFormat)
let multiLineTextEntry = answerFormat.questionType == .text
let scale = answerFormat.questionType == .scale
needExclusiveSection = multiCellChoice || multiLineTextEntry || scale
}
// if we don't need an exclusive section and we have an existing section and it's not exclusive ('singleFormItem'),
// then add this item to that existing section, otherwise create a new one
if !needExclusiveSection, let lastSection = sections.last, !lastSection.singleFormItem {
lastSection.add(formItem: item)
}
else {
let section = SBAGenericStepTableSection(sectionIndex: sections.count)
section.add(formItem: item)
section.title = item.text
section.singleFormItem = needExclusiveSection
sections.append(section)
}
}
}
}
open class SBAGenericStepTableSection: NSObject {
open var itemGroups: Array<SBAGenericStepTableItemGroup> = Array()
private var _title: String?
var title: String? {
get { return _title }
set (newValue) { _title = newValue?.uppercased(with: Locale.current) }
}
/**
Indicates whether this section is exclusive to a single form item or can contain multiple form items.
*/
public var singleFormItem = false
let index: Int!
public init(sectionIndex: Int) {
self.index = sectionIndex
super.init()
}
/**
Add a new ORKFormItem, which results in the creation and addition of a new SBAGenericStepTableItemGroup to the section.
The ItemGroup essectially represents the FormItem and is reponsible for storing and providing answers for the FormItem
when a ORKStepResult is requested.
@param formItem The ORKFormItem to add to the section
*/
public func add(formItem: ORKFormItem) {
guard itemGroups.sba_find({ $0.formItem.identifier == formItem.identifier }) == nil else {
assertionFailure("Cannot add ORKFormItem with duplicate identifier.")
return
}
itemGroups.append(SBAGenericStepTableItemGroup(formItem: formItem, beginningRowIndex: itemCount()))
}
/**
Returns the total count of all Items in this section.
@return The total number of SBAGenericStepTableItems in this section
*/
public func itemCount() -> Int {
return itemGroups.reduce(0, {$0 + $1.items.count})
}
}
open class SBAGenericStepTableItemGroup: NSObject {
let formItem: ORKFormItem!
var items: [SBAGenericStepTableItem]!
var beginningRowIndex = 0
var singleSelection: Bool = true
var answerDate: Date?
var calendar = Calendar.current
var timezone = TimeZone.current
var defaultAnswer: Any = ORKNullAnswerValue() as Any
private var _answer: Any?
/**
Save an answer for this ItemGroup (FormItem). This is used only for those questions that have single answers,
such as text and numeric answers, as opposed to booleans or text choice answers.
*/
public var answer: Any! {
get { return internalAnswer() }
set { setInternalAnswer(newValue) }
}
/**
Determine if the current answer is valid. Also checks the case where answer is required but one has not been provided.
@return A Bool indicating if answer is valid
*/
public var isAnswerValid: Bool {
// if answer is NOT optional and it equals Null (ORKNullAnswerValue()), or is nil, then it's invalid
if !formItem.isOptional, answer is NSNull || answer == nil {
return false
}
return formItem.answerFormat?.implied().isAnswerValid(answer) ?? false
}
/**
Initialize a new ItemGroup with an ORKFormItem. Pass a beginningRowIndex since sections can have multiple ItemGroups.
@param formItem The ORKFormItem to add to the model
@param beginningRowIndex The row index in the section at which this formItem begins
*/
fileprivate init(formItem: ORKFormItem, beginningRowIndex: Int) {
self.formItem = formItem
super.init()
if let textChoiceAnswerFormat = formItem.answerFormat?.implied() as? ORKTextChoiceAnswerFormat {
singleSelection = textChoiceAnswerFormat.style == .singleChoice
self.items = textChoiceAnswerFormat.textChoices.enumerated().map { (index, _) -> SBAGenericStepTableItem in
SBAGenericStepTableItem(formItem: formItem, choiceIndex: index, rowIndex: beginningRowIndex + index)
}
} else {
let tableItem = SBAGenericStepTableItem(formItem: formItem, choiceIndex: 0, rowIndex: beginningRowIndex)
self.items = [tableItem]
}
}
/**
Select or de-select an item (answer) at a specific indexPath. This is used for text choice and boolean answers.
@param selected A bool indicating if item should be selected
@param indexPath The IndexPath of the item
*/
fileprivate func select(_ selected: Bool, indexPath: IndexPath) {
// to get index of our item, add our beginningRowIndex to indexPath.row
let index = beginningRowIndex + indexPath.row
if items.count > index {
items[index].selected = selected
}
// if we selected an item and this is a single-selection group, then we iterate
// our other items and de-select them
if singleSelection {
for (ii, item) in items.enumerated() {
item.selected = (ii == index)
}
}
}
fileprivate func internalAnswer() -> Any {
guard let answerFormat = items.first?.formItem?.answerFormat else {
return _answer ?? defaultAnswer
}
switch answerFormat {
case is ORKBooleanAnswerFormat:
return answerForBoolean()
case is ORKMultipleValuePickerAnswerFormat,
is ORKTextChoiceAnswerFormat:
return answerForTextChoice()
default:
return _answer ?? defaultAnswer
}
}
fileprivate func setInternalAnswer(_ answer: Any) {
guard let answerFormat = items.first?.formItem?.answerFormat else {
return
}
switch answerFormat {
case is ORKBooleanAnswerFormat:
// iterate our items and find the item with a value equal to our answer,
// then select that item
let formattedAnswer = answer as? NSNumber
for item in items {
if (item.choice?.value as? NSNumber)?.boolValue == formattedAnswer?.boolValue {
item.selected = true
}
}
case is ORKTextChoiceAnswerFormat:
// iterate our items and find the items with a value that is contained in our
// answer, which should be an array, then select those items
if let arrayAnswer = answer as? Array<AnyObject> {
for item in items {
item.selected = (item.choice?.value != nil) && arrayAnswer.contains(where: { (value) -> Bool in
return item.choice!.value === value
})
}
}
case is ORKMultipleValuePickerAnswerFormat:
// TODO: Josh Bruhin, 6/12/17 - implement this answer format.
fatalError("setInternalAnswer for ORKMultipleValuePickerAnswerFormat not implemented")
default:
_answer = answer
}
}
private func answerForTextChoice() -> AnyObject {
let array = self.items.sba_mapAndFilter { $0.selected ? $0.choice?.value : nil }
return array.count > 0 ? array as AnyObject : ORKNullAnswerValue() as AnyObject
}
private func answerForBoolean() -> AnyObject {
for item in items {
if item.selected {
if let value = item.choice?.value as? NSNumber {
return NSDecimalNumber(value: value.boolValue)
}
}
}
return ORKNullAnswerValue() as AnyObject
}
}
open class SBAGenericStepTableItem: NSObject {
// the same formItem assigned to the group that this item belongs to
var formItem: ORKFormItem?
var answerFormat: ORKAnswerFormat?
var choice: ORKTextChoice?
var choiceIndex = 0
var rowIndex = 0
var selected: Bool = false
/**
Initialize a new SBAGenericStepTableItem
@param formItem The ORKFormItem representing this tableItem.
@param choiceIndex The index of this item relative to all the choices in this ItemGroup
@param rowIndex The index of this item relative to all rows in the section in which this item resides
*/
fileprivate init(formItem: ORKFormItem!, choiceIndex: Int, rowIndex: Int) {
super.init()
commonInit(formItem: formItem)
self.choiceIndex = choiceIndex
self.rowIndex = rowIndex
if let textChoiceFormat = textChoiceAnswerFormat() {
choice = textChoiceFormat.textChoices[choiceIndex]
}
}
func commonInit(formItem: ORKFormItem!) {
self.formItem = formItem
self.answerFormat = formItem.answerFormat?.implied()
}
func textChoiceAnswerFormat() -> ORKTextChoiceAnswerFormat? {
guard let textChoiceFormat = self.answerFormat as? ORKTextChoiceAnswerFormat else { return nil }
return textChoiceFormat
}
}
| bsd-3-clause | 8c3f36a032ea8d5cf2abb8305b13a884 | 37.582609 | 143 | 0.62993 | 5.277117 | false | false | false | false |
valentin7/pineapple-ios | Pineapple/SettingsTableViewController.swift | 1 | 6430 | //
// SettingsTableViewController.swift
// Pineapple
//
// Created by Valentin Perez on 7/18/15.
// Copyright (c) 2015 Valpe Technologies. All rights reserved.
//
import UIKit
import Parse
import SVProgressHUD
import MessageUI
class SettingsTableViewController: UITableViewController, MFMailComposeViewControllerDelegate {
@IBOutlet var settingsTableView: UITableView!
let user = PFUser.currentUser()!
var parent : UIViewController!
override func viewDidLoad() {
super.viewDidLoad()
parent = self.parentViewController
// Uncomment the following line to preserve selection between presentations
// self.clearsSelectionOnViewWillAppear = false
// Uncomment the following line to display an Edit button in the navigation bar for this view controller.
// self.navigationItem.rightBarButtonItem = self.editButtonItem()
settingsTableView.delegate = self
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
@IBAction func unwindToMainViewController (sender: UIStoryboardSegue){
// bug? exit segue doesn't dismiss so we do it manually...
self.dismissViewControllerAnimated(true, completion: nil)
}
@IBAction func tappedSendFeedback(sender: AnyObject) {
sendFeedback()
}
@IBAction func tappedLogout(sender: AnyObject) {
logout()
}
// MARK: - Table view data source
override func tableView(tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
if (section == 0){
let name = user["name"] as! String
return name
} else {
return ""
}
}
override func tableView(tableView: UITableView, didDeselectRowAtIndexPath indexPath: NSIndexPath) {
print("YOO")
if (indexPath.section == 0) {
print("SECTION 0 DAW")
switch indexPath.row {
case 0:
print("ch pass")
let vc = self.storyboard?.instantiateViewControllerWithIdentifier("passwordChangeController") as! PasswordChangeViewController
parent.presentViewController(vc, animated: true, completion: nil)
case 1:
print("Change phone")
let vc = self.storyboard?.instantiateViewControllerWithIdentifier("phoneChangeController") as! PasswordChangeViewController
parent.presentViewController(vc, animated: true, completion: nil)
default: print("Add credit yo")
}
} else if (indexPath.section == 1) {
print("DIFF SECTION 1")
}
}
func sendFeedback() {
print("TRYNNA SEND FEEDBACK")
let mailComposeViewController = configuredMailComposeViewController()
if MFMailComposeViewController.canSendMail() {
self.presentViewController(mailComposeViewController, animated: true, completion: nil)
} else {
self.showSendMailErrorAlert()
}
}
func configuredMailComposeViewController() -> MFMailComposeViewController {
let mailComposerVC = MFMailComposeViewController()
mailComposerVC.mailComposeDelegate = self // Extremely important to set the --mailComposeDelegate-- property, NOT the --delegate-- property
mailComposerVC.setToRecipients(["[email protected]"])
mailComposerVC.setSubject("Feedback for Pineapple")
mailComposerVC.setMessageBody("", isHTML: false)
return mailComposerVC
}
func showSendMailErrorAlert() {
let sendMailErrorAlert = UIAlertView(title: "Could Not Send Email", message: "Your device could not send e-mail. Please check e-mail configuration and try again.", delegate: self, cancelButtonTitle: "OK")
sendMailErrorAlert.show()
}
// MARK: MFMailComposeViewControllerDelegate
func mailComposeController(controller: MFMailComposeViewController, didFinishWithResult result: MFMailComposeResult, error: NSError?) {
controller.dismissViewControllerAnimated(true, completion: nil)
}
func logout(){
let mainStoryboard : UIStoryboard = UIStoryboard(name: "Main", bundle: nil)
PFUser.logOut()
SVProgressHUD.show()
let vc : OnboardViewController = self.storyboard!.instantiateViewControllerWithIdentifier("onboardController") as! OnboardViewController
let app : AppDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
SVProgressHUD.dismiss()
app.window!.rootViewController = vc
}
/*
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier("reuseIdentifier", forIndexPath: indexPath) as! UITableViewCell
// Configure the cell...
return cell
}
*/
/*
// Override to support conditional editing of the table view.
override func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
// Return NO if you do not want the specified item to be editable.
return true
}
*/
/*
// Override to support editing the table view.
override func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
if editingStyle == .Delete {
// Delete the row from the data source
tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Fade)
} else if editingStyle == .Insert {
// Create a new instance of the appropriate class, insert it into the array, and add a new row to the table view
}
}
*/
/*
// Override to support rearranging the table view.
override func tableView(tableView: UITableView, moveRowAtIndexPath fromIndexPath: NSIndexPath, toIndexPath: NSIndexPath) {
}
*/
/*
// Override to support conditional rearranging of the table view.
override func tableView(tableView: UITableView, canMoveRowAtIndexPath indexPath: NSIndexPath) -> Bool {
// Return NO if you do not want the item to be re-orderable.
return 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.
}
*/
}
| mit | 6f6ee6f6d9159d1be166fe25a4e881eb | 33.385027 | 209 | 0.709487 | 5.491033 | false | false | false | false |
EBGToo/SBCommons | Sources/Func.swift | 1 | 5637 | //
// Func.swift
// SBCommons
//
// Created by Ed Gamble on 10/22/15.
// Copyright © 2015 Edward B. Gamble Jr. All rights reserved.
//
// See the LICENSE file at the project root for license information.
// See the CONTRIBUTORS file at the project root for a list of contributors.
//
/**
* The Y-combinator - for the hell of it
*
* - argument f:
*
* - returns: A function
*/
func Y<T, R> (_ f: @escaping (@escaping (T) -> R) -> ((T) -> R)) -> ((T) -> R) {
return { t in f(Y(f))(t) }
}
/** Factorial, defined using the Y-combinator */
let factorial = Y {
f in {
n in n == 0 ? 1 : n * f(n - 1)
}
}
/**
* A function that always returns x
*
* - argument x:
*
* - returns: A function of (y:T) that (always) return x
*/
public func always<T> (_ x:T) -> (_ y:T) -> T {
return { (y:T) in return x }
}
/**
* Complememnt a predicate
*
* - argument pred: The function to complement
*
* - returns: A function as !pred
*/
public func complement<T> (_ pred : @escaping (T) -> Bool) -> (T) -> Bool {
return { (x:T) in return !pred(x) }
}
/**
* Compose functions `f` and `g` as `f(g(x))`
*
* - argument f:
* - argument g:
*
* - returns: a function of `x:T` returning `f(g(x))`
*/
public func compose<T, U, V> (f: @escaping (U) -> V, g: @escaping (T) -> U) -> (T) -> V {
return { (x:T) in f (g (x)) }
}
/**
* Disjoin two predicates
*
* - argument pred1:
* - argument pred2:
*
* - returns: A function of `x:T` that returns pred1(x) || pred2(x)
*/
public func disjoin<T> (pred1: @escaping (T) -> Bool, pred2: @escaping (T) -> Bool) -> (T) -> Bool {
return { (x:T) in pred1 (x) || pred2 (x) }
}
/**
* Conjoin two predicates
*
* - argument pred1:
* - argument pred2:
*
* - returns: A function of `x:T` that returns pred1(x) && pred2(x)
*/
public func conjoin<T> (pred1: @escaping (T) -> Bool, pred2: @escaping (T) -> Bool) -> (T) -> Bool {
return { (x:T) in pred1 (x) && pred2 (x) }
}
/**
*
*
* - argument pred:
* - argument x:
*
* - returns: A function of (y:T) that returns pred(x,y)
*/
public func equalTo<T> (pred: @escaping (T, T) -> Bool, x:T) -> (T) -> Bool {
return { (y:T) in return pred (x, y) }
}
// MARK: - Sequence App Type
public protocol SequenceAppType : Sequence {
/** Think different: renaming of `forEach` to be analogous to `map` */
func app ( _ body: (Self.Iterator.Element) -> Void) -> Void
}
extension Sequence {
public func app (_ body: (Self.Iterator.Element) throws -> Void) rethrows -> Void {
for item in self { try body (item) }
}
}
// MARK: Sequence Logic Type
public protocol SequenceLogicType : Sequence {
/**
* Check if any element satisfies `predicate`.
*
* - argument predicate:
*
* - returns: `true` if any element satisfies `predicate`; `false` otherwise
*/
func any (_ predicate: (Self.Iterator.Element) throws -> Bool) rethrows -> Bool
/**
* Check if all elements satisfy `predicate`.
*
* - argument predicate:
*
* - returns: `true` if all elements satisfy `predicate`; `false` otherwise
*/
func all (_ predicate: (Self.Iterator.Element) throws -> Bool) rethrows -> Bool
}
extension Sequence {
public func any (_ predicate: (Self.Iterator.Element) throws -> Bool) rethrows -> Bool {
for elt in self {
if (try predicate (elt)) { return true }
}
return false
}
public func all (_ predicate: (Self.Iterator.Element) throws -> Bool) rethrows -> Bool {
for elt in self {
if (try !predicate (elt)) { return false }
}
return true
}
}
// MARK: Sequence Scan Type
public protocol SequenceScanType : Sequence {
/**
* Scan `self` element by element combining elements. Resulting array has one element more
* than `self`.
*
* - argument initial: the resulting array's initial element
* - argument combine: the function combining the 'accumulated' value with next element
*
* - retuns: array with scanned elements
*/
func scan <R> (_ initial: R, combine: (R, Iterator.Element) -> R) -> [R]
}
extension Sequence {
func scan <R> (_ initial: R, combine: (R, Iterator.Element) -> R) -> [R] {
var result = Array<R> (repeating: initial, count: 1)
var accum = initial
for elt in self {
accum = combine (accum, elt)
result.append(accum)
}
return result
}
}
// Mark: Curried Functions
/**
* Curry application of `predicate` on `x`; returns a function of `y` returning `predicate(x,y)`
*
* - argument predicate: the predicate
* - argument x:
*
* - returns: A function of (y:T) that returns predicate(x,y)
*/
public func equateUsing<T> (_ predicate: @escaping (T, T) -> Bool) -> (T) -> (T) -> Bool {
return { (x:T) -> (T) -> Bool in
return { (y:T) -> Bool in
return predicate (x, y) }
}
}
/** Curry `any()` using `predicate` */
public func anyUsing <S: Sequence> (_ predicate: @escaping (S.Iterator.Element) -> Bool) -> (S) -> Bool {
return { (source:S) -> Bool in
return source.any (predicate)
}
}
/** Curry `all()` using `predicate`. */
public func allUsing <S: Sequence> (_ predicate: @escaping (S.Iterator.Element) -> Bool) -> (S) -> Bool {
return { (source:S) -> Bool in
return source.all (predicate)
}
}
/** Curry `map()` using `transform`. */
public func mapUsing <S: Sequence, T> (_ transform: @escaping (S.Iterator.Element) -> T) -> (S) -> [T] {
return { (source:S) in
return source.map (transform)
}
}
/** Curry `app()` using `body`. */
public func appUsing <S: Sequence> (_ body: @escaping (S.Iterator.Element) -> Void) -> (S) -> Void {
return { (source:S) in
return source.app (body)
}
}
| mit | f3fdf84b001662d9fa575c5b51ef9a4b | 23.938053 | 105 | 0.594748 | 3.150363 | false | false | false | false |
LoopKit/LoopKit | LoopKitHostedTests/InsulinDeliveryStoreTests.swift | 1 | 46170 | //
// InsulinDeliveryStoreTests.swift
// LoopKitHostedTests
//
// Created by Darin Krauss on 10/22/20.
// Copyright © 2020 LoopKit Authors. All rights reserved.
//
import XCTest
import HealthKit
@testable import LoopKit
class InsulinDeliveryStoreTestsBase: PersistenceControllerTestCase {
internal let entry1 = DoseEntry(type: .basal,
startDate: Date(timeIntervalSinceNow: -.minutes(6)),
endDate: Date(timeIntervalSinceNow: -.minutes(5.5)),
value: 1.8,
unit: .unitsPerHour,
deliveredUnits: 0.015,
syncIdentifier: "4B14522E-A7B5-4E73-B76B-5043CD7176B0",
scheduledBasalRate: nil)
internal let entry2 = DoseEntry(type: .tempBasal,
startDate: Date(timeIntervalSinceNow: -.minutes(2)),
endDate: Date(timeIntervalSinceNow: -.minutes(1.5)),
value: 2.4,
unit: .unitsPerHour,
deliveredUnits: 0.02,
syncIdentifier: "A1F8E29B-33D6-4B38-B4CD-D84F14744871",
scheduledBasalRate: HKQuantity(unit: .internationalUnitsPerHour, doubleValue: 1.8))
internal let entry3 = DoseEntry(type: .bolus,
startDate: Date(timeIntervalSinceNow: -.minutes(4)),
endDate: Date(timeIntervalSinceNow: -.minutes(3.5)),
value: 1.0,
unit: .units,
deliveredUnits: nil,
syncIdentifier: "1A1D6192-1521-4469-B962-1B82C4534BB1",
scheduledBasalRate: nil)
internal let device = HKDevice(name: UUID().uuidString,
manufacturer: UUID().uuidString,
model: UUID().uuidString,
hardwareVersion: UUID().uuidString,
firmwareVersion: UUID().uuidString,
softwareVersion: UUID().uuidString,
localIdentifier: UUID().uuidString,
udiDeviceIdentifier: UUID().uuidString)
var healthStore: HKHealthStoreMock!
var insulinDeliveryStore: InsulinDeliveryStore!
var authorizationStatus: HKAuthorizationStatus = .notDetermined
override func setUp() {
super.setUp()
let semaphore = DispatchSemaphore(value: 0)
cacheStore.onReady { error in
XCTAssertNil(error)
semaphore.signal()
}
semaphore.wait()
healthStore = HKHealthStoreMock()
healthStore.authorizationStatus = authorizationStatus
insulinDeliveryStore = InsulinDeliveryStore(healthStore: healthStore,
cacheStore: cacheStore,
cacheLength: .hours(1),
provenanceIdentifier: HKSource.default().bundleIdentifier)
}
override func tearDown() {
let semaphore = DispatchSemaphore(value: 0)
insulinDeliveryStore.purgeAllDoseEntries(healthKitPredicate: HKQuery.predicateForObjects(from: HKSource.default())) { error in
XCTAssertNil(error)
semaphore.signal()
}
semaphore.wait()
insulinDeliveryStore = nil
healthStore = nil
super.tearDown()
}
}
class InsulinDeliveryStoreTestsAuthorized: InsulinDeliveryStoreTestsBase {
override func setUp() {
authorizationStatus = .sharingAuthorized
super.setUp()
}
func testObserverQueryStartup() {
// Check that an observer query was registered even before authorize() is called.
XCTAssertFalse(insulinDeliveryStore.authorizationRequired);
XCTAssertNotNil(insulinDeliveryStore.observerQuery);
}
}
class InsulinDeliveryStoreTests: InsulinDeliveryStoreTestsBase {
// MARK: - HealthKitSampleStore
func testHealthKitQueryAnchorPersistence() {
var observerQuery: HKObserverQueryMock? = nil
var anchoredObjectQuery: HKAnchoredObjectQueryMock? = nil
XCTAssert(insulinDeliveryStore.authorizationRequired);
XCTAssertNil(insulinDeliveryStore.observerQuery);
insulinDeliveryStore.createObserverQuery = { (sampleType, predicate, updateHandler) -> HKObserverQuery in
observerQuery = HKObserverQueryMock(sampleType: sampleType, predicate: predicate, updateHandler: updateHandler)
return observerQuery!
}
let authorizationCompletion = expectation(description: "authorization completion")
insulinDeliveryStore.authorize { (result) in
authorizationCompletion.fulfill()
}
waitForExpectations(timeout: 10)
XCTAssertNotNil(observerQuery)
let anchoredObjectQueryCreationExpectation = expectation(description: "anchored object query creation")
insulinDeliveryStore.createAnchoredObjectQuery = { (sampleType, predicate, anchor, limit, resultsHandler) -> HKAnchoredObjectQuery in
anchoredObjectQuery = HKAnchoredObjectQueryMock(type: sampleType, predicate: predicate, anchor: anchor, limit: limit, resultsHandler: resultsHandler)
anchoredObjectQueryCreationExpectation.fulfill()
return anchoredObjectQuery!
}
let observerQueryCompletionExpectation = expectation(description: "observer query completion")
let observerQueryCompletionHandler = {
observerQueryCompletionExpectation.fulfill()
}
// This simulates a signal marking the arrival of new HK Data.
observerQuery!.updateHandler(observerQuery!, observerQueryCompletionHandler, nil)
wait(for: [anchoredObjectQueryCreationExpectation], timeout: 10)
// Trigger results handler for anchored object query
let returnedAnchor = HKQueryAnchor(fromValue: 5)
anchoredObjectQuery!.resultsHandler(anchoredObjectQuery!, [], [], returnedAnchor, nil)
// Wait for observerQueryCompletionExpectation
waitForExpectations(timeout: 10)
XCTAssertNotNil(insulinDeliveryStore.queryAnchor)
cacheStore.managedObjectContext.performAndWait {}
// Create a new glucose store, and ensure it uses the last query anchor
let newInsulinDeliveryStore = InsulinDeliveryStore(healthStore: healthStore,
cacheStore: cacheStore,
provenanceIdentifier: HKSource.default().bundleIdentifier)
let newAuthorizationCompletion = expectation(description: "authorization completion")
observerQuery = nil
newInsulinDeliveryStore.createObserverQuery = { (sampleType, predicate, updateHandler) -> HKObserverQuery in
observerQuery = HKObserverQueryMock(sampleType: sampleType, predicate: predicate, updateHandler: updateHandler)
return observerQuery!
}
newInsulinDeliveryStore.authorize { (result) in
newAuthorizationCompletion.fulfill()
}
waitForExpectations(timeout: 10)
anchoredObjectQuery = nil
let newAnchoredObjectQueryCreationExpectation = expectation(description: "new anchored object query creation")
newInsulinDeliveryStore.createAnchoredObjectQuery = { (sampleType, predicate, anchor, limit, resultsHandler) -> HKAnchoredObjectQuery in
anchoredObjectQuery = HKAnchoredObjectQueryMock(type: sampleType, predicate: predicate, anchor: anchor, limit: limit, resultsHandler: resultsHandler)
newAnchoredObjectQueryCreationExpectation.fulfill()
return anchoredObjectQuery!
}
// This simulates a signal marking the arrival of new HK Data.
observerQuery!.updateHandler(observerQuery!, {}, nil)
waitForExpectations(timeout: 10)
// Assert new glucose store is querying with the last anchor that our HealthKit mock returned
XCTAssertEqual(returnedAnchor, anchoredObjectQuery?.anchor)
anchoredObjectQuery!.resultsHandler(anchoredObjectQuery!, [], [], returnedAnchor, nil)
}
// MARK: - Fetching
func testGetDoseEntries() {
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries1Completion = expectation(description: "getDoseEntries1")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 3)
XCTAssertEqual(entries[0].type, self.entry1.type)
XCTAssertEqual(entries[0].startDate, self.entry1.startDate)
XCTAssertEqual(entries[0].endDate, self.entry1.endDate)
XCTAssertEqual(entries[0].value, 0.015)
XCTAssertEqual(entries[0].unit, .units)
XCTAssertNil(entries[0].deliveredUnits)
XCTAssertEqual(entries[0].description, self.entry1.description)
XCTAssertEqual(entries[0].syncIdentifier, self.entry1.syncIdentifier)
XCTAssertEqual(entries[0].scheduledBasalRate, self.entry1.scheduledBasalRate)
XCTAssertEqual(entries[1].type, self.entry3.type)
XCTAssertEqual(entries[1].startDate, self.entry3.startDate)
XCTAssertEqual(entries[1].endDate, self.entry3.endDate)
XCTAssertEqual(entries[1].value, self.entry3.value)
XCTAssertEqual(entries[1].unit, self.entry3.unit)
XCTAssertEqual(entries[1].deliveredUnits, self.entry3.deliveredUnits)
XCTAssertEqual(entries[1].description, self.entry3.description)
XCTAssertEqual(entries[1].syncIdentifier, self.entry3.syncIdentifier)
XCTAssertEqual(entries[1].scheduledBasalRate, self.entry3.scheduledBasalRate)
XCTAssertEqual(entries[2].type, self.entry2.type)
XCTAssertEqual(entries[2].startDate, self.entry2.startDate)
XCTAssertEqual(entries[2].endDate, self.entry2.endDate)
XCTAssertEqual(entries[2].value, self.entry2.value)
XCTAssertEqual(entries[2].unit, self.entry2.unit)
XCTAssertEqual(entries[2].deliveredUnits, self.entry2.deliveredUnits)
XCTAssertEqual(entries[2].description, self.entry2.description)
XCTAssertEqual(entries[2].syncIdentifier, self.entry2.syncIdentifier)
XCTAssertEqual(entries[2].scheduledBasalRate, self.entry2.scheduledBasalRate)
}
getDoseEntries1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries2Completion = expectation(description: "getDoseEntries2")
insulinDeliveryStore.getDoseEntries(start: Date(timeIntervalSinceNow: -.minutes(3.75)), end: Date(timeIntervalSinceNow: -.minutes(1.75))) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 2)
XCTAssertEqual(entries[0].type, self.entry3.type)
XCTAssertEqual(entries[0].startDate, self.entry3.startDate)
XCTAssertEqual(entries[0].endDate, self.entry3.endDate)
XCTAssertEqual(entries[0].value, self.entry3.value)
XCTAssertEqual(entries[0].unit, self.entry3.unit)
XCTAssertEqual(entries[0].deliveredUnits, self.entry3.deliveredUnits)
XCTAssertEqual(entries[0].description, self.entry3.description)
XCTAssertEqual(entries[0].syncIdentifier, self.entry3.syncIdentifier)
XCTAssertEqual(entries[0].scheduledBasalRate, self.entry3.scheduledBasalRate)
XCTAssertEqual(entries[1].type, self.entry2.type)
XCTAssertEqual(entries[1].startDate, self.entry2.startDate)
XCTAssertEqual(entries[1].endDate, self.entry2.endDate)
XCTAssertEqual(entries[1].value, self.entry2.value)
XCTAssertEqual(entries[1].unit, self.entry2.unit)
XCTAssertEqual(entries[1].deliveredUnits, self.entry2.deliveredUnits)
XCTAssertEqual(entries[1].description, self.entry2.description)
XCTAssertEqual(entries[1].syncIdentifier, self.entry2.syncIdentifier)
XCTAssertEqual(entries[1].scheduledBasalRate, self.entry2.scheduledBasalRate)
}
getDoseEntries2Completion.fulfill()
}
waitForExpectations(timeout: 10)
let purgeCachedInsulinDeliveryObjectsCompletion = expectation(description: "purgeCachedInsulinDeliveryObjects")
insulinDeliveryStore.purgeCachedInsulinDeliveryObjects() { error in
XCTAssertNil(error)
purgeCachedInsulinDeliveryObjectsCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries3Completion = expectation(description: "getDoseEntries3")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 0)
}
getDoseEntries3Completion.fulfill()
}
waitForExpectations(timeout: 10)
}
func testLastBasalEndDate() {
let getLastImmutableBasalEndDate1Completion = expectation(description: "getLastImmutableBasalEndDate1")
insulinDeliveryStore.getLastImmutableBasalEndDate() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let lastBasalEndDate):
XCTAssertEqual(lastBasalEndDate, .distantPast)
}
getLastImmutableBasalEndDate1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getLastImmutableBasalEndDate2Completion = expectation(description: "getLastImmutableBasalEndDate2")
insulinDeliveryStore.getLastImmutableBasalEndDate() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let lastBasalEndDate):
XCTAssertEqual(lastBasalEndDate, self.entry2.endDate)
}
getLastImmutableBasalEndDate2Completion.fulfill()
}
waitForExpectations(timeout: 10)
let purgeCachedInsulinDeliveryObjectsCompletion = expectation(description: "purgeCachedInsulinDeliveryObjects")
insulinDeliveryStore.purgeCachedInsulinDeliveryObjects() { error in
XCTAssertNil(error)
purgeCachedInsulinDeliveryObjectsCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getLastImmutableBasalEndDate3Completion = expectation(description: "getLastImmutableBasalEndDate3")
insulinDeliveryStore.getLastImmutableBasalEndDate() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let lastBasalEndDate):
XCTAssertEqual(lastBasalEndDate, .distantPast)
}
getLastImmutableBasalEndDate3Completion.fulfill()
}
waitForExpectations(timeout: 10)
}
// MARK: - Modification
func testAddDoseEntries() {
let addDoseEntries1Completion = expectation(description: "addDoseEntries1")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntries1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries1Completion = expectation(description: "getDoseEntries1")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 3)
XCTAssertEqual(entries[0].type, self.entry1.type)
XCTAssertEqual(entries[0].startDate, self.entry1.startDate)
XCTAssertEqual(entries[0].endDate, self.entry1.endDate)
XCTAssertEqual(entries[0].value, 0.015)
XCTAssertEqual(entries[0].unit, .units)
XCTAssertNil(entries[0].deliveredUnits)
XCTAssertEqual(entries[0].description, self.entry1.description)
XCTAssertEqual(entries[0].syncIdentifier, self.entry1.syncIdentifier)
XCTAssertEqual(entries[0].scheduledBasalRate, self.entry1.scheduledBasalRate)
XCTAssertEqual(entries[1].type, self.entry3.type)
XCTAssertEqual(entries[1].startDate, self.entry3.startDate)
XCTAssertEqual(entries[1].endDate, self.entry3.endDate)
XCTAssertEqual(entries[1].value, self.entry3.value)
XCTAssertEqual(entries[1].unit, self.entry3.unit)
XCTAssertEqual(entries[1].deliveredUnits, self.entry3.deliveredUnits)
XCTAssertEqual(entries[1].description, self.entry3.description)
XCTAssertEqual(entries[1].syncIdentifier, self.entry3.syncIdentifier)
XCTAssertEqual(entries[1].scheduledBasalRate, self.entry3.scheduledBasalRate)
XCTAssertEqual(entries[2].type, self.entry2.type)
XCTAssertEqual(entries[2].startDate, self.entry2.startDate)
XCTAssertEqual(entries[2].endDate, self.entry2.endDate)
XCTAssertEqual(entries[2].value, self.entry2.value)
XCTAssertEqual(entries[2].unit, self.entry2.unit)
XCTAssertEqual(entries[2].deliveredUnits, self.entry2.deliveredUnits)
XCTAssertEqual(entries[2].description, self.entry2.description)
XCTAssertEqual(entries[2].syncIdentifier, self.entry2.syncIdentifier)
XCTAssertEqual(entries[2].scheduledBasalRate, self.entry2.scheduledBasalRate)
}
getDoseEntries1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let addDoseEntries2Completion = expectation(description: "addDoseEntries2")
insulinDeliveryStore.addDoseEntries([entry3, entry1, entry2], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntries2Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries2Completion = expectation(description: "getDoseEntries2Completion")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 3)
XCTAssertEqual(entries[0].type, self.entry1.type)
XCTAssertEqual(entries[0].startDate, self.entry1.startDate)
XCTAssertEqual(entries[0].endDate, self.entry1.endDate)
XCTAssertEqual(entries[0].value, 0.015)
XCTAssertEqual(entries[0].unit, .units)
XCTAssertNil(entries[0].deliveredUnits)
XCTAssertEqual(entries[0].description, self.entry1.description)
XCTAssertEqual(entries[0].syncIdentifier, self.entry1.syncIdentifier)
XCTAssertEqual(entries[0].scheduledBasalRate, self.entry1.scheduledBasalRate)
XCTAssertEqual(entries[1].type, self.entry3.type)
XCTAssertEqual(entries[1].startDate, self.entry3.startDate)
XCTAssertEqual(entries[1].endDate, self.entry3.endDate)
XCTAssertEqual(entries[1].value, self.entry3.value)
XCTAssertEqual(entries[1].unit, self.entry3.unit)
XCTAssertEqual(entries[1].deliveredUnits, self.entry3.deliveredUnits)
XCTAssertEqual(entries[1].description, self.entry3.description)
XCTAssertEqual(entries[1].syncIdentifier, self.entry3.syncIdentifier)
XCTAssertEqual(entries[1].scheduledBasalRate, self.entry3.scheduledBasalRate)
XCTAssertEqual(entries[2].type, self.entry2.type)
XCTAssertEqual(entries[2].startDate, self.entry2.startDate)
XCTAssertEqual(entries[2].endDate, self.entry2.endDate)
XCTAssertEqual(entries[2].value, self.entry2.value)
XCTAssertEqual(entries[2].unit, self.entry2.unit)
XCTAssertEqual(entries[2].deliveredUnits, self.entry2.deliveredUnits)
XCTAssertEqual(entries[2].description, self.entry2.description)
XCTAssertEqual(entries[2].syncIdentifier, self.entry2.syncIdentifier)
XCTAssertEqual(entries[2].scheduledBasalRate, self.entry2.scheduledBasalRate)
}
getDoseEntries2Completion.fulfill()
}
waitForExpectations(timeout: 10)
}
func testAddDoseEntriesEmpty() {
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
}
func testAddDoseEntriesNotification() {
let doseEntriesDidChangeCompletion = expectation(description: "doseEntriesDidChange")
let observer = NotificationCenter.default.addObserver(forName: InsulinDeliveryStore.doseEntriesDidChange, object: insulinDeliveryStore, queue: nil) { notification in
doseEntriesDidChangeCompletion.fulfill()
}
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
wait(for: [doseEntriesDidChangeCompletion, addDoseEntriesCompletion], timeout: 10, enforceOrder: true)
NotificationCenter.default.removeObserver(observer)
}
func testManuallyEnteredDoses() {
let manualEntry = DoseEntry(type: .bolus,
startDate: Date(timeIntervalSinceNow: -.minutes(15)),
endDate: Date(timeIntervalSinceNow: -.minutes(10)),
value: 3.0,
unit: .units,
syncIdentifier: "C0AB1CBD-6B36-4113-9D49-709A022B2451",
manuallyEntered: true)
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, manualEntry, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getManuallyEnteredDoses1Completion = expectation(description: "getManuallyEnteredDoses1")
insulinDeliveryStore.getManuallyEnteredDoses(since: .distantPast) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 1)
XCTAssertEqual(entries[0], manualEntry)
}
getManuallyEnteredDoses1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getManuallyEnteredDoses2Completion = expectation(description: "getManuallyEnteredDoses2")
insulinDeliveryStore.getManuallyEnteredDoses(since: Date(timeIntervalSinceNow: -.minutes(12))) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 0)
}
getManuallyEnteredDoses2Completion.fulfill()
}
waitForExpectations(timeout: 10)
let deleteAllManuallyEnteredDoses1Completion = expectation(description: "deleteAllManuallyEnteredDoses1")
insulinDeliveryStore.deleteAllManuallyEnteredDoses(since: Date(timeIntervalSinceNow: -.minutes(12))) { error in
XCTAssertNil(error)
deleteAllManuallyEnteredDoses1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getManuallyEnteredDoses3Completion = expectation(description: "getManuallyEnteredDoses3")
insulinDeliveryStore.getManuallyEnteredDoses(since: .distantPast) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 1)
XCTAssertEqual(entries[0], manualEntry)
}
getManuallyEnteredDoses3Completion.fulfill()
}
waitForExpectations(timeout: 10)
let deleteAllManuallyEnteredDose2Completion = expectation(description: "deleteAllManuallyEnteredDose2")
insulinDeliveryStore.deleteAllManuallyEnteredDoses(since: Date(timeIntervalSinceNow: -.minutes(20))) { error in
XCTAssertNil(error)
deleteAllManuallyEnteredDose2Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getManuallyEnteredDoses4Completion = expectation(description: "getManuallyEnteredDoses4")
insulinDeliveryStore.getManuallyEnteredDoses(since: .distantPast) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 0)
}
getManuallyEnteredDoses4Completion.fulfill()
}
waitForExpectations(timeout: 10)
}
// MARK: - Cache Management
func testEarliestCacheDate() {
XCTAssertEqual(insulinDeliveryStore.earliestCacheDate.timeIntervalSinceNow, -.hours(1), accuracy: 1)
}
func testPurgeAllDoseEntries() {
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries1Completion = expectation(description: "getDoseEntries1")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 3)
}
getDoseEntries1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let purgeAllDoseEntriesCompletion = expectation(description: "purgeAllDoseEntries")
insulinDeliveryStore.purgeAllDoseEntries(healthKitPredicate: HKQuery.predicateForObjects(from: HKSource.default())) { error in
XCTAssertNil(error)
purgeAllDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries2Completion = expectation(description: "getDoseEntries2")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 0)
}
getDoseEntries2Completion.fulfill()
}
waitForExpectations(timeout: 10)
}
func testPurgeExpiredGlucoseObjects() {
let expiredEntry = DoseEntry(type: .bolus,
startDate: Date(timeIntervalSinceNow: -.hours(3)),
endDate: Date(timeIntervalSinceNow: -.hours(2)),
value: 3.0,
unit: .units,
deliveredUnits: nil,
syncIdentifier: "7530B8CA-827A-4DE8-ADE3-9E10FF80A4A9",
scheduledBasalRate: nil)
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3, expiredEntry], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntriesCompletion = expectation(description: "getDoseEntries")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 3)
}
getDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
}
func testPurgeCachedInsulinDeliveryObjects() {
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries1Completion = expectation(description: "getDoseEntries1")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 3)
}
getDoseEntries1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let purgeCachedInsulinDeliveryObjects1Completion = expectation(description: "purgeCachedInsulinDeliveryObjects1")
insulinDeliveryStore.purgeCachedInsulinDeliveryObjects(before: Date(timeIntervalSinceNow: -.minutes(5))) { error in
XCTAssertNil(error)
purgeCachedInsulinDeliveryObjects1Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries2Completion = expectation(description: "getDoseEntries2")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 2)
}
getDoseEntries2Completion.fulfill()
}
waitForExpectations(timeout: 10)
let purgeCachedInsulinDeliveryObjects2Completion = expectation(description: "purgeCachedInsulinDeliveryObjects2")
insulinDeliveryStore.purgeCachedInsulinDeliveryObjects() { error in
XCTAssertNil(error)
purgeCachedInsulinDeliveryObjects2Completion.fulfill()
}
waitForExpectations(timeout: 10)
let getDoseEntries3Completion = expectation(description: "getDoseEntries3")
insulinDeliveryStore.getDoseEntries() { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let entries):
XCTAssertEqual(entries.count, 0)
}
getDoseEntries3Completion.fulfill()
}
waitForExpectations(timeout: 10)
}
func testPurgeCachedInsulinDeliveryObjectsNotification() {
let addDoseEntriesCompletion = expectation(description: "addDoseEntries")
insulinDeliveryStore.addDoseEntries([entry1, entry2, entry3], from: device, syncVersion: 2) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success:
break
}
addDoseEntriesCompletion.fulfill()
}
waitForExpectations(timeout: 10)
let doseEntriesDidChangeCompletion = expectation(description: "doseEntriesDidChange")
let observer = NotificationCenter.default.addObserver(forName: InsulinDeliveryStore.doseEntriesDidChange, object: insulinDeliveryStore, queue: nil) { notification in
doseEntriesDidChangeCompletion.fulfill()
}
let purgeCachedInsulinDeliveryObjectsCompletion = expectation(description: "purgeCachedInsulinDeliveryObjects")
insulinDeliveryStore.purgeCachedInsulinDeliveryObjects() { error in
XCTAssertNil(error)
purgeCachedInsulinDeliveryObjectsCompletion.fulfill()
}
wait(for: [doseEntriesDidChangeCompletion, purgeCachedInsulinDeliveryObjectsCompletion], timeout: 10, enforceOrder: true)
NotificationCenter.default.removeObserver(observer)
}
}
class InsulinDeliveryStoreQueryAnchorTests: XCTestCase {
var rawValue: InsulinDeliveryStore.QueryAnchor.RawValue = [
"modificationCounter": Int64(123)
]
func testInitializerDefault() {
let queryAnchor = InsulinDeliveryStore.QueryAnchor()
XCTAssertEqual(queryAnchor.modificationCounter, 0)
}
func testInitializerRawValue() {
let queryAnchor = InsulinDeliveryStore.QueryAnchor(rawValue: rawValue)
XCTAssertNotNil(queryAnchor)
XCTAssertEqual(queryAnchor?.modificationCounter, 123)
}
func testInitializerRawValueMissingModificationCounter() {
rawValue["modificationCounter"] = nil
XCTAssertNil(InsulinDeliveryStore.QueryAnchor(rawValue: rawValue))
}
func testInitializerRawValueInvalidModificationCounter() {
rawValue["modificationCounter"] = "123"
XCTAssertNil(InsulinDeliveryStore.QueryAnchor(rawValue: rawValue))
}
func testRawValueWithDefault() {
let rawValue = InsulinDeliveryStore.QueryAnchor().rawValue
XCTAssertEqual(rawValue.count, 1)
XCTAssertEqual(rawValue["modificationCounter"] as? Int64, Int64(0))
}
func testRawValueWithNonDefault() {
var queryAnchor = InsulinDeliveryStore.QueryAnchor()
queryAnchor.modificationCounter = 123
let rawValue = queryAnchor.rawValue
XCTAssertEqual(rawValue.count, 1)
XCTAssertEqual(rawValue["modificationCounter"] as? Int64, Int64(123))
}
}
class InsulinDeliveryStoreQueryTests: PersistenceControllerTestCase {
let insulinModel = WalshInsulinModel(actionDuration: .hours(4))
let basalProfile = BasalRateSchedule(rawValue: ["timeZone": -28800, "items": [["value": 0.75, "startTime": 0.0], ["value": 0.8, "startTime": 10800.0], ["value": 0.85, "startTime": 32400.0], ["value": 1.0, "startTime": 68400.0]]])
let insulinSensitivitySchedule = InsulinSensitivitySchedule(rawValue: ["unit": "mg/dL", "timeZone": -28800, "items": [["value": 40.0, "startTime": 0.0], ["value": 35.0, "startTime": 21600.0], ["value": 40.0, "startTime": 57600.0]]])
var insulinDeliveryStore: InsulinDeliveryStore!
var completion: XCTestExpectation!
var queryAnchor: InsulinDeliveryStore.QueryAnchor!
var limit: Int!
override func setUp() {
super.setUp()
insulinDeliveryStore = InsulinDeliveryStore(healthStore: HKHealthStoreMock(),
storeSamplesToHealthKit: false,
cacheStore: cacheStore,
observationEnabled: false,
provenanceIdentifier: HKSource.default().bundleIdentifier)
completion = expectation(description: "Completion")
queryAnchor = InsulinDeliveryStore.QueryAnchor()
limit = Int.max
}
override func tearDown() {
limit = nil
queryAnchor = nil
completion = nil
insulinDeliveryStore = nil
super.tearDown()
}
func testDoseEmptyWithDefaultQueryAnchor() {
insulinDeliveryStore.executeDoseQuery(fromQueryAnchor: queryAnchor, limit: limit) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let anchor, let created, let deleted):
XCTAssertEqual(anchor.modificationCounter, 0)
XCTAssertEqual(created.count, 0)
XCTAssertEqual(deleted.count, 0)
}
self.completion.fulfill()
}
wait(for: [completion], timeout: 2, enforceOrder: true)
}
func testDoseEmptyWithMissingQueryAnchor() {
queryAnchor = nil
insulinDeliveryStore.executeDoseQuery(fromQueryAnchor: queryAnchor, limit: limit) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let anchor, let created, let deleted):
XCTAssertEqual(anchor.modificationCounter, 0)
XCTAssertEqual(created.count, 0)
XCTAssertEqual(deleted.count, 0)
}
self.completion.fulfill()
}
wait(for: [completion], timeout: 2, enforceOrder: true)
}
func testDoseEmptyWithNonDefaultQueryAnchor() {
queryAnchor.modificationCounter = 1
insulinDeliveryStore.executeDoseQuery(fromQueryAnchor: queryAnchor, limit: limit) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let anchor, let created, let deleted):
XCTAssertEqual(anchor.modificationCounter, 1)
XCTAssertEqual(created.count, 0)
XCTAssertEqual(deleted.count, 0)
}
self.completion.fulfill()
}
wait(for: [completion], timeout: 2, enforceOrder: true)
}
func testDoseDataWithUnusedQueryAnchor() {
let doseData = [DoseDatum(), DoseDatum(deleted: true), DoseDatum()]
addDoseData(doseData)
insulinDeliveryStore.executeDoseQuery(fromQueryAnchor: queryAnchor, limit: limit) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let anchor, let created, let deleted):
XCTAssertEqual(anchor.modificationCounter, 3)
XCTAssertEqual(created.count, 2)
XCTAssertEqual(deleted.count, 1)
if created.count >= 2 {
XCTAssertEqual(created[0].syncIdentifier, doseData[0].syncIdentifier)
XCTAssertEqual(created[1].syncIdentifier, doseData[2].syncIdentifier)
}
if deleted.count >= 1 {
XCTAssertEqual(deleted[0].syncIdentifier, doseData[1].syncIdentifier)
}
}
self.completion.fulfill()
}
wait(for: [completion], timeout: 2, enforceOrder: true)
}
func testDoseDataWithStaleQueryAnchor() {
let doseData = [DoseDatum(), DoseDatum(deleted: true), DoseDatum()]
addDoseData(doseData)
queryAnchor.modificationCounter = 2
insulinDeliveryStore.executeDoseQuery(fromQueryAnchor: queryAnchor, limit: limit) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let anchor, let created, let deleted):
XCTAssertEqual(anchor.modificationCounter, 3)
XCTAssertEqual(created.count, 1)
XCTAssertEqual(deleted.count, 0)
if created.count >= 1 {
XCTAssertEqual(created[0].syncIdentifier, doseData[2].syncIdentifier)
}
}
self.completion.fulfill()
}
wait(for: [completion], timeout: 2, enforceOrder: true)
}
func testDoseDataWithCurrentQueryAnchor() {
let doseData = [DoseDatum(), DoseDatum(deleted: true), DoseDatum()]
addDoseData(doseData)
queryAnchor.modificationCounter = 3
insulinDeliveryStore.executeDoseQuery(fromQueryAnchor: queryAnchor, limit: limit) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let anchor, let created, let deleted):
XCTAssertEqual(anchor.modificationCounter, 3)
XCTAssertEqual(created.count, 0)
XCTAssertEqual(deleted.count, 0)
}
self.completion.fulfill()
}
wait(for: [completion], timeout: 2, enforceOrder: true)
}
func testDoseDataWithLimitCoveredByData() {
let doseData = [DoseDatum(), DoseDatum(deleted: true), DoseDatum()]
addDoseData(doseData)
limit = 2
insulinDeliveryStore.executeDoseQuery(fromQueryAnchor: queryAnchor, limit: limit) { result in
switch result {
case .failure(let error):
XCTFail("Unexpected failure: \(error)")
case .success(let anchor, let created, let deleted):
XCTAssertEqual(anchor.modificationCounter, 2)
XCTAssertEqual(created.count, 1)
XCTAssertEqual(deleted.count, 1)
if created.count >= 1 {
XCTAssertEqual(created[0].syncIdentifier, doseData[0].syncIdentifier)
}
if deleted.count >= 1 {
XCTAssertEqual(deleted[0].syncIdentifier, doseData[1].syncIdentifier)
}
}
self.completion.fulfill()
}
wait(for: [completion], timeout: 2, enforceOrder: true)
}
private func addDoseData(_ doseData: [DoseDatum]) {
cacheStore.managedObjectContext.performAndWait {
for doseDatum in doseData {
let object = CachedInsulinDeliveryObject(context: self.cacheStore.managedObjectContext)
object.provenanceIdentifier = HKSource.default().bundleIdentifier
object.hasLoopKitOrigin = true
object.startDate = Date().addingTimeInterval(-.minutes(15))
object.endDate = Date().addingTimeInterval(-.minutes(5))
object.syncIdentifier = doseDatum.syncIdentifier
object.value = 1.0
object.reason = .bolus
object.createdAt = Date()
object.deletedAt = doseDatum.deleted ? Date() : nil
object.manuallyEntered = false
object.isSuspend = false
self.cacheStore.save()
}
}
}
private struct DoseDatum {
let syncIdentifier: String
let deleted: Bool
init(deleted: Bool = false) {
self.syncIdentifier = UUID().uuidString
self.deleted = deleted
}
}
}
| mit | 2003b9446ca6a8b4385d93313e630c9a | 44.219393 | 236 | 0.623968 | 5.458619 | false | false | false | false |
ryuichis/swift-ast | Sources/Parser/Parser+Type.swift | 2 | 15909 | /*
Copyright 2016-2018 Ryuichi Intellectual Property and the Yanagiba project contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import AST
import Lexer
import Source
extension Parser {
func parseTypeAnnotation() throws -> TypeAnnotation? {
let startLocation = getStartLocation()
guard _lexer.match(.colon) else {
return nil
}
var isInOutParameter = false
let attrs = try parseAttributes()
if _lexer.look().kind == .inout {
_lexer.advance()
isInOutParameter = true
}
let type = try parseType()
let typeAnnotation = TypeAnnotation(type: type, attributes: attrs, isInOutParameter: isInOutParameter)
typeAnnotation.setSourceRange(startLocation, type.sourceRange.end)
return typeAnnotation
}
func parseType() throws -> Type {
let attrs = try parseAttributes()
let isOpaqueType = isOpaqueTypeHead()
let atomicType = try parseAtomicType()
let containerType = try parseContainerType(atomicType, attributes: attrs)
return isOpaqueType ? OpaqueType(wrappedType: containerType) : containerType
}
func isOpaqueTypeHead() -> Bool {
guard case .name("some")? = _lexer.look().kind.namedIdentifier else { return false }
_lexer.advance()
return true
}
private func parseAtomicType() throws -> Type {
let lookedRange = getLookedRange()
let matched = _lexer.read([
.leftSquare,
.leftParen,
.protocol,
.Any,
.Self,
])
switch matched {
case .leftSquare:
return try parseCollectionType(lookedRange.start)
case .leftParen:
return try parseParenthesizedType(lookedRange.start)
case .protocol:
return try parseOldSyntaxProtocolCompositionType(lookedRange.start)
case .Any:
let anyType = AnyType()
anyType.setSourceRange(lookedRange)
return anyType
case .Self:
let selfType = SelfType()
selfType.setSourceRange(lookedRange)
return selfType
default:
if let idHead = readNamedIdentifier() {
return try parseIdentifierType(idHead, lookedRange)
} else {
throw _raiseFatal(.expectedType)
}
}
}
func parseIdentifierType(_ headId: Identifier, _ startRange: SourceRange) throws -> TypeIdentifier {
var endLocation = startRange.end
let headGenericArgumentClause = parseGenericArgumentClause()
if let headGenericArg = headGenericArgumentClause {
endLocation = headGenericArg.sourceRange.end
}
var names = [
TypeIdentifier.TypeName(name: headId, genericArgumentClause: headGenericArgumentClause)
]
while _lexer.look().kind == .dot, case let .identifier(name, backticked) = _lexer.readNext(.dummyIdentifier) {
endLocation = getStartLocation()
let genericArgumentClause = parseGenericArgumentClause()
if let genericArg = genericArgumentClause {
endLocation = genericArg.sourceRange.end
}
let typeIdentifierName = TypeIdentifier.TypeName(
name: backticked ? .backtickedName(name) : .name(name),
genericArgumentClause: genericArgumentClause)
names.append(typeIdentifierName)
}
let idType = TypeIdentifier(names: names)
idType.setSourceRange(startRange.start, endLocation)
return idType
}
private func parseCollectionType(_ startLocation: SourceLocation) throws -> Type {
let type = try parseType()
var endLocation = getEndLocation()
switch _lexer.read([.rightSquare, .colon]) {
case .rightSquare:
let arrayType = ArrayType(elementType: type)
arrayType.setSourceRange(startLocation, endLocation)
return arrayType
case .colon:
let valueType = try parseType()
endLocation = getEndLocation()
try match(.rightSquare, orFatal: .expectedCloseSquareDictionaryType)
let dictType = DictionaryType(keyType: type, valueType: valueType)
dictType.setSourceRange(startLocation, endLocation)
return dictType
default:
throw _raiseFatal(.expectedCloseSquareArrayType)
}
}
private func parseParenthesizedType(_ startLocation: SourceLocation) throws -> ParenthesizedType {
var endLocation = getEndLocation()
if _lexer.match(.rightParen) {
let parenType = ParenthesizedType(elements: [])
parenType.sourceRange = SourceRange(start: startLocation, end: endLocation)
return parenType
}
var elements: [ParenthesizedType.Element] = []
repeat {
let element = try parseParenthesizedTypeElement()
elements.append(element)
} while _lexer.match(.comma)
endLocation = getEndLocation()
try match(.rightParen, orFatal: .expectedCloseParenParenthesizedType)
let parenType = ParenthesizedType(elements: elements)
parenType.sourceRange = SourceRange(start: startLocation, end: endLocation)
return parenType
}
func parseTupleType(_ startLocation: SourceLocation) throws -> TupleType {
return try parseParenthesizedType(startLocation).toTupleType()
}
private func parseParenthesizedTypeElement() throws -> ParenthesizedType.Element {
var externalName: Identifier?
var localName: Identifier?
let type: Type
var attributes: [Attribute] = []
var isInOutParameter = false
let looked = _lexer.look()
switch looked.kind {
case .at:
attributes = try parseAttributes()
isInOutParameter = _lexer.match(.inout)
type = try parseType()
case .inout:
isInOutParameter = true
_lexer.advance()
type = try parseType()
default:
if let name = looked.kind.namedIdentifierOrWildcard?.id {
let elementBody = try parseParenthesizedTypeElementBody(name)
type = elementBody.type
externalName = elementBody.externalName
localName = elementBody.localName
attributes = elementBody.attributes
isInOutParameter = elementBody.isInOutParameter
} else {
type = try parseType()
}
}
let isVariadic = _lexer.match([
.prefixOperator("..."),
.binaryOperator("..."),
.postfixOperator("..."),
], exactMatch: true)
return ParenthesizedType.Element(
type: type,
externalName: externalName,
localName: localName,
attributes: attributes,
isInOutParameter: isInOutParameter,
isVariadic: isVariadic)
}
private func parseParenthesizedTypeElementBody(_ name: Identifier) throws -> ParenthesizedType.Element {
var externalName: Identifier?
var internalName: Identifier?
if let secondName = _lexer.look(ahead: 1).kind.namedIdentifier?.id, _lexer.look(ahead: 2).kind == .colon {
externalName = name
internalName = secondName
_lexer.advance(by: 2)
} else if _lexer.look(ahead: 1).kind == .colon {
internalName = name
_lexer.advance()
} else {
let nonLabeledType = try parseType()
return ParenthesizedType.Element(type: nonLabeledType)
}
guard let typeAnnotation = try parseTypeAnnotation() else {
throw _raiseFatal(.expectedTypeInTuple)
}
return ParenthesizedType.Element(
type: typeAnnotation.type,
externalName: externalName,
localName: internalName,
attributes: typeAnnotation.attributes,
isInOutParameter: typeAnnotation.isInOutParameter)
}
func parseProtocolCompositionType(_ type: Type) throws -> ProtocolCompositionType {
var endLocation = type.sourceRange.end
var protocolTypes = [type]
repeat {
let idTypeRange = getLookedRange()
guard let idHead = readNamedIdentifier() else {
throw _raiseFatal(.expectedIdentifierTypeForProtocolComposition)
}
let idType = try parseIdentifierType(idHead, idTypeRange)
protocolTypes.append(idType)
endLocation = idType.sourceRange.end
} while testAmp()
let protoType = ProtocolCompositionType(protocolTypes: protocolTypes)
protoType.setSourceRange(type.sourceLocation, endLocation)
return protoType
}
func parseOldSyntaxProtocolCompositionType(_ startLocation: SourceLocation) throws -> ProtocolCompositionType {
try assert(_lexer.matchUnicodeScalar("<"), orFatal: .expectedLeftChevronProtocolComposition)
if _lexer.matchUnicodeScalar(">") {
return ProtocolCompositionType(protocolTypes: [])
}
var protocolTypes: [Type] = []
repeat {
let nestedRange = getLookedRange()
guard let idHead = readNamedIdentifier() else {
throw _raiseFatal(.expectedIdentifierTypeForProtocolComposition)
}
protocolTypes.append(try parseIdentifierType(idHead, nestedRange))
} while _lexer.match(.comma)
let endLocation = getEndLocation()
try assert(_lexer.matchUnicodeScalar(">"), orFatal: .expectedRightChevronProtocolComposition)
let protoType = ProtocolCompositionType(protocolTypes: protocolTypes)
protoType.setSourceRange(startLocation, endLocation)
return protoType
}
private func parseContainerType( /*
swift-lint:rule_configure(CYCLOMATIC_COMPLEXITY=16)
swift-lint:suppress(high_ncss)
*/
_ type: Type, attributes attrs: Attributes = []
) throws -> Type {
func getAtomicType() throws -> Type {
do {
if let parenthesizedType = type as? ParenthesizedType {
return try parenthesizedType.toTupleType()
}
return type
} catch ParenthesizedType.TupleConversionError.isVariadic {
throw _raiseFatal(.tupleTypeVariadicElement)
} catch ParenthesizedType.TupleConversionError.multipleLabels {
throw _raiseFatal(.tupleTypeMultipleLabels)
}
}
if _lexer.matchUnicodeScalar("?", immediateFollow: true) {
let atomicType = try getAtomicType()
let containerType = OptionalType(wrappedType: atomicType)
containerType.setSourceRange(atomicType.sourceLocation, atomicType.sourceRange.end.nextColumn)
return try parseContainerType(containerType)
}
if _lexer.matchUnicodeScalar("!", immediateFollow: true) {
let atomicType = try getAtomicType()
let containerType = ImplicitlyUnwrappedOptionalType(wrappedType: atomicType)
containerType.setSourceRange(atomicType.sourceLocation, atomicType.sourceRange.end.nextColumn)
return try parseContainerType(containerType)
}
if testAmp() {
let atomicType = try getAtomicType()
let protocolCompositionType = try parseProtocolCompositionType(atomicType)
return try parseContainerType(protocolCompositionType)
}
let examined = _lexer.examine([
.throws, .rethrows, .arrow, .dot,
])
guard examined.0 else {
return try getAtomicType()
}
var parsedType: Type
switch examined.1 {
case .throws:
try match(.arrow, orFatal: .throwsInWrongPosition("throws"))
parsedType = try parseFunctionType(attributes: attrs, type: type, throwKind: .throwing)
case .rethrows:
try match(.arrow, orFatal: .throwsInWrongPosition("rethrows"))
parsedType = try parseFunctionType(attributes: attrs, type: type, throwKind: .rethrowing)
case .arrow:
parsedType = try parseFunctionType(attributes: attrs, type: type, throwKind: .nothrowing)
case .dot:
let atomicType = try getAtomicType()
let metatypeEndLocation = getEndLocation()
let metatypeType: MetatypeType
switch _lexer.read([.Type, .Protocol]) {
case .Type:
metatypeType = MetatypeType(referenceType: atomicType, kind: .type)
case .Protocol:
metatypeType = MetatypeType(referenceType: atomicType, kind: .protocol)
default:
throw _raiseFatal(.wrongIdentifierForMetatypeType)
}
metatypeType.setSourceRange(type.sourceLocation, metatypeEndLocation)
parsedType = metatypeType
default:
return try getAtomicType()
}
return try parseContainerType(parsedType)
}
private func parseFunctionType(attributes attrs: Attributes, type: Type, throwKind: ThrowsKind) throws -> Type {
guard let parenthesizedType = type as? ParenthesizedType else {
throw _raiseFatal(.expectedFunctionTypeArguments)
}
let funcArguments = parenthesizedType.elements.map {
FunctionType.Argument(type: $0.type,
externalName: $0.externalName,
localName: $0.localName,
attributes: $0.attributes,
isInOutParameter: $0.isInOutParameter,
isVariadic: $0.isVariadic)
}
let returnType = try parseType()
let funcType = FunctionType(
attributes: attrs,
arguments: funcArguments,
returnType: returnType,
throwsKind: throwKind)
funcType.setSourceRange(type.sourceLocation, returnType.sourceRange.end)
return funcType
}
func parseTypeInheritanceClause() throws -> TypeInheritanceClause? {
guard _lexer.match(.colon) else {
return nil
}
var classRequirement = false
if _lexer.match(.class) {
classRequirement = true
guard _lexer.match(.comma) else {
return TypeInheritanceClause(classRequirement: classRequirement)
}
}
var types = [TypeIdentifier]()
repeat {
let typeSourceRange = getLookedRange()
if _lexer.match(.class) {
throw _raiseFatal(.lateClassRequirement)
} else if let idHead = readNamedIdentifier() {
let type = try parseIdentifierType(idHead, typeSourceRange)
types.append(type)
} else {
throw _raiseFatal(.expectedTypeRestriction)
}
} while _lexer.match(.comma)
return TypeInheritanceClause( classRequirement: classRequirement, typeInheritanceList: types)
}
}
fileprivate class ParenthesizedType : Type {
fileprivate enum TupleConversionError : Error {
case isVariadic
case multipleLabels
}
fileprivate class Element {
fileprivate let externalName: Identifier?
fileprivate let localName: Identifier?
fileprivate let type: Type
fileprivate let attributes: Attributes
fileprivate let isInOutParameter: Bool
fileprivate let isVariadic: Bool
fileprivate init(type: Type,
externalName: Identifier? = nil,
localName: Identifier? = nil,
attributes: Attributes = [],
isInOutParameter: Bool = false,
isVariadic: Bool = false)
{
self.externalName = externalName
self.localName = localName
self.type = type
self.attributes = attributes
self.isInOutParameter = isInOutParameter
self.isVariadic = isVariadic
}
}
fileprivate let elements: [Element]
fileprivate init(elements: [Element]) {
self.elements = elements
}
fileprivate var textDescription: String {
return ""
}
fileprivate var sourceRange: SourceRange = .EMPTY
fileprivate func toTupleType() throws -> TupleType {
var tupleElements: [TupleType.Element] = []
for e in elements {
if e.externalName != nil {
throw TupleConversionError.multipleLabels
} else if e.isVariadic {
throw TupleConversionError.isVariadic
} else if let name = e.localName {
let tupleElement = TupleType.Element(
type: e.type,
name: name,
attributes: e.attributes,
isInOutParameter: e.isInOutParameter)
tupleElements.append(tupleElement)
} else {
let tupleElement = TupleType.Element(type: e.type)
tupleElements.append(tupleElement)
}
}
let tupleType = TupleType(elements: tupleElements)
tupleType.setSourceRange(sourceRange)
return tupleType
}
}
| apache-2.0 | 93fa405b94152f8c8fc1ff641f89fc30 | 32.99359 | 114 | 0.697467 | 4.672247 | false | false | false | false |
vimeo/VimeoUpload | VimeoUpload/Upload/Operations/Async/ExportSessionExportOperation.swift | 1 | 5697 | //
// ExportSessionExportOperation.swift
// VimeoUpload
//
// Created by Hanssen, Alfie on 12/22/15.
// Copyright © 2015 Vimeo. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
import Foundation
import AVFoundation
import VimeoNetworking
import Photos
public typealias ExportProgressBlock = (AVAssetExportSession, Double) -> Void
@objc open class ExportSessionExportOperation: ConcurrentOperation
{
let operationQueue: OperationQueue
@objc open var downloadProgressBlock: ProgressBlock?
@objc open var exportProgressBlock: ExportProgressBlock?
private let phAsset: PHAsset
@objc open var error: NSError?
{
didSet
{
if self.error != nil
{
self.state = .finished
}
}
}
@objc open var result: URL?
private let documentsFolderURL: URL?
/// Initializes an instance of `ExportSessionExportOperation`.
///
/// - Parameters:
/// - phAsset: An instance of `PHAsset` representing a media that the
/// user picks from the Photos app.
/// - documentsFolderURL: An URL pointing to a Documents folder;
/// default to `nil`. For third-party use, this argument should not be
/// filled.
@objc public init(phAsset: PHAsset, documentsFolderURL: URL? = nil)
{
self.phAsset = phAsset
self.operationQueue = OperationQueue()
self.operationQueue.maxConcurrentOperationCount = 1
self.documentsFolderURL = documentsFolderURL
super.init()
}
deinit
{
self.operationQueue.cancelAllOperations()
}
// MARK: Overrides
@objc override open func main()
{
if self.isCancelled
{
return
}
self.requestExportSession()
}
@objc override open func cancel()
{
super.cancel()
self.operationQueue.cancelAllOperations()
if let url = self.result
{
FileManager.default.deleteFile(at: url)
}
}
// MARK: Public API
func requestExportSession()
{
let operation = ExportSessionOperation(phAsset: self.phAsset)
operation.progressBlock = self.downloadProgressBlock
operation.completionBlock = { [weak self] () -> Void in
DispatchQueue.main.async(execute: { [weak self] () -> Void in
guard let strongSelf = self else
{
return
}
if operation.isCancelled == true
{
return
}
if let error = operation.error
{
strongSelf.error = error
}
else
{
let exportSession = operation.result!
let exportOperation = ExportOperation(exportSession: exportSession, documentsFolderURL: strongSelf.documentsFolderURL)
strongSelf.performExport(exportOperation: exportOperation)
}
})
}
self.operationQueue.addOperation(operation)
}
func performExport(exportOperation: ExportOperation)
{
exportOperation.progressBlock = { [weak self] (progress: Double) -> Void in // This block is called on a background thread
if let progressBlock = self?.exportProgressBlock
{
DispatchQueue.main.async(execute: { () -> Void in
progressBlock(exportOperation.exportSession, progress)
})
}
}
exportOperation.completionBlock = { [weak self] () -> Void in
DispatchQueue.main.async(execute: { [weak self] () -> Void in
guard let strongSelf = self else
{
return
}
if exportOperation.isCancelled == true
{
return
}
if let error = exportOperation.error
{
strongSelf.error = error
}
else
{
let url = exportOperation.outputURL!
strongSelf.result = url
strongSelf.state = .finished
}
})
}
self.operationQueue.addOperation(exportOperation)
}
}
| mit | 067a91721b2a7884371179fc28b1e5d6 | 30.125683 | 138 | 0.566362 | 5.482194 | false | false | false | false |
rwbutler/TypographyKit | TypographyKit/Classes/TypographyKitColorCell.swift | 1 | 2261 | //
// TKColorCell.swift
// TypographyKit
//
// Created by Ross Butler on 8/13/19.
//
import Foundation
import UIKit
@available(iOS 9.0, *)
class TypographyKitColorCell: UITableViewCell {
private var titleLabel: UILabel = {
let titleLabel = UILabel()
titleLabel.font = UIFont(name: "Avenir-Book", size: 17.0)
titleLabel.textColor = .white
titleLabel.translatesAutoresizingMaskIntoConstraints = false
return titleLabel
}()
override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
configureView()
}
required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
func configure(title: String, color: UIColor?) {
titleLabel.text = title
if let backgroundColor = color {
self.contentView.backgroundColor = backgroundColor
}
layoutIfNeeded()
}
}
@available(iOS 9.0, *)
private extension TypographyKitColorCell {
private func configureView() {
let effectView = self.effectView()
effectView.addSubview(titleLabel)
NSLayoutConstraint.activate([
titleLabel.leftAnchor.constraint(equalTo: effectView.leftAnchor, constant: 10.0),
titleLabel.rightAnchor.constraint(equalTo: effectView.rightAnchor, constant: -10.0),
titleLabel.topAnchor.constraint(equalTo: effectView.topAnchor, constant: 10.0),
titleLabel.bottomAnchor.constraint(equalTo: effectView.bottomAnchor, constant: -10.0)
])
}
private func effectView() -> UIView {
let blur = UIBlurEffect(style: .dark)
let effectView = UIVisualEffectView(effect: blur)
effectView.translatesAutoresizingMaskIntoConstraints = false
effectView.clipsToBounds = true
effectView.layer.cornerRadius = 5.0
contentView.addSubview(effectView)
NSLayoutConstraint.activate([
effectView.leftAnchor.constraint(equalTo: contentView.leftAnchor, constant: 10.0),
effectView.centerYAnchor.constraint(equalTo: contentView.centerYAnchor)
])
return effectView.contentView
}
}
| mit | 0fd4dcb5a8597176b0774105aad871a3 | 31.768116 | 97 | 0.667404 | 5.115385 | false | false | false | false |
hanangellove/TextFieldEffects | TextFieldEffects/TextFieldEffects/MadokaTextField.swift | 11 | 5506 | //
// MadokaTextField.swift
// TextFieldEffects
//
// Created by Raúl Riera on 05/02/2015.
// Copyright (c) 2015 Raul Riera. All rights reserved.
//
import UIKit
@IBDesignable public class MadokaTextField: TextFieldEffects {
@IBInspectable public var placeholderColor: UIColor? {
didSet {
updatePlaceholder()
}
}
@IBInspectable public var borderColor: UIColor? {
didSet {
updateBorder()
}
}
override public var placeholder: String? {
didSet {
updatePlaceholder()
}
}
override public var bounds: CGRect {
didSet {
updateBorder()
updatePlaceholder()
}
}
private let borderThickness: CGFloat = 1
private let placeholderInsets = CGPoint(x: 6, y: 6)
private let textFieldInsets = CGPoint(x: 6, y: 6)
private let borderLayer = CAShapeLayer()
private var backgroundLayerColor: UIColor?
// MARK: - TextFieldsEffectsProtocol
override func drawViewsForRect(rect: CGRect) {
let frame = CGRect(origin: CGPointZero, size: CGSize(width: rect.size.width, height: rect.size.height))
placeholderLabel.frame = CGRectInset(frame, placeholderInsets.x, placeholderInsets.y)
placeholderLabel.font = placeholderFontFromFont(font)
updateBorder()
updatePlaceholder()
layer.addSublayer(borderLayer)
addSubview(placeholderLabel)
}
private func updateBorder() {
//let path = CGPathCreateWithRect(rectForBorder(bounds), nil)
let rect = rectForBorder(bounds)
let path = UIBezierPath()
path.moveToPoint(CGPoint(x: rect.origin.x + borderThickness, y: rect.height - borderThickness))
path.addLineToPoint(CGPoint(x: rect.width - borderThickness, y: rect.height - borderThickness))
path.addLineToPoint(CGPoint(x: rect.width - borderThickness, y: rect.origin.y + borderThickness))
path.addLineToPoint(CGPoint(x: rect.origin.x + borderThickness, y: rect.origin.y + borderThickness))
path.closePath()
borderLayer.path = path.CGPath
borderLayer.lineCap = kCALineCapSquare
borderLayer.lineWidth = borderThickness
borderLayer.fillColor = nil
borderLayer.strokeColor = borderColor?.CGColor
borderLayer.strokeEnd = percentageForBottomBorder()
}
private func percentageForBottomBorder() -> CGFloat {
let borderRect = rectForBorder(bounds)
let sumOfSides = (borderRect.width * 2) + (borderRect.height * 2)
return (borderRect.width * 100 / sumOfSides) / 100
}
private func updatePlaceholder() {
placeholderLabel.text = placeholder
placeholderLabel.textColor = placeholderColor
placeholderLabel.sizeToFit()
layoutPlaceholderInTextRect()
if isFirstResponder() || !text.isEmpty {
animateViewsForTextEntry()
}
}
private func placeholderFontFromFont(font: UIFont) -> UIFont! {
let smallerFont = UIFont(name: font.fontName, size: font.pointSize * 0.65)
return smallerFont
}
private func rectForBorder(bounds: CGRect) -> CGRect {
var newRect = CGRect(x: 0, y: 0, width: bounds.size.width, height: bounds.size.height - font.lineHeight + textFieldInsets.y)
return newRect
}
private func layoutPlaceholderInTextRect() {
if !text.isEmpty {
return
}
placeholderLabel.transform = CGAffineTransformIdentity
let textRect = textRectForBounds(bounds)
var originX = textRect.origin.x
switch textAlignment {
case .Center:
originX += textRect.size.width/2 - placeholderLabel.bounds.width/2
case .Right:
originX += textRect.size.width - placeholderLabel.bounds.width
default:
break
}
placeholderLabel.frame = CGRect(x: originX, y: textRect.height - placeholderLabel.bounds.height - placeholderInsets.y,
width: placeholderLabel.bounds.width, height: placeholderLabel.bounds.height)
}
override func animateViewsForTextEntry() {
borderLayer.strokeEnd = 1
UIView.animateWithDuration(0.3, animations: { () -> Void in
let translate = CGAffineTransformMakeTranslation(-self.placeholderInsets.x, self.placeholderLabel.bounds.height + (self.placeholderInsets.y * 2))
let scale = CGAffineTransformMakeScale(0.9, 0.9)
self.placeholderLabel.transform = CGAffineTransformConcat(translate, scale)
})
}
override func animateViewsForTextDisplay() {
if text.isEmpty {
borderLayer.strokeEnd = percentageForBottomBorder()
UIView.animateWithDuration(0.3, animations: { () -> Void in
self.placeholderLabel.transform = CGAffineTransformIdentity
})
}
}
// MARK: - Overrides
override public func editingRectForBounds(bounds: CGRect) -> CGRect {
let newBounds = rectForBorder(bounds)
return CGRectInset(newBounds, textFieldInsets.x, 0)
}
override public func textRectForBounds(bounds: CGRect) -> CGRect {
let newBounds = rectForBorder(bounds)
return CGRectInset(newBounds, textFieldInsets.x, 0)
}
}
| mit | ead73aac9907f87679bd436ff3220c62 | 33.192547 | 157 | 0.632698 | 5.349854 | false | false | false | false |
lanjing99/iOSByTutorials | iOS 8 by tutorials/Chapter 05 - Transition Coordinator Updates/KhromaLike/KhromaLike/ViewController.swift | 1 | 3051 | /*
* Copyright (c) 2014 Razeware LLC
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
import UIKit
class ViewController: UIViewController, ColorSwatchSelectionDelegate {
@IBOutlet var tallLayoutContrains: [NSLayoutConstraint]!
@IBOutlet var wideLayoutContrains: [NSLayoutConstraint]!
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
// Wire up any swatch selectors we can find as VC children
for viewController in childViewControllers as [UIViewController] {
if let selector = viewController as? ColorSwatchSelector {
selector.swatchSelectionDelegate = self
}
}
}
// #pragma mark <ColorSwatchSelectionDelegate>
func didSelect(swatch: ColorSwatch, sender: AnyObject?) {
for viewController in childViewControllers as [UIViewController] {
if let selectable = viewController as? ColorSwatchSelectable {
selectable.colorSwatch = swatch
}
}
}
override func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {
super.viewWillTransitionToSize(size, withTransitionCoordinator: coordinator)
let transitionToWide = size.width > size.height
let constraintsToUninstall = transitionToWide ? tallLayoutContrains : wideLayoutContrains
let constraintsToInstall = transitionToWide ? wideLayoutContrains : tallLayoutContrains
// Ask Auto Layout to commit any outstanding changes
view.layoutIfNeeded()
// Animate to the new layout alongside the transition
coordinator.animateAlongsideTransition({ _ in
NSLayoutConstraint.deactivateConstraints(constraintsToUninstall)
NSLayoutConstraint.activateConstraints(constraintsToInstall)
self.view.layoutIfNeeded()
}, completion: nil)
}
}
| mit | 30843a84b655a5c40d863d1947d418b4 | 43.217391 | 136 | 0.720092 | 5.428826 | false | false | false | false |
adolfrank/Swift_practise | 26-day/26-day/TableViewController.swift | 1 | 5477 | //
// TableViewController.swift
// 26-day
//
// Created by Hongbo Yu on 16/5/30.
// Copyright © 2016年 Frank. All rights reserved.
//
import UIKit
import CoreData
class TableViewController: UITableViewController {
var listItems = [NSManagedObject]()
override func viewDidLoad() {
super.viewDidLoad()
self.navigationItem.rightBarButtonItem = UIBarButtonItem(barButtonSystemItem: UIBarButtonSystemItem.Add, target: self, action: #selector(TableViewController.addItem))
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
override func viewDidAppear(animated: Bool) {
let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
let managedContex = appDelegate.managedObjectContext
let fetchRequest = NSFetchRequest(entityName: "ListEntity")
do {
let results = try managedContex.executeFetchRequest(fetchRequest)
listItems = results as! [NSManagedObject]
self.tableView.reloadData()
} catch {
print("error")
}
}
// override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
//
// let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
// let managedContex = appDelegate.managedObjectContext
//
// managedContex.deleteObject(listItems[indexPath.row])
// listItems.removeAtIndex(indexPath.row)
//
// self.tableView.reloadData()
//
// }
func addItem() {
let alertController = UIAlertController(title: "New Resolution", message: "", preferredStyle: UIAlertControllerStyle.Alert)
let confirmAction = UIAlertAction(title: "Confirm", style: UIAlertActionStyle.Default, handler: ({
(_) in
if let field = alertController.textFields![0] as? UITextField {
self.saveItem(field.text!)
self.tableView.reloadData()
}
}))
let cancelAction = UIAlertAction(title: "Cancel", style: UIAlertActionStyle.Cancel, handler: nil)
alertController.addTextFieldWithConfigurationHandler ({
(textField) in
textField.placeholder = "Type smothing..."
})
alertController.addAction(confirmAction)
alertController.addAction(cancelAction)
self.presentViewController(alertController, animated: true, completion: nil)
}
func saveItem(itemToSave: String) {
let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
let managedContex = appDelegate.managedObjectContext
let entity = NSEntityDescription.entityForName("ListEntity", inManagedObjectContext: managedContex)
let item = NSManagedObject(entity: entity!, insertIntoManagedObjectContext: managedContex)
item.setValue(itemToSave, forKey: "item")
do {
try managedContex.save()
listItems.append(item)
} catch {
print("error")
}
}
override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
return 50
}
override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return listItems.count
}
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier("Cell")! as UITableViewCell
let item = listItems[indexPath.row]
cell.textLabel?.text = item.valueForKey("item") as? String
cell.textLabel?.font = UIFont(name: "", size: 25)
return cell
}
override func tableView(tableView: UITableView, editActionsForRowAtIndexPath indexPath: NSIndexPath) -> [UITableViewRowAction]? {
let delete = UITableViewRowAction(style: .Normal, title: "Delete") { action, index in
let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
let managedContex = appDelegate.managedObjectContext
tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: UITableViewRowAnimation.Right)
managedContex.deleteObject(self.listItems[indexPath.row])
do {
try managedContex.save()
self.listItems.removeAtIndex(indexPath.row)
self.tableView.reloadData()
} catch {
print("error: delete ")
}
}
delete.backgroundColor = UIColor.redColor()
return [delete]
}
override func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
return true
}
override func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
}
}
| mit | 16ce3c500f5312b4663da021ad247aa5 | 32.378049 | 174 | 0.614176 | 6.082222 | false | false | false | false |
itamaker/SunnyFPS | SunnyFPS/AppDelegate.swift | 1 | 6090 | //
// AppDelegate.swift
// SunnyFPS
//
// Created by jiazhaoyang on 16/2/15.
// Copyright © 2016年 gitpark. All rights reserved.
//
import UIKit
import CoreData
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Override point for customization after application launch.
return true
}
func applicationWillResignActive(application: UIApplication) {
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
}
func applicationDidEnterBackground(application: UIApplication) {
// Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
// If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}
func applicationWillEnterForeground(application: UIApplication) {
// Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
}
func applicationDidBecomeActive(application: UIApplication) {
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}
func applicationWillTerminate(application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
// 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.gitpark.SunnyFPS" 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("SunnyFPS", 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()
}
}
}
}
| apache-2.0 | 162bb2fa5c09718027d490f96bec261b | 53.837838 | 291 | 0.719566 | 5.841651 | false | false | false | false |
ArtSabintsev/Guitar | Sources/GuitarCase.swift | 1 | 4737 | //
// GuitarCasing.swift
// GuitarExample
//
// Created by Sabintsev, Arthur on 3/9/17.
// Copyright © 2017 Arthur Ariel Sabintsev. All rights reserved.
//
import Foundation
// MARK: - Case Operations
public extension String {
/// Returns a camel cased version of the string.
///
/// let string = "HelloWorld"
/// print(string.camelCased())
/// // Prints "helloWorld"
///
/// - Returns: A camel cased copy of the string.
@discardableResult
func camelCased() -> String {
return pascalCased().decapitalized()
}
/// Returns a capitalized version of the string.
///
/// - Warning: This method is a modified implementation of Swift stdlib's `capitalized` computer variabled.
///
/// let string = "hello World"
/// print(string.capitalized())
/// // Prints "Hello World"
///
/// - Returns: A capitalized copy of the string.
@discardableResult
func capitalized() -> String {
let ranges = Guitar(chord: .firstCharacter).evaluateForRanges(from: self)
var newString = self
for range in ranges {
let character = index(range.lowerBound, offsetBy: 0)
let uppercasedCharacter = String(self[character]).uppercased()
newString = newString.replacingCharacters(in: range, with: uppercasedCharacter)
}
return newString
}
/// Returns a decapitalized version of the string.
///
/// let string = "Hello World"
/// print(string.decapitalized())
/// // Prints "hello world"
///
/// - Returns: A decapitalized copy of the string.
@discardableResult
func decapitalized() -> String {
let ranges = Guitar(chord: .firstCharacter).evaluateForRanges(from: self)
var newString = self
for range in ranges {
let character = self[range.lowerBound]
let lowercasedCharacter = String(character).lowercased()
newString = newString.replacingCharacters(in: range, with: lowercasedCharacter)
}
return newString
}
/// Returns the kebab cased (a.k.a. slug) version of the string.
///
/// let string = "Hello World"
/// print(string.kebabCased())
/// // Prints "hello-world"
///
/// - Returns: The kebabg cased copy of the string.
@discardableResult
func kebabCased() -> String {
return Guitar.sanitze(string: self).splitWordsByCase().replacingOccurrences(of: " ", with: "-").lowercased()
}
/// Returns a pascal cased version of the string.
///
/// let string = "HELLO WORLD"
/// print(string.pascalCased())
/// // Prints "HelloWorld"
///
/// - Returns: A pascal cased copy of the string.
@discardableResult
func pascalCased() -> String {
return Guitar.sanitze(string: self).splitWordsByCase().capitalized().components(separatedBy: .whitespaces).joined()
}
/// Returns the snake cased version of the string.
///
/// let string = "Hello World"
/// print(string.snakeCased())
/// // Prints "hello_world"
///
/// - Returns: The snaked cased copy of the string.
@discardableResult
func snakeCased() -> String {
return Guitar.sanitze(string: self).splitWordsByCase().replacingOccurrences(of: " ", with: "_").lowercased()
}
/// Splits a string into mutliple words, delimited by uppercase letters.
///
/// let string = "HelloWorld"
/// print(string.splitWordsByCase())
/// // Prints "Hello World"
///
/// - Returns: A new string where each word in the original string is delimited by a whitespace.
@discardableResult
func splitWordsByCase() -> String {
var newStringArray: [String] = []
for character in Guitar.sanitze(string: self) {
if String(character) == String(character).uppercased() {
newStringArray.append(" ")
}
newStringArray.append(String(character))
}
return newStringArray
.joined()
.trimmingCharacters(in: .whitespacesAndNewlines)
.components(separatedBy: .whitespaces)
.filter({ !$0.isEmpty })
.joined(separator: " ")
}
/// Returns the swap cased version of the string.
///
/// let string = "Hello World"
/// print(string.swapCased())
/// // Prints "hELLO wORLD"
///
/// - Returns: The swap cased copy of the string.
@discardableResult
func swapCased() -> String {
return map({
String($0).isLowercased() ? String($0).uppercased() : String($0).lowercased()
}).joined()
}
}
| mit | a8063b974003d8e40a500516b299051f | 31.438356 | 123 | 0.593539 | 4.467925 | false | false | false | false |
argon/mas | MasKit/Models/SoftwareProduct.swift | 1 | 995 | //
// SoftwareProduct.swift
// MasKit
//
// Created by Ben Chatelain on 12/27/18.
// Copyright © 2018 mas-cli. All rights reserved.
//
/// Protocol describing the members of CKSoftwareProduct used throughout MasKit.
public protocol SoftwareProduct {
var appName: String { get }
var bundleIdentifier: String { get set }
var bundlePath: String { get set }
var bundleVersion: String { get set }
var itemIdentifier: NSNumber { get set }
}
// MARK: - Equatable
extension SoftwareProduct {
static func == (lhs: Self, rhs: Self) -> Bool {
return lhs.appName == rhs.appName
&& lhs.bundleIdentifier == rhs.bundleIdentifier
&& lhs.bundlePath == rhs.bundlePath
&& lhs.bundleVersion == rhs.bundleVersion
&& lhs.itemIdentifier == rhs.itemIdentifier
}
/// Returns bundleIdentifier if appName is empty string.
var appNameOrBbundleIdentifier: String {
appName == "" ? bundleIdentifier : appName
}
}
| mit | e32792bdd82f7228ae07246da038dcfc | 30.0625 | 80 | 0.655936 | 4.457399 | false | false | false | false |
ravirani/algorithms | Tree/BinaryTreeTraversals.swift | 1 | 1270 | //
// BinaryTreeTraversals.swift
//
// Recursive preorder, inorder, and postorder traversals (DFS)
//
import Foundation
class Node {
var data: Int
var left: Node?
var right: Node?
init(_ nodeData: Int) {
self.data = nodeData
}
}
// V L R
func preorderTraversal(_ rootNode: Node?) -> [Int] {
guard let node = rootNode else {
return []
}
var output = [Int]()
output += [node.data]
if let left = node.left {
output += preorderTraversal(left)
}
if let right = node.right {
output += preorderTraversal(right)
}
return output
}
// L V R
func inorderTraversal(_ rootNode: Node?) -> [Int] {
guard let node = rootNode else {
return []
}
var output = [Int]()
if let left = node.left {
output += inorderTraversal(left)
}
output += [node.data]
if let right = node.right {
output += inorderTraversal(right)
}
return output
}
// L R V
func postorderTraversal(_ rootNode: Node?) -> [Int] {
guard let node = rootNode else {
return []
}
var output = [Int]()
if let left = node.left {
output += postorderTraversal(left)
}
if let right = node.right {
output += postorderTraversal(right)
}
output += [node.data]
return output
}
| mit | 265908ea9ba6bc31608c9c3dd5e04d40 | 14.679012 | 63 | 0.596063 | 3.597734 | false | false | false | false |
josve05a/wikipedia-ios | Wikipedia/Code/WKWebView+EditSelectionJavascript.swift | 3 | 3147 |
import WebKit
extension WKWebView {
private func selectedTextEditInfo(from dictionary: Dictionary<String, Any>) -> SelectedTextEditInfo? {
guard
let selectedAndAdjacentTextDict = dictionary["selectedAndAdjacentText"] as? Dictionary<String, Any>,
let selectedText = selectedAndAdjacentTextDict["selectedText"] as? String,
let textBeforeSelectedText = selectedAndAdjacentTextDict["textBeforeSelectedText"] as? String,
let textAfterSelectedText = selectedAndAdjacentTextDict["textAfterSelectedText"] as? String,
let isSelectedTextInTitleDescription = dictionary["isSelectedTextInTitleDescription"] as? Bool,
let sectionID = dictionary["sectionID"] as? Int
else {
DDLogError("Error converting dictionary to SelectedTextEditInfo")
return nil
}
let selectedAndAdjacentText = SelectedAndAdjacentText(selectedText: selectedText, textAfterSelectedText: textAfterSelectedText, textBeforeSelectedText: textBeforeSelectedText)
return SelectedTextEditInfo(selectedAndAdjacentText: selectedAndAdjacentText, isSelectedTextInTitleDescription: isSelectedTextInTitleDescription, sectionID: sectionID)
}
@objc func wmf_getSelectedTextEditInfo(completionHandler: ((SelectedTextEditInfo?, Error?) -> Void)? = nil) {
evaluateJavaScript("window.wmf.editTextSelection.getSelectedTextEditInfo()") { [weak self] (result, error) in
guard let error = error else {
guard let completionHandler = completionHandler else {
return
}
guard
let resultDict = result as? Dictionary<String, Any>,
let selectedTextEditInfo = self?.selectedTextEditInfo(from: resultDict)
else {
DDLogError("Error handling 'getSelectedTextEditInfo()' dictionary response")
return
}
completionHandler(selectedTextEditInfo, nil)
return
}
DDLogError("Error when evaluating javascript on fetch and transform: \(error)")
}
}
}
class SelectedAndAdjacentText {
public let selectedText: String
public let textAfterSelectedText: String
public let textBeforeSelectedText: String
init(selectedText: String, textAfterSelectedText: String, textBeforeSelectedText: String) {
self.selectedText = selectedText
self.textAfterSelectedText = textAfterSelectedText
self.textBeforeSelectedText = textBeforeSelectedText
}
}
@objcMembers class SelectedTextEditInfo: NSObject {
public let selectedAndAdjacentText: SelectedAndAdjacentText
public let isSelectedTextInTitleDescription: Bool
public let sectionID: Int
init(selectedAndAdjacentText: SelectedAndAdjacentText, isSelectedTextInTitleDescription: Bool, sectionID: Int) {
self.selectedAndAdjacentText = selectedAndAdjacentText
self.isSelectedTextInTitleDescription = isSelectedTextInTitleDescription
self.sectionID = sectionID
}
}
| mit | 7ee8c42ee1ca77520de8ca549c1dcca0 | 48.952381 | 183 | 0.696854 | 5.589698 | false | false | false | false |
katsumeshi/PhotoInfo | PhotoInfo/Classes/ArrayUtil.swift | 1 | 1080 | //
// ArrayUtil.swift
// photoinfo
//
// Created by Yuki Matsushita on 11/20/15.
// Copyright © 2015 Yuki Matsushita. All rights reserved.
//
import MapKit
extension Array where Element : OnlyCustomAnnotations {
func getMaxDistance() -> Double {
let locations = self.map { $0 as! MKAnnotation }
.map{ CLLocation($0.coordinate) }
var distances = [CLLocationDistance]()
for var i = 0; i < locations.count - 1; i++ {
for var j = i + 1; j < locations.count; j++ {
let distance = locations[i].distanceFromLocation(locations[j])
distances.append(distance)
}
}
distances.sortInPlace { $0 > $1 }
return distances.first!
}
func find(photo:Photo) -> (index:Int, annotation:CustomAnnotation) {
let annotations = self.map{ $0 as! CustomAnnotation }
let annotation = annotations.filter { $0.photo == photo }.first!
let index = annotations.indexOf(annotation)!
return (index, annotation)
}
}
func == (left: Photo, right: Photo) -> Bool {
return left.asset == right.asset
}
| mit | 9330107df2891fc8f6de1b58ffabe899 | 27.394737 | 70 | 0.632067 | 3.785965 | false | false | false | false |
fredrikcollden/LittleMaestro | GameViewController.swift | 1 | 2083 | //
// GameViewController.swift
// MaestroLevel
//
// Created by Fredrik Colldén on 2015-10-29.
// Copyright (c) 2015 Marie. All rights reserved.
//
import UIKit
import SpriteKit
class GameViewController: UIViewController, GameSceneDelegate, StartSceneDelegate, CategoriesSceneDelegate {
var whiteTransition = SKTransition.fadeWithColor(UIColor(red: CGFloat(1.0), green: CGFloat(1.0), blue: CGFloat(1.0), alpha: CGFloat(1.0)), duration: 1.0)
override func viewDidLoad() {
super.viewDidLoad()
//GameData.sharedInstance.resetData()
GameData.sharedInstance.loadData()
let skView = self.view as! SKView
let scene = StartScene(size: skView.bounds.size)
skView.showsFPS = true
skView.showsNodeCount = true
skView.ignoresSiblingOrder = true
scene.scaleMode = .AspectFill
scene.startSceneDelegate = self
skView.presentScene(scene)
}
func startSceneActions(action: String) {
let skView = view as! SKView
let categoriesScene = CategoriesScene(size: skView.bounds.size)
categoriesScene.categoriesSceneDelegate = self
skView.presentScene(categoriesScene, transition: whiteTransition)
}
func loadLevel (levelNo: Int) {
let skView = view as! SKView
let gameScene = GameScene(levelNo: levelNo, size: skView.bounds.size)
gameScene.gameSceneDelegate = self
skView.presentScene(gameScene, transition: whiteTransition)
}
override func shouldAutorotate() -> Bool {
return true
}
override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
if UIDevice.currentDevice().userInterfaceIdiom == .Phone {
return .AllButUpsideDown
} else {
return .All
}
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Release any cached data, images, etc that aren't in use.
}
override func prefersStatusBarHidden() -> Bool {
return true
}
}
| lgpl-3.0 | f93e9f5aebb61208f55cccc3fbc34523 | 31.030769 | 157 | 0.663305 | 4.875878 | false | false | false | false |
jasonwedepohl/udacity-ios-on-the-map | On The Map/On The Map/UdacityClient.swift | 1 | 6746 | //
// UdacityClient.swift
// On The Map
//
// Created by Jason Wedepohl on 2017/09/18.
//
//
import Foundation
import FacebookCore
import FacebookLogin
class UdacityClient {
//MARK: Singleton
static let shared = UdacityClient()
//MARK: Constants
let responseHeaderLength = 5
struct Url {
static let session = "https://www.udacity.com/api/session"
static let users = "https://www.udacity.com/api/users/"
}
struct UdacityResponseKey {
static let user = "user"
static let firstName = "first_name"
static let lastName = "last_name"
}
//MARK: Properties
let session = URLSession.shared
var udacitySessionID: String? = nil
var udacityAccountKey: String? = nil
var udacityFirstName: String? = nil
var udacityLastName: String? = nil
//MARK: Functions
func login(email: String, password: String, completion: @escaping (_ success: Bool, _ displayError: String?) -> Void) {
let requestBody = UdacityLoginRequest.get(email, password)
let request = getLoginRequest(withBody: requestBody)
let task = session.dataTask(with: request as URLRequest) { data, response, error in
self.handleLoginTaskCompletion(data, response, error, completion)
}
task.resume()
}
func loginWithFacebook(completion: @escaping (_ success: Bool, _ displayError: String?) -> Void) {
guard let accessToken = AccessToken.current?.authenticationToken else {
print("The Facebook access token is not set.")
completion(false, DisplayError.unexpected)
return
}
let requestBody = UdacityLoginWithFacebookRequest.get(accessToken)
let request = getLoginRequest(withBody: requestBody)
let task = session.dataTask(with: request as URLRequest) { data, response, error in
self.handleLoginTaskCompletion(data, response, error, completion)
}
task.resume()
}
func logout(completion: @escaping (_ success: Bool, _ displayError: String?) -> Void) {
//log out of Facebook if necessary
if (AccessToken.current != nil) {
let loginManager = LoginManager()
loginManager.logOut()
}
let request = NSMutableURLRequest(url: URL(string: Url.session)!)
request.httpMethod = WebMethod.delete
//add anti-XSRF cookie so Udacity server knows this is the client that originally logged in
if let xsrfCookie = Utilities.getCookie(withKey: Cookie.xsrfToken) {
request.setValue(xsrfCookie.value, forHTTPHeaderField: RequestKey.xxsrfToken)
}
let task = session.dataTask(with: request as URLRequest) { data, response, error in
let responseHandler = ResponseHandler(data, response, error)
if let responseError = responseHandler.getResponseError() {
completion(false, responseError)
return
}
completion(true, nil)
}
task.resume()
}
private func getLoginRequest<T: Encodable>(withBody body: T) -> NSMutableURLRequest {
let request = NSMutableURLRequest(url: URL(string: Url.session)!)
request.httpMethod = WebMethod.post
request.addValue(RequestValue.jsonType, forHTTPHeaderField: RequestKey.accept)
request.addValue(RequestValue.jsonType, forHTTPHeaderField: RequestKey.contentType)
request.httpBody = JSONParser.stringify(body).data(using: String.Encoding.utf8)
return request
}
private func handleLoginTaskCompletion(_ data: Data?,
_ response: URLResponse?,
_ error: Error?,
_ completion: @escaping (_ success: Bool, _ displayError: String?) -> Void) {
let responseHandler = ResponseHandler(data, response, error)
if let responseError = responseHandler.getResponseError() {
completion(false, responseError)
return
}
let subsetResponseData = subsetResponse(data!)
guard let response:UdacityLoginResponse = JSONParser.decode(subsetResponseData) else {
completion(false, DisplayError.unexpected)
return
}
udacityAccountKey = response.account.key
udacitySessionID = response.session.id
getUserDetails(completion)
}
private func getUserDetails(_ completion: @escaping (_ success: Bool, _ displayError: String?) -> Void) {
let request = NSMutableURLRequest(url: URL(string: Url.users + udacityAccountKey!)!)
let task = session.dataTask(with: request as URLRequest) { data, response, error in
let responseHandler = ResponseHandler(data, response, error)
if let responseError = responseHandler.getResponseError() {
completion(false, responseError)
return
}
let subsetResponseData = self.subsetResponse(data!)
//TODO: replace use of JSONSerialization with Swift 4 Codable
guard let parsedResponse = JSONParser.deserialize(subsetResponseData) else {
completion(false, DisplayError.unexpected)
return
}
guard let responseDictionary = parsedResponse as? [String: AnyObject] else {
completion(false, DisplayError.unexpected)
return
}
guard let user = responseDictionary[UdacityResponseKey.user] as? [String: AnyObject] else {
completion(false, DisplayError.unexpected)
return
}
guard let firstName = user[UdacityResponseKey.firstName] as? String else {
completion(false, DisplayError.unexpected)
return
}
guard let lastName = user[UdacityResponseKey.lastName] as? String else {
completion(false, DisplayError.unexpected)
return
}
self.udacityFirstName = firstName
self.udacityLastName = lastName
completion(true, nil)
}
task.resume()
}
//All responses from Udacity API start with 5 characters that must be skipped
private func subsetResponse(_ data: Data) -> Data {
let range = Range(responseHeaderLength..<data.count)
return data.subdata(in: range)
}
//MARK: Request structs
private struct UdacityLoginRequest: Codable {
private let udacity : Udacity
private struct Udacity : Codable {
let username: String
let password: String
}
static func get(_ username: String, _ password: String) -> UdacityLoginRequest {
return UdacityLoginRequest(udacity: Udacity(username: username, password: password))
}
}
private struct UdacityLoginWithFacebookRequest: Codable {
private let facebook_mobile : FacebookMobile
private struct FacebookMobile : Codable {
let access_token: String
}
static func get(_ accessToken: String) -> UdacityLoginWithFacebookRequest {
return UdacityLoginWithFacebookRequest(facebook_mobile: FacebookMobile(access_token: accessToken))
}
}
//MARK: Response structs
private struct UdacityLoginResponse: Codable {
let account: Account
let session: Session
struct Account: Codable {
let registered: Bool
let key: String
}
struct Session: Codable {
let id: String
let expiration: String
}
}
}
| mit | 495d89615bffc9ddd39594748b2af421 | 27.82906 | 120 | 0.71346 | 4.083535 | false | false | false | false |
sydvicious/firefox-ios | Providers/Profile.swift | 2 | 26131 | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import Foundation
import Account
import ReadingList
import Shared
import Storage
import Sync
import XCGLogger
// TODO: same comment as for SyncAuthState.swift!
private let log = XCGLogger.defaultInstance()
public protocol SyncManager {
func syncClients() -> SyncResult
func syncClientsThenTabs() -> SyncResult
func syncHistory() -> SyncResult
func syncLogins() -> SyncResult
func syncEverything() -> Success
// The simplest possible approach.
func beginTimedSyncs()
func endTimedSyncs()
func onRemovedAccount(account: FirefoxAccount?) -> Success
func onAddedAccount() -> Success
}
typealias EngineIdentifier = String
typealias SyncFunction = (SyncDelegate, Prefs, Ready) -> SyncResult
class ProfileFileAccessor: FileAccessor {
init(profile: Profile) {
let profileDirName = "profile.\(profile.localName())"
// Bug 1147262: First option is for device, second is for simulator.
var rootPath: String?
if let sharedContainerIdentifier = ExtensionUtils.sharedContainerIdentifier(), url = NSFileManager.defaultManager().containerURLForSecurityApplicationGroupIdentifier(sharedContainerIdentifier), path = url.path {
rootPath = path
} else {
log.error("Unable to find the shared container. Defaulting profile location to ~/Documents instead.")
rootPath = String(NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as! NSString)
}
super.init(rootPath: rootPath!.stringByAppendingPathComponent(profileDirName))
}
}
class CommandStoringSyncDelegate: SyncDelegate {
let profile: Profile
init() {
profile = BrowserProfile(localName: "profile", app: nil)
}
func displaySentTabForURL(URL: NSURL, title: String) {
if let urlString = URL.absoluteString {
let item = ShareItem(url: urlString, title: title, favicon: nil)
self.profile.queue.addToQueue(item)
}
}
}
/**
* This exists because the Sync code is extension-safe, and thus doesn't get
* direct access to UIApplication.sharedApplication, which it would need to
* display a notification.
* This will also likely be the extension point for wipes, resets, and
* getting access to data sources during a sync.
*/
let TabSendURLKey = "TabSendURL"
let TabSendTitleKey = "TabSendTitle"
let TabSendCategory = "TabSendCategory"
enum SentTabAction: String {
case View = "TabSendViewAction"
case Bookmark = "TabSendBookmarkAction"
case ReadingList = "TabSendReadingListAction"
}
class BrowserProfileSyncDelegate: SyncDelegate {
let app: UIApplication
init(app: UIApplication) {
self.app = app
}
// SyncDelegate
func displaySentTabForURL(URL: NSURL, title: String) {
// check to see what the current notification settings are and only try and send a notification if
// the user has agreed to them
let currentSettings = app.currentUserNotificationSettings()
if currentSettings.types.rawValue & UIUserNotificationType.Alert.rawValue != 0 {
log.info("Displaying notification for URL \(URL.absoluteString)")
let notification = UILocalNotification()
notification.fireDate = NSDate()
notification.timeZone = NSTimeZone.defaultTimeZone()
notification.alertBody = String(format: NSLocalizedString("New tab: %@: %@", comment:"New tab [title] [url]"), title, URL.absoluteString!)
notification.userInfo = [TabSendURLKey: URL.absoluteString!, TabSendTitleKey: title]
notification.alertAction = nil
notification.category = TabSendCategory
app.presentLocalNotificationNow(notification)
}
}
}
/**
* A Profile manages access to the user's data.
*/
protocol Profile: class {
var bookmarks: protocol<BookmarksModelFactory, ShareToDestination> { get }
// var favicons: Favicons { get }
var prefs: Prefs { get }
var queue: TabQueue { get }
var searchEngines: SearchEngines { get }
var files: FileAccessor { get }
var history: protocol<BrowserHistory, SyncableHistory> { get }
var favicons: Favicons { get }
var readingList: ReadingListService? { get }
var logins: protocol<BrowserLogins, SyncableLogins> { get }
func shutdown()
// I got really weird EXC_BAD_ACCESS errors on a non-null reference when I made this a getter.
// Similar to <http://stackoverflow.com/questions/26029317/exc-bad-access-when-indirectly-accessing-inherited-member-in-swift>.
func localName() -> String
// URLs and account configuration.
var accountConfiguration: FirefoxAccountConfiguration { get }
// Do we have an account at all?
func hasAccount() -> Bool
// Do we have an account that (as far as we know) is in a syncable state?
func hasSyncableAccount() -> Bool
func getAccount() -> FirefoxAccount?
func removeAccount()
func setAccount(account: FirefoxAccount)
func getClients() -> Deferred<Result<[RemoteClient]>>
func getClientsAndTabs() -> Deferred<Result<[ClientAndTabs]>>
func getCachedClientsAndTabs() -> Deferred<Result<[ClientAndTabs]>>
func storeTabs(tabs: [RemoteTab]) -> Deferred<Result<Int>>
func sendItems(items: [ShareItem], toClients clients: [RemoteClient])
var syncManager: SyncManager { get }
}
public class BrowserProfile: Profile {
private let name: String
weak private var app: UIApplication?
init(localName: String, app: UIApplication?) {
self.name = localName
self.app = app
let notificationCenter = NSNotificationCenter.defaultCenter()
let mainQueue = NSOperationQueue.mainQueue()
notificationCenter.addObserver(self, selector: Selector("onLocationChange:"), name: "LocationChange", object: nil)
if let baseBundleIdentifier = ExtensionUtils.baseBundleIdentifier() {
KeychainWrapper.serviceName = baseBundleIdentifier
} else {
log.error("Unable to get the base bundle identifier. Keychain data will not be shared.")
}
// If the profile dir doesn't exist yet, this is first run (for this profile).
if !files.exists("") {
log.info("New profile. Removing old account data.")
removeAccount()
prefs.clearAll()
}
}
// Extensions don't have a UIApplication.
convenience init(localName: String) {
self.init(localName: localName, app: nil)
}
func shutdown() {
if dbCreated {
db.close()
}
if loginsDBCreated {
loginsDB.close()
}
}
@objc
func onLocationChange(notification: NSNotification) {
if let v = notification.userInfo!["visitType"] as? Int,
let visitType = VisitType(rawValue: v),
let url = notification.userInfo!["url"] as? NSURL where !isIgnoredURL(url),
let title = notification.userInfo!["title"] as? NSString {
// We don't record a visit if no type was specified -- that means "ignore me".
let site = Site(url: url.absoluteString!, title: title as String)
let visit = SiteVisit(site: site, date: NSDate.nowMicroseconds(), type: visitType)
log.debug("Recording visit for \(url) with type \(v).")
history.addLocalVisit(visit)
} else {
let url = notification.userInfo!["url"] as? NSURL
log.debug("Ignoring navigation for \(url).")
}
}
deinit {
self.syncManager.endTimedSyncs()
NSNotificationCenter.defaultCenter().removeObserver(self)
}
func localName() -> String {
return name
}
var files: FileAccessor {
return ProfileFileAccessor(profile: self)
}
lazy var queue: TabQueue = {
return SQLiteQueue(db: self.db)
}()
private var dbCreated = false
lazy var db: BrowserDB = {
self.dbCreated = true
return BrowserDB(filename: "browser.db", files: self.files)
}()
/**
* Favicons, history, and bookmarks are all stored in one intermeshed
* collection of tables.
*/
private lazy var places: protocol<BrowserHistory, Favicons, SyncableHistory> = {
return SQLiteHistory(db: self.db)!
}()
var favicons: Favicons {
return self.places
}
var history: protocol<BrowserHistory, SyncableHistory> {
return self.places
}
lazy var bookmarks: protocol<BookmarksModelFactory, ShareToDestination> = {
return SQLiteBookmarks(db: self.db)
}()
lazy var searchEngines: SearchEngines = {
return SearchEngines(prefs: self.prefs)
}()
func makePrefs() -> Prefs {
return NSUserDefaultsPrefs(prefix: self.localName())
}
lazy var prefs: Prefs = {
return self.makePrefs()
}()
lazy var readingList: ReadingListService? = {
return ReadingListService(profileStoragePath: self.files.rootPath)
}()
private lazy var remoteClientsAndTabs: RemoteClientsAndTabs = {
return SQLiteRemoteClientsAndTabs(db: self.db)
}()
lazy var syncManager: SyncManager = {
return BrowserSyncManager(profile: self)
}()
private func getSyncDelegate() -> SyncDelegate {
if let app = self.app {
return BrowserProfileSyncDelegate(app: app)
}
return CommandStoringSyncDelegate()
}
public func getClients() -> Deferred<Result<[RemoteClient]>> {
return self.syncManager.syncClients()
>>> { self.remoteClientsAndTabs.getClients() }
}
public func getClientsAndTabs() -> Deferred<Result<[ClientAndTabs]>> {
return self.syncManager.syncClientsThenTabs()
>>> { self.remoteClientsAndTabs.getClientsAndTabs() }
}
public func getCachedClientsAndTabs() -> Deferred<Result<[ClientAndTabs]>> {
return self.remoteClientsAndTabs.getClientsAndTabs()
}
func storeTabs(tabs: [RemoteTab]) -> Deferred<Result<Int>> {
return self.remoteClientsAndTabs.insertOrUpdateTabs(tabs)
}
public func sendItems(items: [ShareItem], toClients clients: [RemoteClient]) {
let commands = items.map { item in
SyncCommand.fromShareItem(item, withAction: "displayURI")
}
self.remoteClientsAndTabs.insertCommands(commands, forClients: clients) >>> { self.syncManager.syncClients() }
}
lazy var logins: protocol<BrowserLogins, SyncableLogins> = {
return SQLiteLogins(db: self.loginsDB)
}()
private lazy var loginsKey: String? = {
let key = "sqlcipher.key.logins.db"
if KeychainWrapper.hasValueForKey(key) {
return KeychainWrapper.stringForKey(key)
}
let Length: UInt = 256
let secret = Bytes.generateRandomBytes(Length).base64EncodedString
KeychainWrapper.setString(secret, forKey: key)
return secret
}()
private var loginsDBCreated = false
private lazy var loginsDB: BrowserDB = {
self.loginsDBCreated = true
return BrowserDB(filename: "logins.db", secretKey: self.loginsKey, files: self.files)
}()
let accountConfiguration: FirefoxAccountConfiguration = ProductionFirefoxAccountConfiguration()
private lazy var account: FirefoxAccount? = {
if let dictionary = KeychainWrapper.objectForKey(self.name + ".account") as? [String: AnyObject] {
return FirefoxAccount.fromDictionary(dictionary)
}
return nil
}()
func hasAccount() -> Bool {
return account != nil
}
func hasSyncableAccount() -> Bool {
return account?.actionNeeded == FxAActionNeeded.None
}
func getAccount() -> FirefoxAccount? {
return account
}
func removeAccount() {
let old = self.account
prefs.removeObjectForKey(PrefsKeys.KeyLastRemoteTabSyncTime)
KeychainWrapper.removeObjectForKey(name + ".account")
self.account = nil
// tell any observers that our account has changed
NSNotificationCenter.defaultCenter().postNotificationName(NotificationFirefoxAccountChanged, object: nil)
// Trigger cleanup. Pass in the account in case we want to try to remove
// client-specific data from the server.
self.syncManager.onRemovedAccount(old)
// deregister for remote notifications
app?.unregisterForRemoteNotifications()
}
func setAccount(account: FirefoxAccount) {
KeychainWrapper.setObject(account.asDictionary(), forKey: name + ".account")
self.account = account
// register for notifications for the account
registerForNotifications()
// tell any observers that our account has changed
NSNotificationCenter.defaultCenter().postNotificationName(NotificationFirefoxAccountChanged, object: nil)
self.syncManager.onAddedAccount()
}
func registerForNotifications() {
let viewAction = UIMutableUserNotificationAction()
viewAction.identifier = SentTabAction.View.rawValue
viewAction.title = NSLocalizedString("View", comment: "View a URL - https://bugzilla.mozilla.org/attachment.cgi?id=8624438, https://bug1157303.bugzilla.mozilla.org/attachment.cgi?id=8624440")
viewAction.activationMode = UIUserNotificationActivationMode.Foreground
viewAction.destructive = false
viewAction.authenticationRequired = false
let bookmarkAction = UIMutableUserNotificationAction()
bookmarkAction.identifier = SentTabAction.Bookmark.rawValue
bookmarkAction.title = NSLocalizedString("Bookmark", comment: "Bookmark a URL - https://bugzilla.mozilla.org/attachment.cgi?id=8624438, https://bug1157303.bugzilla.mozilla.org/attachment.cgi?id=8624440")
bookmarkAction.activationMode = UIUserNotificationActivationMode.Foreground
bookmarkAction.destructive = false
bookmarkAction.authenticationRequired = false
let readingListAction = UIMutableUserNotificationAction()
readingListAction.identifier = SentTabAction.ReadingList.rawValue
readingListAction.title = NSLocalizedString("Add to Reading List", comment: "Add URL to the reading list - https://bugzilla.mozilla.org/attachment.cgi?id=8624438, https://bug1157303.bugzilla.mozilla.org/attachment.cgi?id=8624440")
readingListAction.activationMode = UIUserNotificationActivationMode.Foreground
readingListAction.destructive = false
readingListAction.authenticationRequired = false
let sentTabsCategory = UIMutableUserNotificationCategory()
sentTabsCategory.identifier = TabSendCategory
sentTabsCategory.setActions([readingListAction, bookmarkAction, viewAction], forContext: UIUserNotificationActionContext.Default)
sentTabsCategory.setActions([bookmarkAction, viewAction], forContext: UIUserNotificationActionContext.Minimal)
app?.registerUserNotificationSettings(UIUserNotificationSettings(forTypes: UIUserNotificationType.Alert, categories: [sentTabsCategory]))
app?.registerForRemoteNotifications()
}
// Extends NSObject so we can use timers.
class BrowserSyncManager: NSObject, SyncManager {
unowned private let profile: BrowserProfile
let FifteenMinutes = NSTimeInterval(60 * 15)
let OneMinute = NSTimeInterval(60)
private var syncTimer: NSTimer? = nil
/**
* Locking is managed by withSyncInputs. Make sure you take and release these
* whenever you do anything Sync-ey.
*/
var syncLock = OSSpinLock()
private func beginSyncing() -> Bool {
return OSSpinLockTry(&syncLock)
}
private func endSyncing() {
return OSSpinLockUnlock(&syncLock)
}
init(profile: BrowserProfile) {
self.profile = profile
super.init()
let center = NSNotificationCenter.defaultCenter()
center.addObserver(self, selector: "onLoginDidChange:", name: NotificationDataLoginDidChange, object: nil)
}
deinit {
// Remove 'em all.
NSNotificationCenter.defaultCenter().removeObserver(self)
}
// Simple in-memory rate limiting.
var lastTriggeredLoginSync: Timestamp = 0
@objc func onLoginDidChange(notification: NSNotification) {
log.debug("Login did change.")
if (NSDate.now() - lastTriggeredLoginSync) > OneMinuteInMilliseconds {
lastTriggeredLoginSync = NSDate.now()
// Give it a few seconds.
let when: dispatch_time_t = dispatch_time(DISPATCH_TIME_NOW, SyncConstants.SyncDelayTriggered)
// Trigger on the main queue. The bulk of the sync work runs in the background.
dispatch_after(when, dispatch_get_main_queue()) {
self.syncLogins()
}
}
}
var prefsForSync: Prefs {
return self.profile.prefs.branch("sync")
}
func onAddedAccount() -> Success {
return self.syncEverything()
}
func onRemovedAccount(account: FirefoxAccount?) -> Success {
let h: SyncableHistory = self.profile.history
let flagHistory = h.onRemovedAccount()
let clearTabs = self.profile.remoteClientsAndTabs.onRemovedAccount()
let done = allSucceed(flagHistory, clearTabs)
// Clear prefs after we're done clearing everything else -- just in case
// one of them needs the prefs and we race. Clear regardless of success
// or failure.
done.upon { result in
// This will remove keys from the Keychain if they exist, as well
// as wiping the Sync prefs.
SyncStateMachine.clearStateFromPrefs(self.prefsForSync)
}
return done
}
private func repeatingTimerAtInterval(interval: NSTimeInterval, selector: Selector) -> NSTimer {
return NSTimer.scheduledTimerWithTimeInterval(interval, target: self, selector: selector, userInfo: nil, repeats: true)
}
func beginTimedSyncs() {
if self.syncTimer != nil {
log.debug("Already running sync timer.")
return
}
let interval = FifteenMinutes
let selector = Selector("syncOnTimer")
log.debug("Starting sync timer.")
self.syncTimer = repeatingTimerAtInterval(interval, selector: selector)
}
/**
* The caller is responsible for calling this on the same thread on which it called
* beginTimedSyncs.
*/
func endTimedSyncs() {
if let t = self.syncTimer {
log.debug("Stopping sync timer.")
self.syncTimer = nil
t.invalidate()
}
}
private func syncClientsWithDelegate(delegate: SyncDelegate, prefs: Prefs, ready: Ready) -> SyncResult {
log.debug("Syncing clients to storage.")
let clientSynchronizer = ready.synchronizer(ClientsSynchronizer.self, delegate: delegate, prefs: prefs)
return clientSynchronizer.synchronizeLocalClients(self.profile.remoteClientsAndTabs, withServer: ready.client, info: ready.info)
}
private func syncTabsWithDelegate(delegate: SyncDelegate, prefs: Prefs, ready: Ready) -> SyncResult {
let storage = self.profile.remoteClientsAndTabs
let tabSynchronizer = ready.synchronizer(TabsSynchronizer.self, delegate: delegate, prefs: prefs)
return tabSynchronizer.synchronizeLocalTabs(storage, withServer: ready.client, info: ready.info)
}
private func syncHistoryWithDelegate(delegate: SyncDelegate, prefs: Prefs, ready: Ready) -> SyncResult {
log.debug("Syncing history to storage.")
let historySynchronizer = ready.synchronizer(HistorySynchronizer.self, delegate: delegate, prefs: prefs)
return historySynchronizer.synchronizeLocalHistory(self.profile.history, withServer: ready.client, info: ready.info)
}
private func syncLoginsWithDelegate(delegate: SyncDelegate, prefs: Prefs, ready: Ready) -> SyncResult {
log.debug("Syncing logins to storage.")
let loginsSynchronizer = ready.synchronizer(LoginsSynchronizer.self, delegate: delegate, prefs: prefs)
return loginsSynchronizer.synchronizeLocalLogins(self.profile.logins, withServer: ready.client, info: ready.info)
}
/**
* Returns nil if there's no account.
*/
private func withSyncInputs<T>(label: EngineIdentifier? = nil, function: (SyncDelegate, Prefs, Ready) -> Deferred<Result<T>>) -> Deferred<Result<T>>? {
if let account = profile.account {
if !beginSyncing() {
log.info("Not syncing \(label); already syncing something.")
return deferResult(AlreadySyncingError())
}
if let label = label {
log.info("Syncing \(label).")
}
let authState = account.syncAuthState
let syncPrefs = profile.prefs.branch("sync")
let readyDeferred = SyncStateMachine.toReady(authState, prefs: syncPrefs)
let delegate = profile.getSyncDelegate()
let go = readyDeferred >>== { ready in
function(delegate, syncPrefs, ready)
}
// Always unlock when we're done.
go.upon({ res in self.endSyncing() })
return go
}
log.warning("No account; can't sync.")
return nil
}
/**
* Runs the single provided synchronization function and returns its status.
*/
private func sync(label: EngineIdentifier, function: (SyncDelegate, Prefs, Ready) -> SyncResult) -> SyncResult {
return self.withSyncInputs(label: label, function: function) ??
deferResult(.NotStarted(.NoAccount))
}
/**
* Runs each of the provided synchronization functions with the same inputs.
* Returns an array of IDs and SyncStatuses the same length as the input.
*/
private func syncSeveral(synchronizers: (EngineIdentifier, SyncFunction)...) -> Deferred<Result<[(EngineIdentifier, SyncStatus)]>> {
typealias Pair = (EngineIdentifier, SyncStatus)
let combined: (SyncDelegate, Prefs, Ready) -> Deferred<Result<[Pair]>> = { delegate, syncPrefs, ready in
let thunks = synchronizers.map { (i, f) in
return { () -> Deferred<Result<Pair>> in
log.debug("Syncing \(i)…")
return f(delegate, syncPrefs, ready) >>== { deferResult((i, $0)) }
}
}
return accumulate(thunks)
}
return self.withSyncInputs(label: nil, function: combined) ??
deferResult(synchronizers.map { ($0.0, .NotStarted(.NoAccount)) })
}
func syncEverything() -> Success {
return self.syncSeveral(
("clients", self.syncClientsWithDelegate),
("tabs", self.syncTabsWithDelegate),
("logins", self.syncLoginsWithDelegate),
("history", self.syncHistoryWithDelegate)
) >>> succeed
}
@objc func syncOnTimer() {
log.debug("Running timed logins sync.")
// Note that we use .upon here rather than chaining with >>> precisely
// to allow us to sync subsequent engines regardless of earlier failures.
// We don't fork them in parallel because we want to limit perf impact
// due to background syncs, and because we're cautious about correctness.
self.syncLogins().upon { result in
if let success = result.successValue {
log.debug("Timed logins sync succeeded. Status: \(success.description).")
} else {
let reason = result.failureValue?.description ?? "none"
log.debug("Timed logins sync failed. Reason: \(reason).")
}
log.debug("Running timed history sync.")
self.syncHistory().upon { result in
if let success = result.successValue {
log.debug("Timed history sync succeeded. Status: \(success.description).")
} else {
let reason = result.failureValue?.description ?? "none"
log.debug("Timed history sync failed. Reason: \(reason).")
}
}
}
}
func syncClients() -> SyncResult {
// TODO: recognize .NotStarted.
return self.sync("clients", function: syncClientsWithDelegate)
}
func syncClientsThenTabs() -> SyncResult {
return self.syncSeveral(
("clients", self.syncClientsWithDelegate),
("tabs", self.syncTabsWithDelegate)
) >>== { statuses in
let tabsStatus = statuses[1].1
return deferResult(tabsStatus)
}
}
func syncLogins() -> SyncResult {
return self.sync("logins", function: syncLoginsWithDelegate)
}
func syncHistory() -> SyncResult {
// TODO: recognize .NotStarted.
return self.sync("history", function: syncHistoryWithDelegate)
}
}
}
class AlreadySyncingError: ErrorType {
var description: String {
return "Already syncing."
}
}
| mpl-2.0 | ceee1e90ddf0eb28704ff4e7afab3427 | 37.425 | 238 | 0.641471 | 5.26582 | false | false | false | false |
changjiashuai/AudioKit | Tests/Tests/AKLinearADSREnvelope.swift | 14 | 955 | //
// main.swift
// AudioKit
//
// Created by Aurelius Prochazka and Nick Arner on 12/29/14.
// Copyright (c) 2014 Aurelius Prochazka. All rights reserved.
//
import Foundation
let testDuration: NSTimeInterval = 10.0
class Instrument : AKInstrument {
override init() {
super.init()
let adsr = AKLinearADSREnvelope()
enableParameterLog("ADSR value = ", parameter: adsr, timeInterval:0.02)
let oscillator = AKOscillator()
oscillator.amplitude = adsr
setAudioOutput(oscillator)
}
}
AKOrchestra.testForDuration(testDuration)
let instrument = Instrument()
AKOrchestra.addInstrument(instrument)
let note1 = AKNote()
let note2 = AKNote()
let phrase = AKPhrase()
phrase.addNote(note1, atTime:0.5)
phrase.stopNote(note1, atTime: 2.5)
note2.duration.floatValue = 5.0
phrase.addNote(note2, atTime:3.5)
instrument.playPhrase(phrase)
NSThread.sleepForTimeInterval(NSTimeInterval(testDuration))
| mit | 9c2d8a7a3792c34cc8bfb63668dcc79c | 20.222222 | 79 | 0.717277 | 3.913934 | false | true | false | false |
tuannme/Up | Up+/Pods/NVActivityIndicatorView/NVActivityIndicatorView/Animations/NVActivityIndicatorAnimationBallZigZag.swift | 2 | 3650 | //
// NVActivityIndicatorAnimationBallZigZag.swift
// NVActivityIndicatorViewDemo
//
// 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
import QuartzCore
class NVActivityIndicatorAnimationBallZigZag: NVActivityIndicatorAnimationDelegate {
func setUpAnimation(in layer: CALayer, size: CGSize, color: UIColor) {
let circleSize: CGFloat = size.width / 5
let duration: CFTimeInterval = 0.7
let deltaX = size.width / 2 - circleSize / 2
let deltaY = size.height / 2 - circleSize / 2
let frame = CGRect(x: (layer.bounds.size.width - circleSize) / 2, y: (layer.bounds.size.height - circleSize) / 2, width: circleSize, height: circleSize)
// Circle 1 animation
let animation = CAKeyframeAnimation(keyPath:"transform")
animation.keyTimes = [0.0, 0.33, 0.66, 1.0]
animation.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
animation.values = [NSValue(caTransform3D: CATransform3DMakeTranslation(0, 0, 0)),
NSValue(caTransform3D: CATransform3DMakeTranslation(-deltaX, -deltaY, 0)),
NSValue(caTransform3D: CATransform3DMakeTranslation(deltaX, -deltaY, 0)),
NSValue(caTransform3D: CATransform3DMakeTranslation(0, 0, 0))]
animation.duration = duration
animation.repeatCount = HUGE
animation.isRemovedOnCompletion = false
// Draw circle 1
circleAt(frame: frame, layer: layer, size: CGSize(width: circleSize, height: circleSize), color: color, animation: animation)
// Circle 2 animation
animation.values = [NSValue(caTransform3D: CATransform3DMakeTranslation(0, 0, 0)),
NSValue(caTransform3D: CATransform3DMakeTranslation(deltaX, deltaY, 0)),
NSValue(caTransform3D: CATransform3DMakeTranslation(-deltaX, deltaY, 0)),
NSValue(caTransform3D: CATransform3DMakeTranslation(0, 0, 0))]
// Draw circle 2
circleAt(frame: frame, layer: layer, size: CGSize(width: circleSize, height: circleSize), color: color, animation: animation)
}
func circleAt(frame: CGRect, layer: CALayer, size: CGSize, color: UIColor, animation: CAAnimation) {
let circle = NVActivityIndicatorShape.circle.layerWith(size: size, color: color)
circle.frame = frame
circle.add(animation, forKey: "animation")
layer.addSublayer(circle)
}
}
| mit | 9cf454af13f3c28d7fdb75f529ea8f4d | 48.324324 | 160 | 0.684384 | 4.860186 | false | false | false | false |
nathantannar4/NTComponents | NTComponents/Extensions/Int.swift | 1 | 3613 | //
// Int.swift
// NTComponents
//
// Copyright © 2017 Nathan Tannar.
//
// 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.
//
// Created by Nathan Tannar on 6/26/17.
//
public extension Int {
public var cgFloat: CGFloat {
return CGFloat(self)
}
/**
Return a random number between `min` and `max`.
- note: The maximum value cannot be more than `UInt32.max - 1`
- parameter min: The minimum value of the random value (defaults to `0`).
- parameter max: The maximum value of the random value (defaults to `UInt32.max - 1`)
- returns: Returns a random value between `min` and `max`.
*/
public static func random(min : Int = 0, max : Int = Int.max) -> Int {
precondition(min <= max, "attempt to call random() with min > max")
let diff = UInt(bitPattern: max &- min)
let result = UInt.random(min: 0, max: diff)
return min + Int(bitPattern: result)
}
/**
Return a random number with exactly `digits` digits.
- parameter digits: The number of digits the random number should have.
- returns: Returns a random number with exactly `digits` digits.
*/
public static func number(digits : Int? = nil) -> Int {
let nbDigits = digits != nil ? digits! : Int.random(min: 1, max: 9)
let maximum = pow(10, Double(nbDigits)) - 1
let result = Int.random(min: Int(pow(10, Double(nbDigits - 1))), max: Int(maximum))
return result
}
public func randomize(variation : Int) -> Int {
let multiplier = Double(Int.random(min: 100 - variation, max: 100 + variation)) / 100
let randomized = Double(self) * multiplier
return Int(randomized) + 1
}
}
private extension UInt {
static func random(min : UInt, max : UInt) -> UInt {
precondition(min <= max, "attempt to call random() with min > max")
if min == UInt.min && max == UInt.max {
var result : UInt = 0
arc4random_buf(&result, MemoryLayout.size(ofValue: result))
return result
} else {
let range = max - min + 1
let limit = UInt.max - UInt.max % range
var result : UInt = 0
repeat {
arc4random_buf(&result, MemoryLayout.size(ofValue: result))
} while result >= limit
result = result % range
return min + result
}
}
}
| mit | 6927d76108503f44994c050b51619d70 | 35.12 | 93 | 0.611019 | 4.325749 | false | false | false | false |
softwarenerd/Stately | Stately/Code/Event.swift | 1 | 4356 | //
// Event.swift
// Stately
//
// Created by Brian Lambert on 10/4/16.
// See the LICENSE.md file in the project root for license information.
//
import Foundation
// Types alias for a transition tuple.
public typealias Transition = (fromState: State?, toState: State)
// Event error enumeration.
public enum EventError: Error {
case NameEmpty
case NoTransitions
case DuplicateTransition(fromState: State)
case MultipleWildcardTransitions
}
// Event class.
public class Event : Hashable {
// The name of the event.
public let name: String
// The set of transitions for the event.
let transitions: [Transition]
// The wildcard transition.
let wildcardTransition: Transition?
/// Initializes a new instance of the Event class.
///
/// - Parameters:
/// - name: The name of the event. Each event must have a unique name.
/// - transitions: The transitions for the event. An event must define at least one transition.
/// A transition with a from state of nil is the wildcard transition and will match any from
/// state. Only one wildcard transition may defined for an event.
public init(name nameIn: String, transitions transitionsIn: [Transition]) throws {
// Validate the event name.
if nameIn.isEmpty {
throw EventError.NameEmpty
}
// At least one transition must be specified.
if transitionsIn.count == 0 {
throw EventError.NoTransitions
}
// Ensure that there are no duplicate from state transitions defined. (While this wouldn't strictly
// be a bad thing, the presence of duplicate from state transitions more than likely indicates that
// there is a bug in the definition of the state machine, so we don't allow it.) Also, there can be
// only one wildcard transition (a transition with a nil from state) defined.
var wildcardTransitionTemp: Transition? = nil
var fromStatesTemp = Set<State>(minimumCapacity: transitionsIn.count)
for transition in transitionsIn {
// See if there's a from state. If there is, ensure it's not a duplicate. If there isn't, then
// ensure there is only one wildcard transition.
if let fromState = transition.fromState {
if fromStatesTemp.contains(fromState) {
throw EventError.DuplicateTransition(fromState: fromState)
} else {
fromStatesTemp.insert(fromState)
}
} else {
if wildcardTransitionTemp != nil {
throw EventError.MultipleWildcardTransitions
} else {
wildcardTransitionTemp = transition
}
}
}
// Initialize.
name = nameIn
transitions = transitionsIn
wildcardTransition = wildcardTransitionTemp
}
/// Returns the transition with the specified from state, if one is found; otherwise, nil.
///
/// - Parameters:
/// - fromState: The from state.
func transition(fromState: State) -> State? {
// Find the transition. If it cannot be found, and there's a wildcard transition, return its to state.
// Otherwise, nil will be returned.
guard let transition = (transitions.first(where: { (transition: Transition) -> Bool in return transition.fromState === fromState })) else {
return wildcardTransition?.toState
}
// Return the to state.
return transition.toState;
}
/// Gets the hash value.
///
/// Hash values are not guaranteed to be equal across different executions of
/// your program. Do not save hash values to use during a future execution.
public var hashValue: Int {
get {
return name.hashValue
}
}
/// Returns a Boolean value indicating whether two values are equal.
///
/// Equality is the inverse of inequality. For any values `a` and `b`,
/// `a == b` implies that `a != b` is `false`.
///
/// - Parameters:
/// - lhs: A value to compare.
/// - rhs: Another value to compare.
public static func ==(lhs: Event, rhs: Event) -> Bool {
return lhs === rhs
}
}
| mit | d97aba94b6f12d28ac080f665f7712a0 | 36.230769 | 147 | 0.618916 | 4.87794 | false | false | false | false |
iPantry/iPantry-iOS | Pantry/Models/Item.swift | 1 | 4398 | //
// Item.swift
// Pantry
//
// Created by Justin Oroz on 7/29/17.
// Copyright © 2017 Justin Oroz. All rights reserved.
//
import Foundation
import Alamofire
import FirebaseAuth
struct Item {
///
let ean: String
public let suggestions: FirebaseSuggestions
public let UPCResults: [UPCDatabaseItem]
private var modified = FireDictionary()
public var UPCResultIndex = 0
private(set) var expirationEstimate: Int?
public var selectedUPCResult: UPCDatabaseItem? {
guard UPCResults.count > 0 else {
return nil
}
return UPCResults[UPCResultIndex]
}
/// Returns data which can be sent to Firebase
var data: FireDictionary {
return modified
}
var title: String? {
get {
if let userItem = self.modified["title"] as? String {
return userItem
} else if !self.UPCResults.isEmpty, let upcItem = self.UPCResults[UPCResultIndex].title {
return upcItem
} else {
return nil
}
}
set {
self.modified["title"] = newValue
}
}
var description: String? {
get {
if let userItem = self.modified["description"] as? String {
return userItem
} else if !self.UPCResults.isEmpty, let upcItem = self.UPCResults[UPCResultIndex].description {
return upcItem
} else {
return nil
}
}
set {
self.modified["description"] = newValue
}
}
var quantity: UInt? {
return self.modified["quantity"] as? UInt
}
var purchasedDate: String? {
return self.modified["purchasedDate"] as? String
}
var weight: String? {
get {
if let userItem = self.modified["weight"] as? String {
return userItem
} else if !self.UPCResults.isEmpty, let upcItem = self.UPCResults[UPCResultIndex].weight {
return upcItem
} else {
return nil
}
}
set {
self["size"] = newValue
}
}
var size: String? {
get {
if let userItem = self.modified["size"] as? String {
return userItem
} else if !self.UPCResults.isEmpty, let upcItem = self.UPCResults[UPCResultIndex].size {
return upcItem
} else {
return nil
}
}
set {
self["size"] = newValue
}
}
// init from firebase and possible upcdb data
init(_ ean: String, _ suggestions: FirebaseSuggestions? = nil, _ upcData: [UPCDatabaseItem]? = nil) {
self.ean = ean
self.suggestions = suggestions ?? FirebaseSuggestions()
self.UPCResults = upcData ?? [UPCDatabaseItem]()
}
subscript(index: String) -> FireValue? {
get {
let upcInfo = (UPCResults.count > 0) ? UPCResults[UPCResultIndex] : nil
return modified[index] ?? upcInfo?[index] as? FireValue
}
set(newValue) { //can only modify string: values
if newValue == nil {
modified[index] = newValue
return
}
// UPC results are empty, save the data
if UPCResults.count == 0 {
modified[index] = newValue
return
}
// if not in UPC results
if UPCResults[UPCResultIndex][index] == nil {
modified[index] = newValue
return
}
switch newValue!.type {
case .bool(let val):
if UPCResults[UPCResultIndex][index] as? Bool != val {
modified[index] = val
} else {
// do not allow uploading of same data
modified[index] = nil
}
case .string(let val):
if UPCResults[UPCResultIndex][index] as? String != val {
modified[index] = val
} else {
modified[index] = nil
}
default:
return
}
}
}
static func lookup(by UPC: String, completion: ((Item?, Error?) -> Void)?) {
let dispatch = DispatchGroup()
var upcData = [UPCDatabaseItem]()
var firebaseSuggestions = FirebaseSuggestions()
var itemError: Error?
// TODO: Return Item instead
dispatch.enter()
UPCDB.current.lookup(by: UPC, returned: { (data, error) in
defer { dispatch.leave() }
guard error == nil,
data != nil
else {
itemError = error
//completion?(nil, itemError)
return
}
upcData = data!
})
// TODO: Request Firebase Suggestions
dispatch.enter()
//firebaseData = ["": ""]
dispatch.leave()
// after both requests are complete
dispatch.notify(queue: DispatchQueue.global(qos: DispatchQoS.userInitiated.qosClass)) {
guard itemError == nil else {
completion?(nil, itemError)
return
}
let item = Item(UPC, firebaseSuggestions, upcData)
// If no data or suggestions, alert user
guard !firebaseSuggestions.isEmpty || upcData.count > 0 else {
completion?(nil, nil)
return
}
completion?(item, nil)
}
}
}
| agpl-3.0 | 27295201bfee8bba9f22cebb0d8a58ff | 20.985 | 102 | 0.654082 | 3.245018 | false | false | false | false |
zhuyunfeng1224/XiheMtxx | XiheMtxx/VC/EditImage/RotateCtrlView.swift | 1 | 12287 | //
// RotateCtrlView.swift
// XiheMtxx
//
// Created by echo on 2017/3/3.
// Copyright © 2017年 羲和. All rights reserved.
//
import UIKit
protocol RotateCtrlViewDelegate {
func rotateImageChanged() -> Void
}
class RotateCtrlView: UIView {
var delegate: RotateCtrlViewDelegate?
lazy var bgView: UIView = {
let _bgView = UIView(frame: CGRect(origin: CGPoint.zero, size: self.frame.size))
_bgView.backgroundColor = UIColor.colorWithHexString(hex: "#2c2e30")
_bgView.clipsToBounds = true
return _bgView
}()
lazy var imageView: UIImageView = {
let _imageView = UIImageView(frame: CGRect(origin: CGPoint.zero, size: self.frame.size))
_imageView.clipsToBounds = true
_imageView.contentMode = .scaleAspectFit
return _imageView
}()
lazy var clearMaskView: GrayView = {
let _maskView = GrayView(frame: CGRect(origin: CGPoint.zero, size: self.frame.size))
_maskView.clearFrame = CGRect(origin: CGPoint.zero, size: self.frame.size)
_maskView.isUserInteractionEnabled = false
return _maskView
}()
// 结束执行块
var dismissCompletation: ((UIImage) -> (Void))?
/// 原始图片
var originImage: UIImage? {
didSet {
self.imageView.image = originImage
self.image = originImage
}
}
/// 编辑后的图片
var image: UIImage? {
didSet {
self.imageView.image = image
}
}
var enlarged: Bool = false {
didSet {
UIView.animate(withDuration: 0.3) {
let signX = self.scale.width / fabs(self.scale.width)
let signY = self.scale.height / fabs(self.scale.height)
if self.enlarged {
let scale = self.imageViewScale()
self.scale = CGSize(width: signX * scale, height: signY * scale)
self.newImageTransform()
self.clearMaskView.clearFrame = self.imageView.bounds
}
else {
self.scale = CGSize(width: signX, height: signY)
self.newImageTransform()
let cutSize = self.imageView.bounds.size.applying(CGAffineTransform(scaleX: 1 / self.imageViewScale(), y: 1 / self.imageViewScale()))
self.clearMaskView.clearFrame = CGRect(x: self.imageView.center.x - cutSize.width/2,
y: self.imageView.center.y - cutSize.height/2,
width: cutSize.width,
height: cutSize.height)
}
}
}
}
/// 旋转角度
var rotation: CGFloat = 0.0
/// 缩放倍数
var scale: CGSize = CGSize(width: 1, height: 1)
/// 上一次拖动的位置
lazy var lastPosition = CGPoint.zero
override init(frame: CGRect) {
super.init(frame: frame)
self.isUserInteractionEnabled = true
self.addSubview(self.bgView)
self.bgView.addSubview(self.imageView)
self.bgView.addSubview(self.clearMaskView)
// 拖动手势
let panGesture = UIPanGestureRecognizer(target: self, action: #selector(panImage(gesture:)))
self.bgView.addGestureRecognizer(panGesture)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override var isHidden: Bool {
didSet {
if isHidden == true {
self.generateNewTransformImage()
}
}
}
func generateNewTransformImage() -> Void {
if self.image == nil {
return
}
// 生成剪切后的图片
if let cgImage = self.newTransformedImage(transform: self.imageView.transform,
sourceImage: (self.image?.cgImage)!,
imageSize: (self.image?.size)!) {
self.image = UIImage(cgImage: cgImage)
}
if let dismissCompletation = self.dismissCompletation {
dismissCompletation(self.image!)
self.rotation = 0
self.scale = CGSize(width: 1, height: 1)
self.imageView.transform = .identity
}
}
// MARK: Action Events
// 拖动手势响应
func panImage(gesture: UIPanGestureRecognizer) -> Void {
if gesture.state == .changed {
let origin = CGPoint(x: self.bgView.frame.size.width/2, y: self.bgView.frame.size.height/2)
let currentPosition = gesture.location(in: self.bgView)
let vectorA = CGPoint(x: lastPosition.x - origin.x, y: lastPosition.y - origin.y)
let vectorB = CGPoint(x: currentPosition.x - origin.x, y: currentPosition.y - origin.y)
// 向量a的模
let modA = sqrtf(powf(Float(vectorA.x), 2) + powf(Float(vectorA.y), 2))
// 向量b的模
let modB = sqrtf(powf(Float(vectorB.x), 2) + powf(Float(vectorB.y), 2))
// 向量a，b的点乘
let pointMuti = Float(vectorA.x * vectorB.x + vectorA.y * vectorB.y)
// 夹角
let angle = acos(pointMuti / (modA * modB))
// 叉乘求旋转方向，顺时针还是逆时针
let signX = Float(self.scale.width / fabs(self.scale.width))
let signY = Float(self.scale.height / fabs(self.scale.height))
let crossAB = vectorA.x * vectorB.y - vectorA.y * vectorB.x
let sign: Float = crossAB > 0.0 ? 1.0: -1.0
if !angle.isNaN && angle != 0.0 {
self.rotation += CGFloat(angle * sign * signX * signY)
self.newImageTransform()
self.clearMaskView.clearFrame = self.caculateCutRect()
}
}
else if gesture.state == .ended || gesture.state == .cancelled {
// 取消放大
self.enlarged = true
}
lastPosition = gesture.location(in: self.bgView)
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
// 点击缩小
if self.enlarged == true {
self.enlarged = false
}
}
override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
// 取消放大
self.enlarged = true
}
func rotateReset() -> Void {
self.rotation = 0
self.scale = CGSize(width: 1, height: 1)
self.image = self.originImage
UIView.animate(withDuration: 0.3) {
self.imageView.transform = .identity
}
}
func rotateLeft() -> Void {
self.rotation += CGFloat(-Float.pi / 2)
UIView.animate(withDuration: 0.3) {
self.newImageTransform()
}
}
func rotateRight() -> Void {
self.rotation += CGFloat(Float.pi / 2)
UIView.animate(withDuration: 0.3) {
self.newImageTransform()
}
}
func rotateHorizontalMirror() -> Void {
self.scale = CGSize(width: self.scale.width * -1, height: self.scale.height)
UIView.animate(withDuration: 0.3) {
self.newImageTransform()
}
}
func rotateVerticalnMirror() -> Void {
self.scale = CGSize(width: self.scale.width, height: self.scale.height * -1)
UIView.animate(withDuration: 0.3) {
self.newImageTransform()
}
}
func resetLayoutOfSubviews() -> Void {
let rect = self.imageRectToFit()
self.bgView.frame = rect
self.imageView.frame = self.bgView.bounds
self.clearMaskView.frame = self.bgView.bounds
self.clearMaskView.center = self.imageView.center
}
// MARK: Private Method
// 计算剪切区域
func caculateCutRect() -> CGRect {
let scale = self.enlarged ? self.imageViewScale() : 1 / self.imageViewScale()
let cutSize = self.imageView.bounds.size.applying(CGAffineTransform(scaleX: scale, y: scale))
let cutFrame = CGRect(x: self.imageView.center.x - cutSize.width/2,
y: self.imageView.center.y - cutSize.height/2,
width: cutSize.width,
height: cutSize.height)
return cutFrame
}
// 旋转之后图片放大的倍数
func imageViewScale() -> CGFloat {
let scaleX = self.imageView.frame.size.width / self.imageView.bounds.size.width
let scaleY = self.imageView.frame.size.height / self.imageView.bounds.size.height
let scale = fabsf(Float(scaleX)) > fabsf(Float(scaleY)) ? scaleX : scaleY
return scale
}
func newImageTransform() -> Void {
let transform = CGAffineTransform(rotationAngle: self.rotation)
let scaleTransform = CGAffineTransform(scaleX: self.scale.width, y: self.scale.height)
self.imageView.transform = transform.concatenating(scaleTransform)
if self.delegate != nil {
self.delegate?.rotateImageChanged()
}
}
/// create a new image according to transform and origin image
///
/// - Parameters:
/// - transform: the transform after image rotated
/// - sourceImage: sourceImage
/// - imageSize: size of sourceImage
/// - Returns: new Image
func newTransformedImage(transform: CGAffineTransform,
sourceImage:CGImage,
imageSize: CGSize) -> CGImage? {
// 计算旋转后图片的大小
let size = CGSize(width: imageSize.width * self.imageViewScale(), height: imageSize.height * self.imageViewScale())
// 创建画布
let context = CGContext.init(data: nil,
width: Int(imageSize.width),
height: Int(imageSize.height),
bitsPerComponent: sourceImage.bitsPerComponent,
bytesPerRow: 0,
space: sourceImage.colorSpace!,
bitmapInfo: sourceImage.bitmapInfo.rawValue)
context?.setFillColor(UIColor.clear.cgColor)
context?.fill(CGRect(origin: CGPoint.zero, size: imageSize))
// quartz旋转以左上角为中心，so 将画布移到右下角，旋转之后再向上移到原来位置
context?.translateBy(x: imageSize.width / 2, y: imageSize.height / 2)
context?.concatenate(transform.inverted())
context?.translateBy(x: -size.width / 2, y: -size.height / 2)
context?.draw(sourceImage, in: CGRect(x: 0,
y: 0,
width: size.width,
height: size.height))
let result = context?.makeImage()
assert(result != nil, "旋转图片剪切失败")
UIGraphicsEndImageContext()
return result!
}
func imageRectToFit() -> CGRect {
let rect = self.frame
// 原始图片View的尺寸
let originImageScale = (self.image?.size.width)!/(self.image?.size.height)!
let imageViewSize = rect.size
let imageViewScale = imageViewSize.width/imageViewSize.height
var imageSizeInView = imageViewSize
// 得出图片在ImageView中的尺寸
if imageViewScale <= originImageScale {
imageSizeInView = CGSize(width: imageViewSize.width, height: imageViewSize.width / originImageScale)
}
else {
imageSizeInView = CGSize(width: imageViewSize.height * originImageScale, height: imageViewSize.height)
}
let imageOriginInView = CGPoint(x: (rect.size.width - imageSizeInView.width)/2, y: (rect.size.height - imageSizeInView.height)/2)
return CGRect(origin: imageOriginInView, size: imageSizeInView)
}
}
| mit | 11c6ca923257b30c57b152ab6b128cd9 | 35.904025 | 153 | 0.553607 | 4.528875 | false | false | false | false |
radazzouz/firefox-ios | SyncTests/MockSyncServer.swift | 1 | 17774 | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import Foundation
import Shared
import GCDWebServers
import SwiftyJSON
@testable import Sync
import XCTest
private let log = Logger.syncLogger
private func optTimestamp(x: AnyObject?) -> Timestamp? {
guard let str = x as? String else {
return nil
}
return decimalSecondsStringToTimestamp(str)
}
private func optStringArray(x: AnyObject?) -> [String]? {
guard let str = x as? String else {
return nil
}
return str.components(separatedBy: ",").map { $0.trimmingCharacters(in:NSCharacterSet.whitespacesAndNewlines) }
}
private struct SyncRequestSpec {
let collection: String
let id: String?
let ids: [String]?
let limit: Int?
let offset: String?
let sort: SortOption?
let newer: Timestamp?
let full: Bool
static func fromRequest(request: GCDWebServerRequest) -> SyncRequestSpec? {
// Input is "/1.5/user/storage/collection", possibly with "/id" at the end.
// That means we get five or six path components here, the first being empty.
let parts = request.path!.components(separatedBy: "/").filter { !$0.isEmpty }
let id: String?
let query = request.query as! [String: AnyObject]
let ids = optStringArray(x: query["ids"])
let newer = optTimestamp(x: query["newer"])
let full: Bool = query["full"] != nil
let limit: Int?
if let lim = query["limit"] as? String {
limit = Int(lim)
} else {
limit = nil
}
let offset = query["offset"] as? String
let sort: SortOption?
switch query["sort"] as? String ?? "" {
case "oldest":
sort = SortOption.OldestFirst
case "newest":
sort = SortOption.NewestFirst
case "index":
sort = SortOption.Index
default:
sort = nil
}
if parts.count < 4 {
return nil
}
if parts[2] != "storage" {
return nil
}
// Use dropFirst, you say! It's buggy.
switch parts.count {
case 4:
id = nil
case 5:
id = parts[4]
default:
// Uh oh.
return nil
}
return SyncRequestSpec(collection: parts[3], id: id, ids: ids, limit: limit, offset: offset, sort: sort, newer: newer, full: full)
}
}
struct SyncDeleteRequestSpec {
let collection: String?
let id: GUID?
let ids: [GUID]?
let wholeCollection: Bool
static func fromRequest(request: GCDWebServerRequest) -> SyncDeleteRequestSpec? {
// Input is "/1.5/user{/storage{/collection{/id}}}".
// That means we get four, five, or six path components here, the first being empty.
return SyncDeleteRequestSpec.fromPath(path: request.path!, withQuery: request.query as! [NSString : AnyObject])
}
static func fromPath(path: String, withQuery query: [NSString: AnyObject]) -> SyncDeleteRequestSpec? {
let parts = path.components(separatedBy: "/").filter { !$0.isEmpty }
let queryIDs: [GUID]? = (query["ids"] as? String)?.components(separatedBy: ",")
guard [2, 4, 5].contains(parts.count) else {
return nil
}
if parts.count == 2 {
return SyncDeleteRequestSpec(collection: nil, id: nil, ids: queryIDs, wholeCollection: true)
}
if parts[2] != "storage" {
return nil
}
if parts.count == 4 {
let hasIDs = queryIDs != nil
return SyncDeleteRequestSpec(collection: parts[3], id: nil, ids: queryIDs, wholeCollection: !hasIDs)
}
return SyncDeleteRequestSpec(collection: parts[3], id: parts[4], ids: queryIDs, wholeCollection: false)
}
}
private struct SyncPutRequestSpec {
let collection: String
let id: String
static func fromRequest(request: GCDWebServerRequest) -> SyncPutRequestSpec? {
// Input is "/1.5/user/storage/collection/id}}}".
// That means we get six path components here, the first being empty.
let parts = request.path!.components(separatedBy: "/").filter { !$0.isEmpty }
guard parts.count == 5 else {
return nil
}
if parts[2] != "storage" {
return nil
}
return SyncPutRequestSpec(collection: parts[3], id: parts[4])
}
}
class MockSyncServer {
let server = GCDWebServer()
let username: String
var offsets: Int = 0
var continuations: [String: [EnvelopeJSON]] = [:]
var collections: [String: (modified: Timestamp, records: [String: EnvelopeJSON])] = [:]
var baseURL: String!
init(username: String) {
self.username = username
}
class func makeValidEnvelope(guid: GUID, modified: Timestamp) -> EnvelopeJSON {
let clientBody: [String: Any] = [
"id": guid,
"name": "Foobar",
"commands": [],
"type": "mobile",
]
let clientBodyString = JSON(object: clientBody).rawString()!
let clientRecord: [String : Any] = [
"id": guid,
"collection": "clients",
"payload": clientBodyString,
"modified": Double(modified) / 1000,
]
return EnvelopeJSON(JSON(object: clientRecord).rawString()!)
}
class func withHeaders(response: GCDWebServerResponse, lastModified: Timestamp? = nil, records: Int? = nil, timestamp: Timestamp? = nil) -> GCDWebServerResponse {
let timestamp = timestamp ?? Date.now()
let xWeaveTimestamp = millisecondsToDecimalSeconds(timestamp)
response.setValue("\(xWeaveTimestamp)", forAdditionalHeader: "X-Weave-Timestamp")
if let lastModified = lastModified {
let xLastModified = millisecondsToDecimalSeconds(lastModified)
response.setValue("\(xLastModified)", forAdditionalHeader: "X-Last-Modified")
}
if let records = records {
response.setValue("\(records)", forAdditionalHeader: "X-Weave-Records")
}
return response
}
func storeRecords(records: [EnvelopeJSON], inCollection collection: String, now: Timestamp? = nil) {
let now = now ?? Date.now()
let coll = self.collections[collection]
var out = coll?.records ?? [:]
records.forEach {
out[$0.id] = $0.withModified(now)
}
let newModified = max(now, coll?.modified ?? 0)
self.collections[collection] = (modified: newModified, records: out)
}
private func splitArray<T>(items: [T], at: Int) -> ([T], [T]) {
return (Array(items.dropLast(items.count - at)), Array(items.dropFirst(at)))
}
private func recordsMatchingSpec(spec: SyncRequestSpec) -> (records: [EnvelopeJSON], offsetID: String?)? {
// If we have a provided offset, handle that directly.
if let offset = spec.offset {
log.debug("Got provided offset \(offset).")
guard let remainder = self.continuations[offset] else {
log.error("Unknown offset.")
return nil
}
// Remove the old one.
self.continuations.removeValue(forKey: offset)
// Handle the smaller-than-limit or no-provided-limit cases.
guard let limit = spec.limit, limit < remainder.count else {
log.debug("Returning all remaining items.")
return (remainder, nil)
}
// Record the next continuation and return the first slice of records.
let next = "\(self.offsets)"
self.offsets += 1
let (returned, remaining) = splitArray(items: remainder, at: limit)
self.continuations[next] = remaining
log.debug("Returning \(limit) items; next continuation is \(next).")
return (returned, next)
}
guard let records = self.collections[spec.collection]?.records.values else {
// No matching records.
return ([], nil)
}
var items = Array(records)
log.debug("Got \(items.count) candidate records.")
if spec.newer ?? 0 > 0 {
items = items.filter { $0.modified > spec.newer! }
}
if let ids = spec.ids {
let ids = Set(ids)
items = items.filter { ids.contains($0.id) }
}
if let sort = spec.sort {
switch sort {
case SortOption.NewestFirst:
items = items.sorted { $0.modified > $1.modified }
log.debug("Sorted items newest first: \(items.map { $0.modified })")
case SortOption.OldestFirst:
items = items.sorted { $0.modified < $1.modified }
log.debug("Sorted items oldest first: \(items.map { $0.modified })")
case SortOption.Index:
log.warning("Index sorting not yet supported.")
}
}
if let limit = spec.limit, items.count > limit {
let next = "\(self.offsets)"
self.offsets += 1
let (returned, remaining) = splitArray(items: items, at: limit)
self.continuations[next] = remaining
return (returned, next)
}
return (items, nil)
}
private func recordResponse(record: EnvelopeJSON) -> GCDWebServerResponse {
let body = record.asJSON().rawString()!
let bodyData = body.utf8EncodedData
let response = GCDWebServerDataResponse(data: bodyData, contentType: "application/json")
return MockSyncServer.withHeaders(response: response!, lastModified: record.modified)
}
private func modifiedResponse(timestamp: Timestamp) -> GCDWebServerResponse {
let body = JSON(object: ["modified": timestamp]).rawString()
let bodyData = body?.utf8EncodedData
let response = GCDWebServerDataResponse(data: bodyData, contentType: "application/json")!
return MockSyncServer.withHeaders(response: response)
}
func modifiedTimeForCollection(collection: String) -> Timestamp? {
return self.collections[collection]?.modified
}
func removeAllItemsFromCollection(collection: String, atTime: Timestamp) {
if self.collections[collection] != nil {
self.collections[collection] = (atTime, [:])
}
}
func start() {
let basePath = "/1.5/\(self.username)"
let storagePath = "\(basePath)/storage/"
let infoCollectionsPath = "\(basePath)/info/collections"
server?.addHandler(forMethod: "GET", path: infoCollectionsPath, request: GCDWebServerRequest.self) { (request) -> GCDWebServerResponse! in
var ic = [String: Any]()
var lastModified: Timestamp = 0
for collection in self.collections.keys {
if let timestamp = self.modifiedTimeForCollection(collection: collection) {
ic[collection] = Double(timestamp) / 1000
lastModified = max(lastModified, timestamp)
}
}
let body = JSON(object: ic).rawString()
let bodyData = body?.utf8EncodedData
let response = GCDWebServerDataResponse(data: bodyData, contentType: "application/json")!
return MockSyncServer.withHeaders(response: response, lastModified: lastModified, records: ic.count)
}
let matchPut: GCDWebServerMatchBlock = { method, url, headers, path, query -> GCDWebServerRequest! in
guard method == "PUT",
path?.startsWith(basePath) ?? false else {
return nil
}
return GCDWebServerDataRequest(method: method, url: url, headers: headers, path: path, query: query)
}
server?.addHandler(match: matchPut) { (request) -> GCDWebServerResponse! in
guard let request = request as? GCDWebServerDataRequest else {
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(statusCode: 400))
}
guard let spec = SyncPutRequestSpec.fromRequest(request: request) else {
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(statusCode: 400))
}
var body = JSON(object: request.jsonObject)
body["modified"] = JSON(stringLiteral: millisecondsToDecimalSeconds(Date.now()))
let record = EnvelopeJSON(body)
self.storeRecords(records: [record], inCollection: spec.collection)
let timestamp = self.modifiedTimeForCollection(collection: spec.collection)!
let response = GCDWebServerDataResponse(data: millisecondsToDecimalSeconds(timestamp).utf8EncodedData, contentType: "application/json")
return MockSyncServer.withHeaders(response: response!)
}
let matchDelete: GCDWebServerMatchBlock = { method, url, headers, path, query -> GCDWebServerRequest! in
guard method == "DELETE" && (path?.startsWith(basePath))! else {
return nil
}
return GCDWebServerRequest(method: method, url: url, headers: headers, path: path, query: query)
}
server?.addHandler(match: matchDelete) { (request) -> GCDWebServerResponse! in
guard let spec = SyncDeleteRequestSpec.fromRequest(request: request!) else {
return GCDWebServerDataResponse(statusCode: 400)
}
if let collection = spec.collection, let id = spec.id {
guard var items = self.collections[collection]?.records else {
// Unable to find the requested collection.
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(statusCode: 404))
}
guard let item = items[id] else {
// Unable to find the requested id.
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(statusCode: 404))
}
items.removeValue(forKey: id)
return self.modifiedResponse(timestamp: item.modified)
}
if let collection = spec.collection {
if spec.wholeCollection {
self.collections.removeValue(forKey: collection)
} else {
if let ids = spec.ids,
var map = self.collections[collection]?.records {
for id in ids {
map.removeValue(forKey: id)
}
self.collections[collection] = (Date.now(), records: map)
}
}
return self.modifiedResponse(timestamp: Date.now())
}
self.collections = [:]
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(data: "{}".utf8EncodedData, contentType: "application/json"))
}
let match: GCDWebServerMatchBlock = { method, url, headers, path, query -> GCDWebServerRequest! in
guard method == "GET", path?.startsWith(storagePath) ?? false else {
return nil
}
return GCDWebServerRequest(method: method, url: url, headers: headers, path: path, query: query)
}
server?.addHandler(match: match) { (request) -> GCDWebServerResponse! in
// 1. Decide what the URL is asking for. It might be a collection fetch or
// an individual record, and it might have query parameters.
guard let spec = SyncRequestSpec.fromRequest(request: request!) else {
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(statusCode: 400))
}
// 2. Grab the matching set of records. Prune based on TTL, exclude with X-I-U-S, etc.
if let id = spec.id {
guard let collection = self.collections[spec.collection], let record = collection.records[id] else {
// Unable to find the requested collection/id.
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(statusCode: 404))
}
return self.recordResponse(record: record)
}
guard let (items, offset) = self.recordsMatchingSpec(spec: spec) else {
// Unable to find the provided offset.
return MockSyncServer.withHeaders(response: GCDWebServerDataResponse(statusCode: 400))
}
// TODO: TTL
// TODO: X-I-U-S
let body = JSON(object: items.map { $0.asJSON() }).rawString()
let bodyData = body?.utf8EncodedData
let response = GCDWebServerDataResponse(data: bodyData, contentType: "application/json")
// 3. Compute the correct set of headers: timestamps, X-Weave-Records, etc.
if let offset = offset {
response?.setValue(offset, forAdditionalHeader: "X-Weave-Next-Offset")
}
let timestamp = self.modifiedTimeForCollection(collection: spec.collection)!
log.debug("Returning GET response with X-Last-Modified for \(items.count) records: \(timestamp).")
return MockSyncServer.withHeaders(response: response!, lastModified: timestamp, records: items.count)
}
if server?.start(withPort: 0, bonjourName: nil) == false {
XCTFail("Can't start the GCDWebServer.")
}
baseURL = "http://localhost:\(server!.port)\(basePath)"
}
}
| mpl-2.0 | 1f739fc240497bb95d94334f033b5d32 | 38.236203 | 166 | 0.596095 | 4.918096 | false | false | false | false |
justindhill/Jiramazing | src/model/Priority.swift | 1 | 853 | //
// Priority.swift
// Pods
//
// Created by Justin Hill on 8/19/16.
//
//
import Foundation
import HexColors
@objc(JRAPriority) public class Priority: NSObject {
@objc(identifier) public var id: String?
public var url: NSURL?
public var color: UIColor?
public var priorityDescription: String?
public var name: String?
init(attributes: [String: AnyObject]) {
super.init()
if let urlString = attributes["self"] as? String {
self.url = NSURL(string: urlString)
}
if let colorString = attributes["statusColor"] as? String {
self.color = UIColor.hx_colorWithHexString(colorString)
}
self.priorityDescription = attributes["description"] as? String
self.name = attributes["name"] as? String
self.id = attributes["id"] as? String
}
}
| mit | 264fb1a350c7c7d7fc18ee27000362cb | 24.088235 | 71 | 0.631887 | 4.08134 | false | false | false | false |
sivu22/AnyTracker | AnyTracker/App.swift | 1 | 6470 | //
// App.swift
// AnyTracker
//
// Created by Cristian Sava on 10/02/16.
// Copyright © 2016 Cristian Sava. All rights reserved.
//
import UIKit
import Foundation
struct Constants {
struct Key {
static let noContent = "NoContent"
static let numberSeparator = "NumberSeparator"
static let dateFormatLong = "DateFormatLong"
static let addNewListTop = "AddNewListTop"
static let addNewItemTop = "AddNewItemTop"
}
struct Text {
static let listAll = "ALL"
static let listItems = " Items"
}
struct File {
static let ext = ".json"
static let lists = "lists.json"
static let list = "list"
static let item = "item"
}
struct Limits {
static let itemsPerList = 128
}
struct Colors {
static let ItemSum = UIColor(red: 0, green: 122, blue: 255)
static let ItemCounter = UIColor(red: 85, green: 205, blue: 0)
static let ItemJournal = UIColor(red: 255, green: 132, blue: 0)
}
struct Animations {
static let keyboardDuration = 0.3
static let keyboardCurve = UIView.AnimationCurve.easeOut
static let keyboardDistanceToControl: CGFloat = 10
}
}
enum Status: String, Error {
case errorDefault = "Unknown error"
case errorInputString = "Bad input found!"
case errorIndex = "Index error"
case errorFailedToAddList = "Failed to add list. Try again later"
case errorListsFileSave = "Could not save lists data"
case errorListsFileLoad = "Failed to load lists data"
case errorListsBadCache = "Corrupted data!"
case errorListFileSave = "Could not save list. Try again later"
case errorListFileLoad = "Failed to load list"
case errorListDelete = "Failed to delete list"
case errorItemBadID = "Wrong item ID. Please try again"
case errorItemFileSave = "Could not save item. Try again later"
case errorItemFileLoad = "Failed to load item"
case errorJSONDeserialize = "Could not load data: corrupted/invalid format"
case errorJSONSerialize = "Failed to serialize data"
func createErrorAlert() -> UIAlertController {
var title: String;
switch self {
case .errorDefault, .errorInputString, .errorIndex:
title = "Fatal error"
case .errorFailedToAddList, .errorListsFileSave, .errorListsFileLoad, .errorListsBadCache,
.errorListFileSave, .errorListFileLoad, .errorListDelete, .errorItemBadID, .errorItemFileSave, .errorItemFileLoad,
.errorJSONDeserialize, .errorJSONSerialize:
title = "Error"
}
let alert = UIAlertController(title: title, message: self.rawValue, preferredStyle: UIAlertController.Style.alert)
let defaultAction = UIAlertAction(title: "OK", style: UIAlertAction.Style.default, handler: nil)
alert.addAction(defaultAction)
return alert
}
}
class App {
static fileprivate(set) var version: String = {
let appPlist = Bundle.main.infoDictionary as [String: AnyObject]?
return appPlist!["CFBundleShortVersionString"] as! String
}()
// Array of lists ID
var lists: Lists?
// Settings
fileprivate(set) var noContent: Bool
fileprivate(set) var numberSeparator: Bool
fileprivate(set) var dateFormatLong: Bool
fileprivate(set) var addNewListTop: Bool
fileprivate(set) var addNewItemTop: Bool
init(noContent: Bool, numberSeparator: Bool, dateFormatLong: Bool, addNewListTop: Bool, addNewItemTop: Bool) {
self.noContent = noContent
self.numberSeparator = numberSeparator
self.dateFormatLong = dateFormatLong
self.addNewListTop = addNewListTop
self.addNewItemTop = addNewItemTop
Utils.debugLog("Initialized a new App instance with settings \(self.noContent),\(self.numberSeparator),\(self.dateFormatLong),\(self.addNewListTop),\(self.addNewItemTop)")
}
func appInit() {
Utils.debugLog("App init...")
setupDefaultValues()
loadSettings()
}
func appPause() {
Utils.debugLog("App moves to inactive state...")
}
func appResume() {
Utils.debugLog("App moves to active state...")
}
func appExit() {
Utils.debugLog("App will terminate...")
}
fileprivate func setupDefaultValues() {
let defaultPrefsFile = Bundle.main.url(forResource: "DefaultSettings", withExtension: "plist")
if let prefsFile = defaultPrefsFile {
let defaultPrefs = NSDictionary(contentsOf: prefsFile) as! [String : AnyObject]
UserDefaults.standard.register(defaults: defaultPrefs)
} else {
Utils.debugLog("DefaultSettings not found in bundle!")
}
}
fileprivate func loadSettings() {
noContent = UserDefaults.standard.bool(forKey: Constants.Key.noContent)
numberSeparator = UserDefaults.standard.bool(forKey: Constants.Key.numberSeparator)
dateFormatLong = UserDefaults.standard.bool(forKey: Constants.Key.dateFormatLong)
addNewListTop = UserDefaults.standard.bool(forKey: Constants.Key.addNewListTop)
addNewItemTop = UserDefaults.standard.bool(forKey: Constants.Key.addNewItemTop)
}
func toggleNoContent() {
Utils.debugLog("toggleNoContent")
noContent = !noContent
UserDefaults.standard.set(noContent, forKey: Constants.Key.noContent)
}
func toggleNumberSeparator() {
Utils.debugLog("toggleNumberSeparator")
numberSeparator = !numberSeparator
UserDefaults.standard.set(numberSeparator, forKey: Constants.Key.numberSeparator)
}
func toggleDateFormatLong() {
Utils.debugLog("toggleDateFormatLong")
dateFormatLong = !dateFormatLong
UserDefaults.standard.set(dateFormatLong, forKey: Constants.Key.dateFormatLong)
}
func toggleAddNewListTop() {
Utils.debugLog("toggleAddNewListTop")
addNewListTop = !addNewListTop
UserDefaults.standard.set(addNewListTop, forKey: Constants.Key.addNewListTop)
}
func toggleAddNewItemTop() {
Utils.debugLog("toggleAddNewItemTop")
addNewItemTop = !addNewItemTop
UserDefaults.standard.set(addNewItemTop, forKey: Constants.Key.addNewItemTop)
}
}
| mit | c093ddcb738d2929c01546684e71635b | 33.227513 | 179 | 0.659144 | 4.581445 | false | false | false | false |
ericmarkmartin/Nightscouter2 | Common/Extensions/NSURL-Extensions.swift | 1 | 5494 | //
// NSURL-Extensions.swift
//
//
import Foundation
// MARK: NSURL Validation
// Modified by Peter
// Created by James Hickman on 11/18/14.
// Copyright (c) 2014 NitWit Studios. All rights reserved.
public extension NSURL
{
public struct ValidationQueue {
public static var queue = NSOperationQueue()
}
enum ValidationError: ErrorType {
case Empty(String)
case OnlyPrefix(String)
case ContainsWhitespace(String)
case CouldNotCreateURL(String)
}
public class func validateUrl(urlString: String?) throws -> NSURL {
// Description: This function will validate the format of a URL, re-format if necessary, then attempt to make a header request to verify the URL actually exists and responds.
// Return Value: This function has no return value but uses a closure to send the response to the caller.
var formattedUrlString : String?
// Ignore Nils & Empty Strings
if (urlString == nil || urlString == "")
{
throw ValidationError.Empty("Url String was empty")
}
// Ignore prefixes (including partials)
let prefixes = ["http://www.", "https://www.", "www."]
for prefix in prefixes
{
if ((prefix.rangeOfString(urlString!, options: NSStringCompareOptions.CaseInsensitiveSearch, range: nil, locale: nil)) != nil){
throw ValidationError.OnlyPrefix("Url String was prefix only")
}
}
// Ignore URLs with spaces (NOTE - You should use the below method in the caller to remove spaces before attempting to validate a URL)
let range = urlString!.rangeOfCharacterFromSet(NSCharacterSet.whitespaceCharacterSet())
if let _ = range {
throw ValidationError.ContainsWhitespace("Url String cannot contain whitespaces")
}
// Check that URL already contains required 'http://' or 'https://', prepend if it does not
formattedUrlString = urlString
if (!formattedUrlString!.hasPrefix("http://") && !formattedUrlString!.hasPrefix("https://"))
{
formattedUrlString = "https://"+urlString!
}
guard let finalURL = NSURL(string: formattedUrlString!) else {
throw ValidationError.CouldNotCreateURL("Url could not be created.")
}
return finalURL
}
public class func validateUrl(urlString: String?, completion:(success: Bool, urlString: String? , error: NSString) -> Void)
{
let parsedURL = try? validateUrl(urlString)
// Check that an NSURL can actually be created with the formatted string
if let validatedUrl = parsedURL //NSURL(string: formattedUrlString!)
{
// Test that URL actually exists by sending a URL request that returns only the header response
let request = NSMutableURLRequest(URL: validatedUrl)
request.HTTPMethod = "HEAD"
ValidationQueue.queue.cancelAllOperations()
let session = NSURLSession(configuration: NSURLSessionConfiguration.defaultSessionConfiguration(), delegate: nil, delegateQueue: ValidationQueue.queue)
let task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
let url = request.URL!.absoluteString
// URL failed - No Response
if (error != nil)
{
completion(success: false, urlString: url, error: "The url: \(url) received no response")
return
}
// URL Responded - Check Status Code
if let urlResponse = response as? NSHTTPURLResponse
{
if ((urlResponse.statusCode >= 200 && urlResponse.statusCode < 400) || urlResponse.statusCode == 405) // 200-399 = Valid Responses, 405 = Valid Response (Weird Response on some valid URLs)
{
completion(success: true, urlString: url, error: "The url: \(url) is valid!")
return
}
else // Error
{
completion(success: false, urlString: url, error: "The url: \(url) received a \(urlResponse.statusCode) response")
return
}
}
})
task.resume()
}
}
}
// Created by Pete
// inspired by https://github.com/ReactiveCocoa/ReactiveCocoaIO/blob/master/ReactiveCocoaIO/NSURL%2BTrailingSlash.m
// MARK: Detect and remove trailing forward slash in URL.
public extension NSURL {
public var hasTrailingSlash: Bool {
return self.absoluteString.hasSuffix("/")
}
public var URLByAppendingTrailingSlash: NSURL? {
if !self.hasTrailingSlash, let newURL = NSURL(string: self.absoluteString.stringByAppendingString("/")){
return newURL
}
return nil
}
public var URLByDeletingTrailingSlash: NSURL? {
let urlString = self.absoluteString
let stepBackOne = urlString.endIndex.advancedBy(-1)
if self.hasTrailingSlash, let newURL = NSURL(string: urlString.substringToIndex(stepBackOne)) {
return newURL
}
return nil
}
} | mit | 97b27b2a84069b90551e5390d19a2366 | 38.818841 | 208 | 0.595013 | 5.386275 | false | false | false | false |
RCacheaux/SafeDataSourceKit | SafeDataSourceDevelopment.playground/Contents.swift | 1 | 38516 | //: Playground - noun: a place where people can play
import UIKit
import XCPlayground
func - (lhs: Range<Int>, rhs: Int) -> Range<Int> {
if lhs.endIndex == 0 {
return Range(start: 0, end: 0)
} else if lhs.startIndex >= lhs.endIndex - rhs {
return Range(start: lhs.startIndex, end: lhs.startIndex)
} else {
return Range(start: lhs.startIndex, end: lhs.endIndex.advancedBy(-rhs))
}
}
func + (lhs: Range<Int>, rhs: Int) -> Range<Int> {
return Range(start: lhs.startIndex, end: lhs.endIndex.advancedBy(rhs))
}
func add(lhs: Range<Int>, rhs: Int) -> Range<Int> {
return Range(start: lhs.startIndex, end: lhs.endIndex.advancedBy(rhs))
}
//func += (lhs: Range<Int>, rhs: Int) -> Range<Int> {
// return Range(start: lhs.startIndex, end: lhs.endIndex.advancedBy(rhs))
//}
func >> (lhs: Range<Int>, rhs: Int) -> Range<Int> {
return Range(start: lhs.startIndex.advancedBy(rhs), end: lhs.endIndex.advancedBy(rhs))
}
func << (lhs: Range<Int>, rhs: Int) -> Range<Int> {
return Range(start: lhs.startIndex.advancedBy(-rhs), end: lhs.endIndex.advancedBy(-rhs))
}
func shiftAdd(lhs: Range<Int>, rhs: Int) -> Range<Int> {
return Range(start: lhs.startIndex.advancedBy(rhs), end: lhs.endIndex.advancedBy(rhs))
}
func shiftRemove(lhs: Range<Int>, rhs: Int) -> Range<Int> {
return Range(start: lhs.startIndex.advancedBy(-rhs), end: lhs.endIndex.advancedBy(-rhs))
}
var g = 0..<0
g = g - 1
var y = 0...10
let a = y.startIndex.advancedBy(1)
let b = y.endIndex.advancedBy(1)
let z = Range(start: a, end: b)
struct Color {
let hue: CGFloat
let saturation: CGFloat
let brightness: CGFloat
}
extension UIColor {
convenience init(color: Color) {
self.init(hue: color.hue, saturation: color.saturation, brightness: color.brightness, alpha: 1)
}
}
private enum DataChange<T> {
// Section
case AppendSection
case AppendSections(Int) // Number of sections
case InsertSection(Int) // Section Index
case InsertSections(NSIndexSet)
case DeleteSection(Int) // Section Index
case DeleteSections(NSIndexSet)
case DeleteLastSection
case DeleteSectionsStartingAtIndex(Int)
case MoveSection(Int, Int)
// Item
case AppendItem(T, Int) // Item, Section Index
case AppendItems([T], Int) // Items, Section Index
case InsertItem(T, NSIndexPath)
case InsertItems([T], [NSIndexPath])
case DeleteItem(NSIndexPath)
case DeleteItems([NSIndexPath])
case DeleteLastItem(Int) // Section Index
case DeleteItemsStartingAtIndexPath(NSIndexPath) // Will delete all items from index path forward for section
case MoveItem(NSIndexPath, NSIndexPath)
}
public class SafeDataSource<T>: NSObject, UICollectionViewDataSource {
public typealias CellForItemAtIndexPath = (UICollectionView, T, NSIndexPath) -> UICollectionViewCell
let collectionView: UICollectionView
var dataSourceItems: [[T]] = [] // Only change this on main thread an coordinate it with batch insertion completion.
var items: [[T]] = []
private var pendingChanges: [DataChange<T>] = []
let cellForItemAtIndexPath: CellForItemAtIndexPath
let mutateDisplayQueue = SerialOperationQueue()
let dataMutationDispatchQueue = dispatch_queue_create("com.rcach.safeDataSourceKit.dataMutation", DISPATCH_QUEUE_SERIAL)
// New data structures for latest algorithm
// TODO: Validate on insert that it does not already contain the index,
// if this happens it means we are trying to delete the same item twice which is an error
var adjustedIndexPathsToDelete: [Set<NSIndexPath>] = [] // TODO: This can simply be a set of all index paths to delete, they don't need to be organized by section index in a wrapping array
var deletionIndexPathAdjustmentTable: [[Int]] = []
func adjustedDeletionItemIndex(pointInTimeItemIndex: Int, adjustmentTable: [Int]) -> Int {
var adjustment = 0
for adj in adjustmentTable {
if pointInTimeItemIndex >= adj {
adjustment += 1
}
}
return pointInTimeItemIndex + adjustment
}
func adjustTableIfNecessaryWithPointInTimeDeletionItemIndex(pointInTimeItemIndex: Int, inout adjustmentTable: [Int]) {
// If deleting item above previous deletes, need to offset the below adjustments -1
for (i, adj) in adjustmentTable.enumerate() {
if adj > pointInTimeItemIndex {
adjustmentTable[i] = adjustmentTable[i] - 1
}
}
// Add this point in time index to adj table
adjustmentTable.append(pointInTimeItemIndex)
}
// !!!!!!!!! TODO: !!!!!!! Index paths passed into this method are affected by any insertions because the user of this class works off the changelist items, they don't know to filter out insertions when calling delete.
func unsafeDeleteItemAtIndexPath(indexPath: NSIndexPath) -> NSIndexPath {
let adjIndex = adjustedDeletionItemIndex(indexPath.item, adjustmentTable: deletionIndexPathAdjustmentTable[indexPath.section])
adjustTableIfNecessaryWithPointInTimeDeletionItemIndex(indexPath.item, adjustmentTable: &deletionIndexPathAdjustmentTable[indexPath.section])
let adjIndexPath = NSIndexPath(forItem: adjIndex, inSection: indexPath.section)
adjustedIndexPathsToDelete[indexPath.section].insert(adjIndexPath)
return adjIndexPath
}
public convenience init(items: [[T]], collectionView: UICollectionView, cellForItemAtIndexPath: CellForItemAtIndexPath) {
self.init(collectionView: collectionView, cellForItemAtIndexPath: cellForItemAtIndexPath)
self.dataSourceItems = items
self.items = items
}
public init(collectionView: UICollectionView, cellForItemAtIndexPath: CellForItemAtIndexPath) {
self.collectionView = collectionView
self.cellForItemAtIndexPath = cellForItemAtIndexPath
super.init()
self.collectionView.dataSource = self
}
private func dequeuPendingChangesAndOnComplete(onComplete: ([DataChange<T>], [Set<NSIndexPath>]) -> Void) { // TODO: Think about taking in the queue to call the on complete closure.
dispatch_async(dataMutationDispatchQueue) {
let pendingChangesToDequeue = self.pendingChanges
self.pendingChanges.removeAll(keepCapacity: true)
let itemsToDelete = self.adjustedIndexPathsToDelete
//: TODO: Figure out how to mutate arrary's set without copy on write occuring:
var newEmptyItemsToDelete: [Set<NSIndexPath>] = []
for _ in self.adjustedIndexPathsToDelete {
newEmptyItemsToDelete.append(Set<NSIndexPath>())
}
self.adjustedIndexPathsToDelete = newEmptyItemsToDelete
//:
onComplete(pendingChangesToDequeue, itemsToDelete)
}
}
func addApplyOperationIfNeeded() {
if let lastOperation = self.mutateDisplayQueue.operations.last {
if lastOperation.executing {
let applyChangeOp = ApplyDataSourceChangeOperation(safeDataSource: self, collectionView: self.collectionView)
self.mutateDisplayQueue.addOperation(applyChangeOp)
}
} else {
let applyChangeOp = ApplyDataSourceChangeOperation(safeDataSource: self, collectionView: self.collectionView)
self.mutateDisplayQueue.addOperation(applyChangeOp)
}
}
// External Interface
public func appendItem(item: T) {
dispatch_async(dataMutationDispatchQueue) {
// Automatically creates section 0 if it does not exist already.
if self.items.count == 0 {
self.unsafeAppendSectionWithItem(item)
} else {
// self.unsafeAppendItem(item, toSection: 0) // TODO: Remove ObjC msg_send overhead
let section = 0
guard section < self.items.count else { return } // TODO: Add more of these validations
let startingIndex = self.items[section].count
self.pendingChanges.append(.InsertItem(item, NSIndexPath(forItem: startingIndex, inSection: section)))
self.items[section].append(item)
self.addApplyOperationIfNeeded()
}
}
}
public func appendItem(item: T, toSection section: Int) {
dispatch_async(dataMutationDispatchQueue) {
self.unsafeAppendItem(item, toSection: section)
}
}
@nonobjc @inline(__always)
func unsafeAppendItem(item: T, toSection section: Int) {
guard section < self.items.count else { return } // TODO: Add more of these validations
let startingIndex = self.items[section].count
self.pendingChanges.append(.InsertItem(item, NSIndexPath(forItem: startingIndex, inSection: section)))
self.items[section].append(item)
self.addApplyOperationIfNeeded()
}
public func appendSectionWithItems(items: [T]) {
dispatch_async(dataMutationDispatchQueue) {
self.unsafeAppendSectionWithItems(items)
}
}
@nonobjc @inline(__always)
func unsafeAppendSectionWithItems(items: [T]) {
let newSectionIndex = self.items.count // This must happen first.
self.pendingChanges.append(.AppendSection)
self.items.append([])
let indexPaths = items.enumerate().map { (index, item) -> NSIndexPath in
return NSIndexPath(forItem: index, inSection: newSectionIndex)
}
self.pendingChanges.append(.InsertItems(items, indexPaths))
self.items[newSectionIndex] = items
self.addApplyOperationIfNeeded()
}
@nonobjc @inline(__always)
func unsafeAppendSectionWithItem(item: T) {
let newSectionIndex = self.items.count // This must happen first.
self.pendingChanges.append(.AppendSection)
self.items.append([])
let indexPath = NSIndexPath(forItem: 0, inSection: newSectionIndex)
self.pendingChanges.append(.InsertItem(item, indexPath))
self.items[newSectionIndex].append(item)
self.addApplyOperationIfNeeded()
}
// Instead allow consumer to give you a closure that we call and provide current
// data state and they can use that state to apply mutations
public func insertItemWithClosure(getInsertionIndexPath: ([[T]]) -> (item: T, indexPath: NSIndexPath)?) {
dispatch_async(dataMutationDispatchQueue) {
guard let insertion = getInsertionIndexPath(self.items) else { return }
insertion.indexPath.item
self.pendingChanges.append(.InsertItem(insertion.item, insertion.indexPath))
self.items[insertion.indexPath.section].insert(insertion.item, atIndex: insertion.indexPath.item)
self.addApplyOperationIfNeeded()
}
}
public func deleteItemWithClosure(getDeletionIndexPath: ([[T]]) -> NSIndexPath?) {
dispatch_async(dataMutationDispatchQueue) {
guard let indexPath = getDeletionIndexPath(self.items) else { return }
let adjIndexPath = self.unsafeDeleteItemAtIndexPath(indexPath)
self.pendingChanges.append(.DeleteItem(indexPath)) // TODO: Also store adjIndexPath in enum?
self.items[indexPath.section].removeAtIndex(indexPath.item)
self.addApplyOperationIfNeeded()
}
}
public func deleteLastItemInSection(sectionIndex: Int) {
assertionFailure("deleteLastItemInSection not supported yet.")
// dispatch_async(dataMutationDispatchQueue) {
// if self.items[sectionIndex].count > 0 {
// self.items[sectionIndex].removeLast()
// self.pendingChanges.append(.DeleteLastItem(sectionIndex))
// self.addApplyOperationIfNeeded()
// }
// }
}
// TODO: Delete items in range: in section: < more performant for large deletions if they are contiguous
public func collectionView(collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return dataSourceItems[section].count
}
public func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
let cell = cellForItemAtIndexPath(collectionView, dataSourceItems[indexPath.section][indexPath.row], indexPath)
return cell
}
public func numberOfSectionsInCollectionView(collectionView: UICollectionView) -> Int {
return dataSourceItems.count
}
// func collectionView(collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, atIndexPath indexPath: NSIndexPath) -> UICollectionReusableView
// iOS 9+
// func collectionView(collectionView: UICollectionView, canMoveItemAtIndexPath indexPath: NSIndexPath) -> Bool
// iOS 9+
// func collectionView(collectionView: UICollectionView, moveItemAtIndexPath sourceIndexPath: NSIndexPath, toIndexPath destinationIndexPath: NSIndexPath)
}
class SerialOperationQueue: NSOperationQueue {
override init() {
super.init()
maxConcurrentOperationCount = 1
}
override func addOperation(op: NSOperation) {
if let lastOperation = self.operations.last {
if !lastOperation.finished {
op.addDependency(lastOperation)
}
}
super.addOperation(op)
}
}
public class AsyncOperation: NSOperation {
private var _executing = false
private var _finished = false
override private(set) public var executing: Bool {
get {
return _executing
}
set {
willChangeValueForKey("isExecuting")
_executing = newValue
didChangeValueForKey("isExecuting")
}
}
override private(set) public var finished: Bool {
get {
return _finished
}
set {
willChangeValueForKey("isFinished")
_finished = newValue
didChangeValueForKey("isFinished")
}
}
override public var asynchronous: Bool {
return true
}
override public func start() {
if cancelled {
finished = true
return
}
executing = true
autoreleasepool {
run()
}
}
func run() {
preconditionFailure("AsyncOperation.run() abstract method must be overridden.")
}
func finishedExecutingOperation() {
executing = false
finished = true
}
}
/*
switch change {
case .AppendSection:
let x = 1
case .AppendSections(let numberOfSections): // Number of sections
let x = 1
case .InsertSection(let sectionIndex): // Section Index
let x = 1
case .InsertSections(let indexSet):
let x = 1
case .DeleteSection(let sectionIndex): // Section Index
let x = 1
case .DeleteSections(let indexSet):
let x = 1
case .DeleteLastSection:
let x = 1
case .DeleteSectionsStartingAtIndex(let sectionIndex):
let x = 1
case .MoveSection(let fromSectionIndex, let toSectionIndex):
// Item
let x = 1
case .AppendItem(let item, let sectionIndex): // Item, Section Index
let x = 1
case .AppendItems(let items, let sectionIndex): // Items, Section Index
let x = 1
case .InsertItem(let item, let indexPath):
let x = 1
case .InsertItems(let items, let indexPaths):
let x = 1
case .DeleteItem(let indexPath):
let x = 1
case .DeleteItems(let indexPaths):
let x = 1
case .DeleteLastItem(let sectionIndex): // Section Index
let x = 1
case .DeleteItemsStartingAtIndexPath(let indexPath): // Will delete all items from index path forward for section
let x = 1
case .MoveItem(let fromIndexPath, let toIndexPath):
let x = 1
}
*/
class ApplyDataSourceChangeOperation<T>: AsyncOperation {
let safeDataSource: SafeDataSource<T>
let collectionView: UICollectionView
init(safeDataSource: SafeDataSource<T>, collectionView: UICollectionView) {
self.safeDataSource = safeDataSource
self.collectionView = collectionView
super.init()
}
override func run() {
safeDataSource.dequeuPendingChangesAndOnComplete { changes, indexPathsToDelete in
dispatch_async(dispatch_get_main_queue()) {
// TODO: Can make this logic more efficient: Have to process deletions first because batch
// updates will also apply deletions first so, if we haven't added the item we want to delete yet,
// the batch insertion will fail
// Got changes, now head on over to collection view
// We first apply all additions and then on complete we apply deletions and on complete of deletions we mark operation complete
// TODO: Do all this math in a concurrent queue and only get on main queue once set of changes are calculated
// Range of existing items in data source array before any changes applied in this op
let preDeleteSectionStartingRanges = self.safeDataSource.dataSourceItems.enumerate().map { index, items in
return 0..<self.safeDataSource.dataSourceItems[index].count
}
var sectionAdditions: [Int:Range<Int>] = [:]
var sectionInsertions = self.safeDataSource.dataSourceItems.map { _ in
return Set<NSIndexPath>()
}
var sectionDeletions = self.safeDataSource.dataSourceItems.map { _ in
return Set<NSIndexPath>()
}
for change in changes {
if case .DeleteItem(let midPointInTimeIndexPath) = change {
// C:
let indexWithinStartingDataSourceItems =
self.itemBatchStartingIndexPath(deletionsUpToThisPoint: sectionDeletions, givenIndexPath: midPointInTimeIndexPath)
if preDeleteSectionStartingRanges[midPointInTimeIndexPath.section] ~= indexWithinStartingDataSourceItems.item { // Deleting from existing items
sectionDeletions[midPointInTimeIndexPath.section].insert(indexWithinStartingDataSourceItems)
}
// :C
} else if case .DeleteItems(let midPointInTimeIndexPaths) = change {
for midPointInTimeIndexPath in midPointInTimeIndexPaths {
// C:
let indexWithinStartingDataSourceItems =
self.itemBatchStartingIndexPath(deletionsUpToThisPoint: sectionDeletions, givenIndexPath: midPointInTimeIndexPath)
if preDeleteSectionStartingRanges[midPointInTimeIndexPath.section] ~= indexWithinStartingDataSourceItems.item { // Deleting from existing items
sectionDeletions[midPointInTimeIndexPath.section].insert(indexWithinStartingDataSourceItems)
}
// :C
}
}
}
let postDeleteSectionStartingRanges = self.safeDataSource.dataSourceItems.enumerate().map { sectionIndex, items in
return 0..<(self.safeDataSource.dataSourceItems[sectionIndex].count - sectionDeletions[sectionIndex].count)
}
var onGoingExistingDeletes: [[NSIndexPath]] = self.safeDataSource.dataSourceItems.map { _ in
return []
}
for change in changes {
switch change {
case .AppendSection:
let x = 1
case .AppendSections(let numberOfSections): // Number of sections
let x = 1
case .InsertSection(let sectionIndex): // Section Index
let x = 1
case .InsertSections(let indexSet):
let x = 1
case .DeleteSection(let sectionIndex): // Section Index
let x = 1
case .DeleteSections(let indexSet):
let x = 1
case .DeleteLastSection:
let x = 1
case .DeleteSectionsStartingAtIndex(let sectionIndex):
let x = 1
case .MoveSection(let fromSectionIndex, let toSectionIndex):
let x = 1
case .AppendItem(_, let sectionIndex): // Item, Section Index
let x = 1
// if sectionAdditions[sectionIndex] == nil {
// let startingRange = postDeleteSectionStartingRanges[sectionIndex]
// sectionAdditions[sectionIndex] = startingRange.endIndex..<startingRange.endIndex
// }
// if let sectionAdditionsForSection = sectionAdditions[sectionIndex] {
// sectionAdditions[sectionIndex] = sectionAdditionsForSection + 1
// }
case .AppendItems(let items, let sectionIndex): // Items, Section Index
let x = 1
// if sectionAdditions[sectionIndex] == nil {
// let startingRange = postDeleteSectionStartingRanges[sectionIndex]
// sectionAdditions[sectionIndex] = startingRange.endIndex..<startingRange.endIndex
// }
// if let sectionAdditionsForSection = sectionAdditions[sectionIndex] {
// sectionAdditions[sectionIndex] = sectionAdditionsForSection + items.count
// }
case .InsertItem(_, let midPointInTimeIndexPath):
// TODO: What if this is an insertion into a new section?
// A:
let indexWithinStartingDataSourceItems =
self.itemBatchStartingIndexPath(deletionsUpToThisPoint: onGoingExistingDeletes, givenIndexPath: midPointInTimeIndexPath)
if preDeleteSectionStartingRanges[midPointInTimeIndexPath.section] ~= indexWithinStartingDataSourceItems.item { // Inserting into existing items
// Now that we know this insertion is within existing items, its not a simple addition, so find this item's index path after all deletes applied:
let allDeletions = sectionDeletions
let postDeleteIndexPath = self.itemBatchStartingIndexPath(deletionsUpToThisPoint: allDeletions, givenIndexPath: midPointInTimeIndexPath)
sectionInsertions[midPointInTimeIndexPath.section].insert(postDeleteIndexPath)
if let sectionAdditionsForSection = sectionAdditions[midPointInTimeIndexPath.section] {
sectionAdditions[midPointInTimeIndexPath.section] = sectionAdditionsForSection >> 1
}
} else { // NOT inserting into existing items
if sectionAdditions[midPointInTimeIndexPath.section] == nil {
let startingRange = postDeleteSectionStartingRanges[midPointInTimeIndexPath.section]
sectionAdditions[midPointInTimeIndexPath.section] = startingRange.endIndex..<startingRange.endIndex
}
if let sectionAdditionsForSection = sectionAdditions[midPointInTimeIndexPath.section] {
sectionAdditions[midPointInTimeIndexPath.section] = sectionAdditionsForSection + 1 // TODO: Can we make this easier by just keeping a count of additions and take the post delete max item in each section and make that the start of the addtions range?
}
}
// :A
case .InsertItems(_, let midPointInTimeIndexPaths):
for midPointInTimeIndexPath in midPointInTimeIndexPaths {
// A:
let indexWithinStartingDataSourceItems =
self.itemBatchStartingIndexPath(deletionsUpToThisPoint: onGoingExistingDeletes, givenIndexPath: midPointInTimeIndexPath)
if preDeleteSectionStartingRanges[midPointInTimeIndexPath.section] ~= indexWithinStartingDataSourceItems.item { // Inserting into existing items
// Now that we know this insertion is within existing items, its not a simple addition, so find this item's index path after all deletes applied:
let allDeletions = sectionDeletions
let postDeleteIndexPath = self.itemBatchStartingIndexPath(deletionsUpToThisPoint: allDeletions, givenIndexPath: midPointInTimeIndexPath)
sectionInsertions[midPointInTimeIndexPath.section].insert(postDeleteIndexPath)
if let sectionAdditionsForSection = sectionAdditions[midPointInTimeIndexPath.section] {
sectionAdditions[midPointInTimeIndexPath.section] = sectionAdditionsForSection >> 1
}
} else { // NOT inserting into existing items
if sectionAdditions[midPointInTimeIndexPath.section] == nil {
let startingRange = postDeleteSectionStartingRanges[midPointInTimeIndexPath.section]
sectionAdditions[midPointInTimeIndexPath.section] = startingRange.endIndex..<startingRange.endIndex
}
if let sectionAdditionsForSection = sectionAdditions[midPointInTimeIndexPath.section] {
sectionAdditions[midPointInTimeIndexPath.section] = sectionAdditionsForSection + 1 // TODO: Can we make this easier by just keeping a count of additions and take the post delete max item in each section and make that the start of the addtions range?
}
}
// :A
}
case .DeleteItem(let indexPath):
// B:
// This accounts for the fact that the index path given to us is in the context of an array with potentially deleted items.
let indexWithinStartingDataSourceItems =
self.itemBatchStartingIndexPath(deletionsUpToThisPoint: onGoingExistingDeletes, givenIndexPath: midPointInTimeIndexPath)
if preDeleteSectionStartingRanges[indexPath.section] ~= (indexPath.item + onGoingExistingDeletes[indexPath.section].count) { // Deleting from existing items
// Do nothing this deletion has already been accounted for, excpet for keeping track
onGoingExistingDeletes[indexPath.section].append(indexPath) // TODO: will something reference this index path later if so be careful about index that should be shifted!
} else { // NOT deleting from existing items, no deleting from datasource, items never made it to collection view no need to add these items just to delete them
if let sectionAdditionsForSection = sectionAdditions[indexPath.section] {
sectionAdditions[indexPath.section] = sectionAdditionsForSection - 1 // TODO: Remove addition range if range becomes 0..<0
} else {
// This should never occur, this means a delete command was given for an item that hasn't been added yet. We are iterating in the changlist order.
assertionFailure("Encountered an addition deletion for an item that has not been added before in the changelist order.")
}
} // :B
case .DeleteItems(let indexPaths):
for indexPath in indexPaths {
// B:
// This accounts for the fact that the index path given to us is in the context of an array with potentially deleted items.
if preDeleteSectionStartingRanges[indexPath.section] ~= (indexPath.item + onGoingExistingDeletes[indexPath.section].count) { // Deleting from existing items
// Do nothing this deletion has already been accounted for, excpet for keeping track
onGoingExistingDeletes[indexPath.section].append(indexPath)
} else { // NOT deleting from existing items, no deleting from datasource, items never made it to collection view no need to add these items just to delete them
if let sectionAdditionsForSection = sectionAdditions[indexPath.section] {
sectionAdditions[indexPath.section] = sectionAdditionsForSection - 1 // TODO: Remove addition range if range becomes 0..<0
} else {
// This should never occur, this means a delete command was given for an item that hasn't been added yet. We are iterating in the changlist order.
assertionFailure("Encountered an addition deletion for an item that has not been added before in the changelist order.")
}
} // :B
}
case .DeleteLastItem: // Section Index
assertionFailure("Delete Last Item in Section not implemented yet.")
/*
if let sectionAdditionsForSection = sectionAdditions[sectionIndex] { // There are additions, just remove from there
let x = 1
sectionAdditions[sectionIndex]?.startIndex
sectionAdditions[sectionIndex]?.endIndex
sectionAdditions[sectionIndex] = sectionAdditionsForSection - 1
if sectionAdditions[sectionIndex]!.startIndex == sectionAdditions[sectionIndex]!.endIndex {
sectionAdditions[sectionIndex] = nil
}
} else if self.safeDataSource.dataSourceItems[sectionIndex].count > 0 { // If there are existing items in this section, remove the last one
let x = 1
// Look for deletions at the end of the existing items in this section, and a
let candidate = NSIndexPath(forItem: self.safeDataSource.dataSourceItems[sectionIndex].count - 1, inSection: sectionIndex)
if sectionDeletions[sectionIndex].count == 0 {
sectionDeletions[sectionIndex].insert(candidate)
} else {
var fromEnd = 1
var foundDelete = false
while !foundDelete {
let candidate = NSIndexPath(forItem: self.safeDataSource.dataSourceItems[sectionIndex].count - fromEnd, inSection: sectionIndex)
if !sectionDeletions[sectionIndex].contains(candidate) {
if sectionInsertions[sectionIndex].contains(candidate) {
sectionInsertions[sectionIndex].remove(candidate)
}
sectionDeletions[sectionIndex].insert(candidate)
sectionDeletions[sectionIndex].count // TODO: If this results in a deletion of something that is inside the insertion set of index paths, this logic should remove that index path from the insertions index path
foundDelete = true
} else {
let x = 1
fromEnd += 1
}
}
}
} else {
print(":-/")
}
*/
case .DeleteItemsStartingAtIndexPath: // Will delete all items from index path forward for section
assertionFailure("Delete items starting at index path not implemented yet.")
case .MoveItem(let fromIndexPath, let toIndexPath):
// TODO: Handle if move is for item that is to be deleted.
// >>>> TODO!!!!!! - the + shift should only occur for deletions with item index less than this guys
let fromIndexPathInExistingItemRange = preDeleteSectionStartingRanges[fromIndexPath.section] ~= (fro mIndexPath.item + onGoingExistingDeletes[fromIndexPath.section].count)
let toIndexPathInExistingItemRange = preDeleteSectionStartingRanges[toIndexPath.section] ~= (toIndexPath.item + onGoingExistingDeletes[toIndexPath.section].count)
if fromIndexPathInExistingItemRange && toIndexPathInExistingItemRange { // TODO: Test for if existing with pre delete data structure and shift index paths based on ongoing existingDeletes.
// is the move within existing?
// then it's a move operation - Need to figure out what the real from index path and to index path are
// is there a delete...
// is the move going to affect any pending changes within existing items?
// The move is within the postDelete existing items, just need to make a move op with theses index paths
// Take into account any deletions within the existing items and shift the index paths accordingly
} else if !toIndexPathInExistingItemRange && !toIndexPathInExistingItemRange {
// is the move within additions?
// just need to change the index paths where this will initially get inserted, no move necessary
} else {
// is the move across additions and existing
// I THINK this is just a move operation, need to verify
}
let x = 1
}
}
// TODO: Do this with higher order functions
var _newIndexPathsToAdd: [NSIndexPath] = []
for (sectionIndex, sa) in sectionAdditions {
sa
for a in sa {
_newIndexPathsToAdd.append(NSIndexPath(forItem: a, inSection: sectionIndex))
}
}
for insertions in sectionInsertions {
for indexPath in insertions {
_newIndexPathsToAdd.append(indexPath)
}
}
var _newIndexPathsToDelete: [NSIndexPath] = []
for deletions in sectionDeletions {
for indexPath in deletions {
print("Will Delete: \(indexPath.section):\(indexPath.item)")
_newIndexPathsToDelete.append(indexPath)
}
}
self.collectionView.performBatchUpdates({
// Perform changes
var indexPathsToAdd: [NSIndexPath] = []
for change in changes {
if case .AppendSection = change {
let newSectionIndex = self.safeDataSource.dataSourceItems.count
self.safeDataSource.dataSourceItems.append([])
self.collectionView.insertSections(NSIndexSet(index: newSectionIndex))
} else if case .InsertItem(let item, let indexPath) = change {
print(indexPath.item)
indexPathsToAdd.append(indexPath)
// TODO: Validate that item's index path matches index in array below:
self.safeDataSource.dataSourceItems[indexPath.section].insert(item, atIndex: indexPath.item)
} else if case .InsertItems(let items, let newIndexPaths) = change {
indexPathsToAdd += newIndexPaths
for (index, item) in items.enumerate() {
let indexPath = newIndexPaths[index]
self.safeDataSource.dataSourceItems[indexPath.section].insert(item, atIndex: indexPath.item)
}
} else if case .DeleteItem(let indexPath) = change {
self.safeDataSource.dataSourceItems[indexPath.section].removeAtIndex(indexPath.item)
} else if case .DeleteLastItem(let sectionIndex) = change {
if self.safeDataSource.dataSourceItems[sectionIndex].count > 0 {
self.safeDataSource.dataSourceItems[sectionIndex].removeLast()
}
}
}
print("-")
if _newIndexPathsToAdd.count > 0 {
self.collectionView.insertItemsAtIndexPaths(_newIndexPathsToAdd)
}
if _newIndexPathsToDelete.count > 0 {
self.collectionView.deleteItemsAtIndexPaths(_newIndexPathsToDelete)
}
// Plus reload operations
// Plus move operations
}) { completed in
self.finishedExecutingOperation()
}
}
}
}
@nonobjc
func itemBatchStartingIndexPath(deletionsUpToThisPoint deletionsUpToThisPoint: [Set<NSIndexPath>], givenIndexPath: NSIndexPath) -> NSIndexPath {
var offsetCount = 0 // TODO: Use fancy higher order funcs if possible
let deletions = deletionsUpToThisPoint[givenIndexPath.section]
for deletion in deletions {
if deletion.item < givenIndexPath.item { // TODO: Think more about whether this should be <=
offsetCount += 1
}
}
return NSIndexPath(forRow: givenIndexPath.item + offsetCount, inSection: givenIndexPath.section)
}
@nonobjc
func itemBatchStartingIndexPath(deletionsUpToThisPoint deletionsUpToThisPoint: [[NSIndexPath]], givenIndexPath: NSIndexPath) -> NSIndexPath {
var offsetCount = 0 // TODO: Use fancy higher order funcs if possible
let deletions = deletionsUpToThisPoint[givenIndexPath.section]
for deletion in deletions {
if deletion.item < givenIndexPath.item { // TODO: Think more about whether this should be <=
offsetCount += 1
}
}
return NSIndexPath(forRow: givenIndexPath.item + offsetCount, inSection: givenIndexPath.section)
}
}
let cellForItem = { (collectionView: UICollectionView, item: Color, indexPath: NSIndexPath) -> UICollectionViewCell in
let cell = collectionView.dequeueReusableCellWithReuseIdentifier("cell", forIndexPath: indexPath)
cell.backgroundColor = UIColor(color: item)
return cell
}
class InteractionHandler: NSObject {
let safeDataSource: SafeDataSource<Color>
init(safeDataSource: SafeDataSource<Color>) {
self.safeDataSource = safeDataSource
super.init()
}
func handleTap() {
safeDataSource.appendItem(Color(hue: 0.5, saturation: 1.0, brightness: 0.8))
}
}
let flowLayout = UICollectionViewFlowLayout()
flowLayout.itemSize = CGSizeMake(10, 10)
let collectionView = UICollectionView(frame: CGRectZero, collectionViewLayout: flowLayout)
let safeDataSource = SafeDataSource<Color>(items: [[]], collectionView: collectionView, cellForItemAtIndexPath: cellForItem)
collectionView.frame = CGRectMake(0, 0, 500, 1000)
collectionView.registerClass(UICollectionViewCell.self, forCellWithReuseIdentifier: "cell")
XCPlaygroundPage.currentPage.liveView = collectionView
XCPlaygroundPage.currentPage.needsIndefiniteExecution = true
let interactionHandler = InteractionHandler(safeDataSource: safeDataSource)
let tgr = UITapGestureRecognizer(target: interactionHandler, action: "handleTap")
collectionView.addGestureRecognizer(tgr)
dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)) {
for _ in (0...1000) {
interactionHandler.handleTap()
}
interactionHandler.safeDataSource.insertItemWithClosure { colors in
print("Insert item")
if colors.count > 0 {
if colors[0].count > 10 {
colors[0].count - 8
let indexPath = NSIndexPath(forItem: 4, inSection: 0)
indexPath.item
return (Color(hue: 0.1, saturation: 1.0, brightness: 0.9), indexPath)
}
}
return nil
}
for _ in (0...2) { // TODO: Try (0...1) and this will crash, support multiple consecutive deletes
interactionHandler.safeDataSource.deleteItemWithClosure { colors in
print("Delete item: loop")
if colors.count > 0 {
if colors[0].count > 10 {
return NSIndexPath(forItem: colors[0].count - 2, inSection: 0)
}
}
return nil
}
}
interactionHandler.safeDataSource.deleteItemWithClosure { colors in
print("Delete item: last")
return NSIndexPath(forItem: 0, inSection: 0)
}
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0)
// interactionHandler.safeDataSource.deleteLastItemInSection(0) // TODO: uncomment and support this use case
}
| apache-2.0 | c20cd00937201f01fe12f57cfb6bcd94 | 40.193583 | 268 | 0.692232 | 4.888438 | false | false | false | false |
kostiakoval/SpeedLog | Tests/SpeedLogTests.swift | 1 | 1676 | //
// SpeedLogTests.swift
// SpeedLogTests
//
// Created by Kostiantyn Koval on 20/11/15.
// Copyright © 2015 Kostiantyn Koval. All rights reserved.
//
import XCTest
@testable import SpeedLog
class SpeedLogTests: XCTestCase {
func testEmptyPrefix() {
let prefix = logForMode(.None)
XCTAssertEqual(prefix, "")
}
func testFilePrefix() {
let prefix = logForMode(.FileName)
XCTAssertEqual(prefix, "File.: ")
//FIXME: remove "." from string
}
func testFuncPrefix() {
let prefix = logForMode(.FuncName)
XCTAssertEqual(prefix, "FuncA: ")
}
func testLinePrefix() {
let prefix = logForMode(.Line)
XCTAssertEqual(prefix, "[10]: ")
}
func testDatePrefix() {
let prefix = logForMode(.Date)
XCTAssertEqual(prefix, "2015-01-10 06:44:43.060: ")
}
func testFullCodeLocationPrefix() {
let prefix = logForMode(.FullCodeLocation)
XCTAssertEqual(prefix, "File.FuncA[10]: ")
}
func testAllOptionsPrefix() {
let prefix = logForMode(.AllOptions)
XCTAssertEqual(prefix, "2015-01-10 06:44:43.060 File.FuncA[10]: ")
//FIXME: add space between date and file
}
}
// MARK: - Helpers
extension SpeedLogTests {
func logForMode(_ mode: LogMode) -> String {
SpeedLog.mode = mode
return SpeedLog.modePrefix(date, file:"File", function: "FuncA", line: 10)
}
var date: Date {
var components = DateComponents()
components.year = 2015
components.month = 1
components.day = 10
components.hour = 6
components.minute = 44
components.second = 43
components.nanosecond = 60000000 //100000 NSEC_PER_SEC
return Calendar.current.date(from: components)!
}
}
| mit | c6886d82e31468290e290f90659d41c2 | 21.333333 | 78 | 0.666866 | 3.841743 | false | true | false | false |
lvsti/Ilion | Ilion/StringsFileParser.swift | 1 | 4098 | //
// StringsFileParser.swift
// Ilion
//
// Created by Tamas Lustyik on 2017. 05. 19..
// Copyright © 2017. Tamas Lustyik. All rights reserved.
//
import Foundation
struct StringsFileEntry {
let keyRange: NSRange
let valueRange: NSRange
let commentRange: NSRange?
}
struct StringsFile {
let content: NSString
let encoding: String.Encoding
let entries: [LocKey: StringsFileEntry]
func value(for key: LocKey) -> String? {
guard let valueRange = entries[key]?.valueRange else {
return nil
}
return content.substring(with: valueRange)
}
func comment(for key: LocKey) -> String? {
guard let commentRange = entries[key]?.commentRange else {
return nil
}
return content.substring(with: commentRange)
}
}
class StringsFileParser {
private static let stringsRegex: NSRegularExpression = {
let comment = "(\\/\\*(?:[^*]|[\\r\\n]|(?:\\*+(?:[^*\\/]|[\\r\\n])))*\\*+\\/.*|\\/\\/.*)?"
let lineBreak = "[\\r\\n][\\t ]*"
let key = "\"((?:.|[\\r\\n])+?)(?<!\\\\)\""
let assignment = "\\s*=\\s*"
let value = "\"((?:.|[\\r\\n])*?)(?<!\\\\)\""
let trailing = "\\s*;"
return try! NSRegularExpression(pattern: comment + lineBreak + key + assignment + value + trailing,
options: [])
}()
func readStringsFile(at path: String) -> StringsFile? {
var encoding: String.Encoding = .utf8
guard let content = try? String(contentsOfFile: path, usedEncoding: &encoding) else {
return nil
}
var entries: [LocKey: StringsFileEntry] = [:]
let matches = StringsFileParser.stringsRegex.matches(in: content,
options: [],
range: NSRange(location: 0, length: content.length))
for match in matches {
let commentRange: NSRange?
let range = match.range(at: 1)
if range.location != NSNotFound {
let rawComment = (content as NSString).substring(with: range)
let slackChars = CharacterSet(charactersIn: "/*").union(.whitespaces)
let comment = rawComment.trimmingCharacters(in: slackChars)
if !comment.isEmpty {
commentRange = NSRange(location: range.location + (rawComment as NSString).range(of: comment).location,
length: comment.length)
}
else {
commentRange = nil
}
}
else {
commentRange = nil
}
let entry = StringsFileEntry(keyRange: match.range(at: 2),
valueRange: match.range(at: 3),
commentRange: commentRange)
let key = (content as NSString).substring(with: entry.keyRange)
entries[key] = entry
}
return StringsFile(content: content as NSString,
encoding: encoding,
entries: entries)
}
func readStringsDictFile(at path: String) -> [String: LocalizedFormat] {
guard let stringsDict = NSDictionary(contentsOfFile: path) as? [String: Any] else {
return [:]
}
let formatPairs: [(String, LocalizedFormat)]? = try? stringsDict
.map { (key, value) in
guard
let config = value as? [String: Any],
let format = try? LocalizedFormat(config: config)
else {
throw StringsDictParseError.invalidFormat
}
return (key, format)
}
if let formatPairs = formatPairs {
return Dictionary(pairs: formatPairs)
}
return [:]
}
}
| mit | 5abcbe1d1f77eccacde6bf4e66616080 | 33.720339 | 123 | 0.495729 | 5.026994 | false | false | false | false |
SusanDoggie/Doggie | Sources/DoggieMath/Accelerate/Move.swift | 1 | 4202 | //
// Move.swift
//
// The MIT License
// Copyright (c) 2015 - 2022 Susan Cheng. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
@inlinable
@inline(__always)
public func Move<T>(_ count: Int, _ input: UnsafePointer<T>, _ in_stride: Int, _ output: UnsafeMutablePointer<T>, _ out_stride: Int) {
var input = input
var output = output
for _ in 0..<count {
output.pointee = input.pointee
input += in_stride
output += out_stride
}
}
@inlinable
@inline(__always)
public func Move<T: FloatingPoint>(_ count: Int, _ real: UnsafePointer<T>, _ imag: UnsafePointer<T>, _ in_stride: Int, _ _real: UnsafeMutablePointer<T>, _ _imag: UnsafeMutablePointer<T>, _ out_stride: Int) {
var real = real
var imag = imag
var _real = _real
var _imag = _imag
for _ in 0..<count {
_real.pointee = real.pointee
_imag.pointee = imag.pointee
real += in_stride
imag += in_stride
_real += out_stride
_imag += out_stride
}
}
@inlinable
@inline(__always)
public func Swap<T>(_ count: Int, _ left: UnsafeMutablePointer<T>, _ l_stride: Int, _ right: UnsafeMutablePointer<T>, _ r_stride: Int) {
var left = left
var right = right
for _ in 0..<count {
(left.pointee, right.pointee) = (right.pointee, left.pointee)
left += l_stride
right += r_stride
}
}
@inlinable
@inline(__always)
public func Swap<T: FloatingPoint>(_ count: Int, _ lreal: UnsafeMutablePointer<T>, _ limag: UnsafeMutablePointer<T>, _ l_stride: Int, _ rreal: UnsafeMutablePointer<T>, _ rimag: UnsafeMutablePointer<T>, _ r_stride: Int) {
var lreal = lreal
var limag = limag
var rreal = rreal
var rimag = rimag
for _ in 0..<count {
(lreal.pointee, rreal.pointee) = (rreal.pointee, lreal.pointee)
(limag.pointee, rimag.pointee) = (rimag.pointee, limag.pointee)
lreal += l_stride
limag += l_stride
rreal += r_stride
rimag += r_stride
}
}
@inlinable
@inline(__always)
public func Transpose<T>(_ column: Int, _ row: Int, _ input: UnsafePointer<T>, _ in_stride: Int, _ output: UnsafeMutablePointer<T>, _ out_stride: Int) {
var input = input
var output = output
let _in_stride = in_stride * column
let _out_stride = out_stride * row
for _ in 0..<column {
Move(row, input, _in_stride, output, out_stride)
input += in_stride
output += _out_stride
}
}
@inlinable
@inline(__always)
public func Transpose<T: FloatingPoint>(_ column: Int, _ row: Int, _ real: UnsafePointer<T>, _ imag: UnsafePointer<T>, _ in_stride: Int, _ _real: UnsafeMutablePointer<T>, _ _imag: UnsafeMutablePointer<T>, _ out_stride: Int) {
var real = real
var imag = imag
var _real = _real
var _imag = _imag
let _in_stride = in_stride * column
let _out_stride = out_stride * row
for _ in 0..<column {
Move(row, real, imag, _in_stride, _real, _imag, out_stride)
real += in_stride
imag += in_stride
_real += _out_stride
_imag += _out_stride
}
}
| mit | e4c6ebd6ac0ec3ef2894ded1d41d9d76 | 32.887097 | 225 | 0.635412 | 3.731794 | false | false | false | false |
navermaps/maps.ios | NMapSampleSwift/NMapSampleSwift/ReverseGeocoderViewController.swift | 1 | 5313 | //
// GeocoderViewController.swift
// NMapSampleSwift
//
// Created by Junggyun Ahn on 2016. 11. 15..
// Copyright © 2016년 Naver. All rights reserved.
//
import UIKit
class ReverseGeocoderViewController: UIViewController, NMapViewDelegate, NMapPOIdataOverlayDelegate, MMapReverseGeocoderDelegate {
var mapView: NMapView?
override func viewDidLoad() {
super.viewDidLoad()
self.navigationController?.navigationBar.isTranslucent = false
mapView = NMapView(frame: self.view.frame)
if let mapView = mapView {
// set the delegate for map view
mapView.delegate = self
mapView.reverseGeocoderDelegate = self
// set the application api key for Open MapViewer Library
mapView.setClientId("YOUR CLIENT ID")
mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
view.addSubview(mapView)
}
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
mapView?.didReceiveMemoryWarning()
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
mapView?.viewWillAppear()
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
mapView?.viewDidAppear()
requestAddressByCoordination(NGeoPoint(longitude: 126.978371, latitude: 37.5666091))
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
mapView?.viewWillDisappear()
}
override func viewDidDisappear(_ animated: Bool) {
super.viewDidDisappear(animated)
mapView?.viewDidDisappear()
}
// MARK: - NMapViewDelegate Methods
open func onMapView(_ mapView: NMapView!, initHandler error: NMapError!) {
if (error == nil) { // success
// set map center and level
mapView.setMapCenter(NGeoPoint(longitude:126.978371, latitude:37.5666091), atLevel:11)
// set for retina display
mapView.setMapEnlarged(true, mapHD: true)
// set map mode : vector/satelite/hybrid
mapView.mapViewMode = .vector
} else { // fail
print("onMapView:initHandler: \(error.description)")
}
}
open func onMapView(_ mapView: NMapView!, touchesEnded touches: Set<AnyHashable>!, with event: UIEvent!) {
if let touch = event.allTouches?.first {
// Get the specific point that was touched
let scrPoint = touch.location(in: mapView)
print("scrPoint: \(scrPoint)")
print("to: \(mapView.fromPoint(scrPoint))")
requestAddressByCoordination(mapView.fromPoint(scrPoint))
}
}
// MARK: - NMapPOIdataOverlayDelegate Methods
open func onMapOverlay(_ poiDataOverlay: NMapPOIdataOverlay!, imageForOverlayItem poiItem: NMapPOIitem!, selected: Bool) -> UIImage! {
return NMapViewResources.imageWithType(poiItem.poiFlagType, selected: selected);
}
open func onMapOverlay(_ poiDataOverlay: NMapPOIdataOverlay!, anchorPointWithType poiFlagType: NMapPOIflagType) -> CGPoint {
return NMapViewResources.anchorPoint(withType: poiFlagType)
}
open func onMapOverlay(_ poiDataOverlay: NMapPOIdataOverlay!, calloutOffsetWithType poiFlagType: NMapPOIflagType) -> CGPoint {
return CGPoint.zero
}
open func onMapOverlay(_ poiDataOverlay: NMapPOIdataOverlay!, imageForCalloutOverlayItem poiItem: NMapPOIitem!, constraintSize: CGSize, selected: Bool, imageForCalloutRightAccessory: UIImage!, calloutPosition: UnsafeMutablePointer<CGPoint>!, calloutHit calloutHitRect: UnsafeMutablePointer<CGRect>!) -> UIImage! {
return nil
}
// MARK: - MMapReverseGeocoderDelegate Methods
open func location(_ location: NGeoPoint, didFind placemark: NMapPlacemark!) {
let address = placemark.address
self.title = address
let alert = UIAlertController(title: "ReverseGeocoder", message: address, preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "OK", style: .default, handler: nil))
present(alert, animated: true, completion: nil)
}
open func location(_ location: NGeoPoint, didFailWithError error: NMapError!) {
print("location:(\(location.longitude), \(location.latitude)) didFailWithError: \(error.description)")
}
// MARK: -
func requestAddressByCoordination(_ point: NGeoPoint) {
mapView?.findPlacemark(atLocation: point)
setMarker(point)
}
let UserFlagType: NMapPOIflagType = NMapPOIflagTypeReserved + 1
func setMarker(_ point: NGeoPoint) {
clearOverlay()
if let mapOverlayManager = mapView?.mapOverlayManager {
// create POI data overlay
if let poiDataOverlay = mapOverlayManager.newPOIdataOverlay() {
poiDataOverlay.initPOIdata(1)
poiDataOverlay.addPOIitem(atLocation: point, title: "마커 1", type: UserFlagType, iconIndex: 0, with: nil)
poiDataOverlay.endPOIdata()
}
}
}
func clearOverlay() {
if let mapOverlayManager = mapView?.mapOverlayManager {
mapOverlayManager.clearOverlay()
}
}
}
| apache-2.0 | 99d4e47a7d3e62c54b0ccd7cc0822a12 | 31.956522 | 317 | 0.665285 | 4.582038 | false | false | false | false |
ubi-naist/SenStick | ios/Pods/iOSDFULibrary/iOSDFULibrary/Classes/Implementation/DFUServiceInitiator.swift | 4 | 12696 | /*
* Copyright (c) 2016, Nordic Semiconductor
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
import CoreBluetooth
/**
The DFUServiceInitiator object should be used to send a firmware update to a remote BLE target compatible
with the Nordic Semiconductor's DFU (Device Firmware Update).
A `delegate`, `progressDelegate` and `logger` may be specified in order to receive status information.
*/
@objc public class DFUServiceInitiator : NSObject {
//MARK: - Internal variables
internal let centralManager : CBCentralManager
internal let target : CBPeripheral
internal var file : DFUFirmware?
//MARK: - Public variables
/**
The service delegate is an object that will be notified about state changes of the DFU Service.
Setting it is optional but recommended.
*/
public weak var delegate: DFUServiceDelegate?
/**
An optional progress delegate will be called only during upload. It notifies about current upload
percentage and speed.
*/
public weak var progressDelegate: DFUProgressDelegate?
/**
The logger is an object that should print given messages to the user. It is optional.
*/
public weak var logger: LoggerDelegate?
/**
The selector object is used when the device needs to disconnect and start advertising with a different address
to avodi caching problems, for example after switching to the Bootloader mode, or during sending a firmware
containing a Softdevice (or Softdevice and Bootloader) and the Application.
After flashing the first part (containing the Softdevice), the device restarts in the
DFU Bootloader mode and may (since SDK 8.0.0) start advertising with an address incremented by 1.
The peripheral specified in the `init` may no longer be used as there is no device advertising with its address.
The DFU Service will scan for a new device and connect to the first device returned by the selector.
The default selecter returns the first device with the required DFU Service UUID in the advertising packet
(Secure or Legacy DFU Service UUID).
Ignore this property if not updating Softdevice and Application from one ZIP file or your
*/
public var peripheralSelector: DFUPeripheralSelectorDelegate
/**
The number of packets of firmware data to be received by the DFU target before sending
a new Packet Receipt Notification.
If this value is 0, the packet receipt notification will be disabled by the DFU target.
Default value is 12. Higher values (~20+), or disabling it, may speed up the upload process,
but also cause a buffer overflow and hang the Bluetooth adapter.
Maximum verified values were 29 for iPhone 6 Plus or 22 for iPhone 7, both iOS 10.1.
*/
public var packetReceiptNotificationParameter: UInt16 = 12
/**
**Legacy DFU only.**
Setting this property to true will prevent from jumping to the DFU Bootloader
mode in case there is no DFU Version characteristic. Use it if the DFU operation can be handled by your
device running in the application mode. If the DFU Version characteristic exists, the
information whether to begin DFU operation, or jump to bootloader, is taken from the
characteristic's value. The value returned equal to 0x0100 (read as: minor=1, major=0, or version 0.1)
means that the device is in the application mode and buttonless jump to DFU Bootloader is supported.
Currently, the following values of the DFU Version characteristic are supported:
**No DFU Version characteristic** - one of the first implementations of DFU Service. The device
may support only Application update (version from SDK 4.3.0), may support Soft Device, Bootloader
and Application update but without buttonless jump to bootloader (SDK 6.0.0) or with
buttonless jump (SDK 6.1.0).
The DFU Library determines whether the device is in application mode or in DFU Bootloader mode
by counting number of services: if no DFU Service found - device is in app mode and does not support
buttonless jump, if the DFU Service is the only service found (except General Access and General Attribute
services) - it assumes it is in DFU Bootloader mode and may start DFU immediately, if there is
at least one service except DFU Service - the device is in application mode and supports buttonless
jump. In the lase case, you want to perform DFU operation without jumping - call the setForceDfu(force:Bool)
method with parameter equal to true.
**0.1** - Device is in a mode that supports buttonless jump to the DFU Bootloader
**0.5** - Device can handle DFU operation. Extended Init packet is required. Bond information is lost
in the bootloader mode and after updating an app. Released in SDK 7.0.0.
**0.6** - Bond information is kept in bootloader mode and may be kept after updating application
(DFU Bootloader must be configured to preserve the bond information).
**0.7** - The SHA-256 firmware hash is used in the Extended Init Packet instead of CRC-16.
This feature is transparent for the DFU Service.
**0.8** - The Extended Init Packet is signed using the private key. The bootloader, using the public key,
is able to verify the content. Released in SDK 9.0.0 as experimental feature.
Caution! The firmware type (Application, Bootloader, SoftDevice or SoftDevice+Bootloader) is not
encrypted as it is not a part of the Extended Init Packet. A change in the protocol will be required
to fix this issue.
By default the DFU Library will try to switch the device to the DFU Bootloader mode if it finds
more services then one (DFU Service). It assumes it is already in the bootloader mode
if the only service found is the DFU Service. Setting the forceDfu to true (YES) will prevent from
jumping in these both cases.
*/
public var forceDfu = false
/**
Set this flag to true to enable experimental buttonless feature in Secure DFU. When the
experimental Buttonless DFU Service is found on a device, the service will use it to
switch the device to the bootloader mode, connect to it in that mode and proceed with DFU.
**Please, read the information below before setting it to true.**
In the SDK 12.x the Buttonless DFU feature for Secure DFU was experimental.
It is NOT recommended to use it: it was not properly tested, had implementation bugs
(e.g. https://devzone.nordicsemi.com/question/100609/sdk-12-bootloader-erased-after-programming/) and
does not required encryption and therefore may lead to DOS attack (anyone can use it to switch the device
to bootloader mode). However, as there is no other way to trigger bootloader mode on devices
without a button, this DFU Library supports this service, but the feature must be explicitly enabled here.
Be aware, that setting this flag to false will no protect your devices from this kind of attacks, as
an attacker may use another app for that purpose. To be sure your device is secure remove this
experimental service from your device.
Spec:
Buttonless DFU Service UUID: 8E400001-F315-4F60-9FB8-838830DAEA50
Buttonless DFU characteristic UUID: 8E400001-F315-4F60-9FB8-838830DAEA50 (the same)
Enter Bootloader Op Code: 0x01
Correct return value: 0x20-01-01 , where:
0x20 - Response Op Code
0x01 - Request Code
0x01 - Success
The device should disconnect and restart in DFU mode after sending the notification.
In SDK 13 this issue will be fixed by a proper implementation (bonding required,
passing bond information to the bootloader, encryption, well tested). It is recommended to use this
new service when SDK 13 (or later) is out. TODO: fix the docs when SDK 13 is out.
*/
public var enableUnsafeExperimentalButtonlessServiceInSecureDfu = false
//MARK: - Public API
/**
Creates the DFUServiceInitializer that will allow to send an update to the given peripheral.
The peripheral should be disconnected prior to calling start() method.
The DFU service will automatically connect to the device, check if it has required DFU
service (return a delegate callback if does not have such), jump to the DFU Bootloader mode
if necessary and perform the DFU. Proper delegate methods will be called during the process.
- parameter centralManager: manager that will be used to connect to the peripheral
- parameter target: the DFU target peripheral
- returns: the initiator instance
- seeAlso: peripheralSelector property - a selector used when scanning for a device in DFU Bootloader mode
in case you want to update a Softdevice and Application from a single ZIP Distribution Packet.
*/
public init(centralManager: CBCentralManager, target: CBPeripheral) {
self.centralManager = centralManager
// Just to be sure that manager is not scanning
self.centralManager.stopScan()
self.target = target
// Default peripheral selector will choose the service UUID as a filter
self.peripheralSelector = DFUPeripheralSelector()
super.init()
}
/**
Sets the file with the firmware. The file must be specified before calling `start()` method,
and must not be nil.
- parameter file: The firmware wrapper object
- returns: the initiator instance to allow chain use
*/
public func with(firmware file: DFUFirmware) -> DFUServiceInitiator {
self.file = file
return self
}
/**
Starts sending the specified firmware to the DFU target.
When started, the service will automatically connect to the target, switch to DFU Bootloader mode
(if necessary), and send all the content of the specified firmware file in one or two connections.
Two connections will be used if a ZIP file contains a Soft Device and/or Bootloader and an Application.
First the Soft Device and/or Bootloader will be transferred, then the service will disconnect, reconnect to
the (new) Bootloader again and send the Application (unless the target supports receiving all files in a single
connection).
The current version of the DFU Bootloader, due to memory limitations, may receive together only a Softdevice and Bootloader.
- returns: A DFUServiceController object that can be used to control the DFU operation.
*/
public func start() -> DFUServiceController? {
// The firmware file must be specified before calling `start()`
if file == nil {
delegate?.dfuError(.fileNotSpecified, didOccurWithMessage: "Firmare not specified")
return nil
}
let controller = DFUServiceController()
let selector = DFUServiceSelector(initiator: self, controller: controller)
controller.executor = selector
selector.start()
return controller
}
}
| mit | 481b4848214487cd28dfafd6ab179961 | 52.79661 | 145 | 0.724953 | 5.082466 | false | false | false | false |
SusanDoggie/Doggie | Sources/DoggieGraphics/ApplePlatform/Graphic/CGShading.swift | 1 | 5273 | //
// CGShading.swift
//
// The MIT License
// Copyright (c) 2015 - 2022 Susan Cheng. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
#if canImport(CoreGraphics)
public func CGFunctionCreate(
version: UInt32,
domainDimension: Int,
domain: UnsafePointer<CGFloat>?,
rangeDimension: Int,
range: UnsafePointer<CGFloat>?,
callbacks: @escaping (UnsafePointer<CGFloat>, UnsafeMutablePointer<CGFloat>) -> Void
) -> CGFunction? {
typealias CGFunctionCallback = (UnsafePointer<CGFloat>, UnsafeMutablePointer<CGFloat>) -> Void
let info = UnsafeMutablePointer<CGFunctionCallback>.allocate(capacity: 1)
info.initialize(to: callbacks)
let callback = CGFunctionCallbacks(version: version, evaluate: { (info, inputs, ouputs) in
guard let callbacks = info?.assumingMemoryBound(to: CGFunctionCallback.self).pointee else { return }
callbacks(inputs, ouputs)
}, releaseInfo: { info in
guard let info = info?.assumingMemoryBound(to: CGFunctionCallback.self) else { return }
info.deinitialize(count: 1)
info.deallocate()
})
return CGFunction(info: info, domainDimension: domainDimension, domain: domain, rangeDimension: rangeDimension, range: range, callbacks: [callback])
}
public func CGShadingCreate(axialSpace space: CGColorSpace, start: CGPoint, end: CGPoint, extendStart: Bool, extendEnd: Bool, callbacks: @escaping (CGFloat, UnsafeMutableBufferPointer<CGFloat>) -> Void) -> CGShading? {
let rangeDimension = space.numberOfComponents + 1
guard let function = CGFunctionCreate(
version: 0,
domainDimension: 1,
domain: [0, 1],
rangeDimension: rangeDimension,
range: nil,
callbacks: { callbacks($0.pointee, UnsafeMutableBufferPointer(start: $1, count: rangeDimension)) }
) else { return nil }
return CGShading(axialSpace: space, start: start, end: end, function: function, extendStart: extendStart, extendEnd: extendEnd)
}
public func CGShadingCreate(radialSpace space: CGColorSpace, start: CGPoint, startRadius: CGFloat, end: CGPoint, endRadius: CGFloat, extendStart: Bool, extendEnd: Bool, callbacks: @escaping (CGFloat, UnsafeMutableBufferPointer<CGFloat>) -> Void) -> CGShading? {
let rangeDimension = space.numberOfComponents + 1
guard let function = CGFunctionCreate(
version: 0,
domainDimension: 1,
domain: [0, 1],
rangeDimension: rangeDimension,
range: nil,
callbacks: { callbacks($0.pointee, UnsafeMutableBufferPointer(start: $1, count: rangeDimension)) }
) else { return nil }
return CGShading(radialSpace: space, start: start, startRadius: startRadius, end: end, endRadius: endRadius, function: function, extendStart: extendStart, extendEnd: extendEnd)
}
extension CGContext {
public func drawLinearGradient(colorSpace: CGColorSpace, start: CGPoint, end: CGPoint, options: CGGradientDrawingOptions, callbacks: @escaping (CGFloat, UnsafeMutableBufferPointer<CGFloat>) -> Void) {
guard let shading = CGShadingCreate(
axialSpace: colorSpace,
start: start,
end: end,
extendStart: options.contains(.drawsBeforeStartLocation),
extendEnd: options.contains(.drawsAfterEndLocation),
callbacks: callbacks
) else { return }
self.drawShading(shading)
}
public func drawRadialGradient(colorSpace: CGColorSpace, start: CGPoint, startRadius: CGFloat, end: CGPoint, endRadius: CGFloat, options: CGGradientDrawingOptions, callbacks: @escaping (CGFloat, UnsafeMutableBufferPointer<CGFloat>) -> Void) {
guard let shading = CGShadingCreate(
radialSpace: colorSpace,
start: start,
startRadius: startRadius,
end: end,
endRadius: endRadius,
extendStart: options.contains(.drawsBeforeStartLocation),
extendEnd: options.contains(.drawsAfterEndLocation),
callbacks: callbacks
) else { return }
self.drawShading(shading)
}
}
#endif
| mit | ec674dba071dc67d2fff1e140e35fbfa | 41.524194 | 261 | 0.68993 | 4.637643 | false | false | false | false |
natestedman/LayoutModules | LayoutModules/LayoutModuleType.swift | 1 | 6266 | // LayoutModules
// Written in 2015 by Nate Stedman <[email protected]>
//
// To the extent possible under law, the author(s) have dedicated all copyright and
// related and neighboring rights to this software to the public domain worldwide.
// This software is distributed without any warranty.
//
// You should have received a copy of the CC0 Public Domain Dedication along with
// this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
import UIKit
/// A base type for layout modules.
public protocol LayoutModuleType
{
// MARK: - Layout
/**
Performs layout for a section.
- parameter attributes: The array of attributes to update.
- parameter origin: The origin of the module.
- parameter majorAxis: The major axis for the layout.
- parameter minorDimension: The minor, or non-scrolling, dimension of the module.
- returns: A layout result for the section, including the layout attributes for each item, and the new initial
major direction offset for the next section.
*/
func layoutAttributesWith(count count: Int, origin: Point, majorAxis: Axis, minorDimension: CGFloat)
-> LayoutResult
// MARK: - Initial & Final Layout Attributes
/**
Provides the initial layout attributes for an appearing item.
- parameter indexPath: The index path of the appearing item.
- parameter attributes: The layout attributes of the appearing item.
- returns: A layout attributes value, or `nil`.
*/
func initialLayoutAttributesFor(indexPath: NSIndexPath, attributes: LayoutAttributes) -> LayoutAttributes?
/**
Provides the final layout attributes for an disappearing item.
- parameter indexPath: The index path of the disappearing item.
- parameter attributes: The layout attributes of the disappearing item.
- returns: A layout attributes value, or `nil`.
*/
func finalLayoutAttributesFor(indexPath: NSIndexPath, attributes: LayoutAttributes) -> LayoutAttributes?
}
extension LayoutModuleType
{
// MARK: - Default Implementations for Initial & Final Layout Attributes
/// The default implementation returns `nil`.
public func initialLayoutAttributesFor(indexPath: NSIndexPath, attributes: LayoutAttributes) -> LayoutAttributes?
{
return nil
}
/// The default implementation returns `nil`.
public func finalLayoutAttributesFor(indexPath: NSIndexPath, attributes: LayoutAttributes) -> LayoutAttributes?
{
return nil
}
}
extension LayoutModuleType
{
// MARK: - Adding Initial & Final Layout Attributes
/**
Creates a layout module that overrides the initial transition behavior of the receiver.
- parameter transition: A function that produces initial layout attributes.
*/
public func withInitialTransition(transition: LayoutModule.TransitionLayout) -> LayoutModule
{
return LayoutModule(
layout: layoutAttributesWith,
initialLayout: transition,
finalLayout: finalLayoutAttributesFor
)
}
/**
Creates a layout module that overrides the final transition behavior of the receiver.
- parameter transition: A function that produces final layout attributes.
*/
public func withFinalTransition(transition: LayoutModule.TransitionLayout) -> LayoutModule
{
return LayoutModule(
layout: layoutAttributesWith,
initialLayout: initialLayoutAttributesFor,
finalLayout: transition
)
}
}
extension LayoutModuleType
{
// MARK: - Insets
/**
Produces a new layout module by insetting the layout module.
All parameters are optional. If a parameter is omitted, that edge will not be inset.
- parameter minMajor: Insets from the minimum end of the major axis.
- parameter maxMajor: Insets from the maximum end of the major axis.
- parameter minMinor: Insets from the minimum end of the minor axis.
- parameter maxMinor: Insets from the maximum end of the minor axis.
- returns: A new layout module, derived from the module this function was called on.
*/
public func inset(minMajor minMajor: CGFloat = 0,
maxMajor: CGFloat = 0,
minMinor: CGFloat = 0,
maxMinor: CGFloat = 0) -> LayoutModule
{
return LayoutModule { count, origin, majorAxis, minorDimension in
let insetOrigin = Point(major: origin.major + minMajor, minor: origin.minor + minMinor)
let insetMinorDimension = minorDimension - minMinor - maxMinor
let result = self.layoutAttributesWith(
count: count,
origin: insetOrigin,
majorAxis: majorAxis,
minorDimension: insetMinorDimension
)
return LayoutResult(layoutAttributes: result.layoutAttributes, finalOffset: result.finalOffset + maxMajor)
}
}
/**
Produces a new layout module by insetting the layout module equally in all directions.
- parameter inset: The amount to inset.
- returns: A new layout module, derived from the module this function was called on.
*/
public func inset(inset: CGFloat) -> LayoutModule
{
return self.inset(minMajor: inset, maxMajor: inset, minMinor: inset, maxMinor: inset)
}
}
extension LayoutModuleType
{
// MARK: - Transforms
/**
Produces a new layout module by translating the layout module.
- parameter major: The major direction translation.
- parameter minor: The minor direction translation.
- returns: A new layout module, derived from the module this function was called on.
*/
public func translate(major major: CGFloat = 0, minor: CGFloat = 0) -> LayoutModule
{
return LayoutModule { count, origin, majorAxis, minorDimension in
self.layoutAttributesWith(
count: count,
origin: Point(major: origin.major + major, minor: origin.minor + minor),
majorAxis: majorAxis,
minorDimension: minorDimension
)
}
}
}
| cc0-1.0 | 154658967b788b0205b5a770c06a6f1a | 34.40113 | 118 | 0.670444 | 5.123467 | false | false | false | false |
doronkatz/firefox-ios | Sync/SyncStateMachine.swift | 2 | 39729 | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import Foundation
import Shared
import Account
import XCGLogger
import Deferred
private let log = Logger.syncLogger
private let StorageVersionCurrent = 5
// Names of collections for which a synchronizer is implemented locally.
private let LocalEngines: [String] = [
"bookmarks",
"clients",
"history",
"passwords",
"tabs",
]
// Names of collections which will appear in a default meta/global produced locally.
// Map collection name to engine version. See http://docs.services.mozilla.com/sync/objectformats.html.
private let DefaultEngines: [String: Int] = [
"bookmarks": BookmarksStorageVersion,
"clients": ClientsStorageVersion,
"history": HistoryStorageVersion,
"passwords": PasswordsStorageVersion,
"tabs": TabsStorageVersion,
// We opt-in to syncing collections we don't know about, since no client offers to sync non-enabled,
// non-declined engines yet. See Bug 969669.
"forms": 1,
"addons": 1,
"prefs": 2,
]
// Names of collections which will appear as declined in a default
// meta/global produced locally.
private let DefaultDeclined: [String] = [String]()
// public for testing.
public func createMetaGlobalWithEngineConfiguration(_ engineConfiguration: EngineConfiguration) -> MetaGlobal {
var engines: [String: EngineMeta] = [:]
for engine in engineConfiguration.enabled {
// We take this device's version, or, if we don't know the correct version, 0. Another client should recognize
// the engine, see an old version, wipe and start again.
// TODO: this client does not yet do this wipe-and-update itself!
let version = DefaultEngines[engine] ?? 0
engines[engine] = EngineMeta(version: version, syncID: Bytes.generateGUID())
}
return MetaGlobal(syncID: Bytes.generateGUID(), storageVersion: StorageVersionCurrent, engines: engines, declined: engineConfiguration.declined)
}
public func createMetaGlobal() -> MetaGlobal {
let engineConfiguration = EngineConfiguration(enabled: Array(DefaultEngines.keys), declined: DefaultDeclined)
return createMetaGlobalWithEngineConfiguration(engineConfiguration)
}
public typealias TokenSource = () -> Deferred<Maybe<TokenServerToken>>
public typealias ReadyDeferred = Deferred<Maybe<Ready>>
// See docs in docs/sync.md.
// You might be wondering why this doesn't have a Sync15StorageClient like FxALoginStateMachine
// does. Well, such a client is pinned to a particular server, and this state machine must
// acknowledge that a Sync client occasionally must migrate between two servers, preserving
// some state from the last.
// The resultant 'Ready' will be able to provide a suitably initialized storage client.
open class SyncStateMachine {
// The keys are used as a set, to prevent cycles in the state machine.
var stateLabelsSeen = [SyncStateLabel: Bool]()
var stateLabelSequence = [SyncStateLabel]()
let stateLabelsAllowed: Set<SyncStateLabel>
let scratchpadPrefs: Prefs
/// Use this set of states to constrain the state machine to attempt the barest
/// minimum to get to Ready. This is suitable for extension uses. If it is not possible,
/// then no destructive or expensive actions are taken (e.g. total HTTP requests,
/// duration, records processed, database writes, fsyncs, blanking any local collections)
public static let OptimisticStates = Set(SyncStateLabel.optimisticValues)
/// The default set of states that the state machine is allowed to use.
public static let AllStates = Set(SyncStateLabel.allValues)
public init(prefs: Prefs, allowingStates labels: Set<SyncStateLabel> = SyncStateMachine.AllStates) {
self.scratchpadPrefs = prefs.branch("scratchpad")
self.stateLabelsAllowed = labels
}
open class func clearStateFromPrefs(_ prefs: Prefs) {
log.debug("Clearing all Sync prefs.")
Scratchpad.clearFromPrefs(prefs.branch("scratchpad")) // XXX this is convoluted.
prefs.clearAll()
}
fileprivate func advanceFromState(_ state: SyncState) -> ReadyDeferred {
log.info("advanceFromState: \(state.label)")
// Record visibility before taking any action.
let labelAlreadySeen = self.stateLabelsSeen.updateValue(true, forKey: state.label) != nil
stateLabelSequence.append(state.label)
if let ready = state as? Ready {
// Sweet, we made it!
return deferMaybe(ready)
}
// Cycles are not necessarily a problem, but seeing the same (recoverable) error condition is a problem.
if state is RecoverableSyncState && labelAlreadySeen {
return deferMaybe(StateMachineCycleError())
}
guard stateLabelsAllowed.contains(state.label) else {
return deferMaybe(DisallowedStateError(state.label, allowedStates: stateLabelsAllowed))
}
return state.advance() >>== self.advanceFromState
}
open func toReady(_ authState: SyncAuthState) -> ReadyDeferred {
let token = authState.token(Date.now(), canBeExpired: false)
return chainDeferred(token, f: { (token, kB) in
log.debug("Got token from auth state.")
if Logger.logPII {
log.debug("Server is \(token.api_endpoint).")
}
let prior = Scratchpad.restoreFromPrefs(self.scratchpadPrefs, syncKeyBundle: KeyBundle.fromKB(kB))
if prior == nil {
log.info("No persisted Sync state. Starting over.")
}
var scratchpad = prior ?? Scratchpad(b: KeyBundle.fromKB(kB), persistingTo: self.scratchpadPrefs)
// Take the scratchpad and add the hashedUID from the token
let b = Scratchpad.Builder(p: scratchpad)
b.hashedUID = token.hashedFxAUID
scratchpad = b.build()
log.info("Advancing to InitialWithLiveToken.")
let state = InitialWithLiveToken(scratchpad: scratchpad, token: token)
// Start with fresh visibility data.
self.stateLabelsSeen = [:]
self.stateLabelSequence = []
return self.advanceFromState(state)
})
}
}
public enum SyncStateLabel: String {
case Stub = "STUB" // For 'abstract' base classes.
case InitialWithExpiredToken = "initialWithExpiredToken"
case InitialWithExpiredTokenAndInfo = "initialWithExpiredTokenAndInfo"
case InitialWithLiveToken = "initialWithLiveToken"
case InitialWithLiveTokenAndInfo = "initialWithLiveTokenAndInfo"
case ResolveMetaGlobalVersion = "resolveMetaGlobalVersion"
case ResolveMetaGlobalContent = "resolveMetaGlobalContent"
case NeedsFreshMetaGlobal = "needsFreshMetaGlobal"
case NewMetaGlobal = "newMetaGlobal"
case HasMetaGlobal = "hasMetaGlobal"
case NeedsFreshCryptoKeys = "needsFreshCryptoKeys"
case HasFreshCryptoKeys = "hasFreshCryptoKeys"
case Ready = "ready"
case FreshStartRequired = "freshStartRequired" // Go around again... once only, perhaps.
case ServerConfigurationRequired = "serverConfigurationRequired"
case ChangedServer = "changedServer"
case MissingMetaGlobal = "missingMetaGlobal"
case MissingCryptoKeys = "missingCryptoKeys"
case MalformedCryptoKeys = "malformedCryptoKeys"
case SyncIDChanged = "syncIDChanged"
case RemoteUpgradeRequired = "remoteUpgradeRequired"
case ClientUpgradeRequired = "clientUpgradeRequired"
static let allValues: [SyncStateLabel] = [
InitialWithExpiredToken,
InitialWithExpiredTokenAndInfo,
InitialWithLiveToken,
InitialWithLiveTokenAndInfo,
NeedsFreshMetaGlobal,
ResolveMetaGlobalVersion,
ResolveMetaGlobalContent,
NewMetaGlobal,
HasMetaGlobal,
NeedsFreshCryptoKeys,
HasFreshCryptoKeys,
Ready,
FreshStartRequired,
ServerConfigurationRequired,
ChangedServer,
MissingMetaGlobal,
MissingCryptoKeys,
MalformedCryptoKeys,
SyncIDChanged,
RemoteUpgradeRequired,
ClientUpgradeRequired,
]
// This is the list of states needed to get to Ready, or failing.
// This is useful in circumstances where it is important to conserve time and/or battery, and failure
// to timely sync is acceptable.
static let optimisticValues: [SyncStateLabel] = [
InitialWithLiveToken,
InitialWithLiveTokenAndInfo,
HasMetaGlobal,
HasFreshCryptoKeys,
Ready,
]
}
/**
* States in this state machine all implement SyncState.
*
* States are either successful main-flow states, or (recoverable) error states.
* Errors that aren't recoverable are simply errors.
* Main-flow states flow one to one.
*
* (Terminal failure states might be introduced at some point.)
*
* Multiple error states (but typically only one) can arise from each main state transition.
* For example, parsing meta/global can result in a number of different non-routine situations.
*
* For these reasons, and the lack of useful ADTs in Swift, we model the main flow as
* the success branch of a Result, and the recovery flows as a part of the failure branch.
*
* We could just as easily use a ternary Either-style operator, but thanks to Swift's
* optional-cast-let it's no saving to do so.
*
* Because of the lack of type system support, all RecoverableSyncStates must have the same
* signature. That signature implies a possibly multi-state transition; individual states
* will have richer type signatures.
*/
public protocol SyncState {
var label: SyncStateLabel { get }
func advance() -> Deferred<Maybe<SyncState>>
}
/*
* Base classes to avoid repeating initializers all over the place.
*/
open class BaseSyncState: SyncState {
open var label: SyncStateLabel { return SyncStateLabel.Stub }
open let client: Sync15StorageClient!
let token: TokenServerToken // Maybe expired.
var scratchpad: Scratchpad
// TODO: 304 for i/c.
open func getInfoCollections() -> Deferred<Maybe<InfoCollections>> {
return chain(self.client.getInfoCollections(), f: {
return $0.value
})
}
public init(client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken) {
self.scratchpad = scratchpad
self.token = token
self.client = client
log.info("Inited \(self.label.rawValue)")
}
open func synchronizer<T: Synchronizer>(_ synchronizerClass: T.Type, delegate: SyncDelegate, prefs: Prefs) -> T {
return T(scratchpad: self.scratchpad, delegate: delegate, basePrefs: prefs)
}
// This isn't a convenience initializer 'cos subclasses can't call convenience initializers.
public init(scratchpad: Scratchpad, token: TokenServerToken) {
let workQueue = DispatchQueue.global()
let resultQueue = DispatchQueue.main
let backoff = scratchpad.backoffStorage
let client = Sync15StorageClient(token: token, workQueue: workQueue, resultQueue: resultQueue, backoff: backoff)
self.scratchpad = scratchpad
self.token = token
self.client = client
log.info("Inited \(self.label.rawValue)")
}
open func advance() -> Deferred<Maybe<SyncState>> {
return deferMaybe(StubStateError())
}
}
open class BaseSyncStateWithInfo: BaseSyncState {
open let info: InfoCollections
init(client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken, info: InfoCollections) {
self.info = info
super.init(client: client, scratchpad: scratchpad, token: token)
}
init(scratchpad: Scratchpad, token: TokenServerToken, info: InfoCollections) {
self.info = info
super.init(scratchpad: scratchpad, token: token)
}
}
/*
* Error types.
*/
public protocol SyncError: MaybeErrorType, SyncPingFailureFormattable {}
extension SyncError {
public var failureReasonName: SyncPingFailureReasonName {
return .unexpectedError
}
}
open class UnknownError: SyncError {
open var description: String {
return "Unknown error."
}
}
open class StateMachineCycleError: SyncError {
open var description: String {
return "The Sync state machine encountered a cycle. This is a coding error."
}
}
open class CouldNotFetchMetaGlobalError: SyncError {
open var description: String {
return "Could not fetch meta/global."
}
}
open class CouldNotFetchKeysError: SyncError {
open var description: String {
return "Could not fetch crypto/keys."
}
}
open class StubStateError: SyncError {
open var description: String {
return "Unexpectedly reached a stub state. This is a coding error."
}
}
open class ClientUpgradeRequiredError: SyncError {
let targetStorageVersion: Int
public init(target: Int) {
self.targetStorageVersion = target
}
open var description: String {
return "Client upgrade required to work with storage version \(self.targetStorageVersion)."
}
}
open class InvalidKeysError: SyncError {
let keys: Keys
public init(_ keys: Keys) {
self.keys = keys
}
open var description: String {
return "Downloaded crypto/keys, but couldn't parse them."
}
}
open class DisallowedStateError: SyncError {
let state: SyncStateLabel
let allowedStates: Set<SyncStateLabel>
public init(_ state: SyncStateLabel, allowedStates: Set<SyncStateLabel>) {
self.state = state
self.allowedStates = allowedStates
}
open var description: String {
return "Sync state machine reached \(String(describing: state)) state, which is disallowed. Legal states are: \(String(describing: allowedStates))"
}
}
/**
* Error states. These are errors that can be recovered from by taking actions. We use RecoverableSyncState as a
* sentinel: if we see the same recoverable state twice, we bail out and complain that we've seen a cycle. (Seeing
* some states -- principally initial states -- twice is fine.)
*/
public protocol RecoverableSyncState: SyncState {
}
/**
* Recovery: discard our local timestamps and sync states; discard caches.
* Be prepared to handle a conflict between our selected engines and the new
* server's meta/global; if an engine is selected locally but not declined
* remotely, then we'll need to upload a new meta/global and sync that engine.
*/
open class ChangedServerError: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.ChangedServer }
let newToken: TokenServerToken
let newScratchpad: Scratchpad
public init(scratchpad: Scratchpad, token: TokenServerToken) {
self.newToken = token
self.newScratchpad = Scratchpad(b: scratchpad.syncKeyBundle, persistingTo: scratchpad.prefs)
}
open func advance() -> Deferred<Maybe<SyncState>> {
// TODO: mutate local storage to allow for a fresh start.
let state = InitialWithLiveToken(scratchpad: newScratchpad.checkpoint(), token: newToken)
return deferMaybe(state)
}
}
/**
* Recovery: same as for changed server, but no need to upload a new meta/global.
*/
open class SyncIDChangedError: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.SyncIDChanged }
fileprivate let previousState: BaseSyncStateWithInfo
fileprivate let newMetaGlobal: Fetched<MetaGlobal>
public init(previousState: BaseSyncStateWithInfo, newMetaGlobal: Fetched<MetaGlobal>) {
self.previousState = previousState
self.newMetaGlobal = newMetaGlobal
}
open func advance() -> Deferred<Maybe<SyncState>> {
// TODO: mutate local storage to allow for a fresh start.
let s = self.previousState.scratchpad.evolve().setGlobal(self.newMetaGlobal).setKeys(nil).build().checkpoint()
let state = HasMetaGlobal(client: self.previousState.client, scratchpad: s, token: self.previousState.token, info: self.previousState.info)
return deferMaybe(state)
}
}
/**
* Recovery: configure the server.
*/
open class ServerConfigurationRequiredError: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.ServerConfigurationRequired }
fileprivate let previousState: BaseSyncStateWithInfo
public init(previousState: BaseSyncStateWithInfo) {
self.previousState = previousState
}
open func advance() -> Deferred<Maybe<SyncState>> {
let client = self.previousState.client!
let s = self.previousState.scratchpad.evolve()
.setGlobal(nil)
.addLocalCommandsFromKeys(nil)
.setKeys(nil)
.build().checkpoint()
// Upload a new meta/global ...
let metaGlobal: MetaGlobal
if let oldEngineConfiguration = s.engineConfiguration {
metaGlobal = createMetaGlobalWithEngineConfiguration(oldEngineConfiguration)
} else {
metaGlobal = createMetaGlobal()
}
return client.uploadMetaGlobal(metaGlobal, ifUnmodifiedSince: nil)
// ... and a new crypto/keys.
>>> { return client.uploadCryptoKeys(Keys.random(), withSyncKeyBundle: s.syncKeyBundle, ifUnmodifiedSince: nil) }
>>> { return deferMaybe(InitialWithLiveToken(client: client, scratchpad: s, token: self.previousState.token)) }
}
}
/**
* Recovery: wipe the server (perhaps unnecessarily) and proceed to configure the server.
*/
open class FreshStartRequiredError: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.FreshStartRequired }
fileprivate let previousState: BaseSyncStateWithInfo
public init(previousState: BaseSyncStateWithInfo) {
self.previousState = previousState
}
open func advance() -> Deferred<Maybe<SyncState>> {
let client = self.previousState.client!
return client.wipeStorage()
>>> { return deferMaybe(ServerConfigurationRequiredError(previousState: self.previousState)) }
}
}
open class MissingMetaGlobalError: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.MissingMetaGlobal }
fileprivate let previousState: BaseSyncStateWithInfo
public init(previousState: BaseSyncStateWithInfo) {
self.previousState = previousState
}
open func advance() -> Deferred<Maybe<SyncState>> {
return deferMaybe(FreshStartRequiredError(previousState: self.previousState))
}
}
open class MissingCryptoKeysError: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.MissingCryptoKeys }
fileprivate let previousState: BaseSyncStateWithInfo
public init(previousState: BaseSyncStateWithInfo) {
self.previousState = previousState
}
open func advance() -> Deferred<Maybe<SyncState>> {
return deferMaybe(FreshStartRequiredError(previousState: self.previousState))
}
}
open class RemoteUpgradeRequired: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.RemoteUpgradeRequired }
fileprivate let previousState: BaseSyncStateWithInfo
public init(previousState: BaseSyncStateWithInfo) {
self.previousState = previousState
}
open func advance() -> Deferred<Maybe<SyncState>> {
return deferMaybe(FreshStartRequiredError(previousState: self.previousState))
}
}
open class ClientUpgradeRequired: RecoverableSyncState {
open var label: SyncStateLabel { return SyncStateLabel.ClientUpgradeRequired }
fileprivate let previousState: BaseSyncStateWithInfo
let targetStorageVersion: Int
public init(previousState: BaseSyncStateWithInfo, target: Int) {
self.previousState = previousState
self.targetStorageVersion = target
}
open func advance() -> Deferred<Maybe<SyncState>> {
return deferMaybe(ClientUpgradeRequiredError(target: self.targetStorageVersion))
}
}
/*
* Non-error states.
*/
open class InitialWithLiveToken: BaseSyncState {
open override var label: SyncStateLabel { return SyncStateLabel.InitialWithLiveToken }
// This looks totally redundant, but try taking it out, I dare you.
public override init(scratchpad: Scratchpad, token: TokenServerToken) {
super.init(scratchpad: scratchpad, token: token)
}
// This looks totally redundant, but try taking it out, I dare you.
public override init(client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken) {
super.init(client: client, scratchpad: scratchpad, token: token)
}
func advanceWithInfo(_ info: InfoCollections) -> SyncState {
return InitialWithLiveTokenAndInfo(scratchpad: self.scratchpad, token: self.token, info: info)
}
override open func advance() -> Deferred<Maybe<SyncState>> {
return chain(getInfoCollections(), f: self.advanceWithInfo)
}
}
/**
* Each time we fetch a new meta/global, we need to reconcile it with our
* current state.
*
* It might be identical to our current meta/global, in which case we can short-circuit.
*
* We might have no previous meta/global at all, in which case this state
* simply configures local storage to be ready to sync according to the
* supplied meta/global. (Not necessarily datatype elections: those will be per-device.)
*
* Or it might be different. In this case the previous m/g and our local user preferences
* are compared to the new, resulting in some actions and a final state.
*
* This states are similar in purpose to GlobalSession.processMetaGlobal in Android Sync.
*/
open class ResolveMetaGlobalVersion: BaseSyncStateWithInfo {
let fetched: Fetched<MetaGlobal>
init(fetched: Fetched<MetaGlobal>, client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken, info: InfoCollections) {
self.fetched = fetched
super.init(client: client, scratchpad: scratchpad, token: token, info: info)
}
open override var label: SyncStateLabel { return SyncStateLabel.ResolveMetaGlobalVersion }
class func fromState(_ state: BaseSyncStateWithInfo, fetched: Fetched<MetaGlobal>) -> ResolveMetaGlobalVersion {
return ResolveMetaGlobalVersion(fetched: fetched, client: state.client, scratchpad: state.scratchpad, token: state.token, info: state.info)
}
override open func advance() -> Deferred<Maybe<SyncState>> {
// First: check storage version.
let v = fetched.value.storageVersion
if v > StorageVersionCurrent {
// New storage version? Uh-oh. No recovery possible here.
log.info("Client upgrade required for storage version \(v)")
return deferMaybe(ClientUpgradeRequired(previousState: self, target: v))
}
if v < StorageVersionCurrent {
// Old storage version? Uh-oh. Wipe and upload both meta/global and crypto/keys.
log.info("Server storage version \(v) is outdated.")
return deferMaybe(RemoteUpgradeRequired(previousState: self))
}
return deferMaybe(ResolveMetaGlobalContent.fromState(self, fetched: self.fetched))
}
}
open class ResolveMetaGlobalContent: BaseSyncStateWithInfo {
let fetched: Fetched<MetaGlobal>
init(fetched: Fetched<MetaGlobal>, client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken, info: InfoCollections) {
self.fetched = fetched
super.init(client: client, scratchpad: scratchpad, token: token, info: info)
}
open override var label: SyncStateLabel { return SyncStateLabel.ResolveMetaGlobalContent }
class func fromState(_ state: BaseSyncStateWithInfo, fetched: Fetched<MetaGlobal>) -> ResolveMetaGlobalContent {
return ResolveMetaGlobalContent(fetched: fetched, client: state.client, scratchpad: state.scratchpad, token: state.token, info: state.info)
}
override open func advance() -> Deferred<Maybe<SyncState>> {
// Check global syncID and contents.
if let previous = self.scratchpad.global?.value {
// Do checks that only apply when we're coming from a previous meta/global.
if previous.syncID != fetched.value.syncID {
log.info("Remote global sync ID has changed. Dropping keys and resetting all local collections.")
let s = self.scratchpad.freshStartWithGlobal(fetched).checkpoint()
return deferMaybe(HasMetaGlobal.fromState(self, scratchpad: s))
}
let b = self.scratchpad.evolve()
.setGlobal(fetched) // We always adopt the upstream meta/global record.
let previousEngines = Set(previous.engines.keys)
let remoteEngines = Set(fetched.value.engines.keys)
for engine in previousEngines.subtracting(remoteEngines) {
log.info("Remote meta/global disabled previously enabled engine \(engine).")
b.localCommands.insert(.disableEngine(engine: engine))
}
for engine in remoteEngines.subtracting(previousEngines) {
log.info("Remote meta/global enabled previously disabled engine \(engine).")
b.localCommands.insert(.enableEngine(engine: engine))
}
for engine in remoteEngines.intersection(previousEngines) {
let remoteEngine = fetched.value.engines[engine]!
let previousEngine = previous.engines[engine]!
if previousEngine.syncID != remoteEngine.syncID {
log.info("Remote sync ID for \(engine) has changed. Resetting local.")
b.localCommands.insert(.resetEngine(engine: engine))
}
}
let s = b.build().checkpoint()
return deferMaybe(HasMetaGlobal.fromState(self, scratchpad: s))
}
// No previous meta/global. Adopt the new meta/global.
let s = self.scratchpad.freshStartWithGlobal(fetched).checkpoint()
return deferMaybe(HasMetaGlobal.fromState(self, scratchpad: s))
}
}
private func processFailure(_ failure: MaybeErrorType?) -> MaybeErrorType {
if let failure = failure as? ServerInBackoffError {
log.warning("Server in backoff. Bailing out. \(failure.description)")
return failure
}
// TODO: backoff etc. for all of these.
if let failure = failure as? ServerError<HTTPURLResponse> {
// Be passive.
log.error("Server error. Bailing out. \(failure.description)")
return failure
}
if let failure = failure as? BadRequestError<HTTPURLResponse> {
// Uh oh.
log.error("Bad request. Bailing out. \(failure.description)")
return failure
}
log.error("Unexpected failure. \(failure?.description ?? "nil")")
return failure ?? UnknownError()
}
open class InitialWithLiveTokenAndInfo: BaseSyncStateWithInfo {
open override var label: SyncStateLabel { return SyncStateLabel.InitialWithLiveTokenAndInfo }
// This method basically hops over HasMetaGlobal, because it's not a state
// that we expect consumers to know about.
override open func advance() -> Deferred<Maybe<SyncState>> {
// Either m/g and c/k are in our local cache, and they're up-to-date with i/c,
// or we need to fetch them.
// Cached and not changed in i/c? Use that.
// This check would be inaccurate if any other fields were stored in meta/; this
// has been the case in the past, with the Sync 1.1 migration indicator.
if let global = self.scratchpad.global {
if let metaModified = self.info.modified("meta") {
// We check the last time we fetched the record, and that can be
// later than the collection timestamp. All we care about here is if the
// server might have a newer record.
if global.timestamp >= metaModified {
log.debug("Cached meta/global fetched at \(global.timestamp), newer than server modified \(metaModified). Using cached meta/global.")
// Strictly speaking we can avoid fetching if this condition is not true,
// but if meta/ is modified for a different reason -- store timestamps
// for the last collection fetch. This will do for now.
return deferMaybe(HasMetaGlobal.fromState(self))
}
log.info("Cached meta/global fetched at \(global.timestamp) older than server modified \(metaModified). Fetching fresh meta/global.")
} else {
// No known modified time for meta/. That means the server has no meta/global.
// Drop our cached value and fall through; we'll try to fetch, fail, and
// go through the usual failure flow.
log.warning("Local meta/global fetched at \(global.timestamp) found, but no meta collection on server. Dropping cached meta/global.")
// If we bail because we've been overly optimistic, then we nil out the current (broken)
// meta/global. Next time around, we end up in the "No cached meta/global found" branch.
self.scratchpad = self.scratchpad.evolve().setGlobal(nil).setKeys(nil).build().checkpoint()
}
} else {
log.debug("No cached meta/global found. Fetching fresh meta/global.")
}
return deferMaybe(NeedsFreshMetaGlobal.fromState(self))
}
}
/*
* We've reached NeedsFreshMetaGlobal somehow, but we haven't yet done anything about it
* (e.g. fetch a new one with GET /storage/meta/global ).
*
* If we don't want to hit the network (e.g. from an extension), we should stop if we get to this state.
*/
open class NeedsFreshMetaGlobal: BaseSyncStateWithInfo {
open override var label: SyncStateLabel { return SyncStateLabel.NeedsFreshMetaGlobal }
class func fromState(_ state: BaseSyncStateWithInfo) -> NeedsFreshMetaGlobal {
return NeedsFreshMetaGlobal(client: state.client, scratchpad: state.scratchpad, token: state.token, info: state.info)
}
override open func advance() -> Deferred<Maybe<SyncState>> {
// Fetch.
return self.client.getMetaGlobal().bind { result in
if let resp = result.successValue {
// We use the server's timestamp, rather than the record's modified field.
// Either can be made to work, but the latter has suffered from bugs: see Bug 1210625.
let fetched = Fetched(value: resp.value, timestamp: resp.metadata.timestampMilliseconds)
return deferMaybe(ResolveMetaGlobalVersion.fromState(self, fetched: fetched))
}
if let _ = result.failureValue as? NotFound<HTTPURLResponse> {
// OK, this is easy.
// This state is responsible for creating the new m/g, uploading it, and
// restarting with a clean scratchpad.
return deferMaybe(MissingMetaGlobalError(previousState: self))
}
// Otherwise, we have a failure state. Die on the sword!
return deferMaybe(processFailure(result.failureValue))
}
}
}
open class HasMetaGlobal: BaseSyncStateWithInfo {
open override var label: SyncStateLabel { return SyncStateLabel.HasMetaGlobal }
class func fromState(_ state: BaseSyncStateWithInfo) -> HasMetaGlobal {
return HasMetaGlobal(client: state.client, scratchpad: state.scratchpad, token: state.token, info: state.info)
}
class func fromState(_ state: BaseSyncStateWithInfo, scratchpad: Scratchpad) -> HasMetaGlobal {
return HasMetaGlobal(client: state.client, scratchpad: scratchpad, token: state.token, info: state.info)
}
override open func advance() -> Deferred<Maybe<SyncState>> {
// Check if crypto/keys is fresh in the cache already.
if let keys = self.scratchpad.keys, keys.value.valid {
if let cryptoModified = self.info.modified("crypto") {
// Both of these are server timestamps. If the record we stored was fetched after the last time the record was modified, as represented by the "crypto" entry in info/collections, and we're fetching from the
// same server, then the record must be identical, and we can use it directly. If are ever additional records in the crypto collection, this will fetch keys too frequently. In that case, we should use X-I-U-S and expect some 304 responses.
if keys.timestamp >= cryptoModified {
log.debug("Cached keys fetched at \(keys.timestamp), newer than server modified \(cryptoModified). Using cached keys.")
return deferMaybe(HasFreshCryptoKeys.fromState(self, scratchpad: self.scratchpad, collectionKeys: keys.value))
}
// The server timestamp is newer, so there might be new keys.
// Re-fetch keys and check to see if the actual contents differ.
// If the keys are the same, we can ignore this change. If they differ,
// we need to re-sync any collection whose keys just changed.
log.info("Cached keys fetched at \(keys.timestamp) older than server modified \(cryptoModified). Fetching fresh keys.")
return deferMaybe(NeedsFreshCryptoKeys.fromState(self, scratchpad: self.scratchpad, staleCollectionKeys: keys.value))
} else {
// No known modified time for crypto/. That likely means the server has no keys.
// Drop our cached value and fall through; we'll try to fetch, fail, and
// go through the usual failure flow.
log.warning("Local keys fetched at \(keys.timestamp) found, but no crypto collection on server. Dropping cached keys.")
self.scratchpad = self.scratchpad.evolve().setKeys(nil).build().checkpoint()
}
} else {
log.debug("No cached keys found. Fetching fresh keys.")
}
return deferMaybe(NeedsFreshCryptoKeys.fromState(self, scratchpad: self.scratchpad, staleCollectionKeys: nil))
}
}
open class NeedsFreshCryptoKeys: BaseSyncStateWithInfo {
open override var label: SyncStateLabel { return SyncStateLabel.NeedsFreshCryptoKeys }
let staleCollectionKeys: Keys?
class func fromState(_ state: BaseSyncStateWithInfo, scratchpad: Scratchpad, staleCollectionKeys: Keys?) -> NeedsFreshCryptoKeys {
return NeedsFreshCryptoKeys(client: state.client, scratchpad: scratchpad, token: state.token, info: state.info, keys: staleCollectionKeys)
}
public init(client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken, info: InfoCollections, keys: Keys?) {
self.staleCollectionKeys = keys
super.init(client: client, scratchpad: scratchpad, token: token, info: info)
}
override open func advance() -> Deferred<Maybe<SyncState>> {
// Fetch crypto/keys.
return self.client.getCryptoKeys(self.scratchpad.syncKeyBundle, ifUnmodifiedSince: nil).bind { result in
if let resp = result.successValue {
let collectionKeys = Keys(payload: resp.value.payload)
if !collectionKeys.valid {
log.error("Unexpectedly invalid crypto/keys during a successful fetch.")
return Deferred(value: Maybe(failure: InvalidKeysError(collectionKeys)))
}
let fetched = Fetched(value: collectionKeys, timestamp: resp.metadata.timestampMilliseconds)
let s = self.scratchpad.evolve()
.addLocalCommandsFromKeys(fetched)
.setKeys(fetched)
.build().checkpoint()
return deferMaybe(HasFreshCryptoKeys.fromState(self, scratchpad: s, collectionKeys: collectionKeys))
}
if let _ = result.failureValue as? NotFound<HTTPURLResponse> {
// No crypto/keys? We can handle this. Wipe and upload both meta/global and crypto/keys.
return deferMaybe(MissingCryptoKeysError(previousState: self))
}
// Otherwise, we have a failure state.
return deferMaybe(processFailure(result.failureValue))
}
}
}
open class HasFreshCryptoKeys: BaseSyncStateWithInfo {
open override var label: SyncStateLabel { return SyncStateLabel.HasFreshCryptoKeys }
let collectionKeys: Keys
class func fromState(_ state: BaseSyncStateWithInfo, scratchpad: Scratchpad, collectionKeys: Keys) -> HasFreshCryptoKeys {
return HasFreshCryptoKeys(client: state.client, scratchpad: scratchpad, token: state.token, info: state.info, keys: collectionKeys)
}
public init(client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken, info: InfoCollections, keys: Keys) {
self.collectionKeys = keys
super.init(client: client, scratchpad: scratchpad, token: token, info: info)
}
override open func advance() -> Deferred<Maybe<SyncState>> {
return deferMaybe(Ready(client: self.client, scratchpad: self.scratchpad, token: self.token, info: self.info, keys: self.collectionKeys))
}
}
public protocol EngineStateChanges {
func collectionsThatNeedLocalReset() -> [String]
func enginesEnabled() -> [String]
func enginesDisabled() -> [String]
func clearLocalCommands()
}
open class Ready: BaseSyncStateWithInfo {
open override var label: SyncStateLabel { return SyncStateLabel.Ready }
let collectionKeys: Keys
public var hashedFxADeviceID: String {
return (scratchpad.fxaDeviceId + token.hashedFxAUID).sha256.hexEncodedString
}
public init(client: Sync15StorageClient, scratchpad: Scratchpad, token: TokenServerToken, info: InfoCollections, keys: Keys) {
self.collectionKeys = keys
super.init(client: client, scratchpad: scratchpad, token: token, info: info)
}
}
extension Ready: EngineStateChanges {
public func collectionsThatNeedLocalReset() -> [String] {
var needReset: Set<String> = Set()
for command in self.scratchpad.localCommands {
switch command {
case let .resetAllEngines(except: except):
needReset.formUnion(Set(LocalEngines).subtracting(except))
case let .resetEngine(engine):
needReset.insert(engine)
case .enableEngine, .disableEngine:
break
}
}
return Array(needReset).sorted()
}
public func enginesEnabled() -> [String] {
var engines: Set<String> = Set()
for command in self.scratchpad.localCommands {
switch command {
case let .enableEngine(engine):
engines.insert(engine)
default:
break
}
}
return Array(engines).sorted()
}
public func enginesDisabled() -> [String] {
var engines: Set<String> = Set()
for command in self.scratchpad.localCommands {
switch command {
case let .disableEngine(engine):
engines.insert(engine)
default:
break
}
}
return Array(engines).sorted()
}
public func clearLocalCommands() {
self.scratchpad = self.scratchpad.evolve().clearLocalCommands().build().checkpoint()
}
}
| mpl-2.0 | 4bae82ecd267dfde155924403c5c729a | 40.82 | 257 | 0.684789 | 5.004283 | false | false | false | false |
Alecrim/AlecrimCoreData | Sources/Fetch Request Controller/FetchRequestController.swift | 1 | 9778 | //
// FetchRequestController.swift
// AlecrimCoreData
//
// Created by Vanderlei Martinelli on 11/03/18.
// Copyright © 2018 Alecrim. All rights reserved.
//
import Foundation
import CoreData
//
// we cannot inherit from `NSFetchedResultsController` here because the error:
// "inheritance from a generic Objective-C class 'NSFetchedResultsController' must bind type parameters of
// 'NSFetchedResultsController' to specific concrete types"
// and
// `FetchRequestController<Entity: ManagedObject>: NSFetchedResultsController<NSFetchRequestResult>` will not work for us
// (curiously the "rawValue" inside our class is accepted to be `NSFetchedResultsController<Entity>`)
//
// MARK: -
public final class FetchRequestController<Entity: ManagedObject> {
// MARK: -
public let fetchRequest: FetchRequest<Entity>
public let rawValue: NSFetchedResultsController<Entity>
internal let rawValueDelegate: FetchedResultsControllerDelegate<Entity>
fileprivate let initialPredicate: Predicate<Entity>?
fileprivate let initialSortDescriptors: [SortDescriptor<Entity>]?
private var didPerformFetch = false
// MARK: -
public convenience init<Value>(query: Query<Entity>, sectionName sectionNameKeyPathClosure: @autoclosure () -> KeyPath<Entity, Value>, cacheName: String? = nil) {
let sectionNameKeyPath = sectionNameKeyPathClosure().pathString
self.init(fetchRequest: query.fetchRequest, context: query.context, sectionNameKeyPath: sectionNameKeyPath, cacheName: cacheName)
}
public convenience init(query: Query<Entity>, sectionNameKeyPath: String? = nil, cacheName: String? = nil) {
self.init(fetchRequest: query.fetchRequest, context: query.context, sectionNameKeyPath: sectionNameKeyPath, cacheName: cacheName)
}
public convenience init<Value>(fetchRequest: FetchRequest<Entity>, context: ManagedObjectContext, sectionName sectionNameKeyPathClosure: @autoclosure () -> KeyPath<Entity, Value>, cacheName: String? = nil) {
let sectionNameKeyPath = sectionNameKeyPathClosure().pathString
self.init(fetchRequest: fetchRequest, context: context, sectionNameKeyPath: sectionNameKeyPath, cacheName: cacheName)
}
public init(fetchRequest: FetchRequest<Entity>, context: ManagedObjectContext, sectionNameKeyPath: String? = nil, cacheName: String? = nil) {
self.fetchRequest = fetchRequest
self.rawValue = NSFetchedResultsController(fetchRequest: fetchRequest.toRaw() as NSFetchRequest<Entity>, managedObjectContext: context, sectionNameKeyPath: sectionNameKeyPath, cacheName: cacheName)
self.rawValueDelegate = FetchedResultsControllerDelegate<Entity>()
self.initialPredicate = fetchRequest.predicate
self.initialSortDescriptors = fetchRequest.sortDescriptors
//
self.rawValue.delegate = self.rawValueDelegate
}
// MARK: -
public func performFetch() {
try! self.rawValue.performFetch()
self.didPerformFetch = true
}
public func performFetchIfNeeded() {
if !self.didPerformFetch {
try! self.rawValue.performFetch()
self.didPerformFetch = true
}
}
}
// MARK: -
extension FetchRequestController {
public var fetchedObjects: [Entity]? {
self.performFetchIfNeeded()
return self.rawValue.fetchedObjects
}
public func object(at indexPath: IndexPath) -> Entity {
self.performFetchIfNeeded()
return self.rawValue.object(at: indexPath)
}
public func indexPath(for object: Entity) -> IndexPath? {
self.performFetchIfNeeded()
return self.rawValue.indexPath(forObject: object)
}
}
extension FetchRequestController {
public func numberOfSections() -> Int {
self.performFetchIfNeeded()
return self.sections.count
}
public func numberOfObjects(inSection section: Int) -> Int {
self.performFetchIfNeeded()
return self.sections[section].numberOfObjects
}
}
extension FetchRequestController {
public var sections: [FetchedResultsSectionInfo<Entity>] {
self.performFetchIfNeeded()
guard let result = self.rawValue.sections?.map({ FetchedResultsSectionInfo<Entity>(rawValue: $0) }) else {
fatalError("performFetch: hasn't been called.")
}
return result
}
public func section(forSectionIndexTitle title: String, at sectionIndex: Int) -> Int {
self.performFetchIfNeeded()
return self.rawValue.section(forSectionIndexTitle: title, at: sectionIndex)
}
}
extension FetchRequestController {
public func sectionIndexTitle(forSectionName sectionName: String) -> String? {
self.performFetchIfNeeded()
return self.rawValue.sectionIndexTitle(forSectionName: sectionName)
}
public var sectionIndexTitles: [String] {
self.performFetchIfNeeded()
return self.rawValue.sectionIndexTitles
}
}
// MARK: -
extension FetchRequestController {
public func refresh(using predicate: Predicate<Entity>?, keepOriginalPredicate: Bool) {
self.assignPredicate(predicate, keepOriginalPredicate: keepOriginalPredicate)
self.refresh()
}
public func refresh(using rawValue: NSPredicate, keepOriginalPredicate: Bool) {
self.assignPredicate(Predicate<Entity>(rawValue: rawValue), keepOriginalPredicate: keepOriginalPredicate)
self.refresh()
}
public func refresh(using sortDescriptors: [SortDescriptor<Entity>]?, keepOriginalSortDescriptors: Bool) {
self.assignSortDescriptors(sortDescriptors, keepOriginalSortDescriptors: keepOriginalSortDescriptors)
self.refresh()
}
public func refresh(using rawValues: [NSSortDescriptor], keepOriginalSortDescriptors: Bool) {
self.assignSortDescriptors(rawValues.map({ SortDescriptor<Entity>(rawValue: $0) }), keepOriginalSortDescriptors: keepOriginalSortDescriptors)
self.refresh()
}
public func refresh(using predicate: Predicate<Entity>?, sortDescriptors: [SortDescriptor<Entity>]?, keepOriginalPredicate: Bool, keepOriginalSortDescriptors: Bool) {
self.assignPredicate(predicate, keepOriginalPredicate: keepOriginalPredicate)
self.assignSortDescriptors(sortDescriptors, keepOriginalSortDescriptors: keepOriginalSortDescriptors)
self.refresh()
}
public func refresh(using predicateRawValue: NSPredicate, sortDescriptors sortDescriptorRawValues: [NSSortDescriptor], keepOriginalPredicate: Bool, keepOriginalSortDescriptors: Bool) {
self.assignPredicate(Predicate<Entity>(rawValue: predicateRawValue), keepOriginalPredicate: keepOriginalPredicate)
self.assignSortDescriptors(sortDescriptorRawValues.map({ SortDescriptor<Entity>(rawValue: $0) }), keepOriginalSortDescriptors: keepOriginalSortDescriptors)
self.refresh()
}
//
public func resetPredicate() {
self.refresh(using: self.initialPredicate, keepOriginalPredicate: false)
}
public func resetSortDescriptors() {
self.refresh(using: self.initialSortDescriptors, keepOriginalSortDescriptors: false)
}
public func resetPredicateAndSortDescriptors() {
self.refresh(using: self.initialPredicate, sortDescriptors: self.initialSortDescriptors, keepOriginalPredicate: false, keepOriginalSortDescriptors: false)
}
}
extension FetchRequestController {
public func filter(using predicate: Predicate<Entity>) {
self.refresh(using: predicate, keepOriginalPredicate: true)
}
public func filter(using predicateClosure: () -> Predicate<Entity>) {
self.refresh(using: predicateClosure(), keepOriginalPredicate: true)
}
public func filter(using rawValue: NSPredicate) {
self.refresh(using: Predicate<Entity>(rawValue: rawValue), keepOriginalPredicate: true)
}
public func resetFilter() {
self.resetPredicate()
}
public func reset() {
self.resetPredicateAndSortDescriptors()
}
}
extension FetchRequestController {
fileprivate func assignPredicate(_ predicate: Predicate<Entity>?, keepOriginalPredicate: Bool) {
let newPredicate: Predicate<Entity>?
if keepOriginalPredicate {
if let initialPredicate = self.initialPredicate {
if let predicate = predicate {
newPredicate = CompoundPredicate<Entity>(type: .and, subpredicates: [initialPredicate, predicate])
}
else {
newPredicate = initialPredicate
}
}
else {
newPredicate = predicate
}
}
else {
newPredicate = predicate
}
self.rawValue.fetchRequest.predicate = newPredicate?.rawValue
}
fileprivate func assignSortDescriptors(_ sortDescriptors: [SortDescriptor<Entity>]?, keepOriginalSortDescriptors: Bool) {
let newSortDescriptors: [SortDescriptor<Entity>]?
if keepOriginalSortDescriptors {
if let initialSortDescriptors = self.initialSortDescriptors {
if let sortDescriptors = sortDescriptors {
var tempSortDescriptors = initialSortDescriptors
tempSortDescriptors += sortDescriptors
newSortDescriptors = tempSortDescriptors
}
else {
newSortDescriptors = initialSortDescriptors
}
}
else {
newSortDescriptors = sortDescriptors
}
}
else {
newSortDescriptors = sortDescriptors
}
self.rawValue.fetchRequest.sortDescriptors = newSortDescriptors?.map { $0.rawValue }
}
}
| mit | 3aa1eda4c7aa99ab23074ebcbb939a4d | 33.547703 | 211 | 0.701851 | 5.366081 | false | false | false | false |
ccqpein/Arithmetic-Exercises | Date-Arithmetic/DA.swift | 1 | 2428 | let monthDay:[Int] = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,]
let monthDayL:[Int] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,]
let yzero = 2000
func leapYear(_ y:Int) -> Bool {
if (y % 4 == 0) && (y % 400 == 0 || y % 100 != 0) {
return true
} else {
return false
}
}
struct Date {
var d:Int
var m:Int
var y:Int
}
// Can use switch to make algorithm add date by year (now is by month)
// Todo: make this function have ability to decrease the date if input the num is negetive
func addDate(_ days:Int, _ input:Date) -> (reDate:Date, daysLeft:Int) {
guard days > 0 else {
print("sorry, days number is nagetive, try to use \"reduceDate\"")
return (input, 0)
}
var monthTable:[Int] = leapYear(input.y) ? monthDayL : monthDay
let sumDays:Int = days + input.d
var reDate:Date = input
var daysLeft:Int = 0
if sumDays > monthTable[input.m - 1] {
reDate.m += 1
daysLeft = sumDays - monthTable[input.m - 1] - 1
reDate.d = 1
if reDate.m > 12 {
reDate.y += 1
reDate.m -= 12
}
} else {
reDate.d = sumDays
}
return (reDate, daysLeft)
}
func reduceDate(_ days:Int, _ input:Date) -> (reDate:Date, daysLeft:Int) {
guard days < 0 else {
print("sorry, days number is positive, try to use \"addDate\"")
return (input, 0)
}
var monthTable:[Int] = leapYear(input.y) ? monthDayL : monthDay
let sumDays:Int = days + input.d //sumdays may negative
var reDate:Date = input
var daysLeft = 0
if sumDays > 0 {
reDate.d = sumDays
}else{
reDate.m -= 1
if reDate.m < 1 {
reDate.y -= 1
reDate.m = 12
}
daysLeft = sumDays
reDate.d = monthTable[reDate.m - 1]
}
return (reDate, daysLeft)
}
func main(_ days:Int, dateInput date:Date) -> Date {
var daysLeft = days
var reDate = date
var f:((Int, Date) -> (Date, Int))?
if days < 0 {
f = reduceDate
}else {
f = addDate
}
while daysLeft != 0 {
(reDate, daysLeft) = f!(daysLeft, reDate)
}
return reDate
}
let testa = Date(d:25, m:2, y:2004)
let testb = Date(d:25, m:12, y:2004)
let testc = Date(d:1, m:1, y:2005)
//print(main(370, dateInput:testa))
//print(main(7, dateInput:testb))
| apache-2.0 | 2db0dc82ecc9d9cc6eff34d039ec05fa | 21.691589 | 90 | 0.541598 | 3.089059 | false | false | false | false |
zxwWei/SwfitZeng | XWWeibo接收数据/XWWeibo/Classes/Model(模型)/Home(首页)/View/Cell/XWPictureView.swift | 1 | 7432 | //
// XWPictureView.swift
// GZWeibo05
//
// Created by apple1 on 15/11/1.
// Copyright © 2015年 zhangping. All rights reserved.
//
// MARK : - git clone https://github.com/December-XP/swiftweibo05.git 下载地址
import UIKit
import SDWebImage
let XWPictureViewCellNSNotification = "XWPictureViewCellNSNotification"
let XWPictureViewCellSelectedPictureUrlKey = "XWPictureViewCellSelectedPictureUrlKey"
let XWPictureViewCellSelectedIndexPathKey = "XWPictureViewCellSelectedIndexPathKey"
class XWPictureView: UICollectionView {
// MARK: - 微博模型 相当于重写setter
var status: XWSatus? {
didSet{
//print(status?.realPictureUrls?.count)
reloadData()
}
}
// 这个方法是 sizeToFit调用的,而且 返回的 CGSize 系统会设置为当前view的size
override func sizeThatFits(size: CGSize) -> CGSize {
return collectionViewSize()
}
// MARK: - 根据微博模型,计算配图的尺寸 让cell获得配图的大小
func collectionViewSize() -> CGSize {
// 设置itemSize
let itemSize = CGSize(width: 90, height: 90)
layout.itemSize = itemSize
layout.minimumInteritemSpacing = 0
layout.minimumLineSpacing = 0
/// 列数
let column = 3
/// 间距
let margin: CGFloat = 10
// 获取微博里的图片个数来计算size 可以为0
let count = status?.realPictureUrls?.count ?? 0
if count == 0 {
return CGSizeZero
}
if count == 1 { // 当时一张图片的时候，有些图片大，有些小，所以要根据图片的本来大小来调节
// 获取图片url
let urlStr = status!.realPictureUrls![0].absoluteString
var size = CGSizeMake(150, 120)
// 获得图片
if let image = SDWebImageManager.sharedManager().imageCache.imageFromDiskCacheForKey(urlStr) {
size = image.size
}
// 让cell和collectionView一样大
if (size.width < 40){
size.width = 40
}
layout.itemSize = size
return size
}
layout.minimumLineSpacing = 10
layout.minimumInteritemSpacing = 10
if count == 4 {
let width = 2 * itemSize.width + margin
return CGSizeMake(width, width)
}
// 剩下 2, 3, 5, 6, 7, 8, 9
// 计算行数: 公式: 行数 = (图片数量 + 列数 -1) / 列数
let row = (count + column - 1) / column
// 宽度公式: 宽度 = (列数 * item的宽度) + (列数 - 1) * 间距
let widht = (CGFloat(column) * itemSize.width) + (CGFloat(column) - 1) * margin
// 高度公式: 高度 = (行数 * item的高度) + (行数 - 1) * 间距
let height = (CGFloat(row) * itemSize.height) + (CGFloat(row) - 1) * margin
return CGSizeMake(widht, height)
}
// MARK: - collection Layout
private var layout = UICollectionViewFlowLayout()
// MARK: - 构造方法
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
// layout 需在外面定义，不要使用 init(frame: CGRect, collectionViewLayout layout: UICollectionViewLayout)
init() {
super.init(frame: CGRectZero, collectionViewLayout:layout)
backgroundColor = UIColor.clearColor()
// 数据源代理
dataSource = self
delegate = self
// 注册cell
registerClass(XWPictureViewCell.self, forCellWithReuseIdentifier: "cell")
// 准备UI
// prepareUI()
}
}
// MARK: 数据源方法 延伸 代理延伸
extension XWPictureView: UICollectionViewDataSource , UICollectionViewDelegate{
func collectionView(collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return status?.realPictureUrls?.count ?? 0
}
func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
let cell = collectionView.dequeueReusableCellWithReuseIdentifier("cell", forIndexPath: indexPath) as! XWPictureViewCell
// realPictureUrls里面有着转发微博和原创微博的图片数
cell.imgUrl = status?.realPictureUrls?[indexPath.item]
return cell
}
// 当点击cell的时候调用
func collectionView(collectionView: UICollectionView, didSelectItemAtIndexPath indexPath: NSIndexPath) {
// 记录index sttus是从cell处传过来的
let userInfo: [String: AnyObject] = [
XWPictureViewCellSelectedIndexPathKey : indexPath.item,
//MARK: - bug 注意属性间的转换∫
XWPictureViewCellSelectedPictureUrlKey : status!.realLargePictureUrls!
]
// 发送通知 将通知发送到homeVC
NSNotificationCenter.defaultCenter().postNotificationName(XWPictureViewCellNSNotification, object: self, userInfo: userInfo)
}
}
// MARK: - 自定义cell 用来显示图片
class XWPictureViewCell: UICollectionViewCell{
// MARK: - 属性图片路径 NSURL? 要为空
var imgUrl: NSURL? {
didSet{
// 不要用错方法
picture.sd_setImageWithURL(imgUrl)
let gif = (imgUrl!.absoluteString as NSString ) .pathExtension.lowercaseString == "gif"
gifImageView.hidden = !gif
}
}
// MARK: - 构造方法
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override init(frame: CGRect) {
super.init(frame: frame)
prepareUI()
}
// MARK : - 准备UI
func prepareUI() {
contentView.addSubview(picture)
contentView.addSubview(gifImageView)
gifImageView.translatesAutoresizingMaskIntoConstraints = false
// 添加约束 充满子控件
picture.ff_Fill(contentView)
let views = ["gif":gifImageView]
contentView.addConstraints(NSLayoutConstraint .constraintsWithVisualFormat("H:[gif]-4-|", options: NSLayoutFormatOptions(rawValue: 0), metrics: nil, views: views))
contentView.addConstraints(NSLayoutConstraint .constraintsWithVisualFormat("V:[gif]-4-|", options: NSLayoutFormatOptions(rawValue: 0), metrics: nil, views: views))
// gifImageView.ff_AlignInner(type: ff_AlignType.BottomRight, referView: contentView, size: nil)
}
// MARK: - 懒加载
/// 其他图片不需要缓存 设置其适配属性
private lazy var picture: UIImageView = {
let imageView = UIImageView ()
imageView.contentMode = UIViewContentMode.ScaleAspectFill
imageView.clipsToBounds = true
return imageView
}()
/// gif图标
private lazy var gifImageView: UIImageView = UIImageView(image: UIImage(named: "timeline_image_gif"))
} | apache-2.0 | 5923b94c9070f07dc433ec19cca1951d | 28 | 172 | 0.590862 | 4.888329 | false | false | false | false |
agilewalker/SwiftyChardet | SwiftyChardet/euctwfreq.swift | 1 | 33374 | /*
######################## BEGIN LICENSE BLOCK ########################
# The Original Code is Mozilla Communicator client code.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 1998
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
# Wu Hui Yuan - port to Swift
# Mark Pilgrim - port to Python
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301 USA
######################### END LICENSE BLOCK #########################
*/
// EUCTW frequency table
// Converted from big5 work
// by Taiwan's Mandarin Promotion Council
// <http://www.edu.tw:81/mandr/>
// 128 --> 0.42261
// 256 --> 0.57851
// 512 --> 0.74851
// 1024 --> 0.89384
// 2048 --> 0.97583
//
// Idea Distribution Ratio = 0.74851/(1-0.74851) =2.98
// Random Distribution Ration = 512/(5401-512)=0.105
//
// Typical Distribution Ratio about 25% of Ideal one, still much higher than RDR
let EUCTW_TYPICAL_DISTRIBUTION_RATIO = 0.75
// Char to FreqOrder table ,
let EUCTW_TABLE_SIZE = 8102
let EUCTW_CHAR_TO_FREQ_ORDER: [Int] = [
1,1800,1506, 255,1431, 198, 9, 82, 6,7310, 177, 202,3615,1256,2808, 110, // 2742
3735, 33,3241, 261, 76, 44,2113, 16,2931,2184,1176, 659,3868, 26,3404,2643, // 2758
1198,3869,3313,4060, 410,2211, 302, 590, 361,1963, 8, 204, 58,4296,7311,1931, // 2774
63,7312,7313, 317,1614, 75, 222, 159,4061,2412,1480,7314,3500,3068, 224,2809, // 2790
3616, 3, 10,3870,1471, 29,2774,1135,2852,1939, 873, 130,3242,1123, 312,7315, // 2806
4297,2051, 507, 252, 682,7316, 142,1914, 124, 206,2932, 34,3501,3173, 64, 604, // 2822
7317,2494,1976,1977, 155,1990, 645, 641,1606,7318,3405, 337, 72, 406,7319, 80, // 2838
630, 238,3174,1509, 263, 939,1092,2644, 756,1440,1094,3406, 449, 69,2969, 591, // 2854
179,2095, 471, 115,2034,1843, 60, 50,2970, 134, 806,1868, 734,2035,3407, 180, // 2870
995,1607, 156, 537,2893, 688,7320, 319,1305, 779,2144, 514,2374, 298,4298, 359, // 2886
2495, 90,2707,1338, 663, 11, 906,1099,2545, 20,2436, 182, 532,1716,7321, 732, // 2902
1376,4062,1311,1420,3175, 25,2312,1056, 113, 399, 382,1949, 242,3408,2467, 529, // 2918
3243, 475,1447,3617,7322, 117, 21, 656, 810,1297,2295,2329,3502,7323, 126,4063, // 2934
706, 456, 150, 613,4299, 71,1118,2036,4064, 145,3069, 85, 835, 486,2114,1246, // 2950
1426, 428, 727,1285,1015, 800, 106, 623, 303,1281,7324,2127,2354, 347,3736, 221, // 2966
3503,3110,7325,1955,1153,4065, 83, 296,1199,3070, 192, 624, 93,7326, 822,1897, // 2982
2810,3111, 795,2064, 991,1554,1542,1592, 27, 43,2853, 859, 139,1456, 860,4300, // 2998
437, 712,3871, 164,2392,3112, 695, 211,3017,2096, 195,3872,1608,3504,3505,3618, // 3014
3873, 234, 811,2971,2097,3874,2229,1441,3506,1615,2375, 668,2076,1638, 305, 228, // 3030
1664,4301, 467, 415,7327, 262,2098,1593, 239, 108, 300, 200,1033, 512,1247,2077, // 3046
7328,7329,2173,3176,3619,2673, 593, 845,1062,3244, 88,1723,2037,3875,1950, 212, // 3062
266, 152, 149, 468,1898,4066,4302, 77, 187,7330,3018, 37, 5,2972,7331,3876, // 3078
7332,7333, 39,2517,4303,2894,3177,2078, 55, 148, 74,4304, 545, 483,1474,1029, // 3094
1665, 217,1869,1531,3113,1104,2645,4067, 24, 172,3507, 900,3877,3508,3509,4305, // 3110
32,1408,2811,1312, 329, 487,2355,2247,2708, 784,2674, 4,3019,3314,1427,1788, // 3126
188, 109, 499,7334,3620,1717,1789, 888,1217,3020,4306,7335,3510,7336,3315,1520, // 3142
3621,3878, 196,1034, 775,7337,7338, 929,1815, 249, 439, 38,7339,1063,7340, 794, // 3158
3879,1435,2296, 46, 178,3245,2065,7341,2376,7342, 214,1709,4307, 804, 35, 707, // 3174
324,3622,1601,2546, 140, 459,4068,7343,7344,1365, 839, 272, 978,2257,2572,3409, // 3190
2128,1363,3623,1423, 697, 100,3071, 48, 70,1231, 495,3114,2193,7345,1294,7346, // 3206
2079, 462, 586,1042,3246, 853, 256, 988, 185,2377,3410,1698, 434,1084,7347,3411, // 3222
314,2615,2775,4308,2330,2331, 569,2280, 637,1816,2518, 757,1162,1878,1616,3412, // 3238
287,1577,2115, 768,4309,1671,2854,3511,2519,1321,3737, 909,2413,7348,4069, 933, // 3254
3738,7349,2052,2356,1222,4310, 765,2414,1322, 786,4311,7350,1919,1462,1677,2895, // 3270
1699,7351,4312,1424,2437,3115,3624,2590,3316,1774,1940,3413,3880,4070, 309,1369, // 3286
1130,2812, 364,2230,1653,1299,3881,3512,3882,3883,2646, 525,1085,3021, 902,2000, // 3302
1475, 964,4313, 421,1844,1415,1057,2281, 940,1364,3116, 376,4314,4315,1381, 7, // 3318
2520, 983,2378, 336,1710,2675,1845, 321,3414, 559,1131,3022,2742,1808,1132,1313, // 3334
265,1481,1857,7352, 352,1203,2813,3247, 167,1089, 420,2814, 776, 792,1724,3513, // 3350
4071,2438,3248,7353,4072,7354, 446, 229, 333,2743, 901,3739,1200,1557,4316,2647, // 3366
1920, 395,2744,2676,3740,4073,1835, 125, 916,3178,2616,4317,7355,7356,3741,7357, // 3382
7358,7359,4318,3117,3625,1133,2547,1757,3415,1510,2313,1409,3514,7360,2145, 438, // 3398
2591,2896,2379,3317,1068, 958,3023, 461, 311,2855,2677,4074,1915,3179,4075,1978, // 3414
383, 750,2745,2617,4076, 274, 539, 385,1278,1442,7361,1154,1964, 384, 561, 210, // 3430
98,1295,2548,3515,7362,1711,2415,1482,3416,3884,2897,1257, 129,7363,3742, 642, // 3446
523,2776,2777,2648,7364, 141,2231,1333, 68, 176, 441, 876, 907,4077, 603,2592, // 3462
710, 171,3417, 404, 549, 18,3118,2393,1410,3626,1666,7365,3516,4319,2898,4320, // 3478
7366,2973, 368,7367, 146, 366, 99, 871,3627,1543, 748, 807,1586,1185, 22,2258, // 3494
379,3743,3180,7368,3181, 505,1941,2618,1991,1382,2314,7369, 380,2357, 218, 702, // 3510
1817,1248,3418,3024,3517,3318,3249,7370,2974,3628, 930,3250,3744,7371, 59,7372, // 3526
585, 601,4078, 497,3419,1112,1314,4321,1801,7373,1223,1472,2174,7374, 749,1836, // 3542
690,1899,3745,1772,3885,1476, 429,1043,1790,2232,2116, 917,4079, 447,1086,1629, // 3558
7375, 556,7376,7377,2020,1654, 844,1090, 105, 550, 966,1758,2815,1008,1782, 686, // 3574
1095,7378,2282, 793,1602,7379,3518,2593,4322,4080,2933,2297,4323,3746, 980,2496, // 3590
544, 353, 527,4324, 908,2678,2899,7380, 381,2619,1942,1348,7381,1341,1252, 560, // 3606
3072,7382,3420,2856,7383,2053, 973, 886,2080, 143,4325,7384,7385, 157,3886, 496, // 3622
4081, 57, 840, 540,2038,4326,4327,3421,2117,1445, 970,2259,1748,1965,2081,4082, // 3638
3119,1234,1775,3251,2816,3629, 773,1206,2129,1066,2039,1326,3887,1738,1725,4083, // 3654
279,3120, 51,1544,2594, 423,1578,2130,2066, 173,4328,1879,7386,7387,1583, 264, // 3670
610,3630,4329,2439, 280, 154,7388,7389,7390,1739, 338,1282,3073, 693,2857,1411, // 3686
1074,3747,2440,7391,4330,7392,7393,1240, 952,2394,7394,2900,1538,2679, 685,1483, // 3702
4084,2468,1436, 953,4085,2054,4331, 671,2395, 79,4086,2441,3252, 608, 567,2680, // 3718
3422,4087,4088,1691, 393,1261,1791,2396,7395,4332,7396,7397,7398,7399,1383,1672, // 3734
3748,3182,1464, 522,1119, 661,1150, 216, 675,4333,3888,1432,3519, 609,4334,2681, // 3750
2397,7400,7401,7402,4089,3025, 0,7403,2469, 315, 231,2442, 301,3319,4335,2380, // 3766
7404, 233,4090,3631,1818,4336,4337,7405, 96,1776,1315,2082,7406, 257,7407,1809, // 3782
3632,2709,1139,1819,4091,2021,1124,2163,2778,1777,2649,7408,3074, 363,1655,3183, // 3798
7409,2975,7410,7411,7412,3889,1567,3890, 718, 103,3184, 849,1443, 341,3320,2934, // 3814
1484,7413,1712, 127, 67, 339,4092,2398, 679,1412, 821,7414,7415, 834, 738, 351, // 3830
2976,2146, 846, 235,1497,1880, 418,1992,3749,2710, 186,1100,2147,2746,3520,1545, // 3846
1355,2935,2858,1377, 583,3891,4093,2573,2977,7416,1298,3633,1078,2549,3634,2358, // 3862
78,3750,3751, 267,1289,2099,2001,1594,4094, 348, 369,1274,2194,2175,1837,4338, // 3878
1820,2817,3635,2747,2283,2002,4339,2936,2748, 144,3321, 882,4340,3892,2749,3423, // 3894
4341,2901,7417,4095,1726, 320,7418,3893,3026, 788,2978,7419,2818,1773,1327,2859, // 3910
3894,2819,7420,1306,4342,2003,1700,3752,3521,2359,2650, 787,2022, 506, 824,3636, // 3926
534, 323,4343,1044,3322,2023,1900, 946,3424,7421,1778,1500,1678,7422,1881,4344, // 3942
165, 243,4345,3637,2521, 123, 683,4096, 764,4346, 36,3895,1792, 589,2902, 816, // 3958
626,1667,3027,2233,1639,1555,1622,3753,3896,7423,3897,2860,1370,1228,1932, 891, // 3974
2083,2903, 304,4097,7424, 292,2979,2711,3522, 691,2100,4098,1115,4347, 118, 662, // 3990
7425, 611,1156, 854,2381,1316,2861, 2, 386, 515,2904,7426,7427,3253, 868,2234, // 4006
1486, 855,2651, 785,2212,3028,7428,1040,3185,3523,7429,3121, 448,7430,1525,7431, // 4022
2164,4348,7432,3754,7433,4099,2820,3524,3122, 503, 818,3898,3123,1568, 814, 676, // 4038
1444, 306,1749,7434,3755,1416,1030, 197,1428, 805,2821,1501,4349,7435,7436,7437, // 4054
1993,7438,4350,7439,7440,2195, 13,2779,3638,2980,3124,1229,1916,7441,3756,2131, // 4070
7442,4100,4351,2399,3525,7443,2213,1511,1727,1120,7444,7445, 646,3757,2443, 307, // 4086
7446,7447,1595,3186,7448,7449,7450,3639,1113,1356,3899,1465,2522,2523,7451, 519, // 4102
7452, 128,2132, 92,2284,1979,7453,3900,1512, 342,3125,2196,7454,2780,2214,1980, // 4118
3323,7455, 290,1656,1317, 789, 827,2360,7456,3758,4352, 562, 581,3901,7457, 401, // 4134
4353,2248, 94,4354,1399,2781,7458,1463,2024,4355,3187,1943,7459, 828,1105,4101, // 4150
1262,1394,7460,4102, 605,4356,7461,1783,2862,7462,2822, 819,2101, 578,2197,2937, // 4166
7463,1502, 436,3254,4103,3255,2823,3902,2905,3425,3426,7464,2712,2315,7465,7466, // 4182
2332,2067, 23,4357, 193, 826,3759,2102, 699,1630,4104,3075, 390,1793,1064,3526, // 4198
7467,1579,3076,3077,1400,7468,4105,1838,1640,2863,7469,4358,4359, 137,4106, 598, // 4214
3078,1966, 780, 104, 974,2938,7470, 278, 899, 253, 402, 572, 504, 493,1339,7471, // 4230
3903,1275,4360,2574,2550,7472,3640,3029,3079,2249, 565,1334,2713, 863, 41,7473, // 4246
7474,4361,7475,1657,2333, 19, 463,2750,4107, 606,7476,2981,3256,1087,2084,1323, // 4262
2652,2982,7477,1631,1623,1750,4108,2682,7478,2864, 791,2714,2653,2334, 232,2416, // 4278
7479,2983,1498,7480,2654,2620, 755,1366,3641,3257,3126,2025,1609, 119,1917,3427, // 4294
862,1026,4109,7481,3904,3760,4362,3905,4363,2260,1951,2470,7482,1125, 817,4110, // 4310
4111,3906,1513,1766,2040,1487,4112,3030,3258,2824,3761,3127,7483,7484,1507,7485, // 4326
2683, 733, 40,1632,1106,2865, 345,4113, 841,2524, 230,4364,2984,1846,3259,3428, // 4342
7486,1263, 986,3429,7487, 735, 879, 254,1137, 857, 622,1300,1180,1388,1562,3907, // 4358
3908,2939, 967,2751,2655,1349, 592,2133,1692,3324,2985,1994,4114,1679,3909,1901, // 4374
2185,7488, 739,3642,2715,1296,1290,7489,4115,2198,2199,1921,1563,2595,2551,1870, // 4390
2752,2986,7490, 435,7491, 343,1108, 596, 17,1751,4365,2235,3430,3643,7492,4366, // 4406
294,3527,2940,1693, 477, 979, 281,2041,3528, 643,2042,3644,2621,2782,2261,1031, // 4422
2335,2134,2298,3529,4367, 367,1249,2552,7493,3530,7494,4368,1283,3325,2004, 240, // 4438
1762,3326,4369,4370, 836,1069,3128, 474,7495,2148,2525, 268,3531,7496,3188,1521, // 4454
1284,7497,1658,1546,4116,7498,3532,3533,7499,4117,3327,2684,1685,4118, 961,1673, // 4470
2622, 190,2005,2200,3762,4371,4372,7500, 570,2497,3645,1490,7501,4373,2623,3260, // 4486
1956,4374, 584,1514, 396,1045,1944,7502,4375,1967,2444,7503,7504,4376,3910, 619, // 4502
7505,3129,3261, 215,2006,2783,2553,3189,4377,3190,4378, 763,4119,3763,4379,7506, // 4518
7507,1957,1767,2941,3328,3646,1174, 452,1477,4380,3329,3130,7508,2825,1253,2382, // 4534
2186,1091,2285,4120, 492,7509, 638,1169,1824,2135,1752,3911, 648, 926,1021,1324, // 4550
4381, 520,4382, 997, 847,1007, 892,4383,3764,2262,1871,3647,7510,2400,1784,4384, // 4566
1952,2942,3080,3191,1728,4121,2043,3648,4385,2007,1701,3131,1551, 30,2263,4122, // 4582
7511,2026,4386,3534,7512, 501,7513,4123, 594,3431,2165,1821,3535,3432,3536,3192, // 4598
829,2826,4124,7514,1680,3132,1225,4125,7515,3262,4387,4126,3133,2336,7516,4388, // 4614
4127,7517,3912,3913,7518,1847,2383,2596,3330,7519,4389, 374,3914, 652,4128,4129, // 4630
375,1140, 798,7520,7521,7522,2361,4390,2264, 546,1659, 138,3031,2445,4391,7523, // 4646
2250, 612,1848, 910, 796,3765,1740,1371, 825,3766,3767,7524,2906,2554,7525, 692, // 4662
444,3032,2624, 801,4392,4130,7526,1491, 244,1053,3033,4131,4132, 340,7527,3915, // 4678
1041,2987, 293,1168, 87,1357,7528,1539, 959,7529,2236, 721, 694,4133,3768, 219, // 4694
1478, 644,1417,3331,2656,1413,1401,1335,1389,3916,7530,7531,2988,2362,3134,1825, // 4710
730,1515, 184,2827, 66,4393,7532,1660,2943, 246,3332, 378,1457, 226,3433, 975, // 4726
3917,2944,1264,3537, 674, 696,7533, 163,7534,1141,2417,2166, 713,3538,3333,4394, // 4742
3918,7535,7536,1186, 15,7537,1079,1070,7538,1522,3193,3539, 276,1050,2716, 758, // 4758
1126, 653,2945,3263,7539,2337, 889,3540,3919,3081,2989, 903,1250,4395,3920,3434, // 4774
3541,1342,1681,1718, 766,3264, 286, 89,2946,3649,7540,1713,7541,2597,3334,2990, // 4790
7542,2947,2215,3194,2866,7543,4396,2498,2526, 181, 387,1075,3921, 731,2187,3335, // 4806
7544,3265, 310, 313,3435,2299, 770,4134, 54,3034, 189,4397,3082,3769,3922,7545, // 4822
1230,1617,1849, 355,3542,4135,4398,3336, 111,4136,3650,1350,3135,3436,3035,4137, // 4838
2149,3266,3543,7546,2784,3923,3924,2991, 722,2008,7547,1071, 247,1207,2338,2471, // 4854
1378,4399,2009, 864,1437,1214,4400, 373,3770,1142,2216, 667,4401, 442,2753,2555, // 4870
3771,3925,1968,4138,3267,1839, 837, 170,1107, 934,1336,1882,7548,7549,2118,4139, // 4886
2828, 743,1569,7550,4402,4140, 582,2384,1418,3437,7551,1802,7552, 357,1395,1729, // 4902
3651,3268,2418,1564,2237,7553,3083,3772,1633,4403,1114,2085,4141,1532,7554, 482, // 4918
2446,4404,7555,7556,1492, 833,1466,7557,2717,3544,1641,2829,7558,1526,1272,3652, // 4934
4142,1686,1794, 416,2556,1902,1953,1803,7559,3773,2785,3774,1159,2316,7560,2867, // 4950
4405,1610,1584,3036,2419,2754, 443,3269,1163,3136,7561,7562,3926,7563,4143,2499, // 4966
3037,4406,3927,3137,2103,1647,3545,2010,1872,4144,7564,4145, 431,3438,7565, 250, // 4982
97, 81,4146,7566,1648,1850,1558, 160, 848,7567, 866, 740,1694,7568,2201,2830, // 4998
3195,4147,4407,3653,1687, 950,2472, 426, 469,3196,3654,3655,3928,7569,7570,1188, // 5014
424,1995, 861,3546,4148,3775,2202,2685, 168,1235,3547,4149,7571,2086,1674,4408, // 5030
3337,3270, 220,2557,1009,7572,3776, 670,2992, 332,1208, 717,7573,7574,3548,2447, // 5046
3929,3338,7575, 513,7576,1209,2868,3339,3138,4409,1080,7577,7578,7579,7580,2527, // 5062
3656,3549, 815,1587,3930,3931,7581,3550,3439,3777,1254,4410,1328,3038,1390,3932, // 5078
1741,3933,3778,3934,7582, 236,3779,2448,3271,7583,7584,3657,3780,1273,3781,4411, // 5094
7585, 308,7586,4412, 245,4413,1851,2473,1307,2575, 430, 715,2136,2449,7587, 270, // 5110
199,2869,3935,7588,3551,2718,1753, 761,1754, 725,1661,1840,4414,3440,3658,7589, // 5126
7590, 587, 14,3272, 227,2598, 326, 480,2265, 943,2755,3552, 291, 650,1883,7591, // 5142
1702,1226, 102,1547, 62,3441, 904,4415,3442,1164,4150,7592,7593,1224,1548,2756, // 5158
391, 498,1493,7594,1386,1419,7595,2055,1177,4416, 813, 880,1081,2363, 566,1145, // 5174
4417,2286,1001,1035,2558,2599,2238, 394,1286,7596,7597,2068,7598, 86,1494,1730, // 5190
3936, 491,1588, 745, 897,2948, 843,3340,3937,2757,2870,3273,1768, 998,2217,2069, // 5206
397,1826,1195,1969,3659,2993,3341, 284,7599,3782,2500,2137,2119,1903,7600,3938, // 5222
2150,3939,4151,1036,3443,1904, 114,2559,4152, 209,1527,7601,7602,2949,2831,2625, // 5238
2385,2719,3139, 812,2560,7603,3274,7604,1559, 737,1884,3660,1210, 885, 28,2686, // 5254
3553,3783,7605,4153,1004,1779,4418,7606, 346,1981,2218,2687,4419,3784,1742, 797, // 5270
1642,3940,1933,1072,1384,2151, 896,3941,3275,3661,3197,2871,3554,7607,2561,1958, // 5286
4420,2450,1785,7608,7609,7610,3942,4154,1005,1308,3662,4155,2720,4421,4422,1528, // 5302
2600, 161,1178,4156,1982, 987,4423,1101,4157, 631,3943,1157,3198,2420,1343,1241, // 5318
1016,2239,2562, 372, 877,2339,2501,1160, 555,1934, 911,3944,7611, 466,1170, 169, // 5334
1051,2907,2688,3663,2474,2994,1182,2011,2563,1251,2626,7612, 992,2340,3444,1540, // 5350
2721,1201,2070,2401,1996,2475,7613,4424, 528,1922,2188,1503,1873,1570,2364,3342, // 5366
3276,7614, 557,1073,7615,1827,3445,2087,2266,3140,3039,3084, 767,3085,2786,4425, // 5382
1006,4158,4426,2341,1267,2176,3664,3199, 778,3945,3200,2722,1597,2657,7616,4427, // 5398
7617,3446,7618,7619,7620,3277,2689,1433,3278, 131, 95,1504,3946, 723,4159,3141, // 5414
1841,3555,2758,2189,3947,2027,2104,3665,7621,2995,3948,1218,7622,3343,3201,3949, // 5430
4160,2576, 248,1634,3785, 912,7623,2832,3666,3040,3786, 654, 53,7624,2996,7625, // 5446
1688,4428, 777,3447,1032,3950,1425,7626, 191, 820,2120,2833, 971,4429, 931,3202, // 5462
135, 664, 783,3787,1997, 772,2908,1935,3951,3788,4430,2909,3203, 282,2723, 640, // 5478
1372,3448,1127, 922, 325,3344,7627,7628, 711,2044,7629,7630,3952,2219,2787,1936, // 5494
3953,3345,2220,2251,3789,2300,7631,4431,3790,1258,3279,3954,3204,2138,2950,3955, // 5510
3956,7632,2221, 258,3205,4432, 101,1227,7633,3280,1755,7634,1391,3281,7635,2910, // 5526
2056, 893,7636,7637,7638,1402,4161,2342,7639,7640,3206,3556,7641,7642, 878,1325, // 5542
1780,2788,4433, 259,1385,2577, 744,1183,2267,4434,7643,3957,2502,7644, 684,1024, // 5558
4162,7645, 472,3557,3449,1165,3282,3958,3959, 322,2152, 881, 455,1695,1152,1340, // 5574
660, 554,2153,4435,1058,4436,4163, 830,1065,3346,3960,4437,1923,7646,1703,1918, // 5590
7647, 932,2268, 122,7648,4438, 947, 677,7649,3791,2627, 297,1905,1924,2269,4439, // 5606
2317,3283,7650,7651,4164,7652,4165, 84,4166, 112, 989,7653, 547,1059,3961, 701, // 5622
3558,1019,7654,4167,7655,3450, 942, 639, 457,2301,2451, 993,2951, 407, 851, 494, // 5638
4440,3347, 927,7656,1237,7657,2421,3348, 573,4168, 680, 921,2911,1279,1874, 285, // 5654
790,1448,1983, 719,2167,7658,7659,4441,3962,3963,1649,7660,1541, 563,7661,1077, // 5670
7662,3349,3041,3451, 511,2997,3964,3965,3667,3966,1268,2564,3350,3207,4442,4443, // 5686
7663, 535,1048,1276,1189,2912,2028,3142,1438,1373,2834,2952,1134,2012,7664,4169, // 5702
1238,2578,3086,1259,7665, 700,7666,2953,3143,3668,4170,7667,4171,1146,1875,1906, // 5718
4444,2601,3967, 781,2422, 132,1589, 203, 147, 273,2789,2402, 898,1786,2154,3968, // 5734
3969,7668,3792,2790,7669,7670,4445,4446,7671,3208,7672,1635,3793, 965,7673,1804, // 5750
2690,1516,3559,1121,1082,1329,3284,3970,1449,3794, 65,1128,2835,2913,2759,1590, // 5766
3795,7674,7675, 12,2658, 45, 976,2579,3144,4447, 517,2528,1013,1037,3209,7676, // 5782
3796,2836,7677,3797,7678,3452,7679,2602, 614,1998,2318,3798,3087,2724,2628,7680, // 5798
2580,4172, 599,1269,7681,1810,3669,7682,2691,3088, 759,1060, 489,1805,3351,3285, // 5814
1358,7683,7684,2386,1387,1215,2629,2252, 490,7685,7686,4173,1759,2387,2343,7687, // 5830
4448,3799,1907,3971,2630,1806,3210,4449,3453,3286,2760,2344, 874,7688,7689,3454, // 5846
3670,1858, 91,2914,3671,3042,3800,4450,7690,3145,3972,2659,7691,3455,1202,1403, // 5862
3801,2954,2529,1517,2503,4451,3456,2504,7692,4452,7693,2692,1885,1495,1731,3973, // 5878
2365,4453,7694,2029,7695,7696,3974,2693,1216, 237,2581,4174,2319,3975,3802,4454, // 5894
4455,2694,3560,3457, 445,4456,7697,7698,7699,7700,2761, 61,3976,3672,1822,3977, // 5910
7701, 687,2045, 935, 925, 405,2660, 703,1096,1859,2725,4457,3978,1876,1367,2695, // 5926
3352, 918,2105,1781,2476, 334,3287,1611,1093,4458, 564,3146,3458,3673,3353, 945, // 5942
2631,2057,4459,7702,1925, 872,4175,7703,3459,2696,3089, 349,4176,3674,3979,4460, // 5958
3803,4177,3675,2155,3980,4461,4462,4178,4463,2403,2046, 782,3981, 400, 251,4179, // 5974
1624,7704,7705, 277,3676, 299,1265, 476,1191,3804,2121,4180,4181,1109, 205,7706, // 5990
2582,1000,2156,3561,1860,7707,7708,7709,4464,7710,4465,2565, 107,2477,2157,3982, // 6006
3460,3147,7711,1533, 541,1301, 158, 753,4182,2872,3562,7712,1696, 370,1088,4183, // 6022
4466,3563, 579, 327, 440, 162,2240, 269,1937,1374,3461, 968,3043, 56,1396,3090, // 6038
2106,3288,3354,7713,1926,2158,4467,2998,7714,3564,7715,7716,3677,4468,2478,7717, // 6054
2791,7718,1650,4469,7719,2603,7720,7721,3983,2661,3355,1149,3356,3984,3805,3985, // 6070
7722,1076, 49,7723, 951,3211,3289,3290, 450,2837, 920,7724,1811,2792,2366,4184, // 6086
1908,1138,2367,3806,3462,7725,3212,4470,1909,1147,1518,2423,4471,3807,7726,4472, // 6102
2388,2604, 260,1795,3213,7727,7728,3808,3291, 708,7729,3565,1704,7730,3566,1351, // 6118
1618,3357,2999,1886, 944,4185,3358,4186,3044,3359,4187,7731,3678, 422, 413,1714, // 6134
3292, 500,2058,2345,4188,2479,7732,1344,1910, 954,7733,1668,7734,7735,3986,2404, // 6150
4189,3567,3809,4190,7736,2302,1318,2505,3091, 133,3092,2873,4473, 629, 31,2838, // 6166
2697,3810,4474, 850, 949,4475,3987,2955,1732,2088,4191,1496,1852,7737,3988, 620, // 6182
3214, 981,1242,3679,3360,1619,3680,1643,3293,2139,2452,1970,1719,3463,2168,7738, // 6198
3215,7739,7740,3361,1828,7741,1277,4476,1565,2047,7742,1636,3568,3093,7743, 869, // 6214
2839, 655,3811,3812,3094,3989,3000,3813,1310,3569,4477,7744,7745,7746,1733, 558, // 6230
4478,3681, 335,1549,3045,1756,4192,3682,1945,3464,1829,1291,1192, 470,2726,2107, // 6246
2793, 913,1054,3990,7747,1027,7748,3046,3991,4479, 982,2662,3362,3148,3465,3216, // 6262
3217,1946,2794,7749, 571,4480,7750,1830,7751,3570,2583,1523,2424,7752,2089, 984, // 6278
4481,3683,1959,7753,3684, 852, 923,2795,3466,3685, 969,1519, 999,2048,2320,1705, // 6294
7754,3095, 615,1662, 151, 597,3992,2405,2321,1049, 275,4482,3686,4193, 568,3687, // 6310
3571,2480,4194,3688,7755,2425,2270, 409,3218,7756,1566,2874,3467,1002, 769,2840, // 6326
194,2090,3149,3689,2222,3294,4195, 628,1505,7757,7758,1763,2177,3001,3993, 521, // 6342
1161,2584,1787,2203,2406,4483,3994,1625,4196,4197, 412, 42,3096, 464,7759,2632, // 6358
4484,3363,1760,1571,2875,3468,2530,1219,2204,3814,2633,2140,2368,4485,4486,3295, // 6374
1651,3364,3572,7760,7761,3573,2481,3469,7762,3690,7763,7764,2271,2091, 460,7765, // 6390
4487,7766,3002, 962, 588,3574, 289,3219,2634,1116, 52,7767,3047,1796,7768,7769, // 6406
7770,1467,7771,1598,1143,3691,4198,1984,1734,1067,4488,1280,3365, 465,4489,1572, // 6422
510,7772,1927,2241,1812,1644,3575,7773,4490,3692,7774,7775,2663,1573,1534,7776, // 6438
7777,4199, 536,1807,1761,3470,3815,3150,2635,7778,7779,7780,4491,3471,2915,1911, // 6454
2796,7781,3296,1122, 377,3220,7782, 360,7783,7784,4200,1529, 551,7785,2059,3693, // 6470
1769,2426,7786,2916,4201,3297,3097,2322,2108,2030,4492,1404, 136,1468,1479, 672, // 6486
1171,3221,2303, 271,3151,7787,2762,7788,2049, 678,2727, 865,1947,4493,7789,2013, // 6502
3995,2956,7790,2728,2223,1397,3048,3694,4494,4495,1735,2917,3366,3576,7791,3816, // 6518
509,2841,2453,2876,3817,7792,7793,3152,3153,4496,4202,2531,4497,2304,1166,1010, // 6534
552, 681,1887,7794,7795,2957,2958,3996,1287,1596,1861,3154, 358, 453, 736, 175, // 6550
478,1117, 905,1167,1097,7796,1853,1530,7797,1706,7798,2178,3472,2287,3695,3473, // 6566
3577,4203,2092,4204,7799,3367,1193,2482,4205,1458,2190,2205,1862,1888,1421,3298, // 6582
2918,3049,2179,3474, 595,2122,7800,3997,7801,7802,4206,1707,2636, 223,3696,1359, // 6598
751,3098, 183,3475,7803,2797,3003, 419,2369, 633, 704,3818,2389, 241,7804,7805, // 6614
7806, 838,3004,3697,2272,2763,2454,3819,1938,2050,3998,1309,3099,2242,1181,7807, // 6630
1136,2206,3820,2370,1446,4207,2305,4498,7808,7809,4208,1055,2605, 484,3698,7810, // 6646
3999, 625,4209,2273,3368,1499,4210,4000,7811,4001,4211,3222,2274,2275,3476,7812, // 6662
7813,2764, 808,2606,3699,3369,4002,4212,3100,2532, 526,3370,3821,4213, 955,7814, // 6678
1620,4214,2637,2427,7815,1429,3700,1669,1831, 994, 928,7816,3578,1260,7817,7818, // 6694
7819,1948,2288, 741,2919,1626,4215,2729,2455, 867,1184, 362,3371,1392,7820,7821, // 6710
4003,4216,1770,1736,3223,2920,4499,4500,1928,2698,1459,1158,7822,3050,3372,2877, // 6726
1292,1929,2506,2842,3701,1985,1187,2071,2014,2607,4217,7823,2566,2507,2169,3702, // 6742
2483,3299,7824,3703,4501,7825,7826, 666,1003,3005,1022,3579,4218,7827,4502,1813, // 6758
2253, 574,3822,1603, 295,1535, 705,3823,4219, 283, 858, 417,7828,7829,3224,4503, // 6774
4504,3051,1220,1889,1046,2276,2456,4004,1393,1599, 689,2567, 388,4220,7830,2484, // 6790
802,7831,2798,3824,2060,1405,2254,7832,4505,3825,2109,1052,1345,3225,1585,7833, // 6806
809,7834,7835,7836, 575,2730,3477, 956,1552,1469,1144,2323,7837,2324,1560,2457, // 6822
3580,3226,4005, 616,2207,3155,2180,2289,7838,1832,7839,3478,4506,7840,1319,3704, // 6838
3705,1211,3581,1023,3227,1293,2799,7841,7842,7843,3826, 607,2306,3827, 762,2878, // 6854
1439,4221,1360,7844,1485,3052,7845,4507,1038,4222,1450,2061,2638,4223,1379,4508, // 6870
2585,7846,7847,4224,1352,1414,2325,2921,1172,7848,7849,3828,3829,7850,1797,1451, // 6886
7851,7852,7853,7854,2922,4006,4007,2485,2346, 411,4008,4009,3582,3300,3101,4509, // 6902
1561,2664,1452,4010,1375,7855,7856, 47,2959, 316,7857,1406,1591,2923,3156,7858, // 6918
1025,2141,3102,3157, 354,2731, 884,2224,4225,2407, 508,3706, 726,3583, 996,2428, // 6934
3584, 729,7859, 392,2191,1453,4011,4510,3707,7860,7861,2458,3585,2608,1675,2800, // 6950
919,2347,2960,2348,1270,4511,4012, 73,7862,7863, 647,7864,3228,2843,2255,1550, // 6966
1346,3006,7865,1332, 883,3479,7866,7867,7868,7869,3301,2765,7870,1212, 831,1347, // 6982
4226,4512,2326,3830,1863,3053, 720,3831,4513,4514,3832,7871,4227,7872,7873,4515, // 6998
7874,7875,1798,4516,3708,2609,4517,3586,1645,2371,7876,7877,2924, 669,2208,2665, // 7014
2429,7878,2879,7879,7880,1028,3229,7881,4228,2408,7882,2256,1353,7883,7884,4518, // 7030
3158, 518,7885,4013,7886,4229,1960,7887,2142,4230,7888,7889,3007,2349,2350,3833, // 7046
516,1833,1454,4014,2699,4231,4519,2225,2610,1971,1129,3587,7890,2766,7891,2961, // 7062
1422, 577,1470,3008,1524,3373,7892,7893, 432,4232,3054,3480,7894,2586,1455,2508, // 7078
2226,1972,1175,7895,1020,2732,4015,3481,4520,7896,2733,7897,1743,1361,3055,3482, // 7094
2639,4016,4233,4521,2290, 895, 924,4234,2170, 331,2243,3056, 166,1627,3057,1098, // 7110
7898,1232,2880,2227,3374,4522, 657, 403,1196,2372, 542,3709,3375,1600,4235,3483, // 7126
7899,4523,2767,3230, 576, 530,1362,7900,4524,2533,2666,3710,4017,7901, 842,3834, // 7142
7902,2801,2031,1014,4018, 213,2700,3376, 665, 621,4236,7903,3711,2925,2430,7904, // 7158
2431,3302,3588,3377,7905,4237,2534,4238,4525,3589,1682,4239,3484,1380,7906, 724, // 7174
2277, 600,1670,7907,1337,1233,4526,3103,2244,7908,1621,4527,7909, 651,4240,7910, // 7190
1612,4241,2611,7911,2844,7912,2734,2307,3058,7913, 716,2459,3059, 174,1255,2701, // 7206
4019,3590, 548,1320,1398, 728,4020,1574,7914,1890,1197,3060,4021,7915,3061,3062, // 7222
3712,3591,3713, 747,7916, 635,4242,4528,7917,7918,7919,4243,7920,7921,4529,7922, // 7238
3378,4530,2432, 451,7923,3714,2535,2072,4244,2735,4245,4022,7924,1764,4531,7925, // 7254
4246, 350,7926,2278,2390,2486,7927,4247,4023,2245,1434,4024, 488,4532, 458,4248, // 7270
4025,3715, 771,1330,2391,3835,2568,3159,2159,2409,1553,2667,3160,4249,7928,2487, // 7286
2881,2612,1720,2702,4250,3379,4533,7929,2536,4251,7930,3231,4252,2768,7931,2015, // 7302
2736,7932,1155,1017,3716,3836,7933,3303,2308, 201,1864,4253,1430,7934,4026,7935, // 7318
7936,7937,7938,7939,4254,1604,7940, 414,1865, 371,2587,4534,4535,3485,2016,3104, // 7334
4536,1708, 960,4255, 887, 389,2171,1536,1663,1721,7941,2228,4027,2351,2926,1580, // 7350
7942,7943,7944,1744,7945,2537,4537,4538,7946,4539,7947,2073,7948,7949,3592,3380, // 7366
2882,4256,7950,4257,2640,3381,2802, 673,2703,2460, 709,3486,4028,3593,4258,7951, // 7382
1148, 502, 634,7952,7953,1204,4540,3594,1575,4541,2613,3717,7954,3718,3105, 948, // 7398
3232, 121,1745,3837,1110,7955,4259,3063,2509,3009,4029,3719,1151,1771,3838,1488, // 7414
4030,1986,7956,2433,3487,7957,7958,2093,7959,4260,3839,1213,1407,2803, 531,2737, // 7430
2538,3233,1011,1537,7960,2769,4261,3106,1061,7961,3720,3721,1866,2883,7962,2017, // 7446
120,4262,4263,2062,3595,3234,2309,3840,2668,3382,1954,4542,7963,7964,3488,1047, // 7462
2704,1266,7965,1368,4543,2845, 649,3383,3841,2539,2738,1102,2846,2669,7966,7967, // 7478
1999,7968,1111,3596,2962,7969,2488,3842,3597,2804,1854,3384,3722,7970,7971,3385, // 7494
2410,2884,3304,3235,3598,7972,2569,7973,3599,2805,4031,1460, 856,7974,3600,7975, // 7510
2885,2963,7976,2886,3843,7977,4264, 632,2510, 875,3844,1697,3845,2291,7978,7979, // 7526
4544,3010,1239, 580,4545,4265,7980, 914, 936,2074,1190,4032,1039,2123,7981,7982, // 7542
7983,3386,1473,7984,1354,4266,3846,7985,2172,3064,4033, 915,3305,4267,4268,3306, // 7558
1605,1834,7986,2739, 398,3601,4269,3847,4034, 328,1912,2847,4035,3848,1331,4270, // 7574
3011, 937,4271,7987,3602,4036,4037,3387,2160,4546,3388, 524, 742, 538,3065,1012, // 7590
7988,7989,3849,2461,7990, 658,1103, 225,3850,7991,7992,4547,7993,4548,7994,3236, // 7606
1243,7995,4038, 963,2246,4549,7996,2705,3603,3161,7997,7998,2588,2327,7999,4550, // 7622
8000,8001,8002,3489,3307, 957,3389,2540,2032,1930,2927,2462, 870,2018,3604,1746, // 7638
2770,2771,2434,2463,8003,3851,8004,3723,3107,3724,3490,3390,3725,8005,1179,3066, // 7654
8006,3162,2373,4272,3726,2541,3163,3108,2740,4039,8007,3391,1556,2542,2292, 977, // 7670
2887,2033,4040,1205,3392,8008,1765,3393,3164,2124,1271,1689, 714,4551,3491,8009, // 7686
2328,3852, 533,4273,3605,2181, 617,8010,2464,3308,3492,2310,8011,8012,3165,8013, // 7702
8014,3853,1987, 618, 427,2641,3493,3394,8015,8016,1244,1690,8017,2806,4274,4552, // 7718
8018,3494,8019,8020,2279,1576, 473,3606,4275,3395, 972,8021,3607,8022,3067,8023, // 7734
8024,4553,4554,8025,3727,4041,4042,8026, 153,4555, 356,8027,1891,2888,4276,2143, // 7750
408, 803,2352,8028,3854,8029,4277,1646,2570,2511,4556,4557,3855,8030,3856,4278, // 7766
8031,2411,3396, 752,8032,8033,1961,2964,8034, 746,3012,2465,8035,4279,3728, 698, // 7782
4558,1892,4280,3608,2543,4559,3609,3857,8036,3166,3397,8037,1823,1302,4043,2706, // 7798
3858,1973,4281,8038,4282,3167, 823,1303,1288,1236,2848,3495,4044,3398, 774,3859, // 7814
8039,1581,4560,1304,2849,3860,4561,8040,2435,2161,1083,3237,4283,4045,4284, 344, // 7830
1173, 288,2311, 454,1683,8041,8042,1461,4562,4046,2589,8043,8044,4563, 985, 894, // 7846
8045,3399,3168,8046,1913,2928,3729,1988,8047,2110,1974,8048,4047,8049,2571,1194, // 7862
425,8050,4564,3169,1245,3730,4285,8051,8052,2850,8053, 636,4565,1855,3861, 760, // 7878
1799,8054,4286,2209,1508,4566,4048,1893,1684,2293,8055,8056,8057,4287,4288,2210, // 7894
479,8058,8059, 832,8060,4049,2489,8061,2965,2490,3731, 990,3109, 627,1814,2642, // 7910
4289,1582,4290,2125,2111,3496,4567,8062, 799,4291,3170,8063,4568,2112,1737,3013, // 7926
1018, 543, 754,4292,3309,1676,4569,4570,4050,8064,1489,8065,3497,8066,2614,2889, // 7942
4051,8067,8068,2966,8069,8070,8071,8072,3171,4571,4572,2182,1722,8073,3238,3239, // 7958
1842,3610,1715, 481, 365,1975,1856,8074,8075,1962,2491,4573,8076,2126,3611,3240, // 7974
433,1894,2063,2075,8077, 602,2741,8078,8079,8080,8081,8082,3014,1628,3400,8083, // 7990
3172,4574,4052,2890,4575,2512,8084,2544,2772,8085,8086,8087,3310,4576,2891,8088, // 8006
4577,8089,2851,4578,4579,1221,2967,4053,2513,8090,8091,8092,1867,1989,8093,8094, // 8022
8095,1895,8096,8097,4580,1896,4054, 318,8098,2094,4055,4293,8099,8100, 485,8101, // 8038
938,3862, 553,2670, 116,8102,3863,3612,8103,3498,2671,2773,3401,3311,2807,8104, // 8054
3613,2929,4056,1747,2930,2968,8105,8106, 207,8107,8108,2672,4581,2514,8109,3015, // 8070
890,3614,3864,8110,1877,3732,3402,8111,2183,2353,3403,1652,8112,8113,8114, 941, // 8086
2294, 208,3499,4057,2019, 330,4294,3865,2892,2492,3733,4295,8115,8116,8117,8118, // 8102
]
| lgpl-2.1 | 4df8cebb89d04a3f1c67325a1ac55a5e | 84.574359 | 93 | 0.6882 | 2.008909 | false | false | false | false |
huang1988519/WechatArticles | WechatArticles/WechatArticles/Transform/PresentTransiton.swift | 1 | 2816 | //
// PresentTransiton.swift
// WechatArticle
//
// Created by hwh on 15/11/12.
// Copyright © 2015年 hwh. All rights reserved.
//
import UIKit
//import Spring
public class PresentTransition : NSObject, UIViewControllerTransitioningDelegate, UIViewControllerAnimatedTransitioning {
var isPresenting = true
var duration = 0.7
public func animateTransition(transitionContext: UIViewControllerContextTransitioning) {
let container = transitionContext.containerView()!
let fromView = transitionContext.viewForKey(UITransitionContextFromViewKey)!
let toView = transitionContext.viewForKey(UITransitionContextToViewKey)!
let toController = transitionContext.viewControllerForKey(UITransitionContextToViewControllerKey)
var frame = transitionContext.finalFrameForViewController(toController!)
if isPresenting {
container.addSubview(fromView)
container.addSubview(toView)
fromView.backgroundColor = UIColor.clearColor()
frame.origin.x = CGRectGetWidth(frame)
toView.frame = frame
UIView.animateWithDuration(
duration,
delay: 0,
usingSpringWithDamping: 0.5,
initialSpringVelocity: 2,
options: .CurveEaseInOut,
animations: { () -> Void in
frame.origin.x = 0
toView.frame = frame
},
completion: nil)
}
else {
container.addSubview(toView)
container.addSubview(fromView)
UIView.animateWithDuration(
duration,
delay: 0,
usingSpringWithDamping: 0.7,
initialSpringVelocity: 2,
options: .CurveEaseIn,
animations: { () -> Void in
frame.origin.y = CGRectGetHeight(frame)
fromView.frame = frame
}, completion: nil)
}
delay(duration, closure: {
transitionContext.completeTransition(true)
})
}
public func transitionDuration(transitionContext: UIViewControllerContextTransitioning?) -> NSTimeInterval {
return duration
}
public func animationControllerForPresentedController(presented: UIViewController, presentingController presenting: UIViewController, sourceController source: UIViewController) -> UIViewControllerAnimatedTransitioning? {
isPresenting = true
return self
}
public func animationControllerForDismissedController(dismissed: UIViewController) -> UIViewControllerAnimatedTransitioning? {
isPresenting = false
return self
}
} | apache-2.0 | 0eb5b3e6c512d051dc5f9efe3dfb5910 | 34.620253 | 224 | 0.621045 | 6.713604 | false | false | false | false |
jfosterdavis/Charles | Charles/PieTimerView.swift | 1 | 3692 | //
// PieTimerView.swift
// Charles
//
// Created by Jacob Foster Davis on 5/27/17.
// Copyright © 2017 Zero Mu, LLC. All rights reserved.
//
import Foundation
import UIKit
//@IBDesignable
class PieTimerView:UIView
{
@IBInspectable var progressColor: UIColor = UIColor.darkGray
{
didSet {}
}
@IBInspectable var circleColor: UIColor = UIColor.gray
{
didSet { }
}
@IBInspectable var ringThickness: CGFloat = 1.0
{
didSet { }
}
@IBInspectable var fullPie: Bool = true
{
didSet { }
}
@IBInspectable var startAngle: Int = 0
{
didSet { }
}
@IBInspectable var endAngle: Int = 90
{
didSet { }
}
@IBInspectable var percentCrustVisible: CGFloat = 20
{
didSet { }
}
override func draw(_ rect: CGRect)
{
let dotPath = UIBezierPath(ovalIn: rect)
let shapeLayer = CAShapeLayer()
shapeLayer.path = dotPath.cgPath
shapeLayer.fillColor = circleColor.cgColor
layer.addSublayer(shapeLayer)
if percentCrustVisible > 100 {
percentCrustVisible = 100
} else if percentCrustVisible < 0 {
percentCrustVisible = 0
}
if fullPie {
ringThickness = min(bounds.size.width/2, bounds.size.height/2)
}
drawProgressRing(rect: rect)
}
internal func drawProgressRing(rect: CGRect)->()
{
let halfSize:CGFloat = max( bounds.size.width/2, bounds.size.height/2)
let desiredLineWidth:CGFloat = ringThickness * (1 - (percentCrustVisible/100)) // your desired value
let startAngleRads = CGFloat(Double(startAngle - 90) / 180.0 * Double.pi)
let endAngleRads = CGFloat(Double(endAngle - 90) / 180.0 * Double.pi)
let circlePath = UIBezierPath(
arcCenter: CGPoint(x: halfSize, y: halfSize),
radius: CGFloat( (halfSize - (desiredLineWidth/2))) , //make the slice 80% size of crust
startAngle: startAngleRads,
endAngle: endAngleRads,
clockwise: true)
let shapeLayer = CAShapeLayer()
shapeLayer.path = circlePath.cgPath
// let newFillColor = calculateColorDeviation(color1: objectiveRingColor, color2: progressRingColor)
// shapeLayer.fillColor = newFillColor.withAlphaComponent(1.0).cgColor
shapeLayer.fillColor = circleColor.cgColor
shapeLayer.strokeColor = progressColor.cgColor
shapeLayer.lineWidth = desiredLineWidth
layer.addSublayer(shapeLayer)
}
///sets the procession of the progress pie to the given angle
func setProgress(angle: Int) {
var desiredAngle = angle
if desiredAngle > 360 {
desiredAngle = 360
} else if desiredAngle < -360 {
desiredAngle = -360
}
endAngle = desiredAngle
self.setNeedsDisplay()
}
///sets the procession of the progress pie to the given percent of a full rotation
func setProgress(percent: Float) {
var desiredAngle = 360.0 * percent / 100.0
if desiredAngle > 360 {
desiredAngle = 360
} else if desiredAngle < -360 {
desiredAngle = -360
}
endAngle = Int(desiredAngle)
self.setNeedsDisplay()
}
///changes the color of the progress pie
func setProgressColor(color: UIColor) {
progressColor = color
self.setNeedsDisplay()
}
}
| apache-2.0 | a575f0c08a2cce5b2e441913a60e9318 | 26.962121 | 115 | 0.578163 | 4.787289 | false | false | false | false |
mlmc03/SwiftFM-DroidFM | SwiftFM/HanekeSwift/Haneke/UIButton+Haneke.swift | 3 | 11859 | //
// UIButton+Haneke.swift
// Haneke
//
// Created by Joan Romano on 10/1/14.
// Copyright (c) 2014 Haneke. All rights reserved.
//
import UIKit
public extension UIButton {
public var hnk_imageFormat : Format<UIImage> {
let bounds = self.bounds
assert(bounds.size.width > 0 && bounds.size.height > 0, "[\(Mirror(reflecting: self).description) \(#function)]: UIButton size is zero. Set its frame, call sizeToFit or force layout first. You can also set a custom format with a defined size if you don't want to force layout.")
let contentRect = self.contentRectForBounds(bounds)
let imageInsets = self.imageEdgeInsets
let scaleMode = self.contentHorizontalAlignment != UIControlContentHorizontalAlignment.Fill || self.contentVerticalAlignment != UIControlContentVerticalAlignment.Fill ? ImageResizer.ScaleMode.AspectFit : ImageResizer.ScaleMode.Fill
let imageSize = CGSizeMake(CGRectGetWidth(contentRect) - imageInsets.left - imageInsets.right, CGRectGetHeight(contentRect) - imageInsets.top - imageInsets.bottom)
return HanekeGlobals.UIKit.formatWithSize(imageSize, scaleMode: scaleMode, allowUpscaling: scaleMode == ImageResizer.ScaleMode.AspectFit ? false : true)
}
public func hnk_setImageFromURL(URL: NSURL, state: UIControlState = .Normal, placeholder: UIImage? = nil, format: Format<UIImage>? = nil, failure fail: ((NSError?) -> ())? = nil, success succeed: ((UIImage) -> ())? = nil) {
let fetcher = NetworkFetcher<UIImage>(URL: URL)
self.hnk_setImageFromFetcher(fetcher, state: state, placeholder: placeholder, format: format, failure: fail, success: succeed)
}
public func hnk_setImage(image: UIImage, key: String, state: UIControlState = .Normal, placeholder: UIImage? = nil, format: Format<UIImage>? = nil, success succeed: ((UIImage) -> ())? = nil) {
let fetcher = SimpleFetcher<UIImage>(key: key, value: image)
self.hnk_setImageFromFetcher(fetcher, state: state, placeholder: placeholder, format: format, success: succeed)
}
public func hnk_setImageFromFile(path: String, state: UIControlState = .Normal, placeholder: UIImage? = nil, format: Format<UIImage>? = nil, failure fail: ((NSError?) -> ())? = nil, success succeed: ((UIImage) -> ())? = nil) {
let fetcher = DiskFetcher<UIImage>(path: path)
self.hnk_setImageFromFetcher(fetcher, state: state, placeholder: placeholder, format: format, failure: fail, success: succeed)
}
public func hnk_setImageFromFetcher(fetcher: Fetcher<UIImage>, state: UIControlState = .Normal, placeholder: UIImage? = nil, format: Format<UIImage>? = nil, failure fail: ((NSError?) -> ())? = nil, success succeed: ((UIImage) -> ())? = nil){
self.hnk_cancelSetImage()
self.hnk_imageFetcher = fetcher
let didSetImage = self.hnk_fetchImageForFetcher(fetcher, state: state, format : format, failure: fail, success: succeed)
if didSetImage { return }
if let placeholder = placeholder {
self.setImage(placeholder, forState: state)
}
}
public func hnk_cancelSetImage() {
if let fetcher = self.hnk_imageFetcher {
fetcher.cancelFetch()
self.hnk_imageFetcher = nil
}
}
// MARK: Internal Image
// See: http://stackoverflow.com/questions/25907421/associating-swift-things-with-nsobject-instances
var hnk_imageFetcher : Fetcher<UIImage>! {
get {
let wrapper = objc_getAssociatedObject(self, &HanekeGlobals.UIKit.SetImageFetcherKey) as? ObjectWrapper
let fetcher = wrapper?.value as? Fetcher<UIImage>
return fetcher
}
set (fetcher) {
var wrapper : ObjectWrapper?
if let fetcher = fetcher {
wrapper = ObjectWrapper(value: fetcher)
}
objc_setAssociatedObject(self, &HanekeGlobals.UIKit.SetImageFetcherKey, wrapper, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
func hnk_fetchImageForFetcher(fetcher : Fetcher<UIImage>, state : UIControlState = .Normal, format : Format<UIImage>? = nil, failure fail : ((NSError?) -> ())?, success succeed : ((UIImage) -> ())?) -> Bool {
let format = format ?? self.hnk_imageFormat
let cache = Shared.imageCache
if cache.formats[format.name] == nil {
cache.addFormat(format)
}
var animated = false
let fetch = cache.fetch(fetcher: fetcher, formatName: format.name, failure: {[weak self] error in
if let strongSelf = self {
if strongSelf.hnk_shouldCancelImageForKey(fetcher.key) { return }
strongSelf.hnk_imageFetcher = nil
fail?(error)
}
}) { [weak self] image in
if let strongSelf = self {
if strongSelf.hnk_shouldCancelImageForKey(fetcher.key) { return }
strongSelf.hnk_setImage(image, state: state, animated: animated, success: succeed)
}
}
animated = true
return fetch.hasSucceeded
}
func hnk_setImage(image : UIImage, state : UIControlState, animated : Bool, success succeed : ((UIImage) -> ())?) {
self.hnk_imageFetcher = nil
if let succeed = succeed {
succeed(image)
} else if animated {
UIView.transitionWithView(self, duration: HanekeGlobals.UIKit.SetImageAnimationDuration, options: .TransitionCrossDissolve, animations: {
self.setImage(image, forState: state)
}, completion: nil)
} else {
self.setImage(image, forState: state)
}
}
func hnk_shouldCancelImageForKey(key:String) -> Bool {
if self.hnk_imageFetcher?.key == key { return false }
Log.debug("Cancelled set image for \((key as NSString).lastPathComponent)")
return true
}
// MARK: Background image
public var hnk_backgroundImageFormat : Format<UIImage> {
let bounds = self.bounds
assert(bounds.size.width > 0 && bounds.size.height > 0, "[\(Mirror(reflecting: self).description) \(#function)]: UIButton size is zero. Set its frame, call sizeToFit or force layout first. You can also set a custom format with a defined size if you don't want to force layout.")
let imageSize = self.backgroundRectForBounds(bounds).size
return HanekeGlobals.UIKit.formatWithSize(imageSize, scaleMode: .Fill)
}
public func hnk_setBackgroundImageFromURL(URL : NSURL, state : UIControlState = .Normal, placeholder : UIImage? = nil, format : Format<UIImage>? = nil, failure fail : ((NSError?) -> ())? = nil, success succeed : ((UIImage) -> ())? = nil) {
let fetcher = NetworkFetcher<UIImage>(URL: URL)
self.hnk_setBackgroundImageFromFetcher(fetcher, state: state, placeholder: placeholder, format: format, failure: fail, success: succeed)
}
public func hnk_setBackgroundImage(image : UIImage, key: String, state : UIControlState = .Normal, placeholder : UIImage? = nil, format : Format<UIImage>? = nil, success succeed : ((UIImage) -> ())? = nil) {
let fetcher = SimpleFetcher<UIImage>(key: key, value: image)
self.hnk_setBackgroundImageFromFetcher(fetcher, state: state, placeholder: placeholder, format: format, success: succeed)
}
public func hnk_setBackgroundImageFromFile(path: String, state : UIControlState = .Normal, placeholder : UIImage? = nil, format : Format<UIImage>? = nil, failure fail : ((NSError?) -> ())? = nil, success succeed : ((UIImage) -> ())? = nil) {
let fetcher = DiskFetcher<UIImage>(path: path)
self.hnk_setBackgroundImageFromFetcher(fetcher, state: state, placeholder: placeholder, format: format, failure: fail, success: succeed)
}
public func hnk_setBackgroundImageFromFetcher(fetcher : Fetcher<UIImage>, state : UIControlState = .Normal, placeholder : UIImage? = nil, format : Format<UIImage>? = nil, failure fail : ((NSError?) -> ())? = nil, success succeed : ((UIImage) -> ())? = nil){
self.hnk_cancelSetBackgroundImage()
self.hnk_backgroundImageFetcher = fetcher
let didSetImage = self.hnk_fetchBackgroundImageForFetcher(fetcher, state: state, format : format, failure: fail, success: succeed)
if didSetImage { return }
if let placeholder = placeholder {
self.setBackgroundImage(placeholder, forState: state)
}
}
public func hnk_cancelSetBackgroundImage() {
if let fetcher = self.hnk_backgroundImageFetcher {
fetcher.cancelFetch()
self.hnk_backgroundImageFetcher = nil
}
}
// MARK: Internal Background image
// See: http://stackoverflow.com/questions/25907421/associating-swift-things-with-nsobject-instances
var hnk_backgroundImageFetcher : Fetcher<UIImage>! {
get {
let wrapper = objc_getAssociatedObject(self, &HanekeGlobals.UIKit.SetBackgroundImageFetcherKey) as? ObjectWrapper
let fetcher = wrapper?.value as? Fetcher<UIImage>
return fetcher
}
set (fetcher) {
var wrapper : ObjectWrapper?
if let fetcher = fetcher {
wrapper = ObjectWrapper(value: fetcher)
}
objc_setAssociatedObject(self, &HanekeGlobals.UIKit.SetBackgroundImageFetcherKey, wrapper, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
func hnk_fetchBackgroundImageForFetcher(fetcher: Fetcher<UIImage>, state: UIControlState = .Normal, format: Format<UIImage>? = nil, failure fail: ((NSError?) -> ())?, success succeed : ((UIImage) -> ())?) -> Bool {
let format = format ?? self.hnk_backgroundImageFormat
let cache = Shared.imageCache
if cache.formats[format.name] == nil {
cache.addFormat(format)
}
var animated = false
let fetch = cache.fetch(fetcher: fetcher, formatName: format.name, failure: {[weak self] error in
if let strongSelf = self {
if strongSelf.hnk_shouldCancelBackgroundImageForKey(fetcher.key) { return }
strongSelf.hnk_backgroundImageFetcher = nil
fail?(error)
}
}) { [weak self] image in
if let strongSelf = self {
if strongSelf.hnk_shouldCancelBackgroundImageForKey(fetcher.key) { return }
strongSelf.hnk_setBackgroundImage(image, state: state, animated: animated, success: succeed)
}
}
animated = true
return fetch.hasSucceeded
}
func hnk_setBackgroundImage(image: UIImage, state: UIControlState, animated: Bool, success succeed: ((UIImage) -> ())?) {
self.hnk_backgroundImageFetcher = nil
if let succeed = succeed {
succeed(image)
} else if animated {
UIView.transitionWithView(self, duration: HanekeGlobals.UIKit.SetImageAnimationDuration, options: .TransitionCrossDissolve, animations: {
self.setBackgroundImage(image, forState: state)
}, completion: nil)
} else {
self.setBackgroundImage(image, forState: state)
}
}
func hnk_shouldCancelBackgroundImageForKey(key: String) -> Bool {
if self.hnk_backgroundImageFetcher?.key == key { return false }
Log.debug("Cancelled set background image for \((key as NSString).lastPathComponent)")
return true
}
}
| apache-2.0 | 4a2fb49b80a2528a61c4a0e4c408d57f | 49.679487 | 286 | 0.633106 | 4.92279 | false | false | false | false |
ataka/cwmealticket | CWMealTicket/CWHttpClient.swift | 1 | 1426 | //
// CWMHttpClient.swift
// CWMealTicket
//
// Created by 安宅 正之 on 2015/02/25.
// Copyright (c) 2015年 Masayuki Ataka. All rights reserved.
//
import UIKit
class CWHttpClient: NSObject {
private let roomId :String = ""
private let userToken :String = ""
private let baseUrl :String = "https://api.chatwork.com/v1"
private let messageFormat :String = "/rooms/%@/messages"
func sendMessage(message :String)
{
let base :NSURL = NSURL(string: baseUrl)!
let path :String = String(format: messageFormat, arguments: [roomId])
let requestUrl :NSURL = base.URLByAppendingPathComponent(path)
var request = NSMutableURLRequest(URL: requestUrl)
request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
request.addValue(userToken, forHTTPHeaderField: "X-ChatWorkToken")
request.HTTPMethod = "POST"
request.HTTPBody = "body=\(message)".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: true)
var task = NSURLSession.sharedSession().dataTaskWithRequest(request, completionHandler: {data, response, error in
if (error == nil) {
var result = NSString(data: data, encoding: NSUTF8StringEncoding)!
println(result)
} else {
println(error)
}
})
task.resume()
}
}
| mit | 0beba6d6a39eedbaa4fc7fd0326ade1d | 35.307692 | 121 | 0.639831 | 4.45283 | false | false | false | false |
alimysoyang/CommunicationDebugger | CommunicationDebugger/AYHTCPClientsManage.swift | 1 | 3015 | //
// AYHTCPClientsManage.swift
// CommunicationDebugger
//
// Created by alimysoyang on 15/11/23.
// Copyright © 2015年 alimysoyang. All rights reserved.
//
import Foundation
/**
* TCP服务端管理接入的TCP客户端的队列数据管理器
*/
class AYHTCPClientsManage: NSObject
{
// MARK: - properties
private var tcpClients:AYHSynchronizedArray<AYHTCPClientSocket> = AYHSynchronizedArray<AYHTCPClientSocket>();
var tcpClientSocket:AYHTCPClientSocket? {
get {
if (self.tcpClients.count == 0)
{
return nil;
}
return self.tcpClients.last;
}
}
var isEmpty:Bool {
get { return self.tcpClients.isEmpty; }
}
// MARK: - life cycle
override init()
{
super.init();
}
deinit
{
}
// MARK: - public methods
func addClientSocket(newSocket:GCDAsyncSocket)
{
let tcpClientSocket:AYHTCPClientSocket = AYHTCPClientSocket(clientSocket: newSocket);
var isExists:Bool = false;
for index in 0..<self.tcpClients.count
{
let item:AYHTCPClientSocket = self.tcpClients[index];
if let itemSocket = item.socket where itemSocket === newSocket
{
isExists = true;
break;
}
}
if (!isExists)
{
self.tcpClients.append(tcpClientSocket, completionClosure: { () -> Void in
});
}
}
func removeAtSocket(socket:GCDAsyncSocket)
{
var index:Int = self.tcpClients.count - 1;
while (index >= 0)
{
let item:AYHTCPClientSocket = self.tcpClients[index];
if let itemSocket = item.socket where itemSocket === socket
{
self.tcpClients.removeAtIndex(index);
break;
}
index--;
}
}
func removeClientSocketAtIndex(index:Int)
{
if (index < 0 || index > self.tcpClients.count)
{
return;
}
self.tcpClients.removeAtIndex(index);
}
func removeAtClientSocket(clientSocket:AYHTCPClientSocket?)
{
guard let lTcpClientSocket = clientSocket else
{
return;
}
var foundIndex:Int = -1;
for index in 0..<self.tcpClients.count
{
let item:AYHTCPClientSocket = self.tcpClients[index];
if let itemSocket = item.socket, removeSocket = lTcpClientSocket.socket
{
if (itemSocket === removeSocket)
{
foundIndex = index;
break;
}
}
}
if (foundIndex >= 0)
{
self.tcpClients.removeAtIndex(foundIndex);
}
}
func removeAll()
{
self.tcpClients.removeAll({ () -> Void in
});
}
} | mit | 254b01f2eab641082bcdbddf317bed68 | 22.611111 | 113 | 0.51883 | 4.47218 | false | false | false | false |
adanilyak/ShareScreenshot | ShareScreenshot/Classes/Helpers/UITools.swift | 1 | 2298 | //
// UITools.swift
// ShareScreenshot
//
// Created by Alexander Danilyak on 19/07/2017.
//
import UIKit
extension Bundle {
// Shortcut for accessing Pod's bundle
@nonobjc
static func podBundle(for anyClass: AnyClass = UITools.self) -> Bundle? {
let rootBundle = Bundle(for: anyClass)
guard let url = rootBundle.url(forResource: "ShareScreenshot", withExtension: "bundle") else {
return nil
}
return Bundle(url: url)
}
}
// All UI helpers
class UITools {
// Initial Nav Controller
@nonobjc
static var shareScreenshotNavigation: UINavigationController? {
return UIStoryboard(name: "ShareScreenshot", bundle: Bundle.podBundle()).instantiateInitialViewController() as? UINavigationController
}
}
extension UIColor {
// Shortcut for creating UIColor with a hex string like this "ff00ff"
convenience init(hexString: String) {
let hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
var int = UInt32()
Scanner(string: hex).scanHexInt32(&int)
let a, r, g, b: UInt32
switch hex.characters.count {
case 3: // RGB (12-bit)
(a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
case 6: // RGB (24-bit)
(a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
case 8: // ARGB (32-bit)
(a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
default:
(a, r, g, b) = (255, 0, 0, 0)
}
self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
}
// Default Apple's blue color
@nonobjc
static var standardBlue: UIColor = UIColor(hexString: "007AFF")
}
extension String {
// Shortcut for localized string
static func localized(key: String) -> String {
guard let bundle = Bundle.podBundle() else {
return key
}
return NSLocalizedString(key,
tableName: "Localizable",
bundle: bundle,
value: "",
comment: "")
}
}
| mit | 32e189fad18a849f8dd72f01687361b6 | 29.236842 | 142 | 0.549173 | 3.996522 | false | false | false | false |
danielbyon/Convert | Sources/Convert/Energy.swift | 1 | 3216 | //
// Energy.swift
// Convert
//
// Copyright © 2017 Daniel Byon
//
// 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 CoreGraphics
public struct Energy: Convertible {
public enum Unit: Double {
case joule = 1.0
case kilojoule = 1_000.0
case gramcalorie = 4.184
case kilocalorie = 4_184.0
case watthour = 3_600.0
case kilowattHour = 360_000_0.0
case btu = 1_055.06
case footPound = 1.355_82
}
public let value: Double
public let unit: Unit
public init(value: Double, unit: Unit) {
self.value = value
self.unit = unit
}
}
public extension Double {
var joule: Energy {
return Energy(value: self, unit: .joule)
}
var kilojoule: Energy {
return Energy(value: self, unit: .kilojoule)
}
var gramcalorie: Energy {
return Energy(value: self, unit: .gramcalorie)
}
var kilocalorie: Energy {
return Energy(value: self, unit: .kilocalorie)
}
var watthour: Energy {
return Energy(value: self, unit: .watthour)
}
var kilowatthour: Energy {
return Energy(value: self, unit: .kilowattHour)
}
var btu: Energy {
return Energy(value: self, unit: .btu)
}
var footPound: Energy {
return Energy(value: self, unit: .footPound)
}
}
public extension CGFloat {
var joule: Energy {
return Energy(value: Double(self), unit: .joule)
}
var kilojoule: Energy {
return Energy(value: Double(self), unit: .kilojoule)
}
var gramcalorie: Energy {
return Energy(value: Double(self), unit: .gramcalorie)
}
var kilocalorie: Energy {
return Energy(value: Double(self), unit: .kilocalorie)
}
var watthour: Energy {
return Energy(value: Double(self), unit: .watthour)
}
var kilowatthour: Energy {
return Energy(value: Double(self), unit: .kilowattHour)
}
var btu: Energy {
return Energy(value: Double(self), unit: .btu)
}
var footPound: Energy {
return Energy(value: Double(self), unit: .footPound)
}
}
| mit | 68b389a5a5b33f5426f00e6f7daad9a4 | 25.352459 | 82 | 0.650078 | 3.791274 | false | false | false | false |
ishkawa/APIKit | Sources/APIKit/Combine/Combine.swift | 1 | 4058 | #if canImport(Combine)
import Foundation
import Combine
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
public struct SessionTaskPublisher<Request: APIKit.Request>: Publisher {
/// The kind of values published by this publisher.
public typealias Output = Request.Response
/// The kind of errors this publisher might publish.
public typealias Failure = SessionTaskError
private let request: Request
private let session: Session
private let callbackQueue: CallbackQueue?
public init(request: Request, session: Session, callbackQueue: CallbackQueue?) {
self.request = request
self.session = session
self.callbackQueue = callbackQueue
}
public func receive<S>(subscriber: S) where S: Subscriber, S.Failure == SessionTaskPublisher.Failure, S.Input == SessionTaskPublisher.Output {
subscriber.receive(subscription: SessionTaskSubscription(request: request,
session: session,
callbackQueue: callbackQueue,
downstream: subscriber))
}
private final class SessionTaskSubscription<Request: APIKit.Request, Downstream: Subscriber>: Subscription where Request.Response == Downstream.Input, Downstream.Failure == Failure {
private let request: Request
private let session: Session
private let callbackQueue: CallbackQueue?
private var downstream: Downstream?
private var task: SessionTask?
init(request: Request, session: Session, callbackQueue: CallbackQueue?, downstream: Downstream) {
self.request = request
self.session = session
self.callbackQueue = callbackQueue
self.downstream = downstream
}
func request(_ demand: Subscribers.Demand) {
assert(demand > 0)
guard let downstream = self.downstream else { return }
self.downstream = nil
task = session.send(request, callbackQueue: callbackQueue) { result in
switch result {
case .success(let response):
_ = downstream.receive(response)
downstream.receive(completion: .finished)
case .failure(let error):
downstream.receive(completion: .failure(error))
}
}
}
func cancel() {
task?.cancel()
downstream = nil
}
}
}
@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
public extension Session {
/// Calls `sessionTaskPublisher(for:callbackQueue:)` of `Session.shared`.
///
/// - parameter request: The request to be sent.
/// - parameter callbackQueue: The queue where the handler runs. If this parameters is `nil`, default `callbackQueue` of `Session` will be used.
/// - returns: A publisher that wraps a session task for the request.
static func sessionTaskPublisher<Request: APIKit.Request>(for request: Request, callbackQueue: CallbackQueue? = nil) -> SessionTaskPublisher<Request> {
return SessionTaskPublisher(request: request, session: .shared, callbackQueue: callbackQueue)
}
/// Returns a publisher that wraps a session task for the request.
///
/// The publisher publishes `Request.Response` when the task completes, or terminates if the task fails with an error.
/// - parameter request: The request to be sent.
/// - parameter callbackQueue: The queue where the handler runs. If this parameters is `nil`, default `callbackQueue` of `Session` will be used.
/// - returns: A publisher that wraps a session task for the request.
func sessionTaskPublisher<Request: APIKit.Request>(for request: Request, callbackQueue: CallbackQueue? = nil) -> SessionTaskPublisher<Request> {
return SessionTaskPublisher(request: request, session: self, callbackQueue: callbackQueue)
}
}
#endif
| mit | 523538811fc906475a90ddae2c2306cd | 44.088889 | 186 | 0.642928 | 5.263294 | false | false | false | false |
darrarski/DRNet | DRNet-Example-iOS/DRNet-Example-iOS/UI/Example2ViewController.swift | 1 | 8375 | //
// Example2ViewController.swift
// DRNet-Example-iOS
//
// Created by Dariusz Rybicki on 10/11/14.
// Copyright (c) 2014 Darrarski. All rights reserved.
//
import UIKit
import DRNet
class Example2ViewController: ImageTextViewController {
override func viewDidLoad() {
super.viewDidLoad()
navigationItem.title = "Example 2"
initMenu()
}
override func viewDidAppear(animated: Bool) {
super.viewDidAppear(animated)
runExample()
}
func runExample() {
// remove all cached responses in iOS shared URL cache, to assure DRNet caching works
NSURLCache.sharedURLCache().removeAllCachedResponses()
exampleInProgress = true
label.text = "UIImageView extension with remote image loader that supports caching and offline mode."
imageView.loadImageFromURL(
NSURL(string: "http://placekitten.com/g/1024/512")!,
onLoadFromCacheSuccess: { [weak self] (source: DRNet.URLCacheResponse.Source) -> Void in
let sourceString: String = {
switch source {
case .Unknown:
return "unknown"
case .MemoryCache:
return "memory"
case .DiskCache:
return "disk"
}
}()
self?.logText("Successfully loaded from \(sourceString) cache.")
return
},
onLoadFromCacheFailure: { [weak self] (errors) -> Void in
self?.logText("Error(s) occured when loading from cache:")
self?.logErrors(errors)
},
onLoadFromNetworkSuccess: { [weak self] () -> Void in
self?.logText("Successfully loaded from network.")
return
},
onLoadFromNetworkFailure: { [weak self] (errors) -> Void in
self?.logText("Error(s) occured when loading from network:")
self?.logErrors(errors)
},
onComplete: { [weak self] () -> Void in
self?.logText("Done.\n\nTap on image to open options menu.")
self?.exampleInProgress = false
}
)
}
// MARK: - Menu
private var imageViewTapGestureRecognizer: UITapGestureRecognizer?
private func initMenu() {
let gestureRecognizer = UITapGestureRecognizer(target: self, action: "showMenu")
imageView.addGestureRecognizer(gestureRecognizer)
imageView.userInteractionEnabled = true
}
func showMenu() {
if exampleInProgress {
return
}
let alertController = UIAlertController(title: "Options", message: nil, preferredStyle: UIAlertControllerStyle.ActionSheet)
alertController.addAction(
UIAlertAction(
title: "Reload image",
style: UIAlertActionStyle.Default,
handler: { [weak self] (action) -> Void in
self?.runExample()
return
}
)
)
alertController.addAction(
UIAlertAction(
title: "Clear cache",
style: UIAlertActionStyle.Destructive,
handler: { (action) -> Void in
ImageViewCacheProvider.removeAllCachedResponses()
}
)
)
alertController.addAction(
UIAlertAction(
title: "Cancel",
style: UIAlertActionStyle.Cancel,
handler: nil
)
)
self.presentViewController(alertController, animated: true, completion: nil)
}
// MARK: - Helpers
private var exampleInProgress = false
private func logErrors(errors: [NSError]) {
dispatch_async(dispatch_get_main_queue(), { [weak self] () -> Void in
var output: String = "\n\n---\n\n".join(
errors.map({ (error) in
var message: String = error.localizedDescription
if let failureReason = error.localizedFailureReason {
message += ", " + failureReason
}
if countElements(error.debugDescription) > 0 {
message += ", " + error.debugDescription
}
return message
})
)
if let sself = self {
if let currentText = sself.label.text {
sself.label.text = currentText + "\n\n" + output
}
else {
sself.label.text = output
}
}
})
}
private func logText(text: String) {
dispatch_async(dispatch_get_main_queue(), { [weak self] () -> Void in
if let sself = self {
if let currentText = sself.label.text {
sself.label.text = currentText + "\n\n" + text
}
else {
sself.label.text = text
}
}
})
}
}
private let ImageViewNetworkProvider = DRNet.URLSessionProvider(session: NSURLSession.sharedSession())
private let ImageViewCacheProvider = DRNet.URLCacheProvider(
memoryCapacity: .Limit(bytes: 10 * 1024 * 1024),
diskCapacity: .Limit(bytes: 10 * 1024 * 1024),
diskPath: "ImageViewCache"
)
extension UIImageView {
func loadImageFromURL(url: NSURL,
onLoadFromCacheSuccess: (source: DRNet.URLCacheResponse.Source) -> Void,
onLoadFromCacheFailure: (errors: [NSError]) -> Void,
onLoadFromNetworkSuccess: () -> Void,
onLoadFromNetworkFailure: (errors: [NSError]) -> Void,
onComplete: () -> Void) {
let request = DRNet.Request(
method: .GET,
url: url,
headers: DRNet.RequestStandardHeaders(
[
"Accept": "image/*"
]
),
parameters: nil
)
let operation = DRNet.Operation(
validators: [
DRNet.ResponseDataValidator(),
DRNet.ResponseStatusCodeValidator(200..<299)
],
dataDeserializer: DRNet.ResponseImageDeserializer(),
handlerClosure: { [weak self] (operation, request, task, response, deserializedData, errors) -> Void in
dispatch_async(dispatch_get_main_queue(), { () -> Void in
self?.image = deserializedData as? UIImage
return
})
}
)
var loadedFromCache = false
operation.perfromRequest(request,
usingProvider: ImageViewCacheProvider,
onError: { (response, deserializedData, errors, shouldHandle) -> Void in
shouldHandle.memory = false
onLoadFromCacheFailure(errors: errors)
},
onSuccess: { (response, deserializedData, shouldHandle) -> Void in
loadedFromCache = true
onLoadFromCacheSuccess(source: (response as DRNet.URLCacheResponse).source)
},
onComplete: { (response, deserializedData, errors) -> Void in
operation.perfromRequest(request,
usingProvider: ImageViewNetworkProvider,
onError: { (response, deserializedData, errors, shouldHandle) -> Void in
shouldHandle.memory = !loadedFromCache
onLoadFromNetworkFailure(errors: errors)
},
onSuccess: { (response, deserializedData, shouldHandle) -> Void in
ImageViewCacheProvider.saveResponse(response, forRequest: request)
onLoadFromNetworkSuccess()
},
onComplete: { (response, deserializedData, errors) -> Void in
onComplete()
}
)
}
)
}
} | mit | 473da35c0424929ca446d8c03c9c60b9 | 33.755187 | 131 | 0.513313 | 5.651147 | false | false | false | false |
wikimedia/wikipedia-ios | Wikipedia/Code/TalkPageFindInPageState.swift | 1 | 2069 | import Foundation
final class TalkPageFindInPageState {
// MARK: - Properties
let searchController = TalkPageFindInPageSearchController()
var keyboardBar: FindAndReplaceKeyboardBar?
var selectedIndex: Int = -1 {
didSet {
updateView()
}
}
var selectedMatch: TalkPageFindInPageSearchController.SearchResult? {
guard matches.indices.contains(selectedIndex) else {
return nil
}
return matches[selectedIndex]
}
var matches: [TalkPageFindInPageSearchController.SearchResult] = [] {
didSet {
updateView()
}
}
// MARK: - Public
/// Next result, looping to start of matches if at end
func next() {
guard !matches.isEmpty else {
return
}
guard selectedIndex < matches.count - 1 else {
selectedIndex = 0
return
}
selectedIndex += 1
}
/// Previous result, looping to end of matches if at beginning
func previous() {
guard !matches.isEmpty else {
return
}
guard selectedIndex > 0 else {
selectedIndex = matches.count - 1
return
}
selectedIndex -= 1
}
func reset(_ topics: [TalkPageCellViewModel]) {
matches = []
selectedIndex = -1
keyboardBar?.reset()
topics.forEach {
$0.highlightText = nil
$0.activeHighlightResult = nil
}
}
func search(term: String, in topics: [TalkPageCellViewModel], traitCollection: UITraitCollection, theme: Theme) {
selectedIndex = -1
matches = searchController.search(term: term, in: topics, traitCollection: traitCollection, theme: theme)
topics.forEach {
$0.highlightText = matches.isEmpty ? nil : term
$0.activeHighlightResult = nil
}
}
// MARK: - Private
private func updateView() {
keyboardBar?.updateMatchCounts(index: selectedIndex, total: UInt(matches.count))
}
}
| mit | 599e952bb41038db8d6f1785c0f7370f | 23.05814 | 117 | 0.583857 | 5.211587 | false | false | false | false |
idomizrachi/Regen | regen/Dependencies/Stencil/Errors.swift | 1 | 2549 | public class TemplateDoesNotExist: Error, CustomStringConvertible {
let templateNames: [String]
let loader: Loader?
public init(templateNames: [String], loader: Loader? = nil) {
self.templateNames = templateNames
self.loader = loader
}
public var description: String {
let templates = templateNames.joined(separator: ", ")
if let loader = loader {
return "Template named `\(templates)` does not exist in loader \(loader)"
}
return "Template named `\(templates)` does not exist. No loaders found"
}
}
public struct TemplateSyntaxError: Error, Equatable, CustomStringConvertible {
public let reason: String
public var description: String { return reason }
public internal(set) var token: Token?
public internal(set) var stackTrace: [Token]
public var templateName: String? { return token?.sourceMap.filename }
var allTokens: [Token] {
return stackTrace + (token.map { [$0] } ?? [])
}
public init(reason: String, token: Token? = nil, stackTrace: [Token] = []) {
self.reason = reason
self.stackTrace = stackTrace
self.token = token
}
public init(_ description: String) {
self.init(reason: description)
}
}
extension Error {
func withToken(_ token: Token?) -> Error {
if var error = self as? TemplateSyntaxError {
error.token = error.token ?? token
return error
} else {
return TemplateSyntaxError(reason: "\(self)", token: token)
}
}
}
public protocol ErrorReporter: AnyObject {
func renderError(_ error: Error) -> String
}
open class SimpleErrorReporter: ErrorReporter {
open func renderError(_ error: Error) -> String {
guard let templateError = error as? TemplateSyntaxError else { return error.localizedDescription }
func describe(token: Token) -> String {
let templateName = token.sourceMap.filename ?? ""
let location = token.sourceMap.location
let highlight = """
\(String(Array(repeating: " ", count: location.lineOffset)))\
^\(String(Array(repeating: "~", count: max(token.contents.count - 1, 0))))
"""
return """
\(templateName)\(location.lineNumber):\(location.lineOffset): error: \(templateError.reason)
\(location.content)
\(highlight)
"""
}
var descriptions = templateError.stackTrace.reduce([]) { $0 + [describe(token: $1)] }
let description = templateError.token.map(describe(token:)) ?? templateError.reason
descriptions.append(description)
return descriptions.joined(separator: "\n")
}
}
| mit | 150474afdd0cab2fa8954f9b414c6bbb | 29.710843 | 102 | 0.667321 | 4.291246 | false | false | false | false |
material-components/material-components-ios | catalog/MDCCatalog/MDCCatalogComponentsController.swift | 2 | 17406 | // Copyright 2015-present the Material Components for iOS authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
import UIKit
import CatalogByConvention
import MaterialCatalog
import MaterialComponents.MaterialFlexibleHeader
import MaterialComponents.MaterialLibraryInfo
import MaterialComponents.MaterialRipple
import MaterialComponents.MaterialShadowElevations
import MaterialComponents.MaterialShadowLayer
import MaterialComponents.MaterialThemes
import MaterialComponents.MaterialTypography
import MaterialComponents.MaterialIcons_ic_arrow_back
class MDCCatalogComponentsController: UICollectionViewController,
UICollectionViewDelegateFlowLayout, MDCRippleTouchControllerDelegate
{
fileprivate struct Constants {
static let headerScrollThreshold: CGFloat = 30
static let inset: CGFloat = 16
static let menuTopVerticalSpacing: CGFloat = 38
static let logoWidthHeight: CGFloat = 30
static let menuButtonWidthHeight: CGFloat = 24
static let spacing: CGFloat = 1
}
fileprivate lazy var headerViewController = MDCFlexibleHeaderViewController()
private lazy var rippleController: MDCRippleTouchController = {
let controller = MDCRippleTouchController()
controller.delegate = self
controller.shouldProcessRippleWithScrollViewGestures = false
return controller
}()
private lazy var logo: UIImageView = {
let imageView = UIImageView()
imageView.translatesAutoresizingMaskIntoConstraints = false
imageView.contentMode = .scaleAspectFit
return imageView
}()
private lazy var menuButton: UIButton = {
let button = UIButton()
button.translatesAutoresizingMaskIntoConstraints = false
let dotsImage = MDCIcons.imageFor_ic_more_horiz()?.withRenderingMode(.alwaysTemplate)
button.setImage(dotsImage, for: .normal)
button.adjustsImageWhenHighlighted = false
button.accessibilityLabel = "Menu"
button.accessibilityHint = "Opens catalog configuration options."
// Without this compiler version check, the build fails on Xcode versions <11.4 with the error:
// "Use of undeclared type 'UIPointerInteractionDelegate'"
// Ideally, we would be able to tie this to an iOS version rather than a compiler version, but
// such a solution does not seem to be available for Swift.
#if compiler(>=5.2)
if #available(iOS 13.4, *) {
let interaction = UIPointerInteraction(delegate: self)
button.addInteraction(interaction)
}
#endif
return button
}()
private let node: CBCNode
private lazy var titleLabel: UILabel = {
let titleLabel = UILabel()
titleLabel.translatesAutoresizingMaskIntoConstraints = false
titleLabel.adjustsFontSizeToFitWidth = true
return titleLabel
}()
private var logoLeftPaddingConstraint: NSLayoutConstraint?
private var menuButtonRightPaddingConstraint: NSLayoutConstraint?
private var menuTopPaddingConstraint: NSLayoutConstraint?
init(collectionViewLayout ignoredLayout: UICollectionViewLayout, node: CBCNode) {
self.node = node
let layout = UICollectionViewFlowLayout()
let sectionInset: CGFloat = Constants.spacing
layout.sectionInset = UIEdgeInsets(
top: sectionInset,
left: sectionInset,
bottom: sectionInset,
right: sectionInset)
layout.minimumInteritemSpacing = Constants.spacing
layout.minimumLineSpacing = Constants.spacing
super.init(collectionViewLayout: layout)
title = "Material Components for iOS"
addChild(headerViewController)
headerViewController.isTopLayoutGuideAdjustmentEnabled = true
headerViewController.inferTopSafeAreaInsetFromViewController = true
headerViewController.headerView.minMaxHeightIncludesSafeArea = false
headerViewController.headerView.maximumHeight = 128
headerViewController.headerView.minimumHeight = 56
collectionView?.register(
MDCCatalogCollectionViewCell.self,
forCellWithReuseIdentifier: "MDCCatalogCollectionViewCell")
collectionView?.backgroundColor = AppTheme.containerScheme.colorScheme.backgroundColor
MDCIcons.ic_arrow_backUseNewStyle(true)
NotificationCenter.default.addObserver(
self,
selector: #selector(self.themeDidChange),
name: AppTheme.didChangeGlobalThemeNotificationName,
object: nil)
}
@objc func themeDidChange(notification: NSNotification) {
let colorScheme = AppTheme.containerScheme.colorScheme
headerViewController.headerView.backgroundColor = colorScheme.primaryColor
setNeedsStatusBarAppearanceUpdate()
titleLabel.textColor = colorScheme.onPrimaryColor
menuButton.tintColor = colorScheme.onPrimaryColor
collectionView?.collectionViewLayout.invalidateLayout()
collectionView?.reloadData()
}
convenience init(node: CBCNode) {
self.init(collectionViewLayout: UICollectionViewLayout(), node: node)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func viewDidLoad() {
super.viewDidLoad()
rippleController.addRipple(to: self.collectionView!)
let containerView = UIView(frame: headerViewController.headerView.bounds)
containerView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
titleLabel.text = title!
titleLabel.textColor = AppTheme.containerScheme.colorScheme.onPrimaryColor
titleLabel.textAlignment = .center
titleLabel.font = AppTheme.containerScheme.typographyScheme.headline6
titleLabel.sizeToFit()
let titleInsets = UIEdgeInsets(
top: 0,
left: Constants.inset,
bottom: Constants.inset,
right: Constants.inset)
let titleSize = titleLabel.sizeThatFits(containerView.bounds.size)
containerView.addSubview(titleLabel)
headerViewController.headerView.addSubview(containerView)
headerViewController.headerView.forwardTouchEvents(for: containerView)
containerView.addSubview(logo)
let colorScheme = AppTheme.containerScheme.colorScheme
let image = MDCDrawImage(
CGRect(
x: 0,
y: 0,
width: Constants.logoWidthHeight,
height: Constants.logoWidthHeight),
{ MDCCatalogDrawMDCLogoLight($0, $1) },
colorScheme)
logo.image = image
menuButton.addTarget(
self.navigationController,
action: #selector(navigationController?.presentMenu),
for: .touchUpInside)
menuButton.tintColor = colorScheme.onPrimaryColor
containerView.addSubview(menuButton)
setupFlexibleHeaderContentConstraints()
constrainLabel(
label: titleLabel,
containerView: containerView,
insets: titleInsets,
height: titleSize.height)
headerViewController.headerView.backgroundColor = colorScheme.primaryColor
headerViewController.headerView.trackingScrollView = collectionView
headerViewController.headerView.setShadowLayer(MDCShadowLayer()) { (layer, intensity) in
let shadowLayer = layer as? MDCShadowLayer
CATransaction.begin()
CATransaction.setDisableActions(true)
shadowLayer!.elevation = ShadowElevation(intensity * ShadowElevation.appBar.rawValue)
CATransaction.commit()
}
view.addSubview(headerViewController.view)
headerViewController.didMove(toParent: self)
collectionView?.accessibilityIdentifier = "componentList"
collectionView?.contentInsetAdjustmentBehavior = .always
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
collectionView?.collectionViewLayout.invalidateLayout()
navigationController?.setNavigationBarHidden(true, animated: animated)
}
override func willAnimateRotation(
to toInterfaceOrientation: UIInterfaceOrientation, duration: TimeInterval
) {
collectionView?.collectionViewLayout.invalidateLayout()
}
override var childForStatusBarStyle: UIViewController? {
return headerViewController
}
override var childForStatusBarHidden: UIViewController? {
return headerViewController
}
@available(iOS 11, *)
override func viewSafeAreaInsetsDidChange() {
// Re-constraint the title label to account for changes in safeAreaInsets's left and right.
logoLeftPaddingConstraint?.constant = Constants.inset + view.safeAreaInsets.left
menuButtonRightPaddingConstraint?.constant = -1 * (Constants.inset + view.safeAreaInsets.right)
menuTopPaddingConstraint?.constant = Constants.inset + view.safeAreaInsets.top
}
func setupFlexibleHeaderContentConstraints() {
logoLeftPaddingConstraint = NSLayoutConstraint(
item: logo,
attribute: .leading,
relatedBy: .equal,
toItem: logo.superview,
attribute: .leading,
multiplier: 1,
constant: Constants.inset)
logoLeftPaddingConstraint?.isActive = true
menuButtonRightPaddingConstraint = NSLayoutConstraint(
item: menuButton,
attribute: .trailing,
relatedBy: .equal,
toItem: menuButton.superview,
attribute: .trailing,
multiplier: 1,
constant: -1 * Constants.inset)
menuButtonRightPaddingConstraint?.isActive = true
menuTopPaddingConstraint = NSLayoutConstraint(
item: menuButton,
attribute: .top,
relatedBy: .equal,
toItem: menuButton.superview,
attribute: .top,
multiplier: 1,
constant: Constants.menuTopVerticalSpacing)
menuTopPaddingConstraint?.isActive = true
NSLayoutConstraint(
item: logo,
attribute: .centerY,
relatedBy: .equal,
toItem: menuButton,
attribute: .centerY,
multiplier: 1,
constant: 0
).isActive = true
NSLayoutConstraint(
item: logo,
attribute: .width,
relatedBy: .equal,
toItem: logo,
attribute: .height,
multiplier: 1,
constant: 0
).isActive = true
NSLayoutConstraint(
item: logo,
attribute: .width,
relatedBy: .equal,
toItem: nil,
attribute: .notAnAttribute,
multiplier: 1,
constant: Constants.logoWidthHeight
).isActive = true
NSLayoutConstraint(
item: menuButton,
attribute: .width,
relatedBy: .equal,
toItem: menuButton,
attribute: .height,
multiplier: 1,
constant: 0
).isActive = true
NSLayoutConstraint(
item: menuButton,
attribute: .width,
relatedBy: .equal,
toItem: nil,
attribute: .notAnAttribute,
multiplier: 1,
constant: Constants.menuButtonWidthHeight
).isActive = true
}
// MARK: UICollectionViewDataSource
override func numberOfSections(in collectionView: UICollectionView) -> Int {
return 1
}
override func collectionView(
_ collectionView: UICollectionView,
numberOfItemsInSection section: Int
) -> Int {
return node.children.count
}
// MARK: MDCRippleTouchControllerDelegate
func rippleTouchController(
_ rippleTouchController: MDCRippleTouchController,
shouldProcessRippleTouchesAtTouchLocation location: CGPoint
) -> Bool {
return self.collectionView?.indexPathForItem(at: location) != nil
}
func rippleTouchController(
_ rippleTouchController: MDCRippleTouchController,
rippleViewAtTouchLocation location: CGPoint
) -> MDCRippleView? {
if let indexPath = self.collectionView?.indexPathForItem(at: location) {
let cell = self.collectionView?.cellForItem(at: indexPath)
return MDCRippleView.injectedRippleView(for: cell!)
}
return MDCRippleView()
}
// MARK: UICollectionViewDelegate
override func collectionView(
_ collectionView: UICollectionView,
cellForItemAt indexPath: IndexPath
) -> UICollectionViewCell {
let cell =
collectionView.dequeueReusableCell(
withReuseIdentifier: "MDCCatalogCollectionViewCell",
for: indexPath)
cell.backgroundColor = AppTheme.containerScheme.colorScheme.backgroundColor
let componentName = node.children[indexPath.row].title
if let catalogCell = cell as? MDCCatalogCollectionViewCell {
catalogCell.populateView(componentName)
}
// Ensure that ripple animations aren't recycled.
MDCRippleView.injectedRippleView(for: view).cancelAllRipples(animated: false, completion: nil)
return cell
}
func collectionView(
_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
sizeForItemAt indexPath: IndexPath
) -> CGSize {
let dividerWidth: CGFloat = 1
var safeInsets: CGFloat = 0
safeInsets = view.safeAreaInsets.left + view.safeAreaInsets.right
var cellWidthHeight: CGFloat
// iPhones have 2 columns in portrait and 3 in landscape
if UIDevice.current.userInterfaceIdiom == .phone {
cellWidthHeight = (view.frame.size.width - 3 * dividerWidth - safeInsets) / 2
if view.frame.size.width > view.frame.size.height {
cellWidthHeight = (view.frame.size.width - 4 * dividerWidth - safeInsets) / 3
}
} else {
// iPads have 4 columns in portrait, and 5 in landscape
cellWidthHeight = (view.frame.size.width - 5 * dividerWidth - safeInsets) / 4
if view.frame.size.width > view.frame.size.height {
cellWidthHeight = (view.frame.size.width - 6 * dividerWidth - safeInsets) / 5
}
}
return CGSize(width: cellWidthHeight, height: cellWidthHeight)
}
override func collectionView(
_ collectionView: UICollectionView,
didSelectItemAt indexPath: IndexPath
) {
let node = self.node.children[indexPath.row]
var vc: UIViewController
if node.isExample() {
vc = node.createExampleViewController()
} else {
vc = MDCNodeListViewController(node: node)
}
self.navigationController?.setMenuBarButton(for: vc)
self.navigationController?.pushViewController(vc, animated: true)
}
// MARK: Private
func constrainLabel(
label: UILabel,
containerView: UIView,
insets: UIEdgeInsets,
height: CGFloat
) {
NSLayoutConstraint(
item: label,
attribute: .leading,
relatedBy: .equal,
toItem: logo,
attribute: .trailing,
multiplier: 1.0,
constant: insets.left
).isActive = true
NSLayoutConstraint(
item: label,
attribute: .trailing,
relatedBy: .equal,
toItem: menuButton,
attribute: .leading,
multiplier: 1.0,
constant: -insets.right
).isActive = true
NSLayoutConstraint(
item: label,
attribute: .bottom,
relatedBy: .equal,
toItem: containerView,
attribute: .bottom,
multiplier: 1.0,
constant: -insets.bottom
).isActive = true
NSLayoutConstraint(
item: label,
attribute: .height,
relatedBy: .equal,
toItem: nil,
attribute: .notAnAttribute,
multiplier: 1.0,
constant: height
).isActive = true
}
}
// Without this compiler version check, the build fails on Xcode versions <11.4 with the error:
// "Use of undeclared type 'UIPointerInteractionDelegate'"
// Ideally, we would be able to tie this to an iOS version rather than a compiler version, but such
// a solution does not seem to be available for Swift.
#if compiler(>=5.2)
@available(iOS 13.4, *)
extension MDCCatalogComponentsController: UIPointerInteractionDelegate {
@available(iOS 13.4, *)
func pointerInteraction(
_ interaction: UIPointerInteraction,
styleFor region: UIPointerRegion
) -> UIPointerStyle? {
guard let interactionView = interaction.view else {
return nil
}
let targetedPreview = UITargetedPreview(view: interactionView)
let pointerStyle = UIPointerStyle(effect: .highlight(targetedPreview))
return pointerStyle
}
}
#endif
// UIScrollViewDelegate
extension MDCCatalogComponentsController {
override func scrollViewDidScroll(_ scrollView: UIScrollView) {
if scrollView == headerViewController.headerView.trackingScrollView {
self.headerViewController.headerView.trackingScrollDidScroll()
}
}
override func scrollViewDidEndDragging(
_ scrollView: UIScrollView,
willDecelerate decelerate: Bool
) {
let headerView = headerViewController.headerView
if scrollView == headerView.trackingScrollView {
headerView.trackingScrollDidEndDraggingWillDecelerate(decelerate)
}
}
override func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
if scrollView == headerViewController.headerView.trackingScrollView {
self.headerViewController.headerView.trackingScrollDidEndDecelerating()
}
}
override func scrollViewWillEndDragging(
_ scrollView: UIScrollView,
withVelocity velocity: CGPoint,
targetContentOffset: UnsafeMutablePointer<CGPoint>
) {
let headerView = headerViewController.headerView
if scrollView == headerView.trackingScrollView {
headerView.trackingScrollWillEndDragging(
withVelocity: velocity,
targetContentOffset: targetContentOffset)
}
}
}
| apache-2.0 | 5176b4f3070d72c730eaa5e6eb537947 | 31.534579 | 99 | 0.730093 | 5.117906 | false | false | false | false |
jsslai/Action | Carthage/Checkouts/RxSwift/RxCocoa/iOS/UITextView+Rx.swift | 1 | 3468 | //
// UITextView+Rx.swift
// RxCocoa
//
// Created by Yuta ToKoRo on 7/19/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
#if os(iOS) || os(tvOS)
import Foundation
import UIKit
#if !RX_NO_MODULE
import RxSwift
#endif
extension UITextView {
/**
Factory method that enables subclasses to implement their own `delegate`.
- returns: Instance of delegate proxy that wraps `delegate`.
*/
public override func createRxDelegateProxy() -> RxScrollViewDelegateProxy {
return RxTextViewDelegateProxy(parentObject: self)
}
}
extension Reactive where Base: UITextView {
/**
Reactive wrapper for `text` property.
*/
public var text: ControlProperty<String> {
let source: Observable<String> = Observable.deferred { [weak textView = self.base] in
let text = textView?.text ?? ""
let textChanged = textView?.textStorage
// This project uses text storage notifications because
// that's the only way to catch autocorrect changes
// in all cases. Other suggestions are welcome.
.rx.didProcessEditingRangeChangeInLength
// This observe on is here because text storage
// will emit event while process is not completely done,
// so rebinding a value will cause an exception to be thrown.
.observeOn(MainScheduler.asyncInstance)
.map { _ in
return textView?.textStorage.string ?? ""
}
?? Observable.empty()
return textChanged
.startWith(text)
}
let bindingObserver = UIBindingObserver(UIElement: self.base) { (textView, text: String) in
// This check is important because setting text value always clears control state
// including marked text selection which is imporant for proper input
// when IME input method is used.
if textView.text != text {
textView.text = text
}
}
return ControlProperty(values: source, valueSink: bindingObserver)
}
/**
Reactive wrapper for `delegate` message.
*/
public var didBeginEditing: ControlEvent<()> {
return ControlEvent<()>(events: self.delegate.methodInvoked(#selector(UITextViewDelegate.textViewDidBeginEditing(_:)))
.map { a in
return ()
})
}
/**
Reactive wrapper for `delegate` message.
*/
public var didEndEditing: ControlEvent<()> {
return ControlEvent<()>(events: self.delegate.methodInvoked(#selector(UITextViewDelegate.textViewDidEndEditing(_:)))
.map { a in
return ()
})
}
/**
Reactive wrapper for `delegate` message.
*/
public var didChange: ControlEvent<()> {
return ControlEvent<()>(events: self.delegate.methodInvoked(#selector(UITextViewDelegate.textViewDidChange(_:)))
.map { a in
return ()
})
}
/**
Reactive wrapper for `delegate` message.
*/
public var didChangeSelection: ControlEvent<()> {
return ControlEvent<()>(events: self.delegate.methodInvoked(#selector(UITextViewDelegate.textViewDidChangeSelection(_:)))
.map { a in
return ()
})
}
}
#endif
| mit | e841553c10c58c16d609058583f11623 | 30.234234 | 129 | 0.58927 | 5.417188 | false | false | false | false |
mrommel/MiRoRecipeBook | MiRoRecipeBook/MiRoRecipeBook/Presentation/Recipes/RecipesWireframe.swift | 1 | 1467 | //
// RecipesWireframe.swift
// MiRoRecipeBook
//
// Created by Michael Rommel on 12.12.16.
// Copyright © 2016 MiRo Soft. All rights reserved.
//
import UIKit
class RecipesWireframe: CommonWireframe {
fileprivate let kRecipesStoryboardName = "Recipes"
func getRecipesInterface() -> RecipeCollectionViewController {
//let recipesTableViewController = RecipesTableViewController.instantiate(fromStoryboard: kRecipesStoryboardName)
let recipesTableViewController = RecipeCollectionViewController.instantiate(fromStoryboard: kRecipesStoryboardName)
return recipesTableViewController
}
func presentDetail(forRecipe recipe: Recipe?) {
let recipesDetailViewController = RecipeDetailViewController.instantiate(fromStoryboard: kRecipesStoryboardName)
recipesDetailViewController.recipe = recipe
let menuButton = UIButton(type: .custom)
menuButton.setImage(UIImage(named: "menu-alt-24.png"), for: .normal)
menuButton.frame = CGRect(x: 10, y: 0, width: 42, height: 42)
menuButton.addTarget(self, action: #selector(goBack), for: .touchUpInside)
recipesDetailViewController.navigationItem.leftBarButtonItem = UIBarButtonItem(customView: menuButton)
let targetNavigationController = UINavigationController(rootViewController: recipesDetailViewController)
UIApplication.shared.topMostViewController()?.present(targetNavigationController, animated: false, completion: nil)
}
}
| gpl-3.0 | 4d555434c96c8173d15347d31b919fb2 | 38.621622 | 123 | 0.774898 | 5.037801 | false | false | false | false |
Subsets and Splits