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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
crashoverride777/Swift2-iAds-AdMob-CustomAds-Helper | SwiftyAd/SwiftyAdConsentManager.swift | 2 | 10561 | // The MIT License (MIT)
//
// Copyright (c) 2015-2018 Dominik Ringler
//
// 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 PersonalizedAdConsent
/// LocalizedString
/// TODO
private extension String {
static let consentTitle = "Permission to use data"
static let consentMessage = "We care about your privacy and data security. We keep this app free by showing ads. You can change your choice anytime in the app settings. Our partners will collect data and use a unique identifier on your device to show you ads."
static let ok = "OK"
static let weShowAdsFrom = "We show ads from: "
static let weUseAdProviders = "We use the following ad technology providers: "
static let adFree = "Buy ad free app"
static let allowPersonalized = "Allow personalized ads"
static let allowNonPersonalized = "Allow non-personalized ads"
}
/**
SwiftyAdConsentManager
A class to manage consent request for Google AdMob (e.g GDPR).
*/
final class SwiftyAdConsentManager {
// MARK: - Types
struct Configuration: Codable {
let privacyPolicyURL: String
let shouldOfferAdFree: Bool
let mediationNetworks: [String]
let isTaggedForUnderAgeOfConsent: Bool
let isCustomForm: Bool
var mediationNetworksString: String {
return mediationNetworks.map({ $0 }).joined(separator: ", ")
}
}
enum ConsentStatus {
case personalized
case nonPersonalized
case adFree
case unknown
}
// MARK: - Properties
/// The current status
var status: ConsentStatus {
switch consentInformation.consentStatus {
case .personalized:
return .personalized
case .nonPersonalized:
return .nonPersonalized
case .unknown:
return .unknown
@unknown default:
return .unknown
}
}
/// Check if user is in EEA (EU economic area)
var isInEEA: Bool {
return consentInformation.isRequestLocationInEEAOrUnknown
}
var isRequiredToAskForConsent: Bool {
guard isInEEA else { return false }
guard !isTaggedForUnderAgeOfConsent else { return false } // must be non personalized only, cannot legally consent
return true
}
/// Check if we can show ads
var hasConsent: Bool {
guard isInEEA, !isTaggedForUnderAgeOfConsent else { return true }
return status != .unknown
}
/// Check if under age is turned on
var isTaggedForUnderAgeOfConsent: Bool {
return configuration.isTaggedForUnderAgeOfConsent
}
/// Private
private let ids: [String]
private let configuration: Configuration
private let consentInformation: PACConsentInformation = .sharedInstance
// MARK: - Init
init(ids: [String], configuration: Configuration) {
self.ids = ids
self.configuration = configuration
consentInformation.isTaggedForUnderAgeOfConsent = configuration.isTaggedForUnderAgeOfConsent
}
// MARK: - Ask For Consent
func ask(from viewController: UIViewController, skipIfAlreadyAuthorized: Bool = false, handler: @escaping (ConsentStatus) -> Void) {
consentInformation.requestConsentInfoUpdate(forPublisherIdentifiers: ids) { (_ error) in
if let error = error {
print("SwiftyAdConsentManager error requesting consent info update: \(error)")
handler(self.status)
return
}
// If we already have permission dont ask again
if skipIfAlreadyAuthorized {
switch self.consentInformation.consentStatus {
case .personalized:
print("SwiftyAdConsentManager already has consent permission, no need to ask again")
handler(self.status)
return
case .nonPersonalized:
print("SwiftyAdConsentManager already has consent permission, no need to ask again")
handler(self.status)
return
case .unknown:
break
@unknown default:
break
}
}
// We only need to ask for consent if we are in the EEA
guard self.consentInformation.isRequestLocationInEEAOrUnknown else {
print("SwiftyAdConsentManager not in EU, no need to handle consent logic")
self.consentInformation.consentStatus = .personalized
handler(.personalized)
return
}
// We also do not need to ask for consent if under age is turned on because than all add requests have to be non-personalized
guard !self.isTaggedForUnderAgeOfConsent else {
self.consentInformation.consentStatus = .nonPersonalized
print("SwiftyAdConsentManager under age, no need to handle consent logic as it must be non-personalized")
handler(.nonPersonalized)
return
}
// Show consent form
if self.configuration.isCustomForm {
self.showCustomConsentForm(from: viewController, handler: handler)
} else {
self.showDefaultConsentForm(from: viewController, handler: handler)
}
}
}
}
// MARK: - Default Consent Form
private extension SwiftyAdConsentManager {
func showDefaultConsentForm(from viewController: UIViewController, handler: @escaping (ConsentStatus) -> Void) {
// Make sure we have a valid privacy policy url
guard let url = URL(string: configuration.privacyPolicyURL) else {
print("SwiftyAdConsentManager invalid privacy policy URL")
handler(status)
return
}
// Make sure we have a valid consent form
guard let form = PACConsentForm(applicationPrivacyPolicyURL: url) else {
print("SwiftyAdConsentManager PACConsentForm nil")
handler(status)
return
}
// Set form properties
form.shouldOfferPersonalizedAds = true
form.shouldOfferNonPersonalizedAds = true
form.shouldOfferAdFree = configuration.shouldOfferAdFree
// Load form
form.load { (_ error) in
if let error = error {
print("SwiftyAdConsentManager error loading consent form: \(error)")
handler(self.status)
return
}
// Loaded successfully, present it
form.present(from: viewController) { (error, prefersAdFree) in
if let error = error {
print("SwiftyAdConsentManager error presenting consent form: \(error)")
handler(self.status)
return
}
// Check if user prefers to use a paid version of the app (shouldOfferAdFree button)
guard !prefersAdFree else {
self.consentInformation.consentStatus = .unknown
handler(.adFree)
return
}
// Consent info update succeeded. The shared PACConsentInformation instance has been updated
handler(self.status)
}
}
}
}
// MARK: - Custom Consent Form
private extension SwiftyAdConsentManager {
func showCustomConsentForm(from viewController: UIViewController, handler: @escaping (ConsentStatus) -> Void) {
// Create alert message with all ad providers
var message = .consentMessage + "\n\n" + .weShowAdsFrom + "Google AdMob, " + configuration.mediationNetworksString
if let adProviders = consentInformation.adProviders, !adProviders.isEmpty {
message += "\n\n" + .weUseAdProviders + "\((adProviders.map({ $0.name })).joined(separator: ", "))"
}
message += "\n\n\(configuration.privacyPolicyURL)"
// Create alert controller
let alertController = UIAlertController(title: .consentTitle, message: message, preferredStyle: .alert)
// Personalized action
let personalizedAction = UIAlertAction(title: .allowPersonalized, style: .default) { action in
self.consentInformation.consentStatus = .personalized
handler(.personalized)
}
alertController.addAction(personalizedAction)
// Non-Personalized action
let nonPersonalizedAction = UIAlertAction(title: .allowNonPersonalized, style: .default) { action in
self.consentInformation.consentStatus = .nonPersonalized
handler(.nonPersonalized)
}
alertController.addAction(nonPersonalizedAction)
// Ad free action
if configuration.shouldOfferAdFree {
let adFreeAction = UIAlertAction(title: .adFree, style: .default) { action in
self.consentInformation.consentStatus = .unknown
handler(.adFree)
}
alertController.addAction(adFreeAction)
}
// Present alert
DispatchQueue.main.async {
viewController.present(alertController, animated: true)
}
}
}
| mit | 4dac17598660e3b9acbdf34f23d6b126 | 38.114815 | 264 | 0.62229 | 5.546744 | false | true | false | false |
waterskier2007/NVActivityIndicatorView | NVActivityIndicatorView/Animations/NVActivityIndicatorAnimationBallScaleRipple.swift | 1 | 3210 | //
// NVActivityIndicatorAnimationBallScaleRipple.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
class NVActivityIndicatorAnimationBallScaleRipple: NVActivityIndicatorAnimationDelegate {
func setUpAnimation(in layer: CALayer, size: CGSize, color: UIColor) {
let duration: CFTimeInterval = 1
let timingFunction = CAMediaTimingFunction(controlPoints: 0.21, 0.53, 0.56, 0.8)
// Scale animation
let scaleAnimation = CAKeyframeAnimation(keyPath: "transform.scale")
scaleAnimation.keyTimes = [0, 0.7]
scaleAnimation.timingFunction = timingFunction
scaleAnimation.values = [0.1, 1]
scaleAnimation.duration = duration
// Opacity animation
let opacityAnimation = CAKeyframeAnimation(keyPath: "opacity")
opacityAnimation.keyTimes = [0, 0.7, 1]
opacityAnimation.timingFunctions = [timingFunction, timingFunction]
opacityAnimation.values = [1, 0.7, 0]
opacityAnimation.duration = duration
// Animation
let animation = CAAnimationGroup()
animation.animations = [scaleAnimation, opacityAnimation]
animation.duration = duration
animation.repeatCount = HUGE
animation.isRemovedOnCompletion = false
// Draw circle
<<<<<<< HEAD
let circle = NVActivityIndicatorShape.Ring.createLayerWith(size: size, color: color)
let frame = CGRect(x: (layer.bounds.width - size.width) / 2,
y: (layer.bounds.height - size.height) / 2,
width: size.width,
height: size.height)
=======
let circle = NVActivityIndicatorShape.ring.layerWith(size: size, color: color)
let frame = CGRect(x: (layer.bounds.size.width - size.width) / 2,
y: (layer.bounds.size.height - size.height) / 2,
width: size.width,
height: size.height)
>>>>>>> ninjaprox/master
circle.frame = frame
circle.add(animation, forKey: "animation")
layer.addSublayer(circle)
}
}
| mit | d68c9eedb2d7f9f4baeda1bf20f18f0e | 39.125 | 92 | 0.683489 | 4.81982 | false | false | false | false |
carabina/AmazonS3RequestManager | AmazonS3RequestManager/AmazonS3RequestManager.swift | 1 | 15851 | //
// AmazonS3RequestManager.swift
// AmazonS3RequestManager
//
// Based on `AFAmazonS3Manager` by `Matt Thompson`
//
// Created by Anthony Miller. 2015.
//
// 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 MobileCoreServices
import Alamofire
/**
* MARK: Information
*/
/**
MARK: Error Domain
The Error Domain for `ZRAPI`
*/
private let AmazonS3RequestManagerErrorDomain = "com.alamofire.AmazonS3RequestManager"
/**
MARK: Error Codes
The error codes for the `AmazonS3RequestManagerErrorDomain`
- AccessKeyMissing: The `accessKey` for the request manager is `nil`. The `accessKey` must be set in order to make requests with `AmazonS3RequestManager`.
- SecretMissing: The secret for the request manager is `nil`. The secret must be set in order to make requests with `AmazonS3RequestManager`.
*/
public enum AmazonS3RequestManagerErrorCodes: Int {
case AccessKeyMissing = 1,
SecretMissing
}
/**
MARK: Amazon S3 Regions
The possible Amazon Web Service regions for the client.
- USStandard: N. Virginia or Pacific Northwest
- USWest1: Oregon
- USWest2: N. California
- EUWest1: Ireland
- EUCentral1: Frankfurt
- APSoutheast1: Singapore
- APSoutheast2: Sydney
- APNortheast1: Toyko
- SAEast1: Sao Paulo
*/
public enum AmazonS3Region: String {
case USStandard = "s3.amazonaws.com",
USWest1 = "s3-us-west-1.amazonaws.com",
USWest2 = "s3-us-west-2.amazonaws.com",
EUWest1 = "s3-eu-west-1.amazonaws.com",
EUCentral1 = "s3-eu-central-1.amazonaws.com",
APSoutheast1 = "s3-ap-southeast-1.amazonaws.com",
APSoutheast2 = "s3-ap-southeast-2.amazonaws.com",
APNortheast1 = "s3-ap-northeast-1.amazonaws.com",
SAEast1 = "s3-sa-east-1.amazonaws.com"
}
/**
MARK: AmazonS3RequestManager
`AmazonS3RequestManager` is a subclass of `Alamofire.Manager` that encodes requests to the Amazon S3 service.
*/
public class AmazonS3RequestManager {
/**
MARK: Instance Properties
*/
/**
The Amazon S3 Bucket for the client
*/
public var bucket: String?
/**
The Amazon S3 region for the client. `AmazonS3Region.USStandard` by default.
:note: Must not be `nil`.
:see: `AmazonS3Region` for defined regions.
*/
public var region: AmazonS3Region = .USStandard
/**
The Amazon S3 Access Key ID used to generate authorization headers and pre-signed queries
:dicussion: This can be found on the AWS control panel: http://aws-portal.amazon.com/gp/aws/developer/account/index.html?action=access-key
*/
public var accessKey: String?
/**
The Amazon S3 Secret used to generate authorization headers and pre-signed queries
:dicussion: This can be found on the AWS control panel: http://aws-portal.amazon.com/gp/aws/developer/account/index.html?action=access-key
*/
public var secret: String?
/**
The AWS STS session token. `nil` by default.
*/
public var sessionToken: String?
/**
Whether to connect over HTTPS. `true` by default.
*/
public var useSSL: Bool = true
/**
The `Alamofire.Manager` instance to use for network requests.
:note: This defaults to the shared instance of `Manager` used by top-level Alamofire requests.
*/
public var requestManager: Alamofire.Manager = Alamofire.Manager.sharedInstance
/**
A readonly endpoint URL created for the specified bucket, region, and SSL use preference. `AmazonS3RequestManager` uses this as the baseURL for all requests.
*/
public var endpointURL: NSURL {
var URLString = ""
let scheme = self.useSSL ? "https" : "http"
if bucket != nil {
URLString = "\(scheme)://\(region.rawValue)/\(bucket!)"
} else {
URLString = "\(scheme)://\(region.rawValue)"
}
return NSURL(string: URLString)!
}
/**
MARK: Initialization
*/
/**
Initalizes an `AmazonS3RequestManager` with the given Amazon S3 credentials.
:param: bucket The Amazon S3 bucket for the client
:param: region The Amazon S3 region for the client
:param: accessKey The Amazon S3 access key ID for the client
:param: secret The Amazon S3 secret for the client
:returns: An `AmazonS3RequestManager` with the given Amazon S3 credentials and a default configuration.
*/
required public init(bucket: String?, region: AmazonS3Region, accessKey: String?, secret: String?) {
self.bucket = bucket
self.region = region
self.accessKey = accessKey
self.secret = secret
}
/**
MARK: - GET Object Requests
*/
/**
Gets and object from the Amazon S3 service and returns it as the response object without saving to file.
:note: This method performs a standard GET request and does not allow use of progress blocks.
:param: path The object path
:returns: A GET request for the object
*/
public func getObject(path: String) -> Request {
return requestManager.request(amazonURLRequest(.GET, path: path))
}
/**
Gets an object from the Amazon S3 service and saves it to file.
:note: The user for the manager's Amazon S3 credentials must have read access to the object
:dicussion: This method performs a download request that allows for a progress block to be implemented. For more information on using progress blocks, see `Alamofire`.
:param: path The object path
:param: destinationURL The `NSURL` to save the object to
:returns: A download request for the object
*/
public func downloadObject(path: String, saveToURL destinationURL: NSURL) -> Request {
return requestManager.download(amazonURLRequest(.GET, path: path), destination: { (_, _) -> (NSURL) in
return destinationURL
})
}
/**
MARK: PUT Object Requests
*/
/**
Uploads an object to the Amazon S3 service with a given local file URL.
:note: The user for the manager's Amazon S3 credentials must have read access to the bucket
:param: fileURL The local `NSURL` of the file to upload
:param: destinationPath The desired destination path, including the file name and extension, in the Amazon S3 bucket
:param: acl The optional access control list to set the acl headers for the request. For more information see `AmazonS3ACL`.
:returns: An upload request for the object
*/
public func putObject(fileURL: NSURL, destinationPath: String, acl: AmazonS3ACL? = nil) -> Request {
let putRequest = amazonURLRequest(.PUT, path: destinationPath, acl: acl)
return requestManager.upload(putRequest, file: fileURL)
}
/**
Uploads an object to the Amazon S3 service with the given data.
:note: The user for the manager's Amazon S3 credentials must have read access to the bucket
:param: data The `NSData` for the object to upload
:param: destinationPath The desired destination path, including the file name and extension, in the Amazon S3 bucket
:param: acl The optional access control list to set the acl headers for the request. For more information see `AmazonS3ACL`.
:returns: An upload request for the object
*/
public func putObject(data: NSData, destinationPath: String, acl: AmazonS3ACL? = nil) -> Request {
let putRequest = amazonURLRequest(.PUT, path: destinationPath, acl: acl)
return requestManager.upload(putRequest, data: data)
}
/**
MARK: DELETE Object Request
*/
/**
Deletes an object from the Amazon S3 service.
:warning: Once an object has been deleted, there is no way to restore or undelete it.
:param: path The object path
:returns: The delete request
*/
public func deleteObject(path: String) -> Request {
let deleteRequest = amazonURLRequest(.DELETE, path: path)
return requestManager.request(deleteRequest)
}
/**
MARK: ACL Requests
*/
/**
Gets the access control list (ACL) for the current `bucket`
:note: To use this operation, you must have the `AmazonS3ACLPermission.ReadACL` for the bucket.
:see: For more information on the ACL response headers for this request, see "http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETacl.html"
:returns: A GET request for the bucket's ACL
*/
public func getBucketACL() -> Request {
return requestManager.request(amazonURLRequest(.GET, path: "", subresource: "acl", acl: nil))
}
/**
Sets the access control list (ACL) for the current `bucket`
:note: To use this operation, you must have the `AmazonS3ACLPermission.WriteACL` for the bucket.
:see: For more information on the ACL response headers for this request, see "http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html"
:returns: A PUT request to set the bucket's ACL
*/
public func setBucketACL(acl: AmazonS3ACL) -> Request {
return requestManager.request(amazonURLRequest(.PUT, path: "", subresource: "acl", acl: acl))
}
/**
Gets the access control list (ACL) for the object at the given path.
:note: To use this operation, you must have the `AmazonS3ACLPermission.ReadACL` for the object.
:see: For more information on the ACL response headers for this request, see "http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGETacl.html"
:param: path The object path
:returns: A GET request for the object's ACL
*/
public func getACL(forObjectAtPath path:String) -> Request {
return requestManager.request(amazonURLRequest(.GET, path: path, subresource: "acl"))
}
/**
Sets the access control list (ACL) for the object at the given path.
:note: To use this operation, you must have the `AmazonS3ACLPermission.WriteACL` for the object.
:see: For more information on the ACL response headers for this request, see "http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUTacl.html"
:returns: A PUT request to set the objects's ACL
*/
public func setACL(forObjectAtPath path: String, acl: AmazonS3ACL) -> Request {
return requestManager.request(amazonURLRequest(.PUT, path: path, subresource: "acl", acl: acl))
}
/**
MARK: Amazon S3 Request Serialization
:discussion: These methods serialize requests for use with the Amazon S3 service. The `NSURLRequest`s returned from these methods may be used with `Alamofire`, `NSURLSession` or any other network request manager.
*/
/**
This method serializes a request for the Amazon S3 service with the given method and path.
:param: method The HTTP method for the request. For more information see `Alamofire.Method`.
:param: path The desired path, including the file name and extension, in the Amazon S3 Bucket.
:param: acl The optional access control list to set the acl headers for the request. For more information see `AmazonS3ACL`.
:returns: An `NSURLRequest`, serialized for use with the Amazon S3 service.
*/
public func amazonURLRequest(method: Alamofire.Method, path: String, subresource: String? = nil, acl: AmazonS3ACL? = nil) -> NSURLRequest {
var url = endpointURL.URLByAppendingPathComponent(path).URLByAppendingS3Subresource(subresource)
var mutableURLRequest = NSMutableURLRequest(URL: url)
mutableURLRequest.HTTPMethod = method.rawValue
setContentType(forRequest: &mutableURLRequest)
acl?.setACLHeaders(forRequest: &mutableURLRequest)
let error = setAuthorizationHeaders(forRequest: &mutableURLRequest)
return mutableURLRequest
}
private func setContentType(inout forRequest request: NSMutableURLRequest) {
var contentTypeString = MIMEType(request) ?? "application/octet-stream"
request.setValue(contentTypeString, forHTTPHeaderField: "Content-Type")
}
private func MIMEType(request: NSURLRequest) -> String? {
if let fileExtension = request.URL?.pathExtension {
if !fileExtension.isEmpty {
let UTIRef = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, fileExtension, nil)
let UTI = UTIRef.takeUnretainedValue()
UTIRef.release()
if let MIMETypeRef = UTTypeCopyPreferredTagWithClass(UTI, kUTTagClassMIMEType) {
let MIMEType = MIMETypeRef.takeUnretainedValue()
MIMETypeRef.release()
return MIMEType as String
}
}
}
return nil
}
private func setAuthorizationHeaders(inout forRequest request: NSMutableURLRequest) -> NSError? {
request.cachePolicy = .ReloadIgnoringLocalCacheData
let error = validateCredentials()
if error == nil {
if sessionToken != nil {
request.setValue(sessionToken!, forHTTPHeaderField: "x-amz-security-token")
}
let timestamp = currentTimeStamp()
let signature = AmazonS3SignatureHelpers.AWSSignatureForRequest(request,
timeStamp: timestamp,
secret: secret)
request.setValue(timestamp ?? "", forHTTPHeaderField: "Date")
request.setValue("AWS \(accessKey!):\(signature)", forHTTPHeaderField: "Authorization")
}
return error
}
private func currentTimeStamp() -> String {
return requestDateFormatter.stringFromDate(NSDate())
}
private lazy var requestDateFormatter: NSDateFormatter = {
let dateFormatter = NSDateFormatter()
dateFormatter.timeZone = NSTimeZone(name: "GMT")
dateFormatter.dateFormat = "EEE, dd MMM yyyy HH:mm:ss z"
dateFormatter.locale = NSLocale(localeIdentifier: "en_US_POSIX")
return dateFormatter
}()
/**
MARK: Validation
*/
private func validateCredentials() -> NSError? {
if accessKey == nil || accessKey!.isEmpty {
return accessKeyMissingError
}
if secret == nil || secret!.isEmpty {
return secretMissingError
}
return nil
}
/**
MARK: Error Handling
*/
private lazy var accessKeyMissingError: NSError = NSError(
domain: AmazonS3RequestManagerErrorDomain,
code: AmazonS3RequestManagerErrorCodes.AccessKeyMissing.rawValue,
userInfo: [NSLocalizedDescriptionKey: "Access Key Missing",
NSLocalizedFailureReasonErrorKey: "The 'accessKey' must be set in order to make requests with 'AmazonS3RequestManager'."]
)
private lazy var secretMissingError: NSError = NSError(
domain: AmazonS3RequestManagerErrorDomain,
code: AmazonS3RequestManagerErrorCodes.SecretMissing.rawValue,
userInfo: [NSLocalizedDescriptionKey: "Secret Missing",
NSLocalizedFailureReasonErrorKey: "The 'secret' must be set in order to make requests with 'AmazonS3RequestManager'."]
)
}
private extension NSURL {
private func URLByAppendingS3Subresource(subresource: String?) -> NSURL {
if subresource != nil && !subresource!.isEmpty {
let URLString = self.absoluteString!.stringByAppendingString("?\(subresource!)")
return NSURL(string: URLString)!
}
return self
}
} | mit | a9b78e0e457e436ce75cbf2aac0a8d7f | 32.443038 | 214 | 0.709924 | 4.400611 | false | false | false | false |
prolificinteractive/Optik | Optik/Classes/ImageViewController.swift | 1 | 9956 | //
// ImageViewController.swift
// Optik
//
// Created by Htin Linn on 5/5/16.
// Copyright © 2016 Prolific Interactive. All rights reserved.
//
import UIKit
/// View controller for displaying a single photo.
internal final class ImageViewController: UIViewController {
fileprivate struct Constants {
static let MaximumZoomScale: CGFloat = 3
static let MinimumZoomScale: CGFloat = 1
static let ZoomAnimationDuration: TimeInterval = 0.3
}
// MARK: - Properties
var image: UIImage? {
didSet {
imageView?.image = image
resetImageView()
if let _ = image {
activityIndicatorView?.stopAnimating()
}
}
}
private(set) var imageView: UIImageView?
let index: Int
// MARK: - Private properties
private var activityIndicatorColor: UIColor?
private var scrollView: UIScrollView? {
didSet {
guard let scrollView = scrollView else {
return
}
scrollView.decelerationRate = UIScrollView.DecelerationRate.fast
scrollView.showsVerticalScrollIndicator = false
scrollView.showsHorizontalScrollIndicator = false
scrollView.minimumZoomScale = Constants.MinimumZoomScale
scrollView.maximumZoomScale = Constants.MaximumZoomScale
if #available(iOS 11.0, *) {
scrollView.contentInsetAdjustmentBehavior = .never
}
}
}
private var activityIndicatorView: UIActivityIndicatorView? {
didSet {
activityIndicatorView?.color = activityIndicatorColor
}
}
private var effectiveImageSize: CGSize?
// MARK: - Init/Deinit
init(image: UIImage? = nil, activityIndicatorColor: UIColor? = nil, index: Int) {
self.image = image
self.activityIndicatorColor = activityIndicatorColor
self.index = index
super.init(nibName: nil, bundle: nil)
}
required init?(coder aDecoder: NSCoder) {
fatalError("Invalid initializer.")
}
// MARK: - Override functions
override func viewDidLoad() {
super.viewDidLoad()
setupDesign()
}
override func viewWillLayoutSubviews() {
super.viewWillLayoutSubviews()
resizeScrollViewFrame(to: view.bounds.size)
}
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
super.viewWillTransition(to: size, with: coordinator)
coordinator.animate(alongsideTransition: { (_) in
self.resizeScrollViewFrame(to: size)
}, completion: nil)
}
// MARK: - Instance functions
/**
Resets and re-centers the image view.
*/
func resetImageView() {
scrollView?.zoomScale = Constants.MinimumZoomScale
calculateEffectiveImageSize()
if let effectiveImageSize = effectiveImageSize {
imageView?.frame = CGRect(x: 0, y: 0, width: effectiveImageSize.width, height: effectiveImageSize.height)
scrollView?.contentSize = effectiveImageSize
}
centerImage()
}
// MARK: - Private functions
private func setupDesign() {
let scrollView = UIScrollView(frame: view.bounds)
scrollView.delegate = self
view.addSubview(scrollView)
let imageView = UIImageView(frame: scrollView.bounds)
scrollView.addSubview(imageView)
self.scrollView = scrollView
self.imageView = imageView
if let image = image {
imageView.image = image
resetImageView()
} else {
let activityIndicatorView = UIActivityIndicatorView(style: .whiteLarge)
activityIndicatorView.translatesAutoresizingMaskIntoConstraints = false
activityIndicatorView.hidesWhenStopped = true
activityIndicatorView.startAnimating()
view.addSubview(activityIndicatorView)
activityIndicatorView.centerXAnchor.constraint(equalTo: view.centerXAnchor, constant: 0).isActive = true
activityIndicatorView.centerYAnchor.constraint(equalTo: view.centerYAnchor, constant: 0).isActive = true
self.activityIndicatorView = activityIndicatorView
}
setupTapGestureRecognizer()
}
private func setupTapGestureRecognizer() {
let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(ImageViewController.didDoubleTap(_:)))
tapGestureRecognizer.numberOfTouchesRequired = 1
tapGestureRecognizer.numberOfTapsRequired = 2 // Only allow double tap.
view.addGestureRecognizer(tapGestureRecognizer)
}
private func calculateEffectiveImageSize() {
guard
let image = image,
let scrollView = scrollView else {
return
}
let imageViewSize = scrollView.frame.size
let imageSize = image.size
let widthFactor = imageViewSize.width / imageSize.width
let heightFactor = imageViewSize.height / imageSize.height
let scaleFactor = (widthFactor < heightFactor) ? widthFactor : heightFactor
effectiveImageSize = CGSize(width: scaleFactor * imageSize.width, height: scaleFactor * imageSize.height)
}
fileprivate func centerImage() {
guard
let effectiveImageSize = effectiveImageSize,
let scrollView = scrollView else {
return
}
let scaledImageSize = CGSize(width: effectiveImageSize.width * scrollView.zoomScale,
height: effectiveImageSize.height * scrollView.zoomScale)
let verticalInset: CGFloat
let horizontalInset: CGFloat
if scrollView.frame.size.width > scaledImageSize.width {
horizontalInset = (scrollView.frame.size.width - scrollView.contentSize.width) / 2
} else {
horizontalInset = 0
}
if scrollView.frame.size.height > scaledImageSize.height {
verticalInset = (scrollView.frame.size.height - scrollView.contentSize.height) / 2
} else {
verticalInset = 0
}
scrollView.contentInset = UIEdgeInsets(top: verticalInset, left: horizontalInset, bottom: verticalInset, right: horizontalInset)
}
@objc private func didDoubleTap(_ sender: UITapGestureRecognizer) {
guard
let effectiveImageSize = effectiveImageSize,
let imageView = imageView,
let scrollView = scrollView else {
return
}
let tapPointInContainer = sender.location(in: view)
let scrollViewSize = scrollView.frame.size
let scaledImageSize = CGSize(width: effectiveImageSize.width * scrollView.zoomScale,
height: effectiveImageSize.height * scrollView.zoomScale)
let scaledImageRect = CGRect(x: (scrollViewSize.width - scaledImageSize.width) / 2,
y: (scrollViewSize.height - scaledImageSize.height) / 2,
width: scaledImageSize.width,
height: scaledImageSize.height)
guard scaledImageRect.contains(tapPointInContainer) else {
return
}
if scrollView.zoomScale > scrollView.minimumZoomScale {
// Zoom out if the image was zoomed in at all.
UIView.animate(
withDuration: Constants.ZoomAnimationDuration,
delay: 0,
options: [],
animations: {
scrollView.zoomScale = scrollView.minimumZoomScale
self.centerImage()
},
completion: nil
)
} else {
// Otherwise, zoom into the location of the tap point.
let width = scrollViewSize.width / scrollView.maximumZoomScale
let height = scrollViewSize.height / scrollView.maximumZoomScale
let tapPointInImageView = sender.location(in: imageView)
let originX = tapPointInImageView.x - (width / 2)
let originY = tapPointInImageView.y - (height / 2)
let zoomRect = CGRect(x: originX, y: originY, width: width, height: height)
UIView.animate(
withDuration: Constants.ZoomAnimationDuration,
delay: 0,
options: [],
animations: {
scrollView.zoom(to: zoomRect.enclose(imageView.bounds), animated: false)
},
completion: { (_) in
self.centerImage()
}
)
}
}
private func resizeScrollViewFrame(to size: CGSize) {
let oldSize = scrollView?.bounds.size
scrollView?.frame = CGRect(x: 0, y: 0, width: size.width, height: size.height)
if oldSize != size {
resetImageView()
}
}
}
// MARK: - Protocol conformance
// MARK: UIScrollViewDelegate
extension ImageViewController: UIScrollViewDelegate {
func viewForZooming(in scrollView: UIScrollView) -> UIView? {
return imageView
}
func scrollViewDidZoom(_ scrollView: UIScrollView) {
centerImage()
}
func scrollViewDidEndZooming(_ scrollView: UIScrollView, with view: UIView?, atScale scale: CGFloat) {
UIView.animate(withDuration: Constants.ZoomAnimationDuration, animations: {
self.centerImage()
})
}
}
| mit | d4f53967b2b3404f0bda00d69a50b3f7 | 32.745763 | 136 | 0.597187 | 6.051672 | false | false | false | false |
practicalswift/swift | test/PrintAsObjC/availability-real-sdk.swift | 36 | 9681 | // RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -o %t %s
// RUN: %target-swift-frontend -parse-as-library %t/availability-real-sdk.swiftmodule -typecheck -emit-objc-header-path %t/availability-real-sdk.h -import-objc-header %S/../Inputs/empty.h
// RUN: %FileCheck %s < %t/availability-real-sdk.h
// RUN: %check-in-clang %t/availability-real-sdk.h
// REQUIRES: objc_interop
// CHECK-LABEL: @interface NSArray<ObjectType> (SWIFT_EXTENSION(main))
// CHECK-NEXT: - (id _Nonnull)deprecatedMethodInFavorOfReverseObjectEnumerator SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_DEPRECATED_MSG("This method is deprecated in favor to the old reverseObjectEnumerator method", "reverseObjectEnumerator");
// CHECK-NEXT: - (id _Nonnull)deprecatedMethodOnMacOSInFavorOfReverseObjectEnumerator SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_AVAILABILITY(macos,deprecated=0.0.1,message="'deprecatedMethodOnMacOSInFavorOfReverseObjectEnumerator' has been renamed to 'reverseObjectEnumerator': This method is deprecated in favor to the old reverseObjectEnumerator method");
// CHECK-NEXT: - (id _Nonnull)unavailableMethodInFavorOfReverseObjectEnumerator SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_UNAVAILABLE_MSG("'unavailableMethodInFavorOfReverseObjectEnumerator' has been renamed to 'reverseObjectEnumerator': This method is unavailable in favor to the old reverseObjectEnumerator method");
// CHECK-NEXT: - (id _Nonnull)unavailableMethodOnMacOSInFavorOfReverseObjectEnumerator SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_AVAILABILITY(macos,unavailable,message="'unavailableMethodOnMacOSInFavorOfReverseObjectEnumerator' has been renamed to 'reverseObjectEnumerator': This method is unavailable in favor to the old reverseObjectEnumerator method");
// CHECK-NEXT: - (NSArray * _Nonnull)deprecatedMethodInFavorOfAddingObjectWithObject:(id _Nonnull)object SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_DEPRECATED_MSG("This method is deprecated in favor to the old adding method", "arrayByAddingObject:");
// CHECK-NEXT: - (NSArray * _Nonnull)deprecatedMethodOnMacOSInFavorOfAddingObjectWithObject:(id _Nonnull)object SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_AVAILABILITY(macos,deprecated=0.0.1,message="'deprecatedMethodOnMacOSInFavorOfAddingObject' has been renamed to 'arrayByAddingObject:': This method is deprecated in favor to the old adding method");
// CHECK-NEXT: - (NSArray * _Nonnull)unavailableMethodInFavorOfAddingObjectWithObject:(id _Nonnull)object SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_UNAVAILABLE_MSG("'unavailableMethodInFavorOfAddingObject' has been renamed to 'arrayByAddingObject:': This method is unavailable in favor to the old adding method");
// CHECK-NEXT: - (NSArray * _Nonnull)unavailableMethodOnMacOSInFavorOfAddingObjectWithObject:(id _Nonnull)object SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_AVAILABILITY(macos,unavailable,message="'unavailableMethodOnMacOSInFavorOfAddingObject' has been renamed to 'arrayByAddingObject:': This method is unavailable in favor to the old adding method");
// CHECK-NEXT: @end
// CHECK-LABEL: @interface SubClassOfSet : NSSet
// CHECK-NEXT: - (id _Nonnull)deprecatedMethodInFavorOfAnyObject SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_DEPRECATED_MSG("This method is deprecated in favor to the old anyObject method", "anyObject");
// CHECK-NEXT: - (id _Nonnull)deprecatedMethodOnMacOSInFavorOfAnyObject SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_AVAILABILITY(macos,deprecated=0.0.1,message="'deprecatedMethodOnMacOSInFavorOfAnyObject' has been renamed to 'anyObject': This method is deprecated in favor to the old anyObject method");
// CHECK-NEXT: - (id _Nonnull)unavailableMethodInFavorOfAnyObject SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_UNAVAILABLE_MSG("'unavailableMethodInFavorOfAnyObject' has been renamed to 'anyObject': This method is unavailable in favor to the old anyObject method");
// CHECK-NEXT: - (id _Nonnull)unavailableMethodOnMacOSInFavorOfAnyObject SWIFT_WARN_UNUSED_RESULT
// CHECK-SAME: SWIFT_AVAILABILITY(macos,unavailable,message="'unavailableMethodOnMacOSInFavorOfAnyObject' has been renamed to 'anyObject': This method is unavailable in favor to the old anyObject method");
// CHECK-NEXT: @property (nonatomic, readonly) NSInteger deprecatedPropertyInFavorOfCount
// CHECK-SAME: SWIFT_DEPRECATED_MSG("This property is deprecated in favor to the old count property", "count");
// CHECK-NEXT: @property (nonatomic, readonly) NSInteger deprecatedOnMacOSPropertyInFavorOfCount
// CHECK-SAME: SWIFT_AVAILABILITY(macos,deprecated=0.0.1,message="'deprecatedOnMacOSPropertyInFavorOfCount' has been renamed to 'count': This property is deprecated in favor to the old count property");
// CHECK-NEXT: @property (nonatomic, readonly) NSInteger unavailablePropertyInFavorOfCount
// CHECK-SAME: SWIFT_UNAVAILABLE_MSG("'unavailablePropertyInFavorOfCount' has been renamed to 'count': This property is unavailable in favor to the old count property");
// CHECK-NEXT: @property (nonatomic, readonly) NSInteger unavailableOnMacOSPropertyInFavorOfCount
// CHECK-SAME: SWIFT_AVAILABILITY(macos,unavailable,message="'unavailableOnMacOSPropertyInFavorOfCount' has been renamed to 'count': This property is unavailable in favor to the old count property");
// CHECK-NEXT: - (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
// CHECK-NEXT: - (nonnull instancetype)initWithObjects:(id _Nonnull const * _Nullable)objects count:(NSUInteger)cnt OBJC_DESIGNATED_INITIALIZER;
// CHECK-NEXT: - (nullable instancetype)initWithCoder:(NSCoder * _Nonnull){{[a-zA-Z]+}} OBJC_DESIGNATED_INITIALIZER;
// CHECK-NEXT: @end
import Foundation
public class SubClassOfSet: NSSet {
@available(*, deprecated,
message: "This method is deprecated in favor to the old anyObject method",
renamed: "anyObject()")
@objc func deprecatedMethodInFavorOfAnyObject() -> Any { return 0 }
@available(macOS, deprecated,
message: "This method is deprecated in favor to the old anyObject method",
renamed: "anyObject()")
@objc func deprecatedMethodOnMacOSInFavorOfAnyObject() -> Any { return 0 }
@available(*, unavailable,
message: "This method is unavailable in favor to the old anyObject method",
renamed: "anyObject()")
@objc func unavailableMethodInFavorOfAnyObject() -> Any { return 0 }
@available(macOS, unavailable,
message: "This method is unavailable in favor to the old anyObject method",
renamed: "anyObject()")
@objc func unavailableMethodOnMacOSInFavorOfAnyObject() -> Any { return 0 }
@available(*, deprecated,
message: "This property is deprecated in favor to the old count property",
renamed: "count")
@objc var deprecatedPropertyInFavorOfCount: Int {
get {
return 0
}
}
@available(macOS, deprecated,
message: "This property is deprecated in favor to the old count property",
renamed: "count")
@objc var deprecatedOnMacOSPropertyInFavorOfCount: Int {
get {
return 0
}
}
@available(*, unavailable,
message: "This property is unavailable in favor to the old count property",
renamed: "count")
@objc var unavailablePropertyInFavorOfCount: Int {
get {
return 0
}
}
@available(macOS, unavailable,
message: "This property is unavailable in favor to the old count property",
renamed: "count")
@objc var unavailableOnMacOSPropertyInFavorOfCount: Int {
get {
return 0
}
}
}
extension NSArray {
@available(*, deprecated,
message: "This method is deprecated in favor to the old reverseObjectEnumerator method",
renamed: "reverseObjectEnumerator()")
@objc func deprecatedMethodInFavorOfReverseObjectEnumerator() -> Any { return 0 }
@available(macOS, deprecated,
message: "This method is deprecated in favor to the old reverseObjectEnumerator method",
renamed: "reverseObjectEnumerator()")
@objc func deprecatedMethodOnMacOSInFavorOfReverseObjectEnumerator() -> Any { return 0 }
@available(*, unavailable,
message: "This method is unavailable in favor to the old reverseObjectEnumerator method",
renamed: "reverseObjectEnumerator()")
@objc func unavailableMethodInFavorOfReverseObjectEnumerator() -> Any { return 0 }
@available(macOS, unavailable,
message: "This method is unavailable in favor to the old reverseObjectEnumerator method",
renamed: "reverseObjectEnumerator()")
@objc func unavailableMethodOnMacOSInFavorOfReverseObjectEnumerator() -> Any { return 0 }
@available(*, deprecated,
message: "This method is deprecated in favor to the old adding method",
renamed: "adding(_:)")
@objc func deprecatedMethodInFavorOfAddingObject(object: Any) -> NSArray {
return self.adding(object) as NSArray
}
@available(macOS, deprecated,
message: "This method is deprecated in favor to the old adding method",
renamed: "adding(_:)")
@objc func deprecatedMethodOnMacOSInFavorOfAddingObject(object: Any) -> NSArray {
return self.adding(object) as NSArray
}
@available(*, unavailable,
message: "This method is unavailable in favor to the old adding method",
renamed: "adding(_:)")
@objc func unavailableMethodInFavorOfAddingObject(object: Any) -> NSArray {
return self.adding(object) as NSArray
}
@available(macOS, unavailable,
message: "This method is unavailable in favor to the old adding method",
renamed: "adding(_:)")
@objc func unavailableMethodOnMacOSInFavorOfAddingObject(object: Any) -> NSArray {
return self.adding(object) as NSArray
}
}
| apache-2.0 | e932d994dc107092c491c5a8714a9f09 | 61.458065 | 250 | 0.756947 | 4.847772 | false | false | false | false |
drmohundro/Nimble | Nimble/Matchers/BeGreaterThan.swift | 1 | 1425 | import Foundation
public func beGreaterThan<T: Comparable>(expectedValue: T?) -> MatcherFunc<T?> {
return MatcherFunc { actualExpression, failureMessage in
failureMessage.postfixMessage = "be greater than <\(expectedValue)>"
return actualExpression.evaluate() > expectedValue
}
}
public func beGreaterThan(expectedValue: NMBComparable?) -> MatcherFunc<NMBComparable?> {
return MatcherFunc { actualExpression, failureMessage in
failureMessage.postfixMessage = "be greater than <\(expectedValue)>"
let actualValue = actualExpression.evaluate()
let matches = actualValue.hasValue && actualValue!.NMB_compare(expectedValue) == NSComparisonResult.OrderedDescending
return matches
}
}
public func ><T: Comparable>(lhs: Expectation<T?>, rhs: T) -> Bool {
lhs.to(beGreaterThan(rhs))
return true
}
public func >(lhs: Expectation<NMBComparable?>, rhs: NMBComparable?) -> Bool {
lhs.to(beGreaterThan(rhs))
return true
}
extension NMBObjCMatcher {
public class func beGreaterThanMatcher(expected: NMBComparable?) -> NMBObjCMatcher {
return NMBObjCMatcher { actualBlock, failureMessage, location in
let block = ({ actualBlock() as NMBComparable? })
let expr = Expression(expression: block, location: location)
return beGreaterThan(expected).matches(expr, failureMessage: failureMessage)
}
}
}
| apache-2.0 | 7f9da9a4039c2857f34db2aff84ae458 | 37.513514 | 125 | 0.705965 | 5.277778 | false | false | false | false |
stefanoa/Spectrogram | Spectogram/fft.playground/Contents.swift | 1 | 1598 | import UIKit
import Accelerate
func sqrtq(_ x: [Float]) -> [Float] {
var results = [Float](repeating: 0.0, count: x.count)
vvsqrtf(&results, x, [Int32(x.count)])
return results
}
let sliceSize = 128
var inputSlice = [Float](repeating: 0, count: sliceSize)
var window = [Float](repeating: 0, count: sliceSize)
var transfer = [Float](repeating: 0, count: sliceSize)
vDSP_hann_window(&window, vDSP_Length(sliceSize), Int32(vDSP_HANN_NORM))
let log2n = UInt(round(log2(Double(sliceSize))))
let fftSetup = vDSP_create_fftsetup(log2n, Int32(kFFTRadix2))
var realp = [Float](repeating: 0, count: sliceSize/2)
var imagp = [Float](repeating: 0, count: sliceSize/2)
var outputSlice = DSPSplitComplex(realp: &realp, imagp: &imagp)
let f1:Float = 8.1
for i in 0...sliceSize-1{
let x:Float = 2 * .pi * Float(i)/Float(sliceSize)
inputSlice[i] = sin(f1*x)
}
//vDSP_vmul(&inputSlice, 1, &window, 1, &transfer, 1, vDSP_Length(sliceSize))
let temp = UnsafePointer<Float>(inputSlice)
temp.withMemoryRebound(to: DSPComplex.self, capacity: transfer.count) { (typeConvertedTransferBuffer) -> Void in
vDSP_ctoz(typeConvertedTransferBuffer, 2, &outputSlice, 1, vDSP_Length(sliceSize/2))
}
vDSP_fft_zrip(fftSetup!, &outputSlice, 1, log2n, FFTDirection(FFT_FORWARD))
var magnitudes = [Float](repeating: 0.0, count: sliceSize/2)
vDSP_zvmags(&outputSlice, 1, &magnitudes, 1, vDSP_Length(Int(sliceSize/2)))
var normalizedMagnitudes = [Float](repeating: 0.0, count: sliceSize/2)
let csize = sliceSize/2
for i in 0...csize-1{
normalizedMagnitudes[i] = sqrt(magnitudes[i])/Float(csize)
}
| mit | 155ea2eb20e66e59844019a8d8d50d38 | 34.511111 | 112 | 0.712766 | 3.090909 | false | false | false | false |
cherrythia/FYP | BarInsertVariables.swift | 1 | 6206 | //
// BarInsertVariables.swift
// FYP Table
//
// Created by Chia Wei Zheng Terry on 1/3/15.
// Copyright (c) 2015 Chia Wei Zheng Terry. All rights reserved.
//
import UIKit
import CoreData
class BarInsertVariables: UIViewController {
@IBOutlet weak var arrowOutlet: ForceArrow!
@IBOutlet weak var leftLabel: UILabel!
@IBOutlet weak var rightLabel: UILabel!
@IBOutlet weak var barImage: UIImageView!
var barImageArray : [UIImage] = [UIImage(named: "barAtWall.jpg")!,
UIImage(named: "bar.jpg")!,
UIImage(named: "BarAtWall1.jpg")!]
@IBOutlet weak var image: UIImageView!
@IBOutlet weak var forceLabel: UILabel!
@IBOutlet weak var forceEntered: UITextField!
@IBOutlet weak var lengthLabel: UILabel!
@IBOutlet weak var lengthEntered: UITextField!
@IBOutlet weak var modulusLabel: UILabel!
@IBOutlet weak var modulusEntered: UITextField!
@IBOutlet weak var areaLabel: UILabel!
@IBOutlet weak var areaEntered: UITextField!
@IBOutlet weak var isCheckedOutlet: CheckBox2!
var tempForce : Float = 0.0
var tempArea : Float = 0.0
var tempLength : Float = 0.0
var tempMod : Float = 0.0
var tempCount : Int = 0
var tempCheckedGlobal : Bool = false
var tempArrow : Bool = false
var tempMangObj : NSManagedObject!
var tempCanCheckCheckedBox : Bool = false
override func viewDidLoad() {
//disable the checkedbox function when user clicks on the detail view
if(tempMangObj != nil && tempCanCheckCheckedBox == false){
isCheckedOutlet.isEnabled = false
}
else{
isCheckedOutlet.isEnabled = true
}
leftLabel.text = "Node \(tempCount)"
rightLabel.text = "Node \(tempCount + 1)"
if(isCheckedGlobal == false) {
forceEntered.isEnabled = true
arrowOutlet.isEnabled = true
arrowOutlet.isHidden = false
if(tempCount != 0)
{
image.image = barImageArray[1]
} else
{
image.image = barImageArray[0]
}
}
if(isCheckedGlobal == true && tempCount != 0) {
barImage.image = barImageArray[2]
forceEntered.isEnabled = false
forceEntered.text = "0"
arrowOutlet.isEnabled = false
arrowOutlet.isHidden = true
}
}
override func viewDidAppear(_ animated: Bool) {
if(tempMangObj != nil)
{
forceEntered.text = "\(tempForce)N"
areaEntered.text = "\(tempArea)m^2"
lengthEntered.text = "\(tempLength)m"
modulusEntered.text = "\(tempMod)N/m^2"
}
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
self.view.endEditing(true)
}
@IBAction func barCheckboxed(_ sender: AnyObject) {
if(tempCount != 0){
if(isCheckedGlobal == true){
isCheckedGlobal = false
}
else{
isCheckedGlobal = true
}
}
else {
//Warming for the first bar element
let first_bar_alert = UIAlertController(title: "First bar must be inputted here", message: "First bar must always be attached on the left war here", preferredStyle: .alert)
let cancelAction = UIAlertAction(title: "OK", style: .default) {(ACTION: UIAlertAction!) -> Void in}
first_bar_alert.addAction(cancelAction)
present(first_bar_alert, animated: true, completion: nil)
}
self.viewDidLoad()
}
@IBAction func arrow(_ sender: AnyObject) {
if let force = forceEntered.text {
if(ArrowGlobal == true) {
ArrowGlobal = false
let tempForceConversion = (force as NSString).floatValue
forceEntered.text = "\(abs(tempForceConversion))"
}
else{
ArrowGlobal = true
forceEntered.text = "-\(force)"
}
}
}
@IBAction func barSubmit(_ sender: AnyObject) {
//CoreData
//Reference to App Delegate
let appDel : AppDelegate = UIApplication.shared.delegate as! AppDelegate
//Reference moc
let context : NSManagedObjectContext = appDel.managedObjectContext!
let en = NSEntityDescription.entity(forEntityName: "BarVariables", in: context)
if(tempMangObj != nil) { //save changes here
tempMangObj.setValue(NSString(string: forceEntered.text!).floatValue, forKey: "force")
tempMangObj.setValue(NSString(string: areaEntered.text!).floatValue, forKey: "area")
tempMangObj.setValue(NSString(string: lengthEntered.text!).floatValue, forKey: "length")
tempMangObj.setValue(NSString(string: modulusEntered.text!).floatValue, forKey: "youngMod")
tempMangObj.setValue((Bool: isCheckedGlobal), forKey: "globalChecked")
tempMangObj.setValue((Bool: ArrowGlobal), forKey: "arrowChecked")
}
else { //create new item here
var newItem = BarModel(entity:en!,insertInto: context)
newItem.area = NSString(string: areaEntered.text!).floatValue
newItem.length = NSString(string: lengthEntered.text!).floatValue
newItem.youngMod = NSString(string: modulusEntered.text!).floatValue
if(isCheckedGlobal == true){
newItem.force = 0
}
else{
newItem.force = NSString(string: forceEntered.text!).floatValue
}
print(newItem)
}
//save our context
do {
try context.save()
} catch {
}
self.navigationController?.popViewController(animated: true)
}
}
| mit | 213b92252526f67e3aa38943b3fee890 | 33.287293 | 184 | 0.564615 | 5.133168 | false | false | false | false |
netguru/inbbbox-ios | Inbbbox/Source Files/Collection View Layouts/TwoColumnsCollectionViewFlowLayout.swift | 1 | 2599 | //
// TwoColumnsCollectionViewFlowLayout.swift
// Inbbbox
//
// Created by Aleksander Popko on 25.01.2016.
// Copyright © 2016 Netguru Sp. z o.o. All rights reserved.
//
import UIKit
class TwoColumnsCollectionViewFlowLayout: UICollectionViewFlowLayout {
var itemHeightToWidthRatio = CGFloat(1)
var containsHeader = false
override func prepare() {
if let collectionView = collectionView {
let spacings = CollectionViewLayoutSpacings()
let calculatedItemWidth = (round(collectionView.bounds.width) -
3 * spacings.twoColumnsItemMargin) / 2
let calculatedItemHeight = calculatedItemWidth * itemHeightToWidthRatio
itemSize = CGSize(width: calculatedItemWidth, height: calculatedItemHeight)
minimumLineSpacing = spacings.twoColumnsMinimumLineSpacing
minimumInteritemSpacing = spacings.twoColumnsMinimymInterimSpacing
sectionInset = UIEdgeInsets(
top: spacings.twoColumnsSectionMarginVertical,
left: spacings.twoColumnsSectionMarginVertical,
bottom: spacings.twoColumnsSectionMarginHorizontal,
right: spacings.twoColumnsSectionMarginVertical
)
if containsHeader {
headerReferenceSize = CGSize(
width: collectionView.bounds.width,
height: 150
)
}
}
}
override func shouldInvalidateLayout(forBoundsChange newBounds: CGRect) -> Bool {
return true
}
override func layoutAttributesForElements(in rect: CGRect)
-> [UICollectionViewLayoutAttributes]? {
let attributes = super.layoutAttributesForElements(in: rect)
guard let collectionView = collectionView else {
return attributes
}
let insets = collectionView.contentInset
let offset = collectionView.contentOffset
let minY = -insets.top
if offset.y < minY {
let deltaY = fabsf(Float(offset.y - minY))
attributes?.forEach {
if $0.representedElementKind == UICollectionElementKindSectionHeader {
var headerRect = $0.frame
headerRect.size.height = max(minY, headerReferenceSize.height + CGFloat(deltaY))
headerRect.origin.y = headerRect.origin.y - CGFloat(deltaY)
$0.frame = headerRect
$0.zIndex = 64
}
}
}
return attributes
}
}
| gpl-3.0 | 7a01c2110d26d7a80393abc6bfbb0223 | 34.108108 | 100 | 0.615089 | 5.917995 | false | false | false | false |
austinzheng/swift | validation-test/compiler_crashers_fixed/00234-llvm-foldingset-swift-genericfunctiontype-nodeequals.swift | 65 | 4246 | // This source file is part of the Swift.org open source project
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
// RUN: not %target-swift-frontend %s -typecheck
func k<q {
enum k {
func j
var _ = j
}
}
class x {
s m
func j(m)
}
struct j<u> : r {
func j(j: j.n) {
}
}
enum q<v> { let k: v
let u: v.l
}
protocol y {
o= p>(r: m<v>)
}
struct D : y {
s p = Int
func y<v k r {
s m
}
class y<D> {
w <r:
func j<v x: v) {
x.k()
}
func x(j: Int = a) {
}
let k = x
protocol A {
func c() -> String
}
class B {
func d() -> String {
return ""
}
}
class C: B, A {
override func d() -> String {
return ""
}
func c() -> String {
return ""
}
}
func e<T where T: A, T: B>(t: T) {
t.c()
}
struct c<d : Sequence> {
var b: d
}
func a<d>() -> [c<d>] {
return []
}
b
protocol c : b { func b
func f<r>() -> (r, r -> r) -> r {
f r f.j = {
}
{
r) {
s }
}
protocol f {
class func j()
}
class f: f{ class func j {}
protocol j {
class func m()
}
class r: j {
class func m() { }
}
(r() n j).p.m()
j=k n j=k
protocol r {
class func q()
}
s m {
m f: r.q
func q() {
f.q()
}
(l, () -> ())
}
func f<l : o>(r: l)
func f<e>() -> (e, e -> e) -> e {
e b e.c = {}
{
e)
{
f
}
}
protocol f {
class func c()
}
class e: f {
class func c
}
}
func C<D, E: A where D.C == E> {
}
func prefix(with: String) -> <T>(() -> T) -> String {
{ g in "\(withing
}
clasnintln(some(xs))
protocol A {
func c()l k {
func l() -> g {
m ""
}
}
class C: k, A {
j func l()q c() -> g {
m ""
}
}
func e<r where r: A, r: k>(n: r) {
n.c()
}
protocol A {
typealias h
}
c k<r : A> {
p f: r
p p: r.h
}
protocol C l.e()
}
}
class o {
typealias l = l
w
class x<u>: d {
l i: u
init(i: u) {
o.i = j {
r { w s "\(f): \(w())" }
}
protocol h {
q k {
t w
}
w
protocol k : w { func v <h: h m h.p == k>(l: h.p) {
}
}
protocol h {
n func w(w:
}
class h<u : h> {
}
}
class b<i : b> i: g{ func c {}
e g {
: g {
h func i() -> }
struct c<d: Sequence, b where Optional<b> == d.Iterator.Element>
}
class p {
u _ = q() {
}
}
u l = r
u s: k -> k = {
n $h: m.j) {
}
}
o l() {
({})
}
struct m<t> {
let p: [(t, () -> ())] = []
}
protocol p : p {
}
protocol m {
o u() -> String
}
class j {
o m() -> String {
n ""
}
}
class h: j, m {
q o m() -> String {
n ""
}
o u() -> S, q> {
}
protocol u {
typealias u
}
class p {
typealias u = u
func a<d>() -> [c{ enum b {
case c
1, g(f, j)))
m k {
class h k()
}
struct i {
i d: k.l h k() {
n k
}
class g {
typealias k = k
}
class k {
func l((Any, k))(m }
}
func j<f: l: e -> e = {
{
l) {
m }
}
protocol k {
class func j()
}
class e: k{ class func j
func d<b: Sequence, e where Optional<e> == b.Iterator.Element>(c : b) -> e? {
for (mx : e?) in c {
}
}
func o() -> i) -> b {
n { o f "\(k): \(o())" }
}
struct d<d : n, o:j n {
l p
}
protocol o : o {
}
func o<
func i(c: () -> ()) {
}
class a {
var _ = i() {
}
}
() {
g g h g
}
}
func e(i: d) -> <f>(() -> f)>
>(f: B<{ }
})
}
func prefix(with: ng) -> <T>(() -> T)
func b(c) -> <d>(() -> d) {
}
func f() {
({})
}
func j(d: h) -> <k>(() -> k) -> h {
return { n n "\(}
c i<k : i> {
}
c i: i {
}
c e : l {
}
f = e
protocol m : o h = h
}
struct l<e : Sequence> {
l g: e
}
func h<e>() -> [l<e>] {
f []
}
func i(e: g) -> <j>(() -> j) -> k
func c<e>() -> (e -> e) -> e {
e, e -> e) n }
}
protocol f {
class func n()
}
class l: f{ class func n {}
func a<i>() {
b b {
l j
}
}
class a<f : b, l : b m f.l == l> {
}
protocol b {
typealias l
typealias k
}
struct j<n : b> : b {
typealias l = n
typealias k = a<j<n>, l>
}
d ""
e}
class d {
fun
| apache-2.0 | 7517c857f0ef9d298e2698a32bebcd2f | 12.696774 | 79 | 0.421338 | 2.44023 | false | false | false | false |
yaobanglin/viossvc | viossvc/General/Helper/ChatSessionHelper.swift | 1 | 5045 | //
// ChatSessionHelper.swift
// viossvc
//
// Created by yaowang on 2016/12/3.
// Copyright © 2016年 com.yundian. All rights reserved.
//
import UIKit
protocol ChatSessionsProtocol : NSObjectProtocol {
func updateChatSessions(chatSession:[ChatSessionModel])
}
protocol ChatSessionProtocol : NSObjectProtocol {
func receiveMsg(chatMsgModel:ChatMsgModel)
func sessionUid() ->Int
}
class ChatSessionHelper: NSObject {
static let shared = ChatSessionHelper()
private var _chatSessions:[ChatSessionModel] = []
var chatSessions:[ChatSessionModel] {
return _chatSessions
}
weak var chatSessionsDelegate:ChatSessionsProtocol?
weak private var currentChatSessionDelegate:ChatSessionProtocol?
func findHistorySession() {
_chatSessions = ChatDataBaseHelper.ChatSession.findHistorySession()
syncUserInfos()
chatSessionSort()
}
func openChatSession(chatSessionDelegate:ChatSessionProtocol) {
currentChatSessionDelegate = chatSessionDelegate
let chatSession = findChatSession(currentChatSessionDelegate!.sessionUid())
if chatSession != nil {
if UIApplication.sharedApplication().applicationIconBadgeNumber < chatSession.noReading {
UIApplication.sharedApplication().applicationIconBadgeNumber = 0
} else {
UIApplication.sharedApplication().applicationIconBadgeNumber -= chatSession.noReading
}
chatSession.noReading = 0
updateChatSession(chatSession)
}
}
func closeChatSession() {
currentChatSessionDelegate = nil
}
func receiveMsg(chatMsgModel:ChatMsgModel) {
let sessionId = chatMsgModel.from_uid == CurrentUserHelper.shared.uid ? chatMsgModel.to_uid : chatMsgModel.from_uid
var chatSession = findChatSession(sessionId)
if chatSession == nil {
chatSession = createChatSession(sessionId)
chatSession.lastChatMsg = chatMsgModel
}
else if chatSession.lastChatMsg == nil
|| chatSession.lastChatMsg.msg_time < chatMsgModel.msg_time {
chatSession.lastChatMsg = chatMsgModel
chatSessionSort()
}
if currentChatSessionDelegate != nil {
currentChatSessionDelegate?.receiveMsg(chatMsgModel)
}
else if chatMsgModel.from_uid != CurrentUserHelper.shared.uid {
chatSession.noReading += 1
}
updateChatSession(chatSession)
}
func didReqeustUserInfoComplete(userInfo:UserInfoModel!) {
if userInfo != nil {
if let chatSession = findChatSession(userInfo.uid) {
chatSession.title = userInfo.nickname!
chatSession.icon = userInfo.head_url!
updateChatSession(chatSession)
}
}
}
func updateChatSession(chatSession:ChatSessionModel) {
ChatDataBaseHelper.ChatSession.updateModel(chatSession)
chatSessionsDelegate?.updateChatSessions(_chatSessions)
}
private func syncUserInfos() {
var getInfoIds = [String]()
for chatSesion in _chatSessions {
if chatSesion.type == ChatSessionType.Chat.rawValue && NSString.isEmpty(chatSesion.title) {
getInfoIds.append("\(chatSesion.sessionId)")
}
}
if getInfoIds.count > 0 {
AppAPIHelper.userAPI().getUserInfos(getInfoIds, complete: { [weak self] (array) in
let userInfos = array as? [UserInfoModel]
if userInfos != nil {
for userInfo in userInfos! {
self?.didReqeustUserInfoComplete(userInfo)
}
}
}, error: nil)
}
}
private func chatSessionSort() {
_chatSessions.sortInPlace({ (chatSession1, chatSession2) -> Bool in
return chatSession1.lastChatMsg?.msg_time > chatSession2.lastChatMsg?.msg_time
})
}
private func updateChatSessionUserInfo(uid:Int) {
AppAPIHelper.userAPI().getUserInfo(uid, complete: { [weak self](model) in
self?.didReqeustUserInfoComplete(model as? UserInfoModel)
}, error: {(error) in})
}
private func createChatSession(uid:Int) -> ChatSessionModel {
let chatSession = ChatSessionModel()
chatSession.sessionId = uid
_chatSessions.insert(chatSession, atIndex: 0)
if chatSession.type == 0 {
updateChatSessionUserInfo(uid)
}
ChatDataBaseHelper.ChatSession.addModel(chatSession)
return chatSession
}
private func findChatSession(uid:Int) ->ChatSessionModel! {
for chatSession in _chatSessions {
if chatSession.sessionId == uid {
return chatSession
}
}
return nil
}
}
| apache-2.0 | 7baefa7f0f73d8919463d46858a002bd | 31.320513 | 123 | 0.619199 | 5.480435 | false | false | false | false |
jakerockland/Swisp | Sources/SwispFramework/Environment/Environment.swift | 1 | 4170 | //
// Environment.swift
// SwispFramework
//
// MIT License
//
// Copyright (c) 2018 Jake Rockland (http://jakerockland.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
// software and associated documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights to use, copy, modify,
// merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
/// An environment with some Scheme standard procedures
public let standardEnv = Env([
// Constants
"π": Double.pi,
"pi": Double.pi,
"𝑒": Double.e,
"e": Double.e,
// Operators
"+": Operators.add,
"-": Operators.subtract,
"*": Operators.multiply,
"/": Operators.divide,
"%": Operators.mod,
">": Operators.greaterThan,
"<": Operators.lessThan,
">=": Operators.greaterThanEqual,
"<=": Operators.lessThanEqual,
"=": Operators.equal,
// Number-theoretic and representation functions
"ceil": Math.ceil,
"copysign": Math.copysign,
"fabs": Math.fabs,
"factorial":Math.factorial,
"floor": Math.floor,
"fmod": Math.fmod,
"frexp": Math.frexp,
"fsum": Math.fsum,
"isinf": Math.isinf,
"isnan": Math.isnan,
"ldexp": Math.ldexp,
"trunc": Math.trunc,
// Power and logarithmic functions
"exp": Math.exp,
"log": Math.log,
"log1p": Math.log1p,
"log10": Math.log10,
"pow": Math.pow,
"sqrt": Math.sqrt,
// Trigonometric functions
"acos": Math.acos,
"asin": Math.asin,
"atan": Math.atan,
"atan2": Math.atan2,
"cos": Math.cos,
"hypot": Math.hypot,
"sin": Math.sin,
"tan": Math.tan,
// Angular conversion
"degrees": Math.degrees,
"radians": Math.radians,
// Hyperbolic functions
"acosh": Math.acosh,
"asinh": Math.asinh,
"atanh": Math.atanh,
"cosh": Math.cosh,
"sinh": Math.sinh,
"tanh": Math.tanh,
// Special functions
"erf": Math.erf,
"erfc": Math.erfc,
"gamma": Math.gamma,
"lgamma": Math.lgamma,
// // Misc.
"abs": Library.abs,
"append": Library.append,
// // "apply": apply, // [TODO](https://www.drivenbycode.com/the-missing-apply-function-in-swift/)
// "begin": { $0[-1] },
"car": Library.car,
"cdr": Library.cdr,
// "cons": { [$0] + $1 },
// "eq?": { $0 === $1 },
// "equal?": { $0 == $1 },
// "length": { $0.count },
// "list": { List($0) },
// "list?": { $0 is List },
// // "map": map, // [TODO](https://www.weheartswift.com/higher-order-functions-map-filter-reduce-and-more/)
// "max": max,
// "min": min,
"not": Library.not,
// "null?": { $0 == nil },
// "number?": { $0 is Number },
// "procedure?": { String(type(of: $0)).containsString("->") },
// "round": round,
// "symbol?": { $0 is Symbol }
] as [Symbol: Any])
| mit | 5afd6911f458c6c6ba6b1214cf733ae8 | 34.305085 | 127 | 0.535286 | 3.709706 | false | false | false | false |
aestesis/Aether | Sources/Aether/Foundation/Future.swift | 1 | 14195 | //
// Future.swift
// Aether
//
// Created by renan jegouzo on 29/03/2016.
// Copyright © 2016 aestesis. 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 Foundation
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Future : Atom {
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public enum State {
case inProgress
case cancel
case done
case error
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public let onDetach=Event<Void>()
private var _done=Event<Future>()
private var _cancel=Event<Future>()
private var _progress=Event<Future>()
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public private(set) var state:State = .inProgress
public private(set) var result:Any?
public private(set) var progress:Double=0
public private(set) var context:String?
public var autodetach = true
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
var prop:[String:Any]=[String:Any]()
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public subscript(k:String) -> Any? {
get {
return prop[k]
}
set(v) {
prop[k]=v
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public func then(_ fn:@escaping (Future)->()) {
let _ = _done.always(fn)
}
public func pulse(_ fn:@escaping (Future)->()) {
let _ = _progress.always(fn)
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public func cancel() {
if state == .inProgress {
state = .cancel
_cancel.dispatch(self)
if autodetach {
self.detach()
}
}
}
public func done(_ result:Any?=nil) {
if state == .inProgress {
self.result = result
state = .done
progress = 1
_progress.dispatch(self)
_done.dispatch(self)
if autodetach {
self.detach()
}
}
}
public func error(_ error:Error,_ f:String=#file,_ l:Int=#line) {
if state == .inProgress {
self.result=Error(error,f,l)
state = .error
_done.dispatch(self)
if autodetach {
self.detach()
}
}
}
public func error(_ reason:String,_ f:String=#file,_ l:Int=#line) {
error(Error(reason,f,l))
}
public func progress(_ value:Double) {
if state == .inProgress {
progress = value
_progress.dispatch(self)
}
}
public func onCancel(_ fn:@escaping (Future)->()) {
let _ = _cancel.always(fn)
}
/*
// TODO: leaking, must think about unpipe
public func pipe(to:Future) {
self.then { f in
switch f.state {
case .done:
to.done(f.result)
case .error:
let e = f.result as! Error
to.error(e)
default:
Debug.error("strange behavior",#file,#line)
break
}
}
self.pulse { f in
to.progress(f.progress)
}
to.onCancel { f in
self.cancel()
}
}
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
#if DEBUG
private let function:String
private let file:String
private let line:Int
public override var debugDescription: String {
return "Future.init(file:\(file),line:\(line),function:\(function))"
}
#endif
public init(context:String?=nil,file:String=#file,line:Int=#line,function:String=#function) {
#if DEBUG
self.file = file
self.line = line
self.function = function
#endif
self.context=context
super.init()
}
public func detach() {
onDetach.dispatch(())
onDetach.removeAll()
_done.removeAll()
_cancel.removeAll()
_progress.removeAll()
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Job : Future {
public let priority: Priority
public private(set) var action:(()->())?
public private(set) var owner : Node
public let info:String
public enum Priority : Int {
case high=0x0100
case normal=0x0200
case low=0x0300
}
public init(owner: Node, priority:Priority=Priority.normal, info:String="", action:@escaping ()->()) {
self.owner=owner
self.info=info
self.action=action
self.priority=priority
super.init()
}
public override func detach() {
action = nil
super.detach()
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Worker : NodeUI {
public var paused:Bool=false
var jobs=[Job]()
let lock=Lock()
var release:Bool=false
var threads:Int=0
#if DEBUG
var running=[String:Int]()
public func debugInfo() {
for k in running.keys {
if running[k]!>5 {
Debug.info("running \(k) \(running[k]!)")
}
}
}
#endif
public var count:Int {
var c=0
self.lock.synced {
c = self.jobs.count
}
return c
}
public func stop() {
var jl:[Job]?
release=true
self.lock.synced {
jl = self.jobs
self.jobs.removeAll()
}
for j in jl! {
j.cancel()
}
var wait = true
let w = self.wait(1) {
Debug.error("one thread takes too long, stop waiting...",#file,#line)
wait = false
}
while threads>0 && wait {
Thread.sleep(0.01)
}
if wait {
w.cancel()
}
}
public func cancel(_ owner:NodeUI) {
var cancel=[Job]()
lock.synced {
self.jobs = self.jobs.filter({ (j) -> Bool in
if j.owner == owner {
cancel.append(j)
return false
}
return true
})
}
for j in cancel {
j.cancel()
j.detach()
}
}
public func run(_ owner:NodeUI,priority:Job.Priority=Job.Priority.normal,info:String="",action:@escaping ()->()) -> Job {
let j=Job(owner:owner,priority:priority,info:info,action:action)
if release {
Debug.error("returning fake job",#file,#line)
return j // returns fake job
}
lock.synced {
self.jobs.append(j)
self.jobs.sort(by: { (a, b) -> Bool in
return a.priority.rawValue < b.priority.rawValue
})
}
j.onCancel { (p) in
self.lock.synced {
self.jobs=self.jobs.filter({ (ij) -> Bool in
return ij != j
})
}
}
return j
}
override public func detach() {
self.stop()
super.detach()
}
public init(parent:NodeUI,threads:Int=1) {
super.init(parent:parent)
for _ in 1...threads {
let _=Thread {
self.threads += 1
while !self.release {
if !self.paused {
var j:Job?=nil
self.lock.synced {
j=self.jobs.dequeue()
#if DEBUG
if let j=j {
if let r=self.running[j.owner.className] {
self.running[j.owner.className] = r+1
} else {
self.running[j.owner.className] = 1
}
}
#endif
}
if let j=j {
let owner = j.owner
if !self.release {
autoreleasepool {
j.done(j.action!())
}
}
#if DEBUG
self.lock.synced {
if let r=self.running[owner.className] {
if owner.className == "CacheNet" {
Debug.warning("removing CacheNet -> \(r-1)")
}
if r > 1 {
self.running[owner.className] = r-1
} else {
self.running.remove(at: self.running.index(forKey: owner.className)!)
}
}
}
#endif
j.detach()
} else {
Thread.sleep(0.001)
}
} else {
Thread.sleep(0.01)
}
}
self.threads -= 1
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Error : Atom, Swift.Error {
public let message:String
public let file:String
public let line:Int
public private(set) var origin:Error?
public override var description: String {
return "{ error:\"\(message)\" file:\"\(Debug.truncfile(file))\" line:\(line) }"
}
public init(_ message:String,_ file:String=#file,_ line:Int=#line) {
self.message=message
self.file=file
self.line=line
super.init()
}
public init(_ error:Error,_ file:String=#file,_ line:Int=#line) {
self.origin=error
self.message=error.message
self.file=file
self.line=line
super.init()
}
public func get<T>() -> T? {
if let v = self as? T {
return v
}
if let s = self.origin {
let v:T? = s.get()
return v
}
return nil
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
#if os(Linux) // https://lists.swift.org/pipermail/swift-users/Week-of-Mon-20161031/003823.html
func autoreleasepool(fn:()->()) {
fn()
}
#endif
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
| apache-2.0 | cab210775e9d4b1750875a5f789da477 | 36.550265 | 125 | 0.337467 | 6.019508 | false | false | false | false |
SmallElephant/FESwiftDemo | 13-DashLine/13-DashLine/ViewController.swift | 1 | 5614 | //
// ViewController.swift
// 13-DashLine
//
// Created by keso on 2017/3/26.
// Copyright © 2017年 FlyElephant. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.lor.red
setUp()
setUp1()
setUp2()
setUp3()
setUp4()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
// MARK:SetUp
func setUp() {
let imgView:UIImageView = UIImageView(frame: CGRect(x: 0, y: 100, width: self.view.frame.width, height: 20))
self.view.addSubview(imgView)
UIGraphicsBeginImageContext(imgView.frame.size) // 位图上下文绘制区域
imgView.image?.draw(in: imgView.bounds)
let context:CGContext = UIGraphicsGetCurrentContext()!
context.setLineCap(CGLineCap.square)
let lengths:[CGFloat] = [10,20] // 绘制 跳过 无限循环
context.setStrokeColor(UIColor.red.cgColor)
context.setLineWidth(5)
context.setLineDash(phase: 0, lengths: lengths)
context.move(to: CGPoint(x: 0, y: 10))
context.addLine(to: CGPoint(x: self.view.frame.width, y: 10))
context.strokePath()
imgView.image = UIGraphicsGetImageFromCurrentImageContext()
}
func setUp1() {
let imgView:UIImageView = UIImageView(frame: CGRect(x: 0, y: 150, width: self.view.frame.width, height: 20))
self.view.addSubview(imgView)
UIGraphicsBeginImageContext(imgView.frame.size) // 位图上下文绘制区域
imgView.image?.draw(in: imgView.bounds)
let context:CGContext = UIGraphicsGetCurrentContext()!
context.setLineCap(CGLineCap.square)
let lengths:[CGFloat] = [10,20] // 绘制 跳过 无限循环
context.setStrokeColor(UIColor.red.cgColor)
context.setLineWidth(5)
context.setLineDash(phase: 5, lengths: lengths)
context.move(to: CGPoint(x: 0, y: 10))
context.addLine(to: CGPoint(x: self.view.frame.width, y: 10))
context.strokePath()
imgView.image = UIGraphicsGetImageFromCurrentImageContext()
}
func setUp2() {
let imgView:UIImageView = UIImageView(frame: CGRect(x: 0, y: 200, width: self.view.frame.width, height: 20))
self.view.addSubview(imgView)
UIGraphicsBeginImageContext(imgView.frame.size) // 位图上下文绘制区域
imgView.image?.draw(in: imgView.bounds)
let context:CGContext = UIGraphicsGetCurrentContext()!
context.setLineCap(CGLineCap.square)
let lengths:[CGFloat] = [10,20,10] // 绘制 跳过 无限循环
context.setStrokeColor(UIColor.red.cgColor)
context.setLineWidth(5)
context.setLineDash(phase: 0, lengths: lengths)
context.move(to: CGPoint(x: 0, y: 10))
context.addLine(to: CGPoint(x: self.view.frame.width, y: 10))
context.strokePath()
imgView.image = UIGraphicsGetImageFromCurrentImageContext()
}
func setUp3() {
let imgView:UIImageView = UIImageView(frame: CGRect(x: 0, y: 250, width: self.view.frame.width, height: 20))
self.view.addSubview(imgView)
UIGraphicsBeginImageContext(imgView.frame.size) // 位图上下文绘制区域 FlyElephant
imgView.image?.draw(in: imgView.bounds)
let context:CGContext = UIGraphicsGetCurrentContext()!
context.setLineCap(CGLineCap.square)
let lengths:[CGFloat] = [10,20] // 绘制 跳过 无限循环
context.setStrokeColor(UIColor.red.cgColor)
context.setLineWidth(2)
context.setLineDash(phase: 0, lengths: lengths)
context.move(to: CGPoint(x: 0, y: 10))
context.addLine(to: CGPoint(x: self.view.frame.width, y: 10))
context.strokePath()
context.setStrokeColor(UIColor.blue.cgColor)
context.setLineWidth(2)
context.setLineDash(phase: 0, lengths: lengths)
context.move(to: CGPoint(x: 15, y: 10))
context.addLine(to: CGPoint(x: self.view.frame.width, y: 10))
context.strokePath()
imgView.image = UIGraphicsGetImageFromCurrentImageContext()
}
func setUp4() {
let lineView:UIView = UIView(frame: CGRect(x: 0, y: 300, width: self.view.frame.width, height: 20))
self.view.addSubview(lineView)
let shapeLayer:CAShapeLayer = CAShapeLayer()
shapeLayer.bounds = lineView.bounds
shapeLayer.position = CGPoint(x: lineView.frame.width / 2, y: lineView.frame.height / 2)
shapeLayer.fillColor = UIColor.clear.cgColor
shapeLayer.strokeColor = UIColor.red.cgColor
shapeLayer.lineWidth = 5
shapeLayer.lineJoin = kCALineJoinRound
shapeLayer.lineDashPhase = 0
shapeLayer.lineDashPattern = [NSNumber(value: 10), NSNumber(value: 20)]
let path:CGMutablePath = CGMutablePath()
path.move(to: CGPoint(x: 0, y: 10))
path.addLine(to: CGPoint(x: lineView.frame.width, y: 10))
shapeLayer.path = path
lineView.layer.addSublayer(shapeLayer)
}
}
| mit | 0cb92b5a87fb7a65463a3b2523d4e3e2 | 32.181818 | 116 | 0.609863 | 4.517327 | false | false | false | false |
abelsanchezali/ViewBuilder | Source/Layout/View/ManualLayoutHelper.swift | 1 | 1530 | //
// ManualLayoutHelper.swift
// ViewBuilder
//
// Created by Abel Sanchez on 8/13/16.
// Copyright © 2016 Abel Sanchez. All rights reserved.
//
import UIKit
extension CGFloat {
public static let largeValue: CGFloat = 100000000
}
open class ManualLayoutHelper: NSObject {
open class func linearLayout(_ size: CGFloat, before: CGFloat, after: CGFloat, available: CGFloat, alignment: LayoutAlignment) -> (CGFloat, CGFloat) {
switch alignment {
case .minimum:
return (before, before + size)
case .maximum:
let start = available - size - after
return (start, start + size)
case .center:
let start = (available - size + before - after) * 0.5
return (start, start + size)
case .stretch:
return (before, available - after)
}
}
open class func fitViewInContainer(_ view: UIView, container: UIView, margin: UIEdgeInsets = UIEdgeInsets.zero) {
let margin = view.margin
view.translatesAutoresizingMaskIntoConstraints = true
view.autoresizesSubviews = true
view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
let bounds = container.bounds
let frame = CGRect(x: bounds.origin.x + margin.left,
y: bounds.origin.y + margin.top,
width: bounds.size.width - margin.totalWidth,
height: bounds.size.height - margin.totalHeight)
view.frame = frame
}
}
| mit | 99f607237f709e8ee7e4531185f7306b | 32.977778 | 154 | 0.609549 | 4.647416 | false | false | false | false |
Limon-O-O/Lego | Modules/Door/Door/Services/DoorUserDefaults.swift | 1 | 1594 | //
// DoorUserDefaults.swift
// Door
//
// Created by Limon on 27/02/2017.
// Copyright © 2017 Limon.F. All rights reserved.
//
import Foundation
import LegoContext
struct DoorUserDefaults {
fileprivate static let defaults = UserDefaults(suiteName: "top.limon.door")!
private init() {}
static func synchronize() {
defaults.synchronize()
}
static func clear() {
accessToken = nil
for key in defaults.dictionaryRepresentation().keys {
defaults.removeObject(forKey: key)
}
defaults.synchronize()
}
}
extension DoorUserDefaults {
fileprivate enum Keys: String {
case userID
case accessTokenV1
}
}
extension DoorUserDefaults {
static var didLogin: Bool {
return accessToken != nil && userID != nil
}
fileprivate static var _accessToken: String?
static var accessToken: String? {
get {
if _accessToken == nil {
_accessToken = defaults.string(forKey: Keys.accessTokenV1.rawValue)
}
return _accessToken
}
set {
_accessToken = newValue
defaults.set(newValue, forKey: Keys.accessTokenV1.rawValue)
LegoContext.accessToken = newValue
}
}
static var userID: Int? {
get {
let id = defaults.integer(forKey: Keys.userID.rawValue)
return id == 0 ? nil : id
}
set {
LegoContext.userID = newValue
defaults.set(newValue, forKey: Keys.userID.rawValue)
}
}
}
| mit | bd041346967ac6938217212239738664 | 20.527027 | 83 | 0.58506 | 4.727003 | false | false | false | false |
kaojohnny/CoreStore | Sources/ObjectiveC/CSOrderBy.swift | 1 | 3767 | //
// CSOrderBy.swift
// CoreStore
//
// Copyright © 2016 John Rommel Estropia
//
// 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 CoreData
// MARK: - CSOrderBy
/**
The `CSOrderBy` serves as the Objective-C bridging type for `OrderBy`.
- SeeAlso: `OrderBy`
*/
@objc
public final class CSOrderBy: NSObject, CSFetchClause, CSQueryClause, CSDeleteClause, CoreStoreObjectiveCType {
/**
The list of sort descriptors
*/
@objc
public var sortDescriptors: [NSSortDescriptor] {
return self.bridgeToSwift.sortDescriptors
}
/**
Initializes a `CSOrderBy` clause with a single sort descriptor
```
MyPersonEntity *people = [transaction
fetchAllFrom:CSFromClass([MyPersonEntity class])
fetchClauses:@[CSOrderByKey(CSSortAscending(@"fullname"))]]];
```
- parameter sortDescriptor: a `NSSortDescriptor`
*/
@objc
public convenience init(sortDescriptor: NSSortDescriptor) {
self.init(OrderBy(sortDescriptor))
}
/**
Initializes a `CSOrderBy` clause with a list of sort descriptors
```
MyPersonEntity *people = [transaction
fetchAllFrom:CSFromClass([MyPersonEntity class])
fetchClauses:@[CSOrderByKeys(CSSortAscending(@"fullname"), CSSortDescending(@"age"), nil))]]];
```
- parameter sortDescriptors: an array of `NSSortDescriptor`s
*/
@objc
public convenience init(sortDescriptors: [NSSortDescriptor]) {
self.init(OrderBy(sortDescriptors))
}
// MARK: NSObject
public override var hash: Int {
return self.bridgeToSwift.hashValue
}
public override func isEqual(object: AnyObject?) -> Bool {
guard let object = object as? CSOrderBy else {
return false
}
return self.bridgeToSwift == object.bridgeToSwift
}
public override var description: String {
return "(\(String(reflecting: self.dynamicType))) \(self.bridgeToSwift.coreStoreDumpString)"
}
// MARK: CSFetchClause, CSQueryClause, CSDeleteClause
@objc
public func applyToFetchRequest(fetchRequest: NSFetchRequest) {
self.bridgeToSwift.applyToFetchRequest(fetchRequest)
}
// MARK: CoreStoreObjectiveCType
public let bridgeToSwift: OrderBy
public init(_ swiftValue: OrderBy) {
self.bridgeToSwift = swiftValue
super.init()
}
}
// MARK: - OrderBy
extension OrderBy: CoreStoreSwiftType {
// MARK: CoreStoreSwiftType
public typealias ObjectiveCType = CSOrderBy
}
| mit | efc60ebce7ceb416f7673cd126d9accd | 27.530303 | 111 | 0.665959 | 5.075472 | false | false | false | false |
itsaboutcode/WordPress-iOS | WordPress/Classes/System/3DTouch/WP3DTouchShortcutCreator.swift | 1 | 8762 | import UIKit
import WordPressAuthenticator
public protocol ApplicationShortcutsProvider {
var shortcutItems: [UIApplicationShortcutItem]? { get set }
var is3DTouchAvailable: Bool { get }
}
extension UIApplication: ApplicationShortcutsProvider {
@objc public var is3DTouchAvailable: Bool {
return mainWindow?.traitCollection.forceTouchCapability == .available
}
}
open class WP3DTouchShortcutCreator: NSObject {
enum LoggedIn3DTouchShortcutIndex: Int {
case notifications = 0,
stats,
newPhotoPost,
newPost
}
var shortcutsProvider: ApplicationShortcutsProvider
@objc let mainContext = ContextManager.sharedInstance().mainContext
@objc let blogService: BlogService
fileprivate let logInShortcutIconImageName = "icon-shortcut-signin"
fileprivate let notificationsShortcutIconImageName = "icon-shortcut-notifications"
fileprivate let statsShortcutIconImageName = "icon-shortcut-stats"
fileprivate let newPhotoPostShortcutIconImageName = "icon-shortcut-new-photo"
fileprivate let newPostShortcutIconImageName = "icon-shortcut-new-post"
public init(shortcutsProvider: ApplicationShortcutsProvider) {
self.shortcutsProvider = shortcutsProvider
blogService = BlogService(managedObjectContext: mainContext)
super.init()
registerForNotifications()
}
public convenience override init() {
self.init(shortcutsProvider: UIApplication.shared)
}
@objc open func createShortcutsIf3DTouchAvailable(_ loggedIn: Bool) {
guard shortcutsProvider.is3DTouchAvailable else {
return
}
if loggedIn {
if hasBlog() {
createLoggedInShortcuts()
} else {
clearShortcuts()
}
} else {
createLoggedOutShortcuts()
}
}
fileprivate func registerForNotifications() {
let notificationCenter = NotificationCenter.default
notificationCenter.addObserver(self, selector: #selector(WP3DTouchShortcutCreator.createLoggedInShortcuts), name: NSNotification.Name(rawValue: WordPressAuthenticator.WPSigninDidFinishNotification), object: nil)
notificationCenter.addObserver(self, selector: #selector(WP3DTouchShortcutCreator.createLoggedInShortcuts), name: .WPRecentSitesChanged, object: nil)
notificationCenter.addObserver(self, selector: #selector(WP3DTouchShortcutCreator.createLoggedInShortcuts), name: .WPBlogUpdated, object: nil)
notificationCenter.addObserver(self, selector: #selector(WP3DTouchShortcutCreator.createLoggedInShortcuts), name: .WPAccountDefaultWordPressComAccountChanged, object: nil)
}
fileprivate func loggedOutShortcutArray() -> [UIApplicationShortcutItem] {
let logInShortcut = UIMutableApplicationShortcutItem(type: WP3DTouchShortcutHandler.ShortcutIdentifier.LogIn.type,
localizedTitle: NSLocalizedString("Log In", comment: "Log In 3D Touch Shortcut"),
localizedSubtitle: nil,
icon: UIApplicationShortcutIcon(templateImageName: logInShortcutIconImageName),
userInfo: [WP3DTouchShortcutHandler.applicationShortcutUserInfoIconKey: WP3DTouchShortcutHandler.ShortcutIdentifier.LogIn.rawValue as NSSecureCoding])
return [logInShortcut]
}
fileprivate func loggedInShortcutArray() -> [UIApplicationShortcutItem] {
var defaultBlogName: String?
if blogService.blogCountForAllAccounts() > 1 {
defaultBlogName = blogService.lastUsedOrFirstBlog()?.settings?.name
}
let notificationsShortcut = UIMutableApplicationShortcutItem(type: WP3DTouchShortcutHandler.ShortcutIdentifier.Notifications.type,
localizedTitle: NSLocalizedString("Notifications", comment: "Notifications 3D Touch Shortcut"),
localizedSubtitle: nil,
icon: UIApplicationShortcutIcon(templateImageName: notificationsShortcutIconImageName),
userInfo: [WP3DTouchShortcutHandler.applicationShortcutUserInfoIconKey: WP3DTouchShortcutHandler.ShortcutIdentifier.Notifications.rawValue as NSSecureCoding])
let statsShortcut = UIMutableApplicationShortcutItem(type: WP3DTouchShortcutHandler.ShortcutIdentifier.Stats.type,
localizedTitle: NSLocalizedString("Stats", comment: "Stats 3D Touch Shortcut"),
localizedSubtitle: defaultBlogName,
icon: UIApplicationShortcutIcon(templateImageName: statsShortcutIconImageName),
userInfo: [WP3DTouchShortcutHandler.applicationShortcutUserInfoIconKey: WP3DTouchShortcutHandler.ShortcutIdentifier.Stats.rawValue as NSSecureCoding])
let newPhotoPostShortcut = UIMutableApplicationShortcutItem(type: WP3DTouchShortcutHandler.ShortcutIdentifier.NewPhotoPost.type,
localizedTitle: NSLocalizedString("New Photo Post", comment: "New Photo Post 3D Touch Shortcut"),
localizedSubtitle: defaultBlogName,
icon: UIApplicationShortcutIcon(templateImageName: newPhotoPostShortcutIconImageName),
userInfo: [WP3DTouchShortcutHandler.applicationShortcutUserInfoIconKey: WP3DTouchShortcutHandler.ShortcutIdentifier.NewPhotoPost.rawValue as NSSecureCoding])
let newPostShortcut = UIMutableApplicationShortcutItem(type: WP3DTouchShortcutHandler.ShortcutIdentifier.NewPost.type,
localizedTitle: NSLocalizedString("New Post", comment: "New Post 3D Touch Shortcut"),
localizedSubtitle: defaultBlogName,
icon: UIApplicationShortcutIcon(templateImageName: newPostShortcutIconImageName),
userInfo: [WP3DTouchShortcutHandler.applicationShortcutUserInfoIconKey: WP3DTouchShortcutHandler.ShortcutIdentifier.NewPost.rawValue as NSSecureCoding])
return [notificationsShortcut, statsShortcut, newPhotoPostShortcut, newPostShortcut]
}
@objc fileprivate func createLoggedInShortcuts() {
DispatchQueue.main.async {[weak self]() in
guard let strongSelf = self else {
return
}
let entireShortcutArray = strongSelf.loggedInShortcutArray()
var visibleShortcutArray = [UIApplicationShortcutItem]()
if strongSelf.hasWordPressComAccount() {
visibleShortcutArray.append(entireShortcutArray[LoggedIn3DTouchShortcutIndex.notifications.rawValue])
}
if strongSelf.doesCurrentBlogSupportStats() {
visibleShortcutArray.append(entireShortcutArray[LoggedIn3DTouchShortcutIndex.stats.rawValue])
}
if AppConfiguration.allowsNewPostShortcut {
visibleShortcutArray.append(entireShortcutArray[LoggedIn3DTouchShortcutIndex.newPhotoPost.rawValue])
visibleShortcutArray.append(entireShortcutArray[LoggedIn3DTouchShortcutIndex.newPost.rawValue])
}
strongSelf.shortcutsProvider.shortcutItems = visibleShortcutArray
}
}
fileprivate func clearShortcuts() {
shortcutsProvider.shortcutItems = nil
}
fileprivate func createLoggedOutShortcuts() {
shortcutsProvider.shortcutItems = loggedOutShortcutArray()
}
fileprivate func is3DTouchAvailable() -> Bool {
let window = UIApplication.shared.mainWindow
return window?.traitCollection.forceTouchCapability == .available
}
fileprivate func hasWordPressComAccount() -> Bool {
return AccountHelper.isDotcomAvailable()
}
fileprivate func doesCurrentBlogSupportStats() -> Bool {
guard let currentBlog = blogService.lastUsedOrFirstBlog() else {
return false
}
return hasWordPressComAccount() && currentBlog.supports(BlogFeature.stats)
}
fileprivate func hasBlog() -> Bool {
return blogService.blogCountForAllAccounts() > 0
}
}
| gpl-2.0 | 981e11163e04d5fbfd8912ccb38042f4 | 51.467066 | 223 | 0.659438 | 6.931962 | false | false | false | false |
krzysztofzablocki/Sourcery | SourceryRuntime/Sources/FileParserResult.swift | 1 | 4507 | //
// FileParserResult.swift
// Sourcery
//
// Created by Krzysztof Zablocki on 11/01/2017.
// Copyright © 2017 Pixle. All rights reserved.
//
import Foundation
// sourcery: skipJSExport
/// :nodoc:
@objcMembers public final class FileParserResult: NSObject, SourceryModel {
public let path: String?
public let module: String?
public var types = [Type]() {
didSet {
types.forEach { type in
guard type.module == nil, type.kind != "extensions" else { return }
type.module = module
}
}
}
public var functions = [SourceryMethod]()
public var typealiases = [Typealias]()
public var inlineRanges = [String: NSRange]()
public var inlineIndentations = [String: String]()
public var modifiedDate: Date
public var sourceryVersion: String
var isEmpty: Bool {
types.isEmpty && functions.isEmpty && typealiases.isEmpty && inlineRanges.isEmpty && inlineIndentations.isEmpty
}
public init(path: String?, module: String?, types: [Type], functions: [SourceryMethod], typealiases: [Typealias] = [], inlineRanges: [String: NSRange] = [:], inlineIndentations: [String: String] = [:], modifiedDate: Date = Date(), sourceryVersion: String = "") {
self.path = path
self.module = module
self.types = types
self.functions = functions
self.typealiases = typealiases
self.inlineRanges = inlineRanges
self.inlineIndentations = inlineIndentations
self.modifiedDate = modifiedDate
self.sourceryVersion = sourceryVersion
types.forEach { type in type.module = module }
}
// sourcery:inline:FileParserResult.AutoCoding
/// :nodoc:
required public init?(coder aDecoder: NSCoder) {
self.path = aDecoder.decode(forKey: "path")
self.module = aDecoder.decode(forKey: "module")
guard let types: [Type] = aDecoder.decode(forKey: "types") else { NSException.raise(NSExceptionName.parseErrorException, format: "Key '%@' not found.", arguments: getVaList(["types"])); fatalError() }; self.types = types
guard let functions: [SourceryMethod] = aDecoder.decode(forKey: "functions") else { NSException.raise(NSExceptionName.parseErrorException, format: "Key '%@' not found.", arguments: getVaList(["functions"])); fatalError() }; self.functions = functions
guard let typealiases: [Typealias] = aDecoder.decode(forKey: "typealiases") else { NSException.raise(NSExceptionName.parseErrorException, format: "Key '%@' not found.", arguments: getVaList(["typealiases"])); fatalError() }; self.typealiases = typealiases
guard let inlineRanges: [String: NSRange] = aDecoder.decode(forKey: "inlineRanges") else { NSException.raise(NSExceptionName.parseErrorException, format: "Key '%@' not found.", arguments: getVaList(["inlineRanges"])); fatalError() }; self.inlineRanges = inlineRanges
guard let inlineIndentations: [String: String] = aDecoder.decode(forKey: "inlineIndentations") else { NSException.raise(NSExceptionName.parseErrorException, format: "Key '%@' not found.", arguments: getVaList(["inlineIndentations"])); fatalError() }; self.inlineIndentations = inlineIndentations
guard let modifiedDate: Date = aDecoder.decode(forKey: "modifiedDate") else { NSException.raise(NSExceptionName.parseErrorException, format: "Key '%@' not found.", arguments: getVaList(["modifiedDate"])); fatalError() }; self.modifiedDate = modifiedDate
guard let sourceryVersion: String = aDecoder.decode(forKey: "sourceryVersion") else { NSException.raise(NSExceptionName.parseErrorException, format: "Key '%@' not found.", arguments: getVaList(["sourceryVersion"])); fatalError() }; self.sourceryVersion = sourceryVersion
}
/// :nodoc:
public func encode(with aCoder: NSCoder) {
aCoder.encode(self.path, forKey: "path")
aCoder.encode(self.module, forKey: "module")
aCoder.encode(self.types, forKey: "types")
aCoder.encode(self.functions, forKey: "functions")
aCoder.encode(self.typealiases, forKey: "typealiases")
aCoder.encode(self.inlineRanges, forKey: "inlineRanges")
aCoder.encode(self.inlineIndentations, forKey: "inlineIndentations")
aCoder.encode(self.modifiedDate, forKey: "modifiedDate")
aCoder.encode(self.sourceryVersion, forKey: "sourceryVersion")
}
// sourcery:end
}
| mit | efb645b611b9337a644dcebab6c27967 | 56.769231 | 307 | 0.676209 | 4.951648 | false | false | false | false |
uhnmdi/CCContinuousGlucose | CCContinuousGlucose/Classes/ContinuousGlucoseSOCP.swift | 1 | 5096 | //
// ContinuousGlucoseSOCP.swift
// Pods
//
// Created by Kevin Tallevi on 4/19/17.
//
// https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.characteristic.cgm_specific_ops_control_point.xml
import Foundation
import CoreBluetooth
import CCBluetooth
public class ContinuousGlucoseSOCP : NSObject {
private let socpResponseOpCodeRange = NSRange(location:0, length: 1)
private let cgmCommunicationIntervalRange = NSRange(location:1, length: 1)
private let patientHighAlertLevelRange = NSRange(location:1, length: 2)
private let patientLowAlertLevelRange = NSRange(location:1, length: 2)
private let hypoAlertLevelRange = NSRange(location:1, length: 2)
private let hyperAlertLevelRange = NSRange(location:1, length: 2)
private let rateOfDecreaseAlertLevelRange = NSRange(location:1, length: 2)
private let rateOfIncreaseAlertLevelRange = NSRange(location:1, length: 2)
public var cgmCommunicationInterval: Int = 0
public var patientHighAlertLevel: UInt16 = 0
public var patientLowAlertLevel: UInt16 = 0
public var hypoAlertLevel: UInt16 = 0
public var hyperAlertLevel: UInt16 = 0
public var rateOfDecreaseAlertLevel: Float = 0
public var rateOfIncreaseAlertLevel: Float = 0
public var continuousGlucoseCalibration: ContinuousGlucoseCalibration!
enum Fields: Int {
case reserved,
setCGMCommunicationInterval,
getCGMCommunicationInterval,
cgmCommunicationIntervalResponse,
setGlucoseCalibrationValue,
getGlucoseCalibrationValue,
glucoseCalibrationValueResponse,
setPatientHighAlertLevel,
getPatientHighAlertLevel,
patientHighAlertLevelResponse,
setPatientLowAlertLevel,
getPatientLowAlertLevel,
patientLowAlertLevelResponse,
setHypoAlertLevel,
getHypoAlertLevel,
hypoAlertLevelResponse,
setHyperAlertLevel,
getHyperAlertLevel,
hyperAlertLevelResponse,
setRateOfDecreaseAlertLevel,
getRateOfDecreaseAlertLevel,
rateOfDecreaseAlertLevelResponse,
setRateOfIncreaseAlertLevel,
getRateOfIncreaseAlertLevel,
rateOfIncreaseAlertLevelResponse,
resetDeviceSpecificAlert,
startTheSession,
stopTheSession,
responseCode
}
public override init() {
super.init()
}
public func parseSOCP(data: NSData) {
let socpResponseType = (data.subdata(with: socpResponseOpCodeRange) as NSData!)
var socpResponse: Int = 0
socpResponseType?.getBytes(&socpResponse, length: 1)
switch (socpResponse) {
case ContinuousGlucoseSOCP.Fields.cgmCommunicationIntervalResponse.rawValue:
let communicationIntervalData = (data.subdata(with: cgmCommunicationIntervalRange) as NSData!)
communicationIntervalData?.getBytes(&self.cgmCommunicationInterval, length: 1)
return
case ContinuousGlucoseSOCP.Fields.glucoseCalibrationValueResponse.rawValue:
self.continuousGlucoseCalibration = ContinuousGlucoseCalibration(data: data)
return
case ContinuousGlucoseSOCP.Fields.patientHighAlertLevelResponse.rawValue:
let patientHighAlertLevelData = (data.subdata(with: patientHighAlertLevelRange) as NSData!)
patientHighAlertLevelData?.getBytes(&self.patientHighAlertLevel, length: 2)
return
case ContinuousGlucoseSOCP.Fields.patientLowAlertLevelResponse.rawValue:
let patientLowAlertLevelData = (data.subdata(with: patientLowAlertLevelRange) as NSData!)
patientLowAlertLevelData?.getBytes(&self.patientLowAlertLevel, length: 2)
return
case ContinuousGlucoseSOCP.Fields.hypoAlertLevelResponse.rawValue:
let hypoAlertLevelData = (data.subdata(with: hypoAlertLevelRange) as NSData!)
hypoAlertLevelData?.getBytes(&self.hypoAlertLevel, length: 2)
return
case ContinuousGlucoseSOCP.Fields.hyperAlertLevelResponse.rawValue:
let hyperAlertLevelData = (data.subdata(with: hyperAlertLevelRange) as NSData!)
hyperAlertLevelData?.getBytes(&self.hyperAlertLevel, length: 2)
return
case ContinuousGlucoseSOCP.Fields.rateOfDecreaseAlertLevelResponse.rawValue:
let rateOfDecreaseAlertLevelData = (data.subdata(with: rateOfDecreaseAlertLevelRange) as NSData!)
self.rateOfDecreaseAlertLevel = (rateOfDecreaseAlertLevelData?.shortFloatToFloat())!
return
case ContinuousGlucoseSOCP.Fields.rateOfIncreaseAlertLevelResponse.rawValue:
let rateOfIncreaseAlertLevelData = (data.subdata(with: rateOfIncreaseAlertLevelRange) as NSData!)
self.rateOfIncreaseAlertLevel = (rateOfIncreaseAlertLevelData?.shortFloatToFloat())!
return
default:
return
}
}
}
| mit | f384e6ea8fc9b3fdbb4fc73f259c3032 | 44.90991 | 136 | 0.7031 | 5.569399 | false | false | false | false |
muyang00/YEDouYuTV | YEDouYuZB/YEDouYuZB/Home/Controller/GameViewController.swift | 1 | 4640 | //
// GameViewController.swift
// YEDouYuZB
//
// Created by yongen on 17/2/10.
// Copyright © 2017年 yongen. All rights reserved.
//
import UIKit
private let kEdgeMargin : CGFloat = 10
private let kItemW : CGFloat = (kScreenW - 2 * kEdgeMargin) / 3
private let kItemH = kItemW * 6 / 5
private let kGameHeadViewH : CGFloat = 90
private let kGameCellID = "kGameCellID"
private let kHeaderViewID = "kHeaderViewID"
class GameViewController: BaseViewController {
fileprivate lazy var gameVM : GameViewModel = GameViewModel()
fileprivate lazy var collectionView : UICollectionView = {[unowned self] in
let layout = UICollectionViewFlowLayout()
layout.itemSize = CGSize(width: kItemW, height: kItemH)
layout.minimumLineSpacing = 0
layout.minimumInteritemSpacing = 0
layout.headerReferenceSize = CGSize(width: kScreenW, height: kGameHeadViewH)
layout.sectionInset = UIEdgeInsets(top: 0, left: kEdgeMargin, bottom: 0, right: kEdgeMargin)
let collectionView = UICollectionView(frame: self.view.bounds, collectionViewLayout: layout)
collectionView.backgroundColor = UIColor.white
collectionView.dataSource = self
collectionView.delegate = self
collectionView.autoresizingMask = [.flexibleHeight, .flexibleWidth]
collectionView.register(UINib(nibName: "CollectionGameCell", bundle: nil), forCellWithReuseIdentifier: kGameCellID)
collectionView.register(UINib(nibName: "CollectionHeaderView", bundle: nil), forSupplementaryViewOfKind: UICollectionElementKindSectionHeader, withReuseIdentifier: kHeaderViewID)
return collectionView
}()
fileprivate lazy var gameView : RecommendGameView = {
let gameView = RecommendGameView.recommedGameView()
gameView.frame = CGRect(x: 0, y: -kGameHeadViewH, width: kScreenW, height: kGameHeadViewH)
return gameView
}()
fileprivate lazy var topHeaderView : CollectionHeaderView = {
let topHeaderView = CollectionHeaderView.collectionHeaderView()
topHeaderView.frame = CGRect(x: 0, y: -(kGameHeadViewH + kHeaderViewH), width: kScreenW, height: kHeaderViewH)
topHeaderView.headIconImageView.image = UIImage(named: "Img_orange")
topHeaderView.headNameLabel.text = "常用"
topHeaderView.headMoreBtn.isHidden = true
return topHeaderView
}()
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
loadData()
}
}
//MARK: - 设置UI界面内容
extension GameViewController {
override func setupUI(){
contentView = collectionView
collectionView.contentInset = UIEdgeInsets(top: kGameHeadViewH + kHeaderViewH, left: 0, bottom: 0, right: 0)
view.addSubview(collectionView)
collectionView.addSubview(topHeaderView)
collectionView.addSubview(gameView)
super.setupUI()
}
}
//MARK: - 设置请求数据
extension GameViewController {
func loadData(){
gameVM.loadAllGameData {
self.collectionView.reloadData()
self.gameView.groups = Array(self.gameVM.games[0..<10])
self.loadDataFinished()
}
}
}
extension GameViewController : UICollectionViewDataSource {
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return self.gameVM.games.count
}
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
let cell = collectionView.dequeueReusableCell(withReuseIdentifier: kGameCellID, for: indexPath) as! CollectionGameCell
cell.baseGame = self.gameVM.games[indexPath.item]
return cell
}
func collectionView(_ collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, at indexPath: IndexPath) -> UICollectionReusableView {
// 1.取出HeaderView
let headerView = collectionView.dequeueReusableSupplementaryView(ofKind: kind, withReuseIdentifier: kHeaderViewID, for: indexPath) as! CollectionHeaderView
// 2.给HeaderView设置属性
headerView.headNameLabel.text = "全部"
headerView.headIconImageView.image = UIImage(named: "Img_orange")
headerView.headMoreBtn.isHidden = true
return headerView
}
}
extension GameViewController : UICollectionViewDelegate {
func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
print("GameViewController ---- ", indexPath)
}
}
| apache-2.0 | 45b2f2c1513f7a8595e42f9c93c3c980 | 37.579832 | 186 | 0.703115 | 5.504796 | false | false | false | false |
apple/swift-corelibs-foundation | Sources/FoundationNetworking/URLSession/HTTP/HTTPMessage.swift | 1 | 26755 | // Foundation/URLSession/HTTPMessage.swift - HTTP Message parsing
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
// -----------------------------------------------------------------------------
///
/// Helpers for parsing HTTP responses.
/// These are libcurl helpers for the URLSession API code.
/// - SeeAlso: https://curl.haxx.se/libcurl/c/
/// - SeeAlso: URLSession.swift
///
// -----------------------------------------------------------------------------
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import SwiftFoundation
#else
import Foundation
#endif
@_implementationOnly import CoreFoundation
internal extension _HTTPURLProtocol._ResponseHeaderLines {
/// Create an `NSHTTPRULResponse` from the lines.
///
/// This will parse the header lines.
/// - Returns: `nil` if an error occurred while parsing the header lines.
func createHTTPURLResponse(for URL: URL) -> HTTPURLResponse? {
guard let message = createHTTPMessage() else { return nil }
return HTTPURLResponse(message: message, URL: URL)
}
/// Parse the lines into a `_HTTPURLProtocol.HTTPMessage`.
func createHTTPMessage() -> _HTTPURLProtocol._HTTPMessage? {
guard let (head, tail) = lines.decompose else { return nil }
guard let startline = _HTTPURLProtocol._HTTPMessage._StartLine(line: head) else { return nil }
guard let headers = createHeaders(from: tail) else { return nil }
return _HTTPURLProtocol._HTTPMessage(startLine: startline, headers: headers)
}
}
extension HTTPURLResponse {
fileprivate convenience init?(message: _HTTPURLProtocol._HTTPMessage, URL: URL) {
/// This needs to be a request, i.e. it needs to have a status line.
guard case .statusLine(let version, let status, _) = message.startLine else { return nil }
let fields = message.headersAsDictionary
self.init(url: URL, statusCode: status, httpVersion: version.rawValue, headerFields: fields)
}
}
extension _HTTPURLProtocol {
/// HTTP Message
///
/// A message consist of a *start-line* optionally followed by one or multiple
/// message-header lines, and optionally a message body.
///
/// This represents everything except for the message body.
///
/// - SeeAlso: https://tools.ietf.org/html/rfc2616#section-4
struct _HTTPMessage {
let startLine: _HTTPURLProtocol._HTTPMessage._StartLine
let headers: [_HTTPURLProtocol._HTTPMessage._Header]
}
}
extension _HTTPURLProtocol._HTTPMessage {
var headersAsDictionary: [String: String] {
var result: [String: String] = [:]
headers.forEach {
if result[$0.name] == nil {
result[$0.name] = $0.value
}
else {
result[$0.name]! += (", " + $0.value)
}
}
return result
}
}
extension _HTTPURLProtocol._HTTPMessage {
/// A single HTTP message header field
///
/// Most HTTP messages have multiple header fields.
struct _Header {
let name: String
let value: String
}
/// The first line of a HTTP message
///
/// This can either be the *request line* (RFC 2616 Section 5.1) or the
/// *status line* (RFC 2616 Section 6.1)
enum _StartLine {
/// RFC 2616 Section 5.1 *Request Line*
/// - SeeAlso: https://tools.ietf.org/html/rfc2616#section-5.1
case requestLine(method: String, uri: URL, version: _HTTPURLProtocol._HTTPMessage._Version)
/// RFC 2616 Section 6.1 *Status Line*
/// - SeeAlso: https://tools.ietf.org/html/rfc2616#section-6.1
case statusLine(version: _HTTPURLProtocol._HTTPMessage._Version, status: Int, reason: String)
}
/// A HTTP version, e.g. "HTTP/1.1"
struct _Version: RawRepresentable {
let rawValue: String
}
/// An authentication challenge parsed from `WWW-Authenticate` header field.
///
/// Only parts necessary for Basic auth scheme are implemented at the moment.
/// - SeeAlso: https://tools.ietf.org/html/rfc7235#section-4.1
struct _Challenge {
static let AuthSchemeBasic = "basic"
static let AuthSchemeDigest = "digest"
/// A single auth challenge parameter
struct _AuthParameter {
let name: String
let value: String
}
let authScheme: String
let authParameters: [_AuthParameter]
}
}
extension _HTTPURLProtocol._HTTPMessage._Version {
init?(versionString: String) {
rawValue = versionString
}
}
extension _HTTPURLProtocol._HTTPMessage._Challenge {
/// Case-insensitively searches for auth parameter with specified name
func parameter(withName name: String) -> _AuthParameter? {
return authParameters.first { $0.name.caseInsensitiveCompare(name) == .orderedSame }
}
}
extension _HTTPURLProtocol._HTTPMessage._Challenge {
/// Creates authentication challenges from provided `HTTPURLResponse`.
///
/// The value of `WWW-Authenticate` field is used for parsing authentication challenges
/// of supported type.
///
/// - note: `Basic` is the only supported scheme at the moment.
/// - parameter response: A response to get header value from.
/// - returns: An array of supported challenges found in response.
/// # Reference
/// - [RFC 7235 - Hypertext Transfer Protocol (HTTP/1.1): Authentication](https://tools.ietf.org/html/rfc7235)
/// - [RFC 7617 - The 'Basic' HTTP Authentication Scheme](https://tools.ietf.org/html/rfc7617)
static func challenges(from response: HTTPURLResponse) -> [_HTTPURLProtocol._HTTPMessage._Challenge] {
guard let authenticateValue = response.value(forHTTPHeaderField: "WWW-Authenticate") else {
return []
}
return challenges(from: authenticateValue)
}
/// Creates authentication challenges from provided field value.
///
/// Field value is expected to conform [RFC 7235 Section 4.1](https://tools.ietf.org/html/rfc7235#section-4.1)
/// as much as needed to define supported authorization schemes.
///
/// - note: `Basic` is the only supported scheme at the moment.
/// - parameter authenticateFieldValue: A value of `WWW-Authenticate` field
/// - returns: array of supported challenges found.
/// # Reference
/// - [RFC 7235 - Hypertext Transfer Protocol (HTTP/1.1): Authentication](https://tools.ietf.org/html/rfc7235)
/// - [RFC 7617 - The 'Basic' HTTP Authentication Scheme](https://tools.ietf.org/html/rfc7617)
static func challenges(from authenticateFieldValue: String) -> [_HTTPURLProtocol._HTTPMessage._Challenge] {
var challenges = [_HTTPURLProtocol._HTTPMessage._Challenge]()
// Typical WWW-Authenticate header is something like
// WWWW-Authenticate: Digest realm="test", domain="/HTTP/Digest", nonce="e3d002b9b2080453fdacea2d89f2d102"
//
// https://tools.ietf.org/html/rfc7235#section-4.1
// WWW-Authenticate = 1#challenge
//
// https://tools.ietf.org/html/rfc7235#section-2.1
// challenge = auth-scheme [ 1*SP ( token68 / #auth-param ) ]
// auth-scheme = token
// auth-param = token BWS "=" BWS ( token / quoted-string )
// token68 = 1*( ALPHA / DIGIT /
// "-" / "." / "_" / "~" / "+" / "/" ) *"="
//
// https://tools.ietf.org/html/rfc7230#section-3.2.3
// OWS = *( SP / HTAB ) ; optional whitespace
// BWS = OWS ; "bad" whitespace
//
// https://tools.ietf.org/html/rfc7230#section-3.2.6
// token = 1*tchar
// tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*"
// / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
// / DIGIT / ALPHA
// ; any VCHAR, except delimiters
// quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
// qdtext = HTAB / SP /%x21 / %x23-5B / %x5D-7E / obs-text
// obs-text = %x80-FF
// quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
//
// https://tools.ietf.org/html/rfc5234#appendix-B.1
// ALPHA = %x41-5A / %x61-7A ; A-Z / a-z
// SP = %x20
// HTAB = %x09 ; horizontal tab
// VCHAR = %x21-7E ; visible (printing) characters
// DQUOTE = %x22
// DIGIT = %x30-39 ; 0-9
var authenticateView = authenticateFieldValue.unicodeScalars[...]
// Do an "eager" search of supported auth schemes. Same as it implemented in CURL.
// This means we will look after every comma on every step, no matter what was
// (or wasn't) parsed on previous step.
//
// WWW-Authenticate field could contain some sort of ambiguity, because, in general,
// it is a comma-separated list of comma-separated lists. As mentioned
// in https://tools.ietf.org/html/rfc7235#section-4.1, user agents are advised to
// take special care of parsing all challenges completely.
while !authenticateView.isEmpty {
guard let authSchemeRange = authenticateView.rangeOfTokenPrefix else {
break
}
let authScheme = String(authenticateView[authSchemeRange])
if authScheme.caseInsensitiveCompare(AuthSchemeBasic) == .orderedSame {
let authDataView = authenticateView[authSchemeRange.upperBound...]
let authParameters = _HTTPURLProtocol._HTTPMessage._Challenge._AuthParameter.parameters(from: authDataView)
let challenge = _HTTPURLProtocol._HTTPMessage._Challenge(authScheme: authScheme, authParameters: authParameters)
// "realm" is the only mandatory parameter for Basic auth scheme. Otherwise consider parsed data invalid.
if challenge.parameter(withName: "realm") != nil {
challenges.append(challenge)
}
}
// read up to the next comma
guard let commaIndex = authenticateView.firstIndex(of: _Delimiters.Comma) else {
break
}
// skip comma
authenticateView = authenticateView[authenticateView.index(after: commaIndex)...]
// consume spaces
authenticateView = authenticateView.trimSPPrefix
}
return challenges
}
}
private extension _HTTPURLProtocol._HTTPMessage._Challenge._AuthParameter {
/// Reads authorization challenge parameters from provided Unicode Scalar view
static func parameters(from parametersView: String.UnicodeScalarView.SubSequence) -> [_HTTPURLProtocol._HTTPMessage._Challenge._AuthParameter] {
var parametersView = parametersView
var parameters = [_HTTPURLProtocol._HTTPMessage._Challenge._AuthParameter]()
while true {
parametersView = parametersView.trimSPPrefix
guard let parameter = parameter(from: ¶metersView) else {
break
}
parameters.append(parameter)
// trim spaces and expect comma
parametersView = parametersView.trimSPPrefix
guard parametersView.first == _Delimiters.Comma else {
break
}
// drop comma
parametersView = parametersView.dropFirst()
}
return parameters
}
/// Reads a single challenge parameter from provided Unicode Scalar view
private static func parameter(from parametersView: inout String.UnicodeScalarView.SubSequence) -> _HTTPURLProtocol._HTTPMessage._Challenge._AuthParameter? {
// Read parameter name. Return nil if name is not readable.
guard let parameterName = parameterName(from: ¶metersView) else {
return nil
}
// Trim BWS, expect '='
parametersView = parametersView.trimSPHTPrefix ?? parametersView
guard parametersView.first == _Delimiters.Equals else {
return nil
}
// Drop '='
parametersView = parametersView.dropFirst()
// Read parameter value. Return nil if parameter is not readable.
guard let parameterValue = parameterValue(from: ¶metersView) else {
return nil
}
return _HTTPURLProtocol._HTTPMessage._Challenge._AuthParameter(name: parameterName, value: parameterValue)
}
/// Reads a challenge parameter name from provided Unicode Scalar view
private static func parameterName(from nameView: inout String.UnicodeScalarView.SubSequence) -> String? {
guard let nameRange = nameView.rangeOfTokenPrefix else {
return nil
}
let name = String(nameView[nameRange])
nameView = nameView[nameRange.upperBound...]
return name
}
/// Reads a challenge parameter value from provided Unicode Scalar view
private static func parameterValue(from valueView: inout String.UnicodeScalarView.SubSequence) -> String? {
// Trim BWS
valueView = valueView.trimSPHTPrefix ?? valueView
if valueView.first == _Delimiters.DoubleQuote {
// quoted-string
if let valueRange = valueView.rangeOfQuotedStringPrefix {
let value = valueView[valueRange].dequotedString()
valueView = valueView[valueRange.upperBound...]
return value
}
}
else {
// token
if let valueRange = valueView.rangeOfTokenPrefix {
let value = String(valueView[valueRange])
valueView = valueView[valueRange.upperBound...]
return value
}
}
return nil
}
}
private extension _HTTPURLProtocol._HTTPMessage._StartLine {
init?(line: String) {
guard let r = line.splitRequestLine() else { return nil }
if let version = _HTTPURLProtocol._HTTPMessage._Version(versionString: r.0) {
// Status line:
guard let status = Int(r.1), 100 <= status && status <= 999 else { return nil }
self = .statusLine(version: version, status: status, reason: r.2)
} else if let version = _HTTPURLProtocol._HTTPMessage._Version(versionString: r.2),
let URI = URL(string: r.1) {
// The request method must be a token (i.e. without separators):
let separatorIdx = r.0.unicodeScalars.firstIndex(where: { !$0.isValidMessageToken } )
guard separatorIdx == nil else { return nil }
self = .requestLine(method: r.0, uri: URI, version: version)
} else {
return nil
}
}
}
private extension String {
/// Split a request line into its 3 parts: *Method*, *Request-URI*, and *HTTP-Version*.
/// - SeeAlso: https://tools.ietf.org/html/rfc2616#section-5.1
func splitRequestLine() -> (String, String, String)? {
let scalars = self.unicodeScalars[...]
guard let firstSpace = scalars.rangeOfSpace else { return nil }
let remainingRange = firstSpace.upperBound..<scalars.endIndex
let remainder = scalars[remainingRange]
guard let secondSpace = remainder.rangeOfSpace else { return nil }
let methodRange = scalars.startIndex..<firstSpace.lowerBound
let uriRange = remainder.startIndex..<secondSpace.lowerBound
let versionRange = secondSpace.upperBound..<remainder.endIndex
//TODO: is this necessary? If yes, this guard needs an alternate implementation
//guard 0 < methodRange.count && 0 < uriRange.count && 0 < versionRange.count else { return nil }
let m = String(scalars[methodRange])
let u = String(remainder[uriRange])
let v = String(remainder[versionRange])
return (m, u, v)
}
}
/// Parses an array of lines into an array of
/// `URLSessionTask.HTTPMessage.Header`.
///
/// This respects the header folding as described by
/// https://tools.ietf.org/html/rfc2616#section-2.2 :
///
/// - SeeAlso: `_HTTPURLProtocol.HTTPMessage.Header.createOne(from:)`
private func createHeaders(from lines: ArraySlice<String>) -> [_HTTPURLProtocol._HTTPMessage._Header]? {
var headerLines = Array(lines)
var headers: [_HTTPURLProtocol._HTTPMessage._Header] = []
while !headerLines.isEmpty {
guard let (header, remaining) = _HTTPURLProtocol._HTTPMessage._Header.createOne(from: headerLines) else { return nil }
headers.append(header)
headerLines = remaining
}
return headers
}
private extension _HTTPURLProtocol._HTTPMessage._Header {
/// Parse a single HTTP message header field
///
/// Each header field consists
/// of a name followed by a colon (":") and the field value. Field names
/// are case-insensitive. The field value MAY be preceded by any amount
/// of LWS, though a single SP is preferred. Header fields can be
/// extended over multiple lines by preceding each extra line with at
/// least one SP or HT. Applications ought to follow "common form", where
/// one is known or indicated, when generating HTTP constructs, since
/// there might exist some implementations that fail to accept anything
/// beyond the common forms.
///
/// Consumes lines from the given array of lines to produce a single HTTP
/// message header and returns the resulting header plus the remainder.
///
/// If an error occurs, it returns `nil`.
///
/// - SeeAlso: https://tools.ietf.org/html/rfc2616#section-4.2
static func createOne(from lines: [String]) -> (_HTTPURLProtocol._HTTPMessage._Header, [String])? {
// HTTP/1.1 header field values can be folded onto multiple lines if the
// continuation line begins with a space or horizontal tab. All linear
// white space, including folding, has the same semantics as SP. A
// recipient MAY replace any linear white space with a single SP before
// interpreting the field value or forwarding the message downstream.
guard let (head, tail) = lines.decompose else { return nil }
let headView = head.unicodeScalars[...]
guard let nameRange = headView.rangeOfTokenPrefix else { return nil }
guard headView.index(after: nameRange.upperBound) <= headView.endIndex && headView[nameRange.upperBound] == _Delimiters.Colon else { return nil }
let name = String(headView[nameRange])
var value: String?
let line = headView[headView.index(after: nameRange.upperBound)..<headView.endIndex]
if !line.isEmpty {
if line.hasSPHTPrefix && line.count == 1 {
// to handle empty headers i.e header without value
value = ""
} else {
guard let v = line.trimSPHTPrefix else { return nil }
value = String(v)
}
}
do {
var t = tail
while t.first?.unicodeScalars[...].hasSPHTPrefix ?? false {
guard let (h2, t2) = t.decompose else { return nil }
t = t2
guard let v = h2.unicodeScalars[...].trimSPHTPrefix else { return nil }
let valuePart = String(v)
value = value.map { $0 + " " + valuePart } ?? valuePart
}
return (_HTTPURLProtocol._HTTPMessage._Header(name: name, value: value ?? ""), Array(t))
}
}
}
private extension Collection {
/// Splits the collection into its first element and the remainder.
var decompose: (Iterator.Element, Self.SubSequence)? {
guard let head = self.first else { return nil }
let tail = self[self.index(after: startIndex)..<endIndex]
return (head, tail)
}
}
private extension String.UnicodeScalarView.SubSequence {
/// The range of *Token* characters as specified by RFC 2616.
var rangeOfTokenPrefix: Range<Index>? {
guard !isEmpty else { return nil }
var end = startIndex
while self[end].isValidMessageToken {
end = self.index(after: end)
}
guard end != startIndex else { return nil }
return startIndex..<end
}
/// The range of space (U+0020) characters.
var rangeOfSpace: Range<Index>? {
guard !isEmpty else { return startIndex..<startIndex }
guard let idx = firstIndex(of: _Delimiters.Space!) else { return nil }
return idx..<self.index(after: idx)
}
// Has a space (SP) or horizontal tab (HT) prefix
var hasSPHTPrefix: Bool {
guard !isEmpty else { return false }
return self[startIndex] == _Delimiters.Space || self[startIndex] == _Delimiters.HorizontalTab
}
/// Unicode scalars after removing the leading spaces (SP) and horizontal tabs (HT).
/// Returns `nil` if the unicode scalars do not start with a SP or HT.
var trimSPHTPrefix: SubSequence? {
guard !isEmpty else { return nil }
var idx = startIndex
while idx < endIndex {
if self[idx] == _Delimiters.Space || self[idx] == _Delimiters.HorizontalTab {
idx = self.index(after: idx)
} else {
guard startIndex < idx else { return nil }
return self[idx..<endIndex]
}
}
return nil
}
var trimSPPrefix: SubSequence {
var idx = startIndex
while idx < endIndex {
if self[idx] == _Delimiters.Space {
idx = self.index(after: idx)
} else {
return self[idx..<endIndex]
}
}
return self
}
/// Returns range of **quoted-string** starting from first index of sequence.
///
/// - returns: range of **quoted-string** or `nil` if value can not be parsed.
var rangeOfQuotedStringPrefix: Range<Index>? {
// quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
// qdtext = HTAB / SP /%x21 / %x23-5B / %x5D-7E / obs-text
// obs-text = %x80-FF
// quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
guard !isEmpty else {
return nil
}
var idx = startIndex
// Expect and consume dquote
guard self[idx] == _Delimiters.DoubleQuote else {
return nil
}
idx = self.index(after: idx)
var isQuotedPair = false
while idx < endIndex {
let currentScalar = self[idx]
if currentScalar == _Delimiters.Backslash && !isQuotedPair {
isQuotedPair = true
} else if isQuotedPair {
guard currentScalar.isQuotedPairEscapee else {
return nil
}
isQuotedPair = false
} else if currentScalar == _Delimiters.DoubleQuote {
break
} else {
guard currentScalar.isQdtext else {
return nil
}
}
idx = self.index(after: idx)
}
// Expect stop on dquote
guard idx < endIndex, self[idx] == _Delimiters.DoubleQuote else {
return nil
}
return startIndex..<self.index(after: idx)
}
/// Returns dequoted string if receiver contains **quoted-string**
///
/// - returns: dequoted string or `nil` if receiver does not contain valid quoted string
func dequotedString() -> String? {
guard !isEmpty else {
return nil
}
var resultView = String.UnicodeScalarView()
resultView.reserveCapacity(self.count)
var idx = startIndex
// Expect and consume dquote
guard self[idx] == _Delimiters.DoubleQuote else {
return nil
}
idx = self.index(after: idx)
var isQuotedPair = false
while idx < endIndex {
let currentScalar = self[idx]
if currentScalar == _Delimiters.Backslash && !isQuotedPair {
isQuotedPair = true
} else if isQuotedPair {
guard currentScalar.isQuotedPairEscapee else {
return nil
}
isQuotedPair = false
resultView.append(currentScalar)
} else if currentScalar == _Delimiters.DoubleQuote {
break
} else {
guard currentScalar.isQdtext else {
return nil
}
resultView.append(currentScalar)
}
idx = self.index(after: idx)
}
// Expect stop on dquote
guard idx < endIndex, self[idx] == _Delimiters.DoubleQuote else {
return nil
}
return String(resultView)
}
}
private extension UnicodeScalar {
/// Is this a valid **token** as defined by RFC 2616 ?
///
/// - SeeAlso: https://tools.ietf.org/html/rfc2616#section-2
var isValidMessageToken: Bool {
guard UnicodeScalar(32) <= self && self <= UnicodeScalar(126) else { return false }
return !_Delimiters.Separators.characterIsMember(UInt16(self.value))
}
/// Is this a valid **qdtext** character
///
/// - SeeAlso: https://tools.ietf.org/html/rfc7230#section-3.2.6
var isQdtext: Bool {
// qdtext = HTAB / SP /%x21 / %x23-5B / %x5D-7E / obs-text
// obs-text = %x80-FF
let value = self.value
return self == _Delimiters.HorizontalTab
|| self == _Delimiters.Space
|| value == 0x21
|| 0x23 <= value && value <= 0x5B
|| 0x5D <= value && value <= 0x7E
|| 0x80 <= value && value <= 0xFF
}
/// Is this a valid second octet of **quoted-pair**
///
/// - SeeAlso: https://tools.ietf.org/html/rfc7230#section-3.2.6
/// - SeeAlso: https://tools.ietf.org/html/rfc5234#appendix-B.1
var isQuotedPairEscapee: Bool {
// quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
// obs-text = %x80-FF
let value = self.value
return self == _Delimiters.HorizontalTab
|| self == _Delimiters.Space
|| 0x21 <= value && value <= 0x7E
|| 0x80 <= value && value <= 0xFF
}
}
| apache-2.0 | a62498f0239cf277997da1613fe21e66 | 43.517471 | 160 | 0.599178 | 4.653043 | false | false | false | false |
MillmanY/MMPlayerView | MMPlayerView/Classes/Subtitles/MMSubtitleSetting.swift | 1 | 2021 | //
// MMSubtitleSetting.swift
// MMPlayerView
//
// Created by Millman on 2019/12/18.
//
import UIKit
public protocol MMSubtitleSettingProtocol: class {
func setting(_ mmsubtitleSetting: MMSubtitleSetting, fontChange: UIFont)
func setting(_ mmsubtitleSetting: MMSubtitleSetting, textColorChange: UIColor)
func setting(_ mmsubtitleSetting: MMSubtitleSetting, labelEdgeChange: (bottom: CGFloat, left: CGFloat, right: CGFloat))
func setting(_ mmsubtitleSetting: MMSubtitleSetting, typeChange: MMSubtitleSetting.SubtitleType?)
}
extension MMSubtitleSetting {
public enum SubtitleType {
case srt(info: String)
}
}
public class MMSubtitleSetting: NSObject {
weak var delegate: MMSubtitleSettingProtocol?
public init(delegate: MMSubtitleSettingProtocol) {
self.delegate = delegate
}
var subtitleObj: AnyObject?
public var defaultFont: UIFont = UIFont.systemFont(ofSize: 17) {
didSet {
self.delegate?.setting(self, fontChange: defaultFont)
}
}
public var defaultTextColor: UIColor = UIColor.white {
didSet {
self.delegate?.setting(self, textColorChange: defaultTextColor)
}
}
public var defaultTextBackground: UIColor = UIColor.clear {
didSet {
}
}
public var defaultLabelEdge: (bottom: CGFloat, left: CGFloat, right: CGFloat) = (20,10,10) {
didSet {
self.delegate?.setting(self, labelEdgeChange: defaultLabelEdge)
}
}
public var subtitleType: SubtitleType? {
didSet {
guard let type = self.subtitleType else {
subtitleObj = nil
subtitleType = nil
return
}
switch type {
case .srt(let info):
let obj = SubtitleConverter(SRT())
obj.parseText(info)
subtitleObj = obj
}
self.delegate?.setting(self, typeChange: subtitleType)
}
}
}
| mit | 882247b41c978998b02a5445b47d83a6 | 29.621212 | 123 | 0.626917 | 4.990123 | false | false | false | false |
roambotics/swift | test/ConstExtraction/fields.swift | 2 | 3580 | // RUN: %empty-directory(%t)
// RUN: %empty-directory(%t/inputs)
// RUN: echo "[MyProto]" > %t/inputs/protocols.json
// RUN: %target-swift-frontend -typecheck -emit-const-values-path %t/fields.swiftconstvalues -const-gather-protocols-file %t/inputs/protocols.json -primary-file %s
// RUN: cat %t/fields.swiftconstvalues 2>&1 | %FileCheck %s
// CHECK: [
// CHECK-NEXT: {
// CHECK-NEXT: "typeName": "fields.Foo",
// CHECK-NEXT: "kind": "struct",
// CHECK-NEXT: "properties": [
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p1",
// CHECK-NEXT: "type": "Swift.String",
// CHECK-NEXT: "isStatic": "false",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "\"Hello, World\""
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p5",
// CHECK-NEXT: "type": "[Swift.Int]",
// CHECK-NEXT: "isStatic": "false",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p6",
// CHECK-NEXT: "type": "Swift.Bool",
// CHECK-NEXT: "isStatic": "false",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "false"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p7",
// CHECK-NEXT: "type": "Swift.Bool?",
// CHECK-NEXT: "isStatic": "false",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "nil"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p8",
// CHECK-NEXT: "type": "(Swift.Int, Swift.Float)",
// CHECK-NEXT: "isStatic": "false",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "(42, 6.6)"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p9",
// CHECK-NEXT: "type": "[Swift.String : Swift.Int]",
// CHECK-NEXT: "isStatic": "false",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "[(\"One\", 1), (\"Two\", 2), (\"Three\", 3)]"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p0",
// CHECK-NEXT: "type": "Swift.Int",
// CHECK-NEXT: "isStatic": "true",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "11"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p2",
// CHECK-NEXT: "type": "Swift.Float",
// CHECK-NEXT: "isStatic": "true",
// CHECK-NEXT: "isComputed": "false",
// CHECK-NEXT: "value": "42.2"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p3",
// CHECK-NEXT: "type": "Swift.Int",
// CHECK-NEXT: "isStatic": "false",
// CHECK-NEXT: "isComputed": "true",
// CHECK-NEXT: "value": "Unknown"
// CHECK-NEXT: },
// CHECK-NEXT: {
// CHECK-NEXT: "label": "p4",
// CHECK-NEXT: "type": "Swift.Int",
// CHECK-NEXT: "isStatic": "true",
// CHECK-NEXT: "isComputed": "true",
// CHECK-NEXT: "value": "Unknown"
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT:]
protocol MyProto {}
public struct Foo {
static _const let p0: Int = 11
let p1: String = "Hello, World"
static let p2: Float = 42.2
var p3: Int {3}
static var p4: Int {3}
let p5: [Int] = [1,2,3,4,5,6,7,8,9]
let p6: Bool = false
let p7: Bool? = nil
let p8: (Int, Float) = (42, 6.6)
let p9: [String: Int] = ["One": 1, "Two": 2, "Three": 3]
}
extension Foo : MyProto {}
| apache-2.0 | b58197bfdd3fd37188da70215ae6d5f0 | 34.098039 | 163 | 0.505587 | 2.89644 | false | false | false | false |
roambotics/swift | test/SourceKit/Diagnostics/diags.swift | 2 | 1718 | // Use -print-raw-response on the first request so we don't wait for semantic info which will never come.
// RUN: %sourcekitd-test -req=open %s -req-opts=syntactic_only=1 -print-raw-response -- %s == \
// RUN: -req=stats == \
// RUN: -req=diags %s -print-raw-response -- %s == \
// RUN: -req=stats == \
// RUN: -req=diags %s -print-raw-response -- %s == \
// RUN: -req=stats | %FileCheck %s
func foo(y: String) {
foo(y: 1)
}
// We shouldn't build an AST for the syntactic open
// CHECK: 0 {{.*}} source.statistic.num-ast-builds
// Retrieving diagnostics should work
// CHECK: {
// CHECK: key.diagnostics: [
// CHECK: {
// CHECK: key.line: 10,
// CHECK: key.column: 10,
// CHECK: key.filepath: "{{.*}}",
// CHECK: key.severity: source.diagnostic.severity.error,
// CHECK: key.id: "cannot_convert_argument_value",
// CHECK: key.description: "cannot convert value of type 'Int' to expected argument type 'String'"
// CHECK: }
// CHECK: ]
// CHECK: }
// ... and we should have built an AST for it
// CHECK: 1 {{.*}} source.statistic.num-ast-builds
// Retrieving diagnostics again should work
// CHECK: {
// CHECK: key.diagnostics: [
// CHECK: {
// CHECK: key.line: 10,
// CHECK: key.column: 10,
// CHECK: key.filepath: "{{.*}}",
// CHECK: key.severity: source.diagnostic.severity.error,
// CHECK: key.id: "cannot_convert_argument_value",
// CHECK: key.description: "cannot convert value of type 'Int' to expected argument type 'String'"
// CHECK: }
// CHECK: ]
// CHECK: }
// ... but we shouldn't rebuild an AST
// CHECK: 1 {{.*}} source.statistic.num-ast-builds
// CHECK: 1 {{.*}} source.statistic.num-ast-cache-hits
| apache-2.0 | fcd15163610194e6c7b46fee589a2839 | 34.061224 | 105 | 0.611176 | 3.247637 | false | false | false | false |
cohena100/Shimi | Carthage/Checkouts/Action/Tests/ActionTests/AlertActionTests.swift | 1 | 2551 | import Quick
import Nimble
import RxSwift
import RxBlocking
import Action
class AlertActionTests: QuickSpec {
override func spec() {
it("is nil by default") {
let subject = UIAlertAction.Action("Hi", style: .default)
expect(subject.rx.action).to( beNil() )
}
it("respects setter") {
var subject = UIAlertAction.Action("Hi", style: .default)
let action = emptyAction()
subject.rx.action = action
expect(subject.rx.action) === action
}
it("disables the alert action while executing") {
var subject = UIAlertAction.Action("Hi", style: .default)
var observer: AnyObserver<Void>!
let action = CocoaAction(workFactory: { _ in
return Observable.create { (obsv) -> Disposable in
observer = obsv
return Disposables.create()
}
})
subject.rx.action = action
action.execute()
expect(subject.isEnabled).toEventually( beFalse() )
observer.onCompleted()
expect(subject.isEnabled).toEventually( beTrue() )
}
it("disables the alert action if the Action is disabled") {
var subject = UIAlertAction.Action("Hi", style: .default)
let disposeBag = DisposeBag()
subject.rx.action = emptyAction(.just(false))
waitUntil { done in
subject.rx.observe(Bool.self, "enabled")
.take(1)
.subscribe(onNext: { _ in
done()
})
.disposed(by: disposeBag)
}
expect(subject.isEnabled) == false
}
it("disposes of old action subscriptions when re-set") {
var subject = UIAlertAction.Action("Hi", style: .default)
var disposed = false
autoreleasepool {
let disposeBag = DisposeBag()
let action = emptyAction()
subject.rx.action = action
action
.elements
.subscribe(onNext: nil, onError: nil, onCompleted: nil, onDisposed: {
disposed = true
})
.disposed(by: disposeBag)
}
subject.rx.action = nil
expect(disposed) == true
}
}
}
| mit | 653a5524b5e5bfe8c50503933efa38cb | 29.369048 | 89 | 0.490396 | 5.509719 | false | false | false | false |
roambotics/swift | test/attr/attr_availability_transitive_osx.swift | 2 | 6644 | // RUN: %target-typecheck-verify-swift -parse-as-library
// REQUIRES: OS=macosx
// Allow referencing unavailable API in situations where the caller is marked unavailable in the same circumstances.
@available(OSX, unavailable)
@discardableResult
func osx() -> Int { return 0 } // expected-note * {{'osx()' has been explicitly marked unavailable here}}
@available(OSXApplicationExtension, unavailable)
func osx_extension() {}
@available(OSX, unavailable)
func osx_pair() -> (Int, Int) { return (0, 0) } // expected-note * {{'osx_pair()' has been explicitly marked unavailable here}}
func call_osx_extension() {
osx_extension() // OK; osx_extension is only unavailable if -application-extension is passed.
}
func call_osx() {
osx() // expected-error {{'osx()' is unavailable}}
}
@available(OSX, unavailable)
func osx_call_osx_extension() {
osx_extension() // OK; osx_extension is only unavailable if -application-extension is passed.
}
@available(OSX, unavailable)
func osx_call_osx() {
osx() // OK; same
}
@available(OSXApplicationExtension, unavailable)
func osx_extension_call_osx_extension() {
osx_extension()
}
@available(OSXApplicationExtension, unavailable)
func osx_extension_call_osx() {
osx() // expected-error {{'osx()' is unavailable}}
}
@available(OSX, unavailable)
var osx_init_osx = osx() // OK
@available(OSXApplicationExtension, unavailable)
var osx_extension_init_osx = osx() // expected-error {{'osx()' is unavailable}}
@available(OSX, unavailable)
var osx_inner_init_osx = { let inner_var = osx() } // OK
@available(OSXApplicationExtension, unavailable)
var osx_extension_inner_init_osx = { let inner_var = osx() } // expected-error {{'osx()' is unavailable}}
struct Outer {
@available(OSX, unavailable)
var osx_init_osx = osx() // OK
@available(OSX, unavailable)
lazy var osx_lazy_osx = osx() // OK
@available(OSXApplicationExtension, unavailable)
var osx_extension_init_osx = osx() // expected-error {{'osx()' is unavailable}}
@available(OSXApplicationExtension, unavailable)
var osx_extension_lazy_osx = osx() // expected-error {{'osx()' is unavailable}}
@available(OSX, unavailable)
var osx_init_multi1_osx = osx(), osx_init_multi2_osx = osx() // OK
@available(OSXApplicationExtension, unavailable)
var osx_extension_init_multi1_osx = osx(), osx_extension_init_multi2_osx = osx() // expected-error 2 {{'osx()' is unavailable}}
@available(OSX, unavailable)
var (osx_init_deconstruct1_osx, osx_init_deconstruct2_osx) = osx_pair() // OK
@available(OSXApplicationExtension, unavailable)
var (osx_extension_init_deconstruct1_osx, osx_extension_init_deconstruct2_osx) = osx_pair() // expected-error {{'osx_pair()' is unavailable}}
@available(OSX, unavailable)
var (_, osx_init_deconstruct2_only_osx) = osx_pair() // OK
@available(OSXApplicationExtension, unavailable)
var (_, osx_extension_init_deconstruct2_only_osx) = osx_pair() // expected-error {{'osx_pair()' is unavailable}}
@available(OSX, unavailable)
var (osx_init_deconstruct1_only_osx, _) = osx_pair() // OK
@available(OSXApplicationExtension, unavailable)
var (osx_extension_init_deconstruct1_only_osx, _) = osx_pair() // expected-error {{'osx_pair()' is unavailable}}
@available(OSX, unavailable)
var osx_inner_init_osx = { let inner_var = osx() } // OK
@available(OSXApplicationExtension, unavailable)
var osx_extension_inner_init_osx = { let inner_var = osx() } // expected-error {{'osx()' is unavailable}}
}
extension Outer {
@available(OSX, unavailable)
static var also_osx_init_osx = osx() // OK
@available(OSXApplicationExtension, unavailable)
static var also_osx_extension_init_osx = osx() // expected-error {{'osx()' is unavailable}}
}
@available(OSX, unavailable)
// expected-note@+1 {{enclosing scope has been explicitly marked unavailable here}}
extension Outer {
// expected-note@+1 {{'outer_osx_init_osx' has been explicitly marked unavailable here}}
static var outer_osx_init_osx = osx() // OK
// expected-note@+1 {{'osx_call_osx()' has been explicitly marked unavailable here}}
func osx_call_osx() {
osx() // OK
}
func osx_call_osx_extension() {
osx_extension() // OK; osx_extension is only unavailable if -application-extension is passed.
}
func takes_and_returns_osx(_ x: NotOnOSX) -> NotOnOSX {
return x // OK
}
// This @available should be ignored; inherited unavailability takes precedence
@available(OSX 999, *) // expected-warning {{instance method cannot be more available than unavailable enclosing scope}}
// expected-note@+1 {{'osx_more_available_but_still_unavailable_call_osx()' has been explicitly marked unavailable here}}
func osx_more_available_but_still_unavailable_call_osx() {
osx() // OK
}
// rdar://92551870
func osx_call_osx_more_available_but_still_unavailable() {
osx_more_available_but_still_unavailable_call_osx() // OK
}
}
func takesOuter(_ o: Outer) {
_ = Outer.outer_osx_init_osx // expected-error {{'outer_osx_init_osx' is unavailable in macOS}}
o.osx_call_osx() // expected-error {{'osx_call_osx()' is unavailable in macOS}}
o.osx_more_available_but_still_unavailable_call_osx() // expected-error {{'osx_more_available_but_still_unavailable_call_osx()' is unavailable in macOS}}
}
@available(OSX, unavailable)
struct NotOnOSX { // expected-note {{'NotOnOSX' has been explicitly marked unavailable here}}
var osx_init_osx = osx() // OK
lazy var osx_lazy_osx = osx() // OK
var osx_init_multi1_osx = osx(), osx_init_multi2_osx = osx() // OK
var (osx_init_deconstruct1_osx, osx_init_deconstruct2_osx) = osx_pair() // OK
var (_, osx_init_deconstruct2_only_osx) = osx_pair() // OK
var (osx_init_deconstruct1_only_osx, _) = osx_pair() // OK
}
@available(OSX, unavailable)
extension NotOnOSX {
func osx_call_osx() {
osx() // OK
}
func osx_call_osx_extension() {
osx_extension() // OK; osx_extension is only unavailable if -application-extension is passed.
}
}
@available(OSXApplicationExtension, unavailable)
extension NotOnOSX { } // expected-error {{'NotOnOSX' is unavailable in macOS}}
@available(OSXApplicationExtension, unavailable)
struct NotOnOSXApplicationExtension { }
@available(OSX, unavailable)
extension NotOnOSXApplicationExtension { } // OK; NotOnOSXApplicationExtension is only unavailable if -application-extension is passed.
@available(OSXApplicationExtension, unavailable)
extension NotOnOSXApplicationExtension {
func osx_call_osx() {
osx() // expected-error {{'osx()' is unavailable in macOS}}
}
func osx_call_osx_extension() {
osx_extension() // OK
}
}
| apache-2.0 | f57bb38df2570c4a706f562488ac53e3 | 35.108696 | 155 | 0.704846 | 3.728395 | false | false | false | false |
li-wenxue/Weibo | 新浪微博/新浪微博/Class/Tools/Networking/WBNetworkingManager+Extension.swift | 1 | 3850 | //
// WBNetworkingManager+Extension.swift
// 新浪微博
//
// Created by win_学 on 16/8/20.
// Copyright © 2016年 win_学. All rights reserved.
//
import Foundation
// MARK: - 封装新浪微博的网络请求方法
extension WBNetworkingManager {
/// 加载微博数据字典数组
///
/// - parameter since_id 返回ID比since_id大的微博（即比since_id时间晚的微博），默认为0（下拉）
/// - parameter max_id 返回ID小于或等于max_id的微博，默认为0 （上拉）
/// - parameter completion 完成回调
func statusList(since_id: Int64 = 0, max_id: Int64 = 0, completion:(list: [[String: AnyObject]]?, isSuccess: Bool) -> ()) {
let urlString = "https://api.weibo.com/2/statuses/home_timeline.json"
// swift中 Int 可以转换成 AnyObject ，但是 Int64 不行
let parameters = ["since_id": "\(since_id)", "max_id": "\(max_id > 0 ? max_id - 1 : 0)"]
tokenRequest(urlString: urlString, parameters: parameters) { (json: AnyObject?, isSuccess: Bool) -> () in
// 从json 中获取 statuses 字典数组
// 如果 as? 失败，返回为nil
let result = json?["statuses"] as? [[String: AnyObject]]
completion(list: result, isSuccess: isSuccess)
}
}
func unreadStatus(completion:(count: Int)->()) {
guard let uid = userAccount.uid else {
return
}
// 1. url
let urlString = "https://rm.api.weibo.com/2/remind/unread_count.json"
// 2. 参数
let parameters = ["uid":uid]
tokenRequest(urlString: urlString, parameters: parameters) { (json: AnyObject?, isSuccess: Bool) -> () in
completion(count: (json as? [String:AnyObject])?["status"] as? Int ?? 0)
}
}
}
// MARK: - 用户信息相关
extension WBNetworkingManager {
// 加载当前用户信息，一旦登录成功应立即调用
func loadUserInfo(completion:(dict:[String: AnyObject])->()) {
let urlString = "https://api.weibo.com/2/users/show.json"
guard let uid = userAccount.uid else {
return
}
let parameters = ["uid": uid]
tokenRequest(urlString: urlString, parameters: parameters) { (json, isSuccess) in
// 完成回调
completion(dict: (json as? [String: AnyObject]) ?? [:])
}
}
}
// MARK: - OAuth相关方法
extension WBNetworkingManager {
func loadOAuthToken(code: String, completion:(isSuccess: Bool)->()) {
let urlString = "https://api.weibo.com/oauth2/access_token"
let parameters = ["client_id": WBAppKey,
"client_secret": WBAppSecret,
"grant_type":"authorization_code",
"code": code,
"redirect_uri": WBRedirectURL]
request(method: .POST, urlString: urlString, parameters: parameters) {
(json, isSuccess) in
// 此时的json 已经是序列化后的 ‘泛型’ 了
// 字典转模型
self.userAccount.yy_modelSet(with: json as? [String: AnyObject] ?? [:])
self.loadUserInfo(completion: { (dict) in
// 使用用户字典给用户模型赋值
self.userAccount.yy_modelSet(with: dict)
print(self.userAccount)
// 磁盘存储用户信息
self.userAccount.saveAccount()
// 注意loadUserInfo中输出与下面的completion执行顺序的问题
completion(isSuccess: isSuccess)
})
}
}
}
| mit | 977b38e123cc0e052175ba40d6731060 | 31.575472 | 127 | 0.531422 | 4.262963 | false | false | false | false |
jvesala/teknappi | teknappi/Pods/RxCocoa/RxCocoa/iOS/UITableView+Rx.swift | 13 | 7261 | //
// UITableView+Rx.swift
// RxCocoa
//
// Created by Krunoslav Zaher on 4/2/15.
// Copyright (c) 2015 Krunoslav Zaher. All rights reserved.
//
import Foundation
#if !RX_NO_MODULE
import RxSwift
#endif
import UIKit
// Items
extension UITableView {
/**
Binds sequences of elements to table view rows.
- parameter source: Observable sequence of items.
- parameter cellFactory: Transform between sequence elements and view cells.
- returns: Disposable object that can be used to unbind.
*/
public func rx_itemsWithCellFactory<S: SequenceType, O: ObservableType where O.E == S>
(source: O)
(cellFactory: (UITableView, Int, S.Generator.Element) -> UITableViewCell)
-> Disposable {
let dataSource = RxTableViewReactiveArrayDataSourceSequenceWrapper<S>(cellFactory: cellFactory)
return self.rx_itemsWithDataSource(dataSource)(source: source)
}
/**
Binds sequences of elements to table view rows.
- parameter cellIdentifier: Identifier used to dequeue cells.
- parameter source: Observable sequence of items.
- parameter configureCell: Transform between sequence elements and view cells.
- returns: Disposable object that can be used to unbind.
*/
public func rx_itemsWithCellIdentifier<S: SequenceType, Cell: UITableViewCell, O : ObservableType where O.E == S>
(cellIdentifier: String)
(source: O)
(configureCell: (Int, S.Generator.Element, Cell) -> Void)
-> Disposable {
let dataSource = RxTableViewReactiveArrayDataSourceSequenceWrapper<S> { (tv, i, item) in
let indexPath = NSIndexPath(forItem: i, inSection: 0)
let cell = tv.dequeueReusableCellWithIdentifier(cellIdentifier, forIndexPath: indexPath) as! Cell
configureCell(i, item, cell)
return cell
}
return self.rx_itemsWithDataSource(dataSource)(source: source)
}
/**
Binds sequences of elements to table view rows using a custom reactive data used to perform the transformation.
- parameter dataSource: Data source used to transform elements to view cells.
- parameter source: Observable sequence of items.
- returns: Disposable object that can be used to unbind.
*/
public func rx_itemsWithDataSource<DataSource: protocol<RxTableViewDataSourceType, UITableViewDataSource>, S: SequenceType, O: ObservableType where DataSource.Element == S, O.E == S>
(dataSource: DataSource)
(source: O)
-> Disposable {
return source.subscribeProxyDataSourceForObject(self, dataSource: dataSource, retainDataSource: false) { [weak self] (_: RxTableViewDataSourceProxy, event) -> Void in
guard let tableView = self else {
return
}
dataSource.tableView(tableView, observedEvent: event)
}
}
}
extension UITableView {
/**
Factory method that enables subclasses to implement their own `rx_delegate`.
- returns: Instance of delegate proxy that wraps `delegate`.
*/
override func rx_createDelegateProxy() -> RxScrollViewDelegateProxy {
return RxTableViewDelegateProxy(parentObject: self)
}
/**
Reactive wrapper for `dataSource`.
For more information take a look at `DelegateProxyType` protocol documentation.
*/
public var rx_dataSource: DelegateProxy {
return proxyForObject(self) as RxTableViewDataSourceProxy
}
/**
Installs data source as forwarding delegate on `rx_dataSource`.
It enables using normal delegate mechanism with reactive delegate mechanism.
- parameter dataSource: Data source object.
- returns: Disposable object that can be used to unbind the data source.
*/
public func rx_setDataSource(dataSource: UITableViewDataSource)
-> Disposable {
let proxy: RxTableViewDataSourceProxy = proxyForObject(self)
return installDelegate(proxy, delegate: dataSource, retainDelegate: false, onProxyForObject: self)
}
// events
/**
Reactive wrapper for `delegate` message `tableView:didSelectRowAtIndexPath:`.
*/
public var rx_itemSelected: ControlEvent<NSIndexPath> {
let source = rx_delegate.observe("tableView:didSelectRowAtIndexPath:")
.map { a in
return a[1] as! NSIndexPath
}
return ControlEvent(source: source)
}
/**
Reactive wrapper for `delegate` message `tableView:commitEditingStyle:forRowAtIndexPath:`.
*/
public var rx_itemInserted: ControlEvent<NSIndexPath> {
let source = rx_dataSource.observe("tableView:commitEditingStyle:forRowAtIndexPath:")
.filter { a in
return UITableViewCellEditingStyle(rawValue: (a[1] as! NSNumber).integerValue) == .Insert
}
.map { a in
return (a[2] as! NSIndexPath)
}
return ControlEvent(source: source)
}
/**
Reactive wrapper for `delegate` message `tableView:commitEditingStyle:forRowAtIndexPath:`.
*/
public var rx_itemDeleted: ControlEvent<NSIndexPath> {
let source = rx_dataSource.observe("tableView:commitEditingStyle:forRowAtIndexPath:")
.filter { a in
return UITableViewCellEditingStyle(rawValue: (a[1] as! NSNumber).integerValue) == .Delete
}
.map { a in
return (a[2] as! NSIndexPath)
}
return ControlEvent(source: source)
}
/**
Reactive wrapper for `delegate` message `tableView:moveRowAtIndexPath:toIndexPath:`.
*/
public var rx_itemMoved: ControlEvent<ItemMovedEvent> {
let source: Observable<ItemMovedEvent> = rx_dataSource.observe("tableView:moveRowAtIndexPath:toIndexPath:")
.map { a in
return ((a[1] as! NSIndexPath), (a[2] as! NSIndexPath))
}
return ControlEvent(source: source)
}
/**
Reactive wrapper for `delegate` message `tableView:didSelectRowAtIndexPath:`.
It can be only used when one of the `rx_itemsWith*` methods is used to bind observable sequence.
If custom data source is being bound, new `rx_modelSelected` wrapper needs to be written also.
public func rx_myModelSelected<T>() -> ControlEvent<T> {
let source: Observable<T> = rx_itemSelected.map { indexPath in
let dataSource: MyDataSource = self.rx_dataSource.forwardToDelegate() as! MyDataSource
return dataSource.modelAtIndex(indexPath.item)!
}
return ControlEvent(source: source)
}
*/
public func rx_modelSelected<T>() -> ControlEvent<T> {
let source: Observable<T> = rx_itemSelected.map { ip in
let dataSource: RxTableViewReactiveArrayDataSource<T> = castOrFatalError(self.rx_dataSource.forwardToDelegate(), message: "This method only works in case one of the `rx_subscribeItemsTo` methods was used.")
return dataSource.modelAtIndex(ip.item)!
}
return ControlEvent(source: source)
}
} | gpl-3.0 | cd62397eb39307b048aadd36b5b2423c | 35.862944 | 218 | 0.652114 | 5.23504 | false | false | false | false |
matt-deboer/kuill | vendor/github.com/googleapis/gnostic/plugins/gnostic-swift-generator/Sources/gnostic-swift-generator/Renderer.swift | 25 | 12439 | // Copyright 2017 Google Inc. 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 Foundation
import Gnostic
extension String {
func capitalizingFirstLetter() -> String {
let first = String(characters.prefix(1)).capitalized
let other = String(characters.dropFirst())
return first + other
}
mutating func capitalizeFirstLetter() {
self = self.capitalizingFirstLetter()
}
}
class ServiceType {
var name : String = ""
var fields : [ServiceTypeField] = []
var isInterfaceType : Bool = false
}
class ServiceTypeField {
var name : String = ""
var typeName : String = ""
var isArrayType : Bool = false
var isCastableType : Bool = false
var isConvertibleType : Bool = false
var elementType : String = ""
var jsonName : String = ""
var position: String = "" // "body", "header", "formdata", "query", or "path"
var initialValue : String = ""
func setTypeForName(_ name : String, _ format : String) {
switch name {
case "integer":
if format == "int32" {
self.typeName = "Int32"
} else if format == "int64" {
self.typeName = "Int64"
} else {
self.typeName = "Int"
}
self.initialValue = "0"
self.isCastableType = true
default:
self.typeName = name.capitalizingFirstLetter()
self.initialValue = self.typeName + "()"
self.isConvertibleType = true
}
}
func setTypeForSchema(_ schema : Openapi_V2_Schema, optional : Bool = false) {
let ref = schema.ref
if ref != "" {
self.typeName = typeForRef(ref)
self.isConvertibleType = true
self.initialValue = self.typeName + "()"
}
if schema.hasType {
let types = schema.type.value
let format = schema.format
if types.count == 1 && types[0] == "string" {
self.typeName = "String"
self.isCastableType = true
self.initialValue = "\"\""
}
if types.count == 1 && types[0] == "integer" && format == "int32" {
self.typeName = "Int32"
self.isCastableType = true
self.initialValue = "0"
}
if types.count == 1 && types[0] == "array" && schema.hasItems {
// we have an array.., but of what?
let items = schema.items.schema
if items.count == 1 && items[0].ref != "" {
self.isArrayType = true
self.elementType = typeForRef(items[0].ref)
self.typeName = "[" + self.elementType + "]"
self.initialValue = "[]"
}
}
}
// this function is incomplete... so return a string representing anything that we don't handle
if self.typeName == "" {
self.typeName = "\(schema)"
}
if optional {
self.typeName += "?"
self.initialValue = "nil"
}
}
}
class ServiceMethod {
var name : String = ""
var path : String = ""
var method : String = ""
var description : String = ""
var handlerName : String = ""
var processorName : String = ""
var clientName : String = ""
var resultTypeName : String?
var parametersTypeName : String?
var responsesTypeName : String?
var parametersType : ServiceType?
var responsesType : ServiceType?
}
func propertyNameForResponseCode(_ code:String) -> String {
switch code {
case "200":
return "ok"
case "default":
return "error"
default:
return code
}
}
func typeForRef(_ ref : String) -> String {
let parts = ref.components(separatedBy:"/")
return parts.last!.capitalizingFirstLetter()
}
class ServiceRenderer {
internal var name : String = ""
internal var package: String = ""
internal var types : [ServiceType] = []
internal var methods : [ServiceMethod] = []
internal var surface : Surface_V1_Model
public init(surface : Surface_V1_Model, document : Openapi_V2_Document) {
self.surface = surface
loadService(document:document)
}
private func loadServiceTypeFromParameters(_ name:String,
_ parameters:[Openapi_V2_ParametersItem])
-> ServiceType? {
let t = ServiceType()
t.name = name.capitalizingFirstLetter() + "Parameters"
for parametersItem in parameters {
let f = ServiceTypeField()
f.typeName = "\(parametersItem)"
switch parametersItem.oneof! {
case .parameter(let parameter):
switch parameter.oneof! {
case .bodyParameter(let bodyParameter):
f.name = bodyParameter.name
if bodyParameter.hasSchema {
f.setTypeForSchema(bodyParameter.schema)
f.position = "body"
}
case .nonBodyParameter(let nonBodyParameter):
switch (nonBodyParameter.oneof!) {
case .headerParameterSubSchema(let headerParameter):
f.name = headerParameter.name
f.position = "header"
case .formDataParameterSubSchema(let formDataParameter):
f.name = formDataParameter.name
f.position = "formdata"
case .queryParameterSubSchema(let queryParameter):
f.name = queryParameter.name
f.position = "query"
case .pathParameterSubSchema(let pathParameter):
f.name = pathParameter.name
f.jsonName = pathParameter.name
f.position = "path"
f.setTypeForName(pathParameter.type, pathParameter.format)
}
}
case .jsonReference: // (let reference):
Log("?")
}
t.fields.append(f)
}
if t.fields.count > 0 {
self.types.append(t)
return t
} else {
return nil
}
}
private func loadServiceTypeFromResponses(_ m:ServiceMethod,
_ name:String,
_ responses:Openapi_V2_Responses)
-> ServiceType? {
let t = ServiceType()
t.name = name.capitalizingFirstLetter() + "Responses"
for responseCode in responses.responseCode {
let f = ServiceTypeField()
f.name = propertyNameForResponseCode(responseCode.name)
f.jsonName = ""
if let responseCodeValueOneOf = responseCode.value.oneof {
switch responseCodeValueOneOf {
case .response(let response):
let schema = response.schema
if let schemaOneOf = schema.oneof {
switch schemaOneOf {
case .schema(let schema):
f.setTypeForSchema(schema, optional:true)
t.fields.append(f)
if f.name == "ok" {
m.resultTypeName = f.typeName.replacingOccurrences(of:"?", with:"")
}
default:
break
}
}
default:
break
}
}
}
if t.fields.count > 0 {
self.types.append(t)
return t
} else {
return nil
}
}
private func loadOperation(_ operation : Openapi_V2_Operation,
method : String,
path : String) {
let m = ServiceMethod()
m.name = operation.operationID
m.path = path
m.method = method
m.description = operation.description_p
m.handlerName = "handle" + m.name
m.processorName = "" + m.name
m.clientName = m.name
m.parametersType = loadServiceTypeFromParameters(m.name, operation.parameters)
if m.parametersType != nil {
m.parametersTypeName = m.parametersType!.name
}
m.responsesType = loadServiceTypeFromResponses(m, m.name, operation.responses)
if m.responsesType != nil {
m.responsesTypeName = m.responsesType!.name
}
self.methods.append(m)
}
private func loadService(document : Openapi_V2_Document) {
// collect service type descriptions
for pair in document.definitions.additionalProperties {
let t = ServiceType()
t.isInterfaceType = true
let schema = pair.value
for pair2 in schema.properties.additionalProperties {
let f = ServiceTypeField()
f.name = pair2.name
f.setTypeForSchema(pair2.value)
f.jsonName = pair2.name
t.fields.append(f)
}
t.name = pair.name.capitalizingFirstLetter()
self.types.append(t)
}
// collect service method descriptions
for pair in document.paths.path {
let v = pair.value
if v.hasGet {
loadOperation(v.get, method:"GET", path:pair.name)
}
if v.hasPost {
loadOperation(v.post, method:"POST", path:pair.name)
}
if v.hasPut {
loadOperation(v.put, method:"PUT", path:pair.name)
}
if v.hasDelete {
loadOperation(v.delete, method:"DELETE", path:pair.name)
}
}
}
public func generate(filenames : [String], response : inout Gnostic_Plugin_V1_Response) throws {
for filename in filenames {
var data : Data?
switch filename {
case "types.swift":
data = renderTypes().data(using:.utf8)
case "server.swift":
data = renderServer().data(using:.utf8)
case "client.swift":
data = renderClient().data(using:.utf8)
case "fetch.swift":
data = renderFetch().data(using:.utf8)
default:
print("error: unable to render \(filename)")
}
if let data = data {
var clientfile = Gnostic_Plugin_V1_File()
clientfile.name = filename
clientfile.data = data
response.files.append(clientfile)
}
}
}
}
let header = """
// Copyright 2017 Google Inc. 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.
"""
| mit | 1289d3c2a1de892355d4f6c7eb7ef29c | 36.020833 | 103 | 0.517887 | 4.989571 | false | false | false | false |
telip007/ChatFire | Pods/SwiftMessages/SwiftMessages/UIViewController+Utils.swift | 2 | 4460 | //
// UIViewController+Utils.swift
// SwiftMessages
//
// Created by Timothy Moose on 8/5/16.
// Copyright © 2016 SwiftKick Mobile LLC. All rights reserved.
//
import UIKit
private let fullScreenStyles: [UIModalPresentationStyle] = [.FullScreen, .OverFullScreen]
extension UIViewController {
func sm_selectPresentationContextTopDown(presentationStyle: SwiftMessages.PresentationStyle) -> UIViewController {
if let presented = sm_presentedFullScreenViewController() {
return presented.sm_selectPresentationContextTopDown(presentationStyle)
} else if case .Top = presentationStyle, let navigationController = sm_selectNavigationControllerTopDown() {
return navigationController
} else if case .Bottom = presentationStyle, let tabBarController = sm_selectTabBarControllerTopDown() {
return tabBarController
}
return WindowViewController(windowLevel: self.view.window?.windowLevel ?? UIWindowLevelNormal)
}
private func sm_selectNavigationControllerTopDown() -> UINavigationController? {
if let presented = sm_presentedFullScreenViewController() {
return presented.sm_selectNavigationControllerTopDown()
} else if let navigationController = self as? UINavigationController {
if navigationController.sm_isVisible(view: navigationController.navigationBar) {
return navigationController
}
return navigationController.topViewController?.sm_selectNavigationControllerTopDown()
} else if let tabBarController = self as? UITabBarController {
return tabBarController.selectedViewController?.sm_selectNavigationControllerTopDown()
}
return nil
}
private func sm_selectTabBarControllerTopDown() -> UITabBarController? {
if let presented = sm_presentedFullScreenViewController() {
return presented.sm_selectTabBarControllerTopDown()
} else if let navigationController = self as? UINavigationController {
return navigationController.topViewController?.sm_selectTabBarControllerTopDown()
} else if let tabBarController = self as? UITabBarController {
if tabBarController.sm_isVisible(view: tabBarController.tabBar) {
return tabBarController
}
return tabBarController.selectedViewController?.sm_selectTabBarControllerTopDown()
}
return nil
}
private func sm_presentedFullScreenViewController() -> UIViewController? {
if let presented = self.presentedViewController where fullScreenStyles.contains(presented.modalPresentationStyle) {
return presented
}
return nil
}
func sm_selectPresentationContextBottomUp(presentationStyle: SwiftMessages.PresentationStyle) -> UIViewController {
if let parent = parentViewController {
if let navigationController = parent as? UINavigationController {
if case .Top = presentationStyle where navigationController.sm_isVisible(view: navigationController.navigationBar) {
return navigationController
}
return navigationController.sm_selectPresentationContextBottomUp(presentationStyle)
} else if let tabBarController = parent as? UITabBarController {
if case .Bottom = presentationStyle where tabBarController.sm_isVisible(view: tabBarController.tabBar) {
return tabBarController
}
return tabBarController.sm_selectPresentationContextBottomUp(presentationStyle)
}
}
if self.view is UITableView {
// Never select scroll view as presentation context
// because, you know, it scrolls.
if let parent = self.parentViewController {
return parent.sm_selectPresentationContextBottomUp(presentationStyle)
} else {
return WindowViewController(windowLevel: self.view.window?.windowLevel ?? UIWindowLevelNormal)
}
}
return self
}
func sm_isVisible(view view: UIView) -> Bool {
if view.hidden { return false }
if view.alpha == 0.0 { return false }
let frame = self.view.convertRect(view.bounds, fromView: view)
if !CGRectIntersectsRect(self.view.bounds, frame) { return false }
return true
}
}
| apache-2.0 | cc0e506559089221e783041b2f8bf22e | 46.43617 | 132 | 0.685355 | 6.280282 | false | false | false | false |
FabrizioBrancati/BFKit-Swift | Sources/BFKit/Linux/BFKit/BFApp.swift | 1 | 6920 | //
// BFApp.swift
// BFKit-Swift
//
// The MIT License (MIT)
//
// Copyright (c) 2015 - 2019 Fabrizio Brancati.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
import Foundation
// MARK: - Global variables
/// NSLocalizedString without comment parameter.
///
/// - Parameter key: The key of the localized string.
/// - Returns: Returns a localized string.
public func NSLocalizedString(_ key: String) -> String {
NSLocalizedString(key, comment: "")
}
// MARK: - BFApp struct
/// This class adds some useful functions for the App.
public enum BFApp {
// MARK: - Variables
/// Used to store the BFHasBeenOpened in defaults.
internal static let BFAppHasBeenOpened = "BFAppHasBeenOpened"
/// Use this var to set you DEBUG or not builds.
/// More info on how to use it [here](http://stackoverflow.com/questions/26890537/disabling-nslog-for-production-in-swift-project/26891797#26891797).
public static var isDebug = false
// MARK: - Functions
/// Executes a block only if in DEBUG mode.
///
/// - Parameter block: The block to be executed.
public static func debug(_ block: () -> Void) {
if isDebug {
block()
}
}
/// Executes a block only if NOT in DEBUG mode.
///
/// - Parameter block: The block to be executed.
public static func release(_ block: () -> Void) {
if !isDebug {
block()
}
}
/// If version is set returns if is first start for that version,
/// otherwise returns if is first start of the App.
///
/// - Parameter version: Version to be checked, you can use the variable `BFApp.version` to pass the current App version.
/// - Returns: Returns if is first start of the App or for custom version.
public static func isFirstStart(version: String = "") -> Bool {
let key: String = BFAppHasBeenOpened + version
let defaults = UserDefaults.standard
let hasBeenOpened: Bool = defaults.bool(forKey: key)
return !hasBeenOpened
}
/// Executes a block on first start of the App, if version is set it will be for given version.
///
/// Remember to execute UI instuctions on main thread.
///
/// - Parameters:
/// - version: Version to be checked, you can use the variable `BFApp.version` to pass the current App version.
/// - block: The block to execute, returns isFirstStart.
public static func onFirstStart(version: String = "", block: (_ isFirstStart: Bool) -> Void) {
let key: String = BFAppHasBeenOpened + version
let defaults = UserDefaults.standard
let hasBeenOpened: Bool = defaults.bool(forKey: key)
if hasBeenOpened != true {
defaults.set(true, forKey: key)
}
block(!hasBeenOpened)
}
/// Reset the App like has never been started.
///
/// - Parameter version: Version to be checked, you can use the variable `BFApp.version` to pass the current App version.
public static func resetFirstStart(version: String = "") {
let key: String = BFAppHasBeenOpened + version
let defaults = UserDefaults.standard
defaults.removeObject(forKey: key)
}
/// Set the App setting for a given object and key. The file will be saved in the Library directory.
///
/// - Parameters:
/// - object: Object to set.
/// - objectKey: Key to set the object.
/// - Returns: Returns true if the operation was successful, otherwise false.
@discardableResult
public static func setAppSetting(object: Any, forKey objectKey: String) -> Bool {
FileManager.default.setSettings(filename: BFApp.name, object: object, forKey: objectKey)
}
/// Get the App setting for a given key.
///
/// - Parameter objectKey: Key to get the object.
/// - Returns: Returns the object for the given key.
public static func getAppSetting(objectKey: String) -> Any? {
FileManager.default.getSettings(filename: BFApp.name, forKey: objectKey)
}
/// Check if the app has been installed from TestFlight.
///
/// - Returns: Returns `true` if the app has been installed via TestFlight, otherwise `false`.
public static func isFromTestFlight() -> Bool {
guard let appStoreReceiptURL = Bundle.main.appStoreReceiptURL else {
return false
}
return appStoreReceiptURL.lastPathComponent == "sandboxReceipt"
}
}
// MARK: - BFApp extension
/// Extends BFApp with project infos.
public extension BFApp {
// MARK: - Variables
/// Return the App name.
static var name: String = {
BFApp.stringFromInfoDictionary(forKey: "CFBundleDisplayName")
}()
/// Returns the App version.
static var version: String = {
BFApp.stringFromInfoDictionary(forKey: "CFBundleShortVersionString")
}()
/// Returns the App build.
static var build: String = {
BFApp.stringFromInfoDictionary(forKey: "CFBundleVersion")
}()
/// Returns the App executable.
static var executable: String = {
BFApp.stringFromInfoDictionary(forKey: "CFBundleExecutable")
}()
/// Returns the App bundle.
static var bundle: String = {
BFApp.stringFromInfoDictionary(forKey: "CFBundleIdentifier")
}()
// MARK: - Functions
/// Returns a String from the Info dictionary of the App.
///
/// - Parameter key: Key to search.
/// - Returns: Returns a String from the Info dictionary of the App.
private static func stringFromInfoDictionary(forKey key: String) -> String {
guard let infoDictionary = Bundle.main.infoDictionary, let value = infoDictionary[key] as? String else {
return ""
}
return value
}
}
| mit | 1c4fbe371bff01996c014579f98d5785 | 35.421053 | 153 | 0.653179 | 4.688347 | false | false | false | false |
wwu-pi/md2-framework | de.wwu.md2.framework/res/resources/ios/lib/controller/validator/MD2TimeRangeValidator.swift | 1 | 1924 | //
// MD2TimeRangeValidator.swift
// md2-ios-library
//
// Created by Christoph Rieger on 23.07.15.
// Copyright (c) 2015 Christoph Rieger. All rights reserved.
//
/**
Validator to check for a given time range.
*/
class MD2TimeRangeValidator: MD2Validator {
/// Unique identification string.
let identifier: MD2String
/// Custom message to display.
var message: (() -> MD2String)?
/// Default message to display.
var defaultMessage: MD2String {
get {
return MD2String("The time must be between \(min.toString()) and \(max.toString())!")
}
}
/// Minimum allowed time.
let min: MD2Time
/// Maximum allowed time.
let max: MD2Time
/**
Default initializer.
:param: identifier The unique validator identifier.
:param: message Closure of the custom method to display.
:param: min The minimum value of a valid time.
:param: max The maximum value of a valid time.
*/
init(identifier: MD2String, message: (() -> MD2String)?, min: MD2Time, max: MD2Time) {
self.identifier = identifier
self.message = message
self.min = min
self.max = max
}
/**
Validate a value.
:param: value The value to check.
:return: Validation result
*/
func isValid(value: MD2Type) -> Bool {
if value is MD2Time
&& (value as! MD2Time).gte(min)
&& (value as! MD2Time).lte(max) {
return true
} else {
return false
}
}
/**
Return the message to display on wrong validation.
Use custom method if set or else use default message.
*/
func getMessage() -> MD2String {
if let _ = message {
return message!()
} else {
return defaultMessage
}
}
} | apache-2.0 | 53f9f7e398988de4adacc3e228a47478 | 24 | 97 | 0.558732 | 4.362812 | false | false | false | false |
ibru/Swifter | Swifter/SwifterOAuthClient.swift | 2 | 8155 | //
// SwifterOAuthClient.swift
// Swifter
//
// Copyright (c) 2014 Matt Donnelly.
//
// 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 Accounts
internal class SwifterOAuthClient: SwifterClientProtocol {
struct OAuth {
static let version = "1.0"
static let signatureMethod = "HMAC-SHA1"
}
var consumerKey: String
var consumerSecret: String
var credential: SwifterCredential?
var dataEncoding: NSStringEncoding
init(consumerKey: String, consumerSecret: String) {
self.consumerKey = consumerKey
self.consumerSecret = consumerSecret
self.dataEncoding = NSUTF8StringEncoding
}
init(consumerKey: String, consumerSecret: String, accessToken: String, accessTokenSecret: String) {
self.consumerKey = consumerKey
self.consumerSecret = consumerSecret
let credentialAccessToken = SwifterCredential.OAuthAccessToken(key: accessToken, secret: accessTokenSecret)
self.credential = SwifterCredential(accessToken: credentialAccessToken)
self.dataEncoding = NSUTF8StringEncoding
}
func get(path: String, baseURL: NSURL, parameters: Dictionary<String, Any>, uploadProgress: SwifterHTTPRequest.UploadProgressHandler?, downloadProgress: SwifterHTTPRequest.DownloadProgressHandler?, success: SwifterHTTPRequest.SuccessHandler?, failure: SwifterHTTPRequest.FailureHandler?) -> SwifterHTTPRequest {
let url = NSURL(string: path, relativeToURL: baseURL)!
let method = "GET"
let request = SwifterHTTPRequest(URL: url, method: method, parameters: parameters)
request.headers = ["Authorization": self.authorizationHeaderForMethod(method, url: url, parameters: parameters, isMediaUpload: false)]
request.downloadProgressHandler = downloadProgress
request.successHandler = success
request.failureHandler = failure
request.dataEncoding = self.dataEncoding
request.start()
return request
}
func post(path: String, baseURL: NSURL, var parameters: Dictionary<String, Any>, uploadProgress: SwifterHTTPRequest.UploadProgressHandler?, downloadProgress: SwifterHTTPRequest.DownloadProgressHandler?, success: SwifterHTTPRequest.SuccessHandler?, failure: SwifterHTTPRequest.FailureHandler?) -> SwifterHTTPRequest {
let url = NSURL(string: path, relativeToURL: baseURL)!
let method = "POST"
var postData: NSData?
var postDataKey: String?
if let key: Any = parameters[Swifter.DataParameters.dataKey] {
if let keyString = key as? String {
postDataKey = keyString
postData = parameters[postDataKey!] as? NSData
parameters.removeValueForKey(Swifter.DataParameters.dataKey)
parameters.removeValueForKey(postDataKey!)
}
}
var postDataFileName: String?
if let fileName: Any = parameters[Swifter.DataParameters.fileNameKey] {
if let fileNameString = fileName as? String {
postDataFileName = fileNameString
parameters.removeValueForKey(fileNameString)
}
}
let request = SwifterHTTPRequest(URL: url, method: method, parameters: parameters)
request.headers = ["Authorization": self.authorizationHeaderForMethod(method, url: url, parameters: parameters, isMediaUpload: postData != nil)]
request.downloadProgressHandler = downloadProgress
request.successHandler = success
request.failureHandler = failure
request.dataEncoding = self.dataEncoding
request.encodeParameters = postData == nil
if postData != nil {
let fileName = postDataFileName ?? "media.jpg"
request.addMultipartData(postData!, parameterName: postDataKey!, mimeType: "application/octet-stream", fileName: fileName)
}
request.start()
return request
}
func authorizationHeaderForMethod(method: String, url: NSURL, parameters: Dictionary<String, Any>, isMediaUpload: Bool) -> String {
var authorizationParameters = Dictionary<String, Any>()
authorizationParameters["oauth_version"] = OAuth.version
authorizationParameters["oauth_signature_method"] = OAuth.signatureMethod
authorizationParameters["oauth_consumer_key"] = self.consumerKey
authorizationParameters["oauth_timestamp"] = String(Int(NSDate().timeIntervalSince1970))
authorizationParameters["oauth_nonce"] = NSUUID().UUIDString
if self.credential?.accessToken != nil {
authorizationParameters["oauth_token"] = self.credential!.accessToken!.key
}
for (key, value): (String, Any) in parameters {
if key.hasPrefix("oauth_") {
authorizationParameters.updateValue(value, forKey: key)
}
}
let combinedParameters = authorizationParameters +| parameters
let finalParameters = isMediaUpload ? authorizationParameters : combinedParameters
authorizationParameters["oauth_signature"] = self.oauthSignatureForMethod(method, url: url, parameters: finalParameters, accessToken: self.credential?.accessToken)
var authorizationParameterComponents = authorizationParameters.urlEncodedQueryStringWithEncoding(self.dataEncoding).componentsSeparatedByString("&") as [String]
authorizationParameterComponents.sortInPlace { $0 < $1 }
var headerComponents = [String]()
for component in authorizationParameterComponents {
let subcomponent = component.componentsSeparatedByString("=") as [String]
if subcomponent.count == 2 {
headerComponents.append("\(subcomponent[0])=\"\(subcomponent[1])\"")
}
}
return "OAuth " + headerComponents.joinWithSeparator(", ")
}
func oauthSignatureForMethod(method: String, url: NSURL, parameters: Dictionary<String, Any>, accessToken token: SwifterCredential.OAuthAccessToken?) -> String {
var tokenSecret: NSString = ""
if token != nil {
tokenSecret = token!.secret.urlEncodedStringWithEncoding(self.dataEncoding)
}
let encodedConsumerSecret = self.consumerSecret.urlEncodedStringWithEncoding(self.dataEncoding)
let signingKey = "\(encodedConsumerSecret)&\(tokenSecret)"
var parameterComponents = parameters.urlEncodedQueryStringWithEncoding(self.dataEncoding).componentsSeparatedByString("&") as [String]
parameterComponents.sortInPlace { $0 < $1 }
let parameterString = parameterComponents.joinWithSeparator("&")
let encodedParameterString = parameterString.urlEncodedStringWithEncoding(self.dataEncoding)
let encodedURL = url.absoluteString.urlEncodedStringWithEncoding(self.dataEncoding)
let signatureBaseString = "\(method)&\(encodedURL)&\(encodedParameterString)"
// let signature = signatureBaseString.SHA1DigestWithKey(signingKey)
return signatureBaseString.SHA1DigestWithKey(signingKey).base64EncodedStringWithOptions([])
}
}
| mit | 14aad9cc01a4e4725b4e2d729e1a5e9a | 44.558659 | 320 | 0.709381 | 5.643599 | false | false | false | false |
russelhampton05/MenMew | App Prototypes/Test_004_QRScanner/Test_004_QRScanner/Test_004_QRScanner/CircleTransition.swift | 1 | 4587 | //
// CircleTransition.swift
// Test_004_QRScanner
//
// Created by Jon Calanio on 9/16/16.
// Copyright © 2016 Jon Calanio. All rights reserved.
//
import UIKit
class CircleTransition: NSObject {
var circle = UIView()
var startingPoint = CGPoint.zero {
didSet {
circle.center = startingPoint
}
}
var circleColor = UIColor.whiteColor()
var duration = 1.0
enum CircularTransitionMode: Int {
case present, dismiss, pop
}
var transitionMode: CircularTransitionMode = .present
}
extension CircleTransition: UIViewControllerAnimatedTransitioning {
func transitionDuration(transitionContext: UIViewControllerContextTransitioning?) -> NSTimeInterval {
return duration
}
func animateTransition(transitionContext: UIViewControllerContextTransitioning) {
let containerView = transitionContext.containerView()
if transitionMode == .present {
if let presentedView = transitionContext.viewForKey(UITransitionContextToViewKey) {
let viewCenter = presentedView.center
let viewSize = presentedView.frame.size
circle = UIView()
circle.frame = frameForCircle(withViewCenter: viewCenter, size: viewSize, startPoint: startingPoint)
circle.layer.cornerRadius = circle.frame.size.height / 2
circle.center = startingPoint
circle.backgroundColor = circleColor
circle.transform = CGAffineTransformMakeScale(0.001, 0.001)
containerView!.addSubview(circle)
presentedView.center = startingPoint
presentedView.transform = CGAffineTransformMakeScale(0.001, 0.001)
presentedView.alpha = 0
containerView!.addSubview(presentedView)
UIView.animateWithDuration(duration, animations: {
self.circle.transform = CGAffineTransformIdentity
presentedView.transform = CGAffineTransformIdentity
presentedView.alpha = 1
presentedView.center = viewCenter
}, completion: { (success: Bool) in
transitionContext.completeTransition(success)
})
}
}
else{
let transitionModeKey = (transitionMode == .pop) ? UITransitionContextToViewKey : UITransitionContextFromViewKey
if let returningView = transitionContext.viewForKey(transitionModeKey) {
let viewCenter = returningView.center
let viewSize = returningView.frame.size
circle.frame = frameForCircle(withViewCenter: viewCenter, size: viewSize, startPoint: startingPoint)
circle.layer.cornerRadius = circle.frame.size.height / 2
circle.center = startingPoint
UIView.animateWithDuration(duration, animations: {
self.circle.transform = CGAffineTransformMakeScale(0.001, 0.001)
returningView.transform = CGAffineTransformMakeScale(0.001, 0.001)
returningView.center = self.startingPoint
returningView.alpha = 0
if self.transitionMode == .pop {
containerView!.insertSubview(returningView, belowSubview: returningView)
containerView!.insertSubview(self.circle, belowSubview: returningView)
}
}, completion: { (success: Bool) in
returningView.center = viewCenter
returningView.removeFromSuperview()
self.circle.removeFromSuperview()
transitionContext.completeTransition(success)
})
}
}
}
func frameForCircle (withViewCenter viewCenter: CGPoint, size viewSize: CGSize, startPoint: CGPoint) -> CGRect {
let xLength = fmax(startPoint.x, viewSize.width - startPoint.x)
let yLength = fmax(startPoint.y, viewSize.height - startPoint.y)
let offsetVector = sqrt(xLength * xLength + yLength * yLength) * 2
let size = CGSize(width: offsetVector, height: offsetVector)
return CGRect(origin: CGPoint.zero, size: size)
}
}
| mit | 4b34b0806daa5b93ea6fc4ae7d8625f1 | 38.878261 | 124 | 0.584387 | 6.299451 | false | false | false | false |
yuhao-ios/DouYuTVForSwift | DouYuTVForSwift/DouYuTVForSwift/Home/Controller/AmuseVC.swift | 1 | 1363 | //
// AmuseVC.swift
// DouYuTVForSwift
//
// Created by t4 on 17/5/22.
// Copyright © 2017年 t4. All rights reserved.
//
import UIKit
fileprivate let kMenuViewHeight : CGFloat = 200
class AmuseVC: BaseAnchorViewController {
fileprivate lazy var amuseVM : AmuseVM = AmuseVM()
fileprivate lazy var amuseMenuView : AmuseMenuView = {
let menuView = AmuseMenuView.amuseMenuView()
menuView.frame = CGRect(x: 0, y: -kMenuViewHeight, width: kMainWidth, height: kMenuViewHeight)
menuView.backgroundColor = UIColor.white
return menuView
}()
}
extension AmuseVC {
//加载界面
override func loadUI() {
super.loadUI()
//添加菜单View
collectionView.addSubview(amuseMenuView)
collectionView.contentInset = UIEdgeInsets(top: kMenuViewHeight, left: 0, bottom: 0, right: 0)
}
//加载数据
override func loadData () {
super.loadData()
//1.将数据model赋值父类
baseAnchorVm = amuseVM
amuseVM.loadAmuseAllData {
//2.刷新界面
self.collectionView.reloadData()
self.amuseMenuView.groups = self.amuseVM.anchorGroups
//3.数据加载完成 展示内容
self.showContentView()
}
}
}
| mit | b505a781c96f9863e4ef3fe583d9bfd7 | 18.907692 | 106 | 0.598918 | 4.556338 | false | false | false | false |
squiffy/AlienKit | Example/Pods/p2.OAuth2/Sources/Base/OAuth2Base.swift | 1 | 10927 | //
// OAuth2Base.swift
// OAuth2
//
// Created by Pascal Pfiffner on 6/2/15.
// Copyright 2015 Pascal Pfiffner
//
// 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
/// Typealias to ease working with JSON dictionaries.
public typealias OAuth2JSON = [String: AnyObject]
/// Typealias to work with dictionaries full of strings.
public typealias OAuth2StringDict = [String: String]
/**
Abstract base class for OAuth2 authorization as well as client registration classes.
*/
public class OAuth2Base {
/// Server-side settings, as set upon initialization.
final let settings: OAuth2JSON
/// Set to `true` to log all the things. `false` by default. Use `"verbose": bool` in settings.
public var verbose = false
/// If set to `true` (the default) will use system keychain to store tokens. Use `"keychain": bool` in settings.
public var useKeychain = true {
didSet {
if useKeychain {
updateFromKeychain()
}
}
}
/// Defaults to `kSecAttrAccessibleWhenUnlocked`
public internal(set) var keychainAccessMode = kSecAttrAccessibleWhenUnlocked
/**
Base initializer.
Looks at the `keychain`, `keychain_access_mode` and `verbose` keys in the _settings_ dict. Everything else is handled by subclasses.
*/
public init(settings: OAuth2JSON) {
self.settings = settings
// client settings
if let keychain = settings["keychain"] as? Bool {
useKeychain = keychain
}
if let accessMode = settings["keychain_access_mode"] as? String {
keychainAccessMode = accessMode
}
if let verb = settings["verbose"] as? Bool {
verbose = verb
}
// init from keychain
if useKeychain {
updateFromKeychain()
}
logIfVerbose("Initialization finished")
}
// MARK: - Keychain Integration
/** The service key under which to store keychain items. Returns "http://localhost", subclasses override to return the authorize URL. */
public func keychainServiceName() -> String {
return "http://localhost"
}
/** Queries the keychain for tokens stored for the receiver's authorize URL, and updates the token properties accordingly. */
private func updateFromKeychain() {
logIfVerbose("Looking for items in keychain")
do {
var creds = OAuth2KeychainAccount(oauth2: self, account: OAuth2KeychainTokenKey)
let creds_data = try creds.fetchedFromKeychain()
updateFromKeychainItems(creds_data)
}
catch {
logIfVerbose("Failed to load client credentials from keychain: \(error)")
}
do {
var toks = OAuth2KeychainAccount(oauth2: self, account: OAuth2KeychainCredentialsKey)
let toks_data = try toks.fetchedFromKeychain()
updateFromKeychainItems(toks_data)
}
catch {
logIfVerbose("Failed to load tokens from keychain: \(error)")
}
}
/** Updates instance properties according to the items found in the given dictionary, which was found in the keychain. */
func updateFromKeychainItems(items: [String: NSCoding]) {
}
/** Items that should be stored when storing client credentials. */
func storableCredentialItems() -> [String: NSCoding]? {
return nil
}
/** Stores our client credentials in the keychain. */
internal func storeClientToKeychain() {
if let items = storableCredentialItems() {
logIfVerbose("Storing client credentials to keychain")
let keychain = OAuth2KeychainAccount(oauth2: self, account: OAuth2KeychainTokenKey, data: items)
do {
try keychain.saveInKeychain()
}
catch {
logIfVerbose("Failed to store client credentials to keychain: \(error)")
}
}
}
/** Items that should be stored when tokens are stored to the keychain. */
func storableTokenItems() -> [String: NSCoding]? {
return nil
}
/** Stores our current token(s) in the keychain. */
internal func storeTokensToKeychain() {
if let items = storableTokenItems() {
logIfVerbose("Storing tokens to keychain")
let keychain = OAuth2KeychainAccount(oauth2: self, account: OAuth2KeychainCredentialsKey, data: items)
do {
try keychain.saveInKeychain()
}
catch {
logIfVerbose("Failed to store tokens to keychain: \(error)")
}
}
}
/** Unsets the client credentials and deletes them from the keychain. */
public func forgetClient() {
logIfVerbose("Forgetting client credentials and removing them from keychain")
let keychain = OAuth2KeychainAccount(oauth2: self, account: OAuth2KeychainTokenKey)
do {
try keychain.removeFromKeychain()
}
catch {
logIfVerbose("Failed to delete credentials from keychain: \(error)")
}
}
/** Unsets the tokens and deletes them from the keychain. */
public func forgetTokens() {
logIfVerbose("Forgetting tokens and removing them from keychain")
let keychain = OAuth2KeychainAccount(oauth2: self, account: OAuth2KeychainCredentialsKey)
do {
try keychain.removeFromKeychain()
}
catch {
logIfVerbose("Failed to delete tokens from keychain: \(error)")
}
}
// MARK: - Requests
/// The instance's current session, creating one by the book if necessary.
public var session: NSURLSession {
if nil == _session {
if let delegate = sessionDelegate {
let config = sessionConfiguration ?? NSURLSessionConfiguration.defaultSessionConfiguration()
_session = NSURLSession(configuration: config, delegate: delegate, delegateQueue: nil)
}
else if let config = sessionConfiguration {
_session = NSURLSession(configuration: config, delegate: nil, delegateQueue: nil)
}
else {
_session = NSURLSession.sharedSession()
}
}
return _session!
}
/// The backing store for `session`.
private var _session: NSURLSession?
/// The configuration to use when creating `session`. Uses `sharedSession` or one with `defaultSessionConfiguration` if nil.
public var sessionConfiguration: NSURLSessionConfiguration? {
didSet {
_session = nil
}
}
/// URL session delegate that should be used for the `NSURLSession` the instance uses for requests.
public var sessionDelegate: NSURLSessionDelegate? {
didSet {
_session = nil
}
}
/**
Perform the supplied request and call the callback with the response JSON dict or an error.
This implementation uses the shared `NSURLSession` and executes a data task. If the server responds with an error, this will be
converted into an error according to information supplied in the response JSON (if availale).
- parameter request: The request to execute
- parameter callback: The callback to call when the request completes/fails; data and error are mutually exclusive
*/
public func performRequest(request: NSURLRequest, callback: ((data: NSData?, status: Int?, error: ErrorType?) -> Void)) {
let task = session.dataTaskWithRequest(request) { sessData, sessResponse, error in
self.abortableTask = nil
if let error = error {
if NSURLErrorDomain == error.domain && -999 == error.code { // request was cancelled
callback(data: nil, status: nil, error: OAuth2Error.RequestCancelled)
}
else {
callback(data: nil, status: nil, error: error)
}
}
else if let data = sessData, let http = sessResponse as? NSHTTPURLResponse {
callback(data: data, status: http.statusCode, error: nil)
}
else {
let error = OAuth2Error.Generic("Unknown response \(sessResponse) with data “\(NSString(data: sessData!, encoding: NSUTF8StringEncoding))”")
callback(data: nil, status: nil, error: error)
}
}
abortableTask = task
task.resume()
}
/// Currently running abortable session task.
private var abortableTask: NSURLSessionTask?
/**
Can be called to immediately abort the currently running authorization request, if it was started by `performRequest()`.
- returns: A bool indicating whether a task was aborted or not
*/
func abortTask() -> Bool {
guard let task = abortableTask else {
return false
}
logIfVerbose("Aborting request")
task.cancel()
return true
}
// MARK: - Response Verification
/**
Handles access token error response.
- parameter params: The URL parameters returned from the server
- parameter fallback: The message string to use in case no error description is found in the parameters
- returns: An OAuth2Error
*/
public func assureNoErrorInResponse(params: OAuth2JSON, fallback: String? = nil) throws {
// "error_description" is optional, we prefer it if it's present
if let err_msg = params["error_description"] as? String {
throw OAuth2Error.ResponseError(err_msg)
}
// the "error" response is required for error responses, so it should be present
if let err_code = params["error"] as? String {
throw OAuth2Error.fromResponseError(err_code, fallback: fallback)
}
}
// MARK: - Utilities
/**
Parse string-only JSON from NSData.
- parameter data: NSData returned from the call, assumed to be JSON with string-values only.
- returns: An OAuth2JSON instance
*/
func parseJSON(data: NSData) throws -> OAuth2JSON {
if let json = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? OAuth2JSON {
return json
}
if let str = NSString(data: data, encoding: NSUTF8StringEncoding) {
logIfVerbose("Unparsable JSON was: \(str)")
}
throw OAuth2Error.JSONParserError
}
/**
Parse a query string into a dictionary of String: String pairs.
If you're retrieving a query or fragment from NSURLComponents, use the `percentEncoded##` variant as the others
automatically perform percent decoding, potentially messing with your query string.
- parameter query: The query string you want to have parsed
- returns: A dictionary full of strings with the key-value pairs found in the query
*/
public final class func paramsFromQuery(query: String) -> OAuth2StringDict {
let parts = query.characters.split() { $0 == "&" }.map() { String($0) }
var params = OAuth2StringDict(minimumCapacity: parts.count)
for part in parts {
let subparts = part.characters.split() { $0 == "=" }.map() { String($0) }
if 2 == subparts.count {
params[subparts[0]] = subparts[1].wwwFormURLDecodedString
}
}
return params
}
/**
Debug logging, will only log if `verbose` is YES.
*/
public func logIfVerbose(log: String) {
if verbose {
print("OAuth2: \(log)")
}
}
}
/**
Helper function to ensure that the callback is executed on the main thread.
*/
func callOnMainThread(callback: (Void -> Void)) {
if NSThread.isMainThread() {
callback()
}
else {
dispatch_sync(dispatch_get_main_queue(), callback)
}
}
| mit | f61c59ed95be298d784fd8c77bb9eca6 | 30.208571 | 144 | 0.716378 | 3.960479 | false | false | false | false |
Tombio/Trafalert | iOS Client/Trafalert/DataFetcher.swift | 1 | 2925 | //
// DataFetcher.swift
// Trafalert
//
// Created by Tomi Lahtinen on 02/02/16.
// Copyright © 2016 Tomi Lahtinen. All rights reserved.
//
import Foundation
import Alamofire
import ObjectMapper
class DataFetcher {
//static let server = "http://localhost:8080"
static let server = "https://trafalert.herokuapp.com"
static let infoEndPoint = "/info" // get weather + warnings
static let weatherEndPoint = "/weather" // get weather only
static let warningEndPoint = "/warning" // get warnings only
static let stationMetaEndPoint = "/meta/station"
func updateWeatherInfo(station: Int, callback: (WeatherStationData) -> Void) {
let address = String(format: "%@%@/%d", arguments:[DataFetcher.server, DataFetcher.infoEndPoint, station])
debugPrint("Address \(address)")
Alamofire.request(.POST, address, parameters: nil,
headers: ["API_KEY": DataFetcher.apiKey]).responseJSON() {
(response) in
if let json = response.result.value {
if let weather = Mapper<WeatherStationData>().map(json) {
callback(weather)
}
}
else {
debugPrint("Failed to update info \(address) => \(response.result.error)")
}
}
}
func updateWarningStations(callback: (Array<WarningInfo>) -> Void){
let address = String(format: "%@%@", arguments:[DataFetcher.server, DataFetcher.warningEndPoint])
Alamofire.request(.POST, address, parameters: nil,
headers: ["API_KEY": DataFetcher.apiKey]).responseJSON() {
(response) in
if let warnings = Mapper<WarningInfo>().mapArray(response.result.value) {
callback(warnings)
}
}
}
func fetchStationMetaData(callback: (Array<WeatherStationGroup>) -> Void) {
let address = String(format: "%@%@", arguments:[DataFetcher.server, DataFetcher.stationMetaEndPoint])
Alamofire.request(.POST, address, parameters: nil,
headers: ["API_KEY": DataFetcher.apiKey]).responseJSON() {
(response) in
if let stations = Mapper<WeatherStationGroup>().mapArray(response.result.value) {
debugPrint("Stations \(stations.count)")
callback(stations)
}
else {
fatalError("Station fetching failed")
}
}
}
static var apiKey: String {
if let path = NSBundle.mainBundle().pathForResource("properties", ofType: "plist"), dict = NSDictionary(contentsOfFile: path) as? [String: AnyObject] {
if let apiKey = dict["API_KEY"] {
return apiKey as! String
}
}
fatalError("Unable to read API key from properties.plist")
}
} | mit | c4c041e7f1fcaaa5595d265b73215510 | 39.068493 | 159 | 0.581053 | 4.914286 | false | false | false | false |
tatsuyamoriguchi/PoliPoli | View Controller/LoginViewController.swift | 1 | 12014 | //
// LoginViewController.swift
// Poli
//
// Created by Tatsuya Moriguchi on 8/4/18.
// Copyright © 2018 Becko's Inc. All rights reserved.
//
import UIKit
import QuartzCore
// Keychain Configuration
struct KeychainConfiguration {
static let serviceName = "Poli"
static let accessGroup: String? = nil
}
class LoginViewController: UIViewController, UITextFieldDelegate, CAAnimationDelegate, CALayerDelegate {
@IBOutlet weak var loginButton: UIButton!
@IBOutlet weak var createLogin: UIButton!
@IBOutlet weak var createInfoLabel: UILabel!
@IBOutlet weak var touchIDButton: UIButton!
var passwordItems: [KeychainPasswordItem] = []
// MARK: - ANIMATION
// Declare a layer variable for animation
var mask: CALayer?
// MARK: - LOGIN VIEW
// Variables
var userName: String = ""
var userPassword: String = ""
var isOpening: Bool = true
// Create a reference to BiometricIDAuth
let touchMe = BiometricIDAuth()
// Properties
@IBOutlet weak var userNameTextField: UITextField!
@IBOutlet weak var passwordTextField: UITextField!
@IBAction func registerPressed(_ sender: UIButton) {
userName = userNameTextField.text!
userPassword = passwordTextField.text!
// User login account already exists alert
if (UserDefaults.standard.object(forKey: "userName") as? String) != nil {
let NSL_alertTitle_001 = NSLocalizedString("NSL_alertTitle_001", value: "User Already Exists", comment: "")
let NSL_alertMessage_001 = NSLocalizedString("NSL_alertMessage_001", value: "This App already has a user. To change your user info, login Poli and go to Settings.", comment: " ")
AlertNotification().alert(title: NSL_alertTitle_001, message: NSL_alertMessage_001, sender: self)
// If any of user info is missing, display an alert.
} else if userNameTextField.text == "" || passwordTextField.text == "" {
// no enough input entry alert
let NSL_alertTitle_002 = NSLocalizedString("NSL_alertTitle_002", value: "Need More Information", comment: " ")
let NSL_alertMessage_002 = NSLocalizedString("NSL_alertMessage_002", value: "Fill both information: User Name and Password", comment: " ")
AlertNotification().alert(title: NSL_alertTitle_002, message: NSL_alertMessage_002, sender: self)
} else {
// Create a KeychainPasswordItem with the service Name, newAccountName(username) and accessGroup. Using Swift's error handling, you try to save the password. The catch is there if something goes wrong.
do {
// This is a new account, create a new keychain item with the account name.
let passwordItem = KeychainPasswordItem(service: KeychainConfiguration.serviceName, account: userName, accessGroup: KeychainConfiguration.accessGroup)
// Save the password for the new item.
try passwordItem.savePassword(userPassword)
}catch {
fatalError("Error updating keychain = \(error)")
}
// Set a user login account
UserDefaults.standard.set(userName, forKey: "userName")
//UserDefaults.standard.set(userPassword, forKey: "userPassword")
userNameTextField.text = ""
passwordTextField.text = ""
let NSL_alertTitle_003 = NSLocalizedString("NSL_NSL_alertTitle_003", value: "User Account Created", comment: " ")
let NSL_alertMessage_003 = NSLocalizedString("NSL_alertMessage_003", value: "Please use the user name and password just created to login Poli.", comment: " ")
AlertNotification().alert(title: NSL_alertTitle_003, message: NSL_alertMessage_003, sender: self)
}
}
@IBAction func loginPressed(_ sender: UIButton) {
userName = userNameTextField.text!
userPassword = passwordTextField.text!
let storedUserName = UserDefaults.standard.object(forKey: "userName") as? String
//let storedPassword = UserDefaults.standard.object(forKey: "userPassword") as? String
if (storedUserName == nil) {
let NSL_alertTitle_004 = NSLocalizedString("NSL_alertTitle_004", value: "No Account", comment: " ")
let NSL_alertMessage_004 = NSLocalizedString("NSL_alertMessage_004", value: "No account is registered yet. Please create an account.", comment: " ")
AlertNotification().alert(title: NSL_alertTitle_004, message: NSL_alertMessage_004, sender: self)
}
//else if userName == storedUserName && userPassword == storedPassword {
// If the user is logging in, call checkLogin to verify the user-provided credentials; if they match then you dismiss the login view.
else if checkLogin(username: userName, password: userPassword) {
UserDefaults.standard.set(true, forKey: "isLoggedIn")
UserDefaults.standard.synchronize()
performSegue(withIdentifier: "loginSegue", sender: self)
} else {
let NSL_alertTitle_005 = NSLocalizedString("NSL_alertTitle_005", value: "Authentification Failed", comment: " ")
let NSL_alertMessage_005 = NSLocalizedString("NSL_alertMessage_005", value: "Data you entered didn't match with user information.", comment: " ")
AlertNotification().alert(title: NSL_alertTitle_005, message: NSL_alertMessage_005, sender: self)
}
}
@IBAction func touchIDLoginAction() {
/*
touchMe.authenticateUser() { [weak self] inrr
self?.performSegue(withIdentifier: "loginSegue", sender: self)
}
*/
// 1 Update the trailing closure to accept an optional message.
// If biometric ID works, no message.
touchMe.authenticateUser() { [weak self] message in
// 2 Unwrap the message and display it with an alert.
if (UserDefaults.standard.object(forKey: "userName") as? String) == nil {
AlertNotification().alert(title: "Error", message: "No User Name found", sender: self!)
} else if let message = message {
// if the completion is not nil show an alert
let alertView = UIAlertController(title: "Error",
message: message,
preferredStyle: .alert)
let okAction = UIAlertAction(title: "Darn!", style: .default)
alertView.addAction(okAction)
self?.present(alertView, animated: true)
} else {
UserDefaults.standard.set(true, forKey: "isLoggedIn")
UserDefaults.standard.synchronize()
// 3 if no message, dismiss the Login view.
self?.performSegue(withIdentifier: "loginSegue", sender: self)
}
}
}
func checkLogin(username: String, password: String) -> Bool {
guard username == UserDefaults.standard.value(forKey: "userName") as? String else {
return false
}
do {
let passwordItem = KeychainPasswordItem(service: KeychainConfiguration.serviceName, account: username, accessGroup: KeychainConfiguration.accessGroup)
let keychainPassword = try passwordItem.readPassword()
return password == keychainPassword
} catch {
fatalError("Error reading passwod from keychain - \(error)")
}
}
override func viewDidLoad() {
super.viewDidLoad()
// Opening Animation
maskView()
animate()
// Opening Sound
if isOpening != false {
PlayAudio.sharedInstance.playClick(fileName: "bigdog", fileExt: ".wav")
isOpening = false
}
userNameTextField.delegate = self
passwordTextField.delegate = self
// Find whether the device can implement biometric authentication
// If so, show the Touch ID button.
touchIDButton.isHidden = !touchMe.canEvaluatePolicy()
// Fix the button's icon
switch touchMe.biometricType() {
case .faceID:
touchIDButton.setImage(UIImage(named: "FaceIcon"), for: .normal)
default:
touchIDButton.setImage(UIImage(named: "Touch-icon-lg"), for: .normal)
}
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
let touchBool = touchMe.canEvaluatePolicy()
if touchBool {
touchIDLoginAction()
}
}
// Create a layer
func maskView() {
self.mask = CALayer()
self.mask!.contents = UIImage(named: "dogpow")!.cgImage
self.mask!.bounds = CGRect(x: 0, y: 0, width: 100, height: 100)
self.mask!.anchorPoint = CGPoint(x: 0.5, y: 0.5)
self.mask!.position = CGPoint(x: view.frame.size.width/2, y: view.frame.size.height/2)
view.layer.mask = mask
}
// Do Animation
func animate() {
let keyFrameAnimation = CAKeyframeAnimation(keyPath: "bounds")
keyFrameAnimation.delegate = self
keyFrameAnimation.beginTime = CACurrentMediaTime() + 1
keyFrameAnimation.duration = 2
keyFrameAnimation.timingFunctions = [CAMediaTimingFunction(name: CAMediaTimingFunctionName.easeInEaseOut), CAMediaTimingFunction(name: CAMediaTimingFunctionName.easeInEaseOut)]
let initialBounds = NSValue(cgRect: mask!.bounds)
let secondBounds = NSValue(cgRect: CGRect(x: 0, y: 0, width: 60, height: 60))
let finalBounds = NSValue(cgRect: CGRect(x: 0, y: 0, width: 1500, height: 1500))
keyFrameAnimation.values = [initialBounds, secondBounds, finalBounds]
keyFrameAnimation.keyTimes = [0, 0.3, 1]
self.mask!.add(keyFrameAnimation, forKey: "bounds")
}
// Remove sublayer after animation is done to expose login view
func animationDidStop(_ anim: CAAnimation, finished flag: Bool) {
mask?.removeFromSuperlayer()
}
// To dismiss a keyboard
func textFieldShouldReturn(_ textField: UITextField) -> Bool {
userNameTextField.resignFirstResponder()
passwordTextField.resignFirstResponder()
return true
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
self.view.endEditing(true)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
/*
// Refactoring alert message
// Learn how to pass action to handler
func alert(title: String, message: String) {
let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "OK", style: .default, handler: nil))
self.present(alert, animated: true, completion: nil)
}
*/
// 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.
if segue.identifier == "loginSegue" {
let destVC = segue.destination as! UINavigationController
let targetVC = destVC.topViewController as! GoalTableViewController
targetVC.userName = userName
}
// Pass the selected object to the new view controller.
}
}
| gpl-3.0 | ea55769aada27c46d817812e89e97176 | 39.312081 | 213 | 0.620078 | 5.200433 | false | false | false | false |
IamAlchemist/DemoAnimations | Animations/DraggableView.swift | 2 | 1389 | //
// DraggableView.swift
// DemoAnimations
//
// Created by wizard on 5/4/16.
// Copyright © 2016 Alchemist. All rights reserved.
//
import UIKit
protocol DraggableViewDelegate : class {
func draggableView(view: DraggableView, draggingEndedWithVelocity velocity: CGPoint)
func draggableViewBeganDraggin(view: DraggableView)
}
class DraggableView : UIView {
weak var delegate : DraggableViewDelegate?
override init(frame: CGRect) {
super.init(frame: frame)
setup()
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
setup()
}
func setup() {
let recognizer = UIPanGestureRecognizer(target: self, action: #selector(didPan(_:)))
addGestureRecognizer(recognizer)
}
func didPan(recognizer : UIPanGestureRecognizer) {
let point = recognizer.translationInView(superview)
center = CGPoint(x: center.x, y: center.y + point.y)
recognizer.setTranslation(CGPointZero, inView: superview)
if case .Ended = recognizer.state {
var velocity = recognizer.velocityInView(superview)
velocity.x = 0
delegate?.draggableView(self, draggingEndedWithVelocity: velocity)
}
else if case .Began = recognizer.state {
delegate?.draggableViewBeganDraggin(self)
}
}
} | mit | 6180c7455313a6ed67da9b279cbd616a | 27.9375 | 92 | 0.650576 | 4.673401 | false | false | false | false |
karyjan/KMediaPlayer | KMediaPlayer/Button.swift | 1 | 1465 | //
// Button.swift
// MobilePlayer
//
// Created by Baris Sencan on 9/16/15.
// Copyright (c) 2015 MovieLaLa. All rights reserved.
//
import UIKit
class Button: UIButton {
let config: ButtonConfig
init(config: ButtonConfig = ButtonConfig()) {
self.config = config
super.init(frame: CGRectZero)
accessibilityLabel = accessibilityLabel ?? config.identifier
tintColor = config.tintColor
setImage(config.image, forState: .Normal)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func sizeThatFits(size: CGSize) -> CGSize {
let superSize = super.sizeThatFits(size)
return CGSize(
width: (config.widthCalculation == .AsDefined) ? config.width : superSize.width,
height: config.height)
}
override func setImage(image: UIImage?, forState state: UIControlState) {
let tintedImage = image?.imageWithRenderingMode(UIImageRenderingMode.AlwaysTemplate)
super.setImage(tintedImage, forState: state)
}
}
// MARK: - Element
extension Button: Element {
var type: ElementType { return config.type }
var identifier: String? { return config.identifier }
var widthCalculation: ElementWidthCalculation { return config.widthCalculation }
var width: CGFloat { return config.width }
var marginLeft: CGFloat { return config.marginLeft }
var marginRight: CGFloat { return config.marginRight }
var view: UIView { return self }
}
| apache-2.0 | 20da556f3a123571bb826e0722b07ece | 30.170213 | 92 | 0.716724 | 4.466463 | false | true | false | false |
oddpanda/SegmentControl | segmentControl.swift | 1 | 2066 | //
// segmentControl.swift
// Edinburgh Mums
//
// Created by Shaun Gillon on 27/08/2015.
// Copyright (c) 2015 Odd Panda Design Ltd. All rights reserved.
//
import UIKit
class segmentControlView: UISegmentedControl {
var borderView: UIView!
var segBackgroundColor : UIColor = UIColor.whiteColor()
//border Variables
var borderColor : UIColor = UIColor.greenColor()
var borderHeight :CGFloat = 2
//Font Variables
var fontColour = UIColor(red: 102.0/255, green: 145.0/255, blue: 142.0/255, alpha: 1.0)
var selectedFontColour = UIColor(red: 102.0/255, green: 145.0/255, blue: 142.0/255, alpha: 1.0)
var fontType = UIFont(name: "AvenirNext-Regular", size: 14.0)
override func drawRect(rect: CGRect) {
self.setTitleTextAttributes([NSForegroundColorAttributeName: fontColour, NSFontAttributeName : fontType!], forState: .Normal)
self.setTitleTextAttributes([NSForegroundColorAttributeName: selectedFontColour, NSFontAttributeName : fontType!], forState: .Selected)
self.backgroundColor = segBackgroundColor
self.tintColor = UIColor.clearColor()
let segmentCount = self.numberOfSegments
let width = self.frame.width
let height = self.frame.height - 5
let border = width/CGFloat(segmentCount)
self.borderView = UIView(frame: CGRectMake(0, height, border, borderHeight))
self.borderView.backgroundColor = borderColor
self.addSubview(borderView)
}
func animateBorderToSegment(segment : Int){
UIView.animateWithDuration(0.7, delay: 0, usingSpringWithDamping: 0.5, initialSpringVelocity: 0, options: nil, animations: {
let segmentCount = self.numberOfSegments
let width = self.frame.width
let border = width/CGFloat(segmentCount)
let difference = CGFloat(segment) * border
self.borderView.frame.origin.x = difference
}, completion: nil)
}
}
| gpl-2.0 | 52ce51a6e1fc6738a97b2239088521d3 | 34.016949 | 144 | 0.655857 | 4.695455 | false | false | false | false |
Yurssoft/QuickFile | QuickFile/ViewModels/YSPlaylistViewModel.swift | 1 | 4479 | //
// YSPlaylistViewModel.swift
// YSGGP
//
// Created by Yurii Boiko on 12/6/16.
// Copyright © 2016 Yurii Boiko. All rights reserved.
//
import Foundation
class YSPlaylistViewModel: YSPlaylistViewModelProtocol {
func viewIsLoadedAndReadyToDisplay(_ completion: @escaping CompletionHandler) {
getFiles { (_) in
completion()
}
}
var model: YSPlaylistAndPlayerModelProtocol?
fileprivate var files = [YSDriveFileProtocol]() {
didSet {
folders = selectFolders()
}
}
var folders = [YSDriveFileProtocol]()
weak var viewDelegate: YSPlaylistViewModelViewDelegate?
weak var coordinatorDelegate: YSPlaylistViewModelCoordinatorDelegate?
func numberOfFiles(in folder: Int) -> Int {
guard folders.count > folder else { return 0 }
let folderFile = folders[folder]
let filesInFolder = files.filter { $0.folder.folderID == folderFile.id && $0.isAudio }
return filesInFolder.count
}
var numberOfFolders: Int {
return folders.count
}
func selectFolders() -> [YSDriveFileProtocol] {
let folders = files.filter {
let folderFile = $0
if !folderFile.isAudio {
let filesInFolder = files.filter { $0.folder.folderID == folderFile.id && $0.isAudio }
return filesInFolder.count > 0
} else {
return false
}
}
return folders
}
var error: YSErrorProtocol = YSError() {
didSet {
if !error.isEmpty() {
viewDelegate?.errorDidChange(viewModel: self, error: error)
}
}
}
func file(at index: Int, folderIndex: Int) -> YSDriveFileProtocol? {
guard folders.count > folderIndex else { return nil }
let folderFile = folders[folderIndex]
let filesInFolder = files.filter { $0.folder.folderID == folderFile.id && $0.isAudio }
guard filesInFolder.count > index else { return nil }
let file = filesInFolder[index]
return file
}
func folder(at index: Int) -> YSDriveFileProtocol? {
guard folders.count > index else { return nil }
let folderFile = folders[index]
return folderFile
}
func useFile(at folder: Int, file: Int) {
let audio = self.file(at: file, folderIndex: folder)
coordinatorDelegate?.playlistViewModelDidSelectFile(self, file: audio!)
}
func removeDownloads() {
}
func getFiles(completion: @escaping ErrorCH) {
files = []
model?.allFiles { (files, currentPlayingFile, error) in
defer {
}
self.files = files
if let error = error {
self.error = error
}
DispatchQueue.main.async {
completion(error)
}
if let currentPlayingFile = currentPlayingFile {
let indexPathOfCurrentPlaying = self.indexPath(of: currentPlayingFile)
if !files.isEmpty {
self.viewDelegate?.scrollToCurrentlyPlayingFile(at: indexPathOfCurrentPlaying)
}
}
}
}
func indexPath(of file: YSDriveFileProtocol) -> IndexPath {
let fileFolderIndex = folders.index(where: { $0.id == file.folder.folderID })
let filesInFolder = files.filter { $0.folder.folderID == file.folder.folderID && $0.isAudio }
let fileIndex = filesInFolder.index(where: { $0.id == file.id })
let indexPath = IndexPath.init(row: fileIndex ?? 0, section: fileFolderIndex ?? 0)
return indexPath
}
}
extension YSPlaylistViewModel: YSUpdatingDelegate {
func downloadDidChange(_ download: YSDownloadProtocol, _ error: YSErrorProtocol?) {
getFiles { (_) in
self.viewDelegate?.filesDidChange(viewModel: self)
}
}
func filesDidChange() {
getFiles { (_) in
self.viewDelegate?.filesDidChange(viewModel: self)
}
}
}
extension YSPlaylistViewModel: YSPlayerDelegate {
func fileDidChange(file: YSDriveFileProtocol) {
let indexOfUpdatingFile = files.index(where: { $0.id == file.id })
if let indexOfUpdatingFile = indexOfUpdatingFile, files.indices.contains(indexOfUpdatingFile) {
files[indexOfUpdatingFile] = file
}
viewDelegate?.fileDidChange(viewModel: self)
}
}
| mit | 6762a4d1b95bd500bf0b23913de6c0cc | 30.535211 | 106 | 0.604064 | 4.851571 | false | false | false | false |
MrAlek/Swift-NSFetchedResultsController-Trickery | CoreDataTrickerySwift/ToDoSection.swift | 1 | 677 | //
// ToDoSection.swift
// CoreDataTrickerySwift
//
// Created by Alek Åström on 2015-09-13.
// Copyright © 2015 Apps and Wonders. All rights reserved.
//
import Foundation
enum ToDoSection: String {
case ToDo = "10"
case HighPriority = "11"
case MediumPriority = "12"
case LowPriority = "13"
case Done = "20"
var title: String {
switch self {
case .ToDo: return "Left to do"
case .Done: return "Done"
case .HighPriority: return "High priority"
case .MediumPriority: return "Medium priority"
case .LowPriority: return "Low priority"
}
}
}
| mit | 1cca8c94664e62d21cb8303a5e5f2015 | 23.962963 | 59 | 0.578635 | 3.873563 | false | false | false | false |
cp3hnu/Bricking | Bricking/Source/Collapse.swift | 1 | 7052 | //
// Collapse.swift
// Bricking
//
// Created by CP3 on 17/4/12.
// Copyright © 2017年 CP3. All rights reserved.
//
import Foundation
#if os(iOS)
import UIKit
#elseif os(OSX)
import AppKit
#endif
extension View {
private struct AssociatedKeys {
static var previousConstraint = "previousConstraint"
static var nextConstraint = "nextConstraint"
static var currentConstraint = "currentConstraint"
static var isBottomSpaceReserved = "isBottomSpaceReserved"
static var isRightSpaceReserved = "isRightSpaceReserved"
}
private var previousConstraint: NSLayoutConstraint? {
get {
return objc_getAssociatedObject(self, &AssociatedKeys.previousConstraint) as? NSLayoutConstraint
}
set {
objc_setAssociatedObject(self, &AssociatedKeys.previousConstraint, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
private var nextConstraint: NSLayoutConstraint? {
get {
return objc_getAssociatedObject(self, &AssociatedKeys.nextConstraint) as? NSLayoutConstraint
}
set {
objc_setAssociatedObject(self, &AssociatedKeys.nextConstraint, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
private var currentConstraint: NSLayoutConstraint? {
get {
return objc_getAssociatedObject(self, &AssociatedKeys.currentConstraint) as? NSLayoutConstraint
}
set {
objc_setAssociatedObject(self, &AssociatedKeys.currentConstraint, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
public var isBottomSpaceReserved: Bool? {
get {
return objc_getAssociatedObject(self, &AssociatedKeys.isBottomSpaceReserved) as? Bool
}
set {
objc_setAssociatedObject(self, &AssociatedKeys.isBottomSpaceReserved, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_ASSIGN)
}
}
public var isRightSpaceReserved: Bool? {
get {
return objc_getAssociatedObject(self, &AssociatedKeys.isRightSpaceReserved) as? Bool
}
set {
objc_setAssociatedObject(self, &AssociatedKeys.isRightSpaceReserved, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_ASSIGN)
}
}
public var collapseVertically: Bool {
get {
return isHidden
}
set {
isHidden = newValue
if newValue {
changeVerticalConstraint()
} else {
self.currentConstraint?.isActive = false
self.previousConstraint?.isActive = true
self.nextConstraint?.isActive = true
}
}
}
public var collapseHorizontally: Bool {
get {
return isHidden
}
set {
isHidden = newValue
if newValue {
changeHorizontalConstraint()
} else {
self.currentConstraint?.isActive = false
self.previousConstraint?.isActive = true
self.nextConstraint?.isActive = true
}
}
}
private func changeVerticalConstraint() {
let (pView, pConstraint, pAttribute, pConstant) = constraintFor(.top)
let (nView, nConstraint, nAttribute, nConstant) = constraintFor(.bottom)
guard let preView = pView, let nextView = nView, let preConstraint = pConstraint, let nextConstraint = nConstraint, let preAttribute = pAttribute, let nextAttribute = nAttribute else { return }
preConstraint.isActive = false
nextConstraint.isActive = false
self.previousConstraint = preConstraint
self.nextConstraint = nextConstraint
var constant = pConstant
if let isBottom = self.isBottomSpaceReserved, isBottom == true {
constant = nConstant
}
self.currentConstraint = NSLayoutConstraint(item: preView,
attribute: preAttribute,
relatedBy: .equal,
toItem: nextView,
attribute: nextAttribute,
multiplier: 1.0,
constant: constant)
self.currentConstraint!.isActive = true
}
private func changeHorizontalConstraint() {
let (pView, pConstraint, pAttribute, pConstant) = constraintFor(.leading)
let (nView, nConstraint, nAttribute, nConstant) = constraintFor(.trailing)
guard let preView = pView, let nextView = nView, let preConstraint = pConstraint, let nextConstraint = nConstraint, let preAttribute = pAttribute, let nextAttribute = nAttribute else { return }
preConstraint.isActive = false
nextConstraint.isActive = false
self.previousConstraint = preConstraint
self.nextConstraint = nextConstraint
var constant = pConstant
if let isRight = self.isRightSpaceReserved, isRight == true {
constant = nConstant
}
self.currentConstraint = NSLayoutConstraint(item: preView,
attribute: preAttribute,
relatedBy: .equal,
toItem: nextView,
attribute: nextAttribute,
multiplier: 1.0,
constant: constant)
self.currentConstraint!.isActive = true
}
private func constraintFor(_ attribute: LayoutAttribute) -> (View?, NSLayoutConstraint?, LayoutAttribute?, constant: CGFloat) {
if let spv = superview {
for c in spv.constraints {
if let fi = c.firstItem as? View, fi == self && c.firstAttribute == attribute {
var constant = c.constant
if attribute == LayoutAttribute.leading || attribute == LayoutAttribute.top {
constant = -c.constant
}
return (c.secondItem as? View, c, c.secondAttribute, constant)
}
if let si = c.secondItem as? View, si == self && c.secondAttribute == attribute {
var constant = c.constant
if attribute == LayoutAttribute.trailing || attribute == LayoutAttribute.bottom {
constant = -c.constant
}
return (c.firstItem as? View, c, c.firstAttribute, constant)
}
}
}
return (nil, nil, nil, 0)
}
}
| mit | 18e076123b836c758474e18bd7adb6d8 | 37.944751 | 201 | 0.559228 | 6.045455 | false | false | false | false |
buyiyang/iosstar | iOSStar/General/Extension/QiniuTool.swift | 3 | 4870 | //
// QiniuTool.swift
// iOSStar
//
// Created by mu on 2017/8/19.
// Copyright © 2017年 YunDian. All rights reserved.
//
import UIKit
import Alamofire
import Kingfisher
import Qiniu
class QiniuTool: NSObject {
static let tool = QiniuTool()
class func shared() -> QiniuTool{
return tool
}
func getIPAdrees() {
Alamofire.request(AppConst.ipUrl).responseString { (response) in
if let value = response.result.value {
if let ipValue = value.components(separatedBy: ",").first{
print(ipValue)
let ipString = (ipValue as NSString).substring(with: NSRange.init(location: 6, length: ipValue.length() - 7))
self.getIPInfoAdrees(ipString)
}
}
}
}
func getIPInfoAdrees(_ ipString: String) {
Alamofire.request(AppConst.ipInfoUrl).responseJSON { (response) in
if let value = response.result.value as? NSDictionary{
if let dataDic = value.value(forKey: "data") as? NSDictionary{
if let area = dataDic.value(forKey: "area") as? String{
ShareDataModel.share().netInfo.area = area
self.getQiniuHeader(area)
}
if let areaId = dataDic.value(forKey: "area_id") as? NSString{
ShareDataModel.share().netInfo.area_id = Int((areaId).intValue)
}
if let isp = dataDic.value(forKey: "isp") as? String{
ShareDataModel.share().netInfo.isp = isp
}
if let isp_id = dataDic.value(forKey: "isp_id") as? NSString{
ShareDataModel.share().netInfo.isp_id = Int((isp_id).intValue)
}
}
}
}
}
func getQiniuHeader(_ area: String) {
AppAPIHelper.login().qiniuHttpHeader(complete: { (result) in
if let model = result as? QinniuModel{
if area == "华南"{
ShareDataModel.share().qiniuHeader = model.QINIU_URL_HUANAN
return
}
if area == "华北"{
ShareDataModel.share().qiniuHeader = model.QINIU_URL_HUABEI
return
}
if area == "华东"{
ShareDataModel.share().qiniuHeader = model.QINIU_URL_HUADONG
return
}
}
}, error: nil)
}
func upload(_ path : URL, _ type : Bool){
//获取 token
}
//上传图片
class func qiniuUploadImage(image: UIImage,imageName: String, complete: CompleteBlock?, error: ErrorBlock?) {
let filePath = UIImage.cacheImage(image, imageName: imageName)
let timestamp = NSDate().timeIntervalSince1970
let key = "\(imageName)\(Int(timestamp)).png"
uploadResource(filePath: filePath, key: key, complete: complete, error: error)
}
//上传视频
class func qiniuUploadVideo(filePath: String,videoName: String, complete: CompleteBlock?, error: ErrorBlock?) {
let timestamp = NSDate().timeIntervalSince1970
let key = "\(videoName)\(Int(timestamp)).mp4"
uploadResource(filePath: filePath, key: key, complete: complete, error: error)
}
//上传声音
class func qiniuUploadVoice(filePath: String,voiceName: String, complete: CompleteBlock?, error: ErrorBlock?) {
let timestamp = NSDate().timeIntervalSince1970
let key = "\(voiceName)\(Int(timestamp)).mp3"
uploadResource(filePath: filePath, key: key, complete: complete, error: error)
}
class func uploadResource(filePath : String, key : String, complete: CompleteBlock?, error: ErrorBlock?){
AppAPIHelper.user().uploadimg(complete: { (result) in
if let response = result as? UploadTokenModel{
let qiniuManager = QNUploadManager()
qiniuManager?.putFile(filePath, key: key, token: response.uptoken, complete: { (info, key, resp) in
if complete == nil{
return
}
if resp == nil {
complete!(nil)
return
}
//3,返回URL
let respDic: NSDictionary? = resp as NSDictionary?
let value:String? = respDic!.value(forKey: "key") as? String
let imageUrl = value!
complete!(imageUrl as AnyObject?)
}, option: nil)
}
}) { (error ) in
}
}
}
| gpl-3.0 | 8bb171767968617ba13195ab4cb106ef | 35.537879 | 129 | 0.52063 | 4.808574 | false | false | false | false |
SASAbus/SASAbus-ios | SASAbus Watch Extension/Controller/MainInterfaceController.swift | 1 | 2192 | import WatchKit
import Foundation
import Realm
import RealmSwift
class MainInterfaceController: WKInterfaceController {
let color = UIColor(hue: 0.08, saturation: 0.85, brightness: 0.90, alpha: 1)
@IBOutlet var nearbyButton: WKInterfaceButton!
@IBOutlet var recentButton: WKInterfaceButton!
@IBOutlet var favoritesButton: WKInterfaceButton!
@IBOutlet var searchButton: WKInterfaceButton!
@IBOutlet var nearbyIcon: WKInterfaceImage!
@IBOutlet var recentIcon: WKInterfaceImage!
@IBOutlet var favoritesIcon: WKInterfaceImage!
@IBOutlet var searchIcon: WKInterfaceImage!
override func awake(withContext context: Any?) {
super.awake(withContext: context)
nearbyIcon.setTintColor(color)
recentIcon.setTintColor(color)
favoritesIcon.setTintColor(color)
searchIcon.setTintColor(color)
}
@IBAction func onSearchButtonPress() {
displaySearch()
}
private func displaySearch() {
var defaults = [String]()
let realm = Realm.busStops()
var filterChain = ""
for id in SearchInterfaceController.defaultBusStopsIds {
filterChain += "family == \(id) OR "
}
filterChain = filterChain.substring(to: filterChain.index(filterChain.endIndex, offsetBy: -4))
let busStops = realm.objects(BusStop.self).filter(filterChain)
for busStop in busStops {
defaults.append(busStop.name())
}
// Filter out duplicate bus stops
defaults = defaults.uniques().sorted()
presentTextInputController(withSuggestions: defaults, allowedInputMode: .plain, completion: {(results) -> Void in
guard let results = results, !results.isEmpty else {
Log.warning("No results returned")
self.popToRootController()
return
}
let busStop = results[0] as! String
Log.info("Searched for '\(busStop)'")
self.pushController(withName: "SearchInterfaceController", context: busStop)
})
}
}
| gpl-3.0 | 38410feecdacb7f4c9dc305e2cca194e | 31.235294 | 121 | 0.626825 | 5.307506 | false | false | false | false |
moppymopperson/HeartView | HeartView/HeartView/HeartView.swift | 1 | 2896 | //
// HeartView.swift
// HeartView
//
// Created by Erik Hornberger on 2017/01/23.
// Copyright © 2017年 EExT. All rights reserved.
//
import Foundation
import UIKit
/**
A heart shaped view that mimicking the one in Apple's CareKit, but
built with .xib file instead, and made to render properly in IB.
*/
@IBDesignable class HeartView: RenderableView {
/**
This is used as the outline of the heart when it is not
full
*/
@IBOutlet private weak var outlineView: UIImageView!
/**
A second copy of the outline image, but this time with the
rendering mode set to template so that all non-transparent pixels
are made the tint color of the view
*/
@IBOutlet private weak var filledHeartImage: UIImageView!
/**
This is resized to hide the top part of the heart view
and create the illusion of the heart filling up.
*/
@IBOutlet private weak var clippingView: UIView!
/**
The distance from the top of the view to the top of the
clipping view (effectively the top of the fill)
*/
@IBOutlet private weak var topConstraint: NSLayoutConstraint!
/**
Set this to between 0 and 1 to adjust the percent of the
heart that is filled.
*/
@IBInspectable var value:CGFloat = 1.0 {
didSet {
updateHeight(animated: true)
}
}
/**
Sets the fill color of the heart. Actually just a mapping of tint.
*/
@IBInspectable var fillColor:UIColor {
get { return tintColor }
set { tintColor = newValue }
}
/**
Additional setup can be performed here. Essentially equivalent to 'viewDidLoad'
*/
override func setup() {
layoutIfNeeded()
filledHeartImage.image = outlineView.image?.withRenderingMode(.alwaysTemplate)
fillColor = .red
}
/**
Play a fill animation
*/
private func updateHeight(animated: Bool) {
if !animated {
topConstraint.constant = self.frame.height * (1 - self.value)
layoutIfNeeded()
return
}
// fill
UIView.animate(withDuration: 1.0) {
self.layoutIfNeeded()
self.topConstraint.constant = self.frame.height * (1 - self.value)
self.layoutIfNeeded()
}
// beat
let animator = UIViewPropertyAnimator(duration: 0.3, curve: .easeOut) {
self.transform = CGAffineTransform.init(scaleX: 1.2, y: 1.2)
}
animator.addCompletion { (position) in
UIViewPropertyAnimator.runningPropertyAnimator(withDuration: 0.5, delay: 0, options: .curveEaseOut, animations: {
self.transform = CGAffineTransform.identity
}, completion: nil)
}
animator.startAnimation()
}
}
| mit | a5569ea752af44d97ad53129825f695e | 27.087379 | 126 | 0.606637 | 4.758224 | false | false | false | false |
CodeEagle/Animate | Source/BasicProperties.swift | 1 | 17071 | //
// BasicProperties.swift
// Pods
//
// Created by LawLincoln on 15/6/24.
//
//
import Foundation
import pop
public class BasicProperties: NSObject {
// MARK: - UIView
public var alpha: CGFloat!{
didSet {
if let value = alpha {
let anim = animator(kPOPViewAlpha)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var center: CGPoint!{
didSet {
if let value = center {
let anim = animator(kPOPViewCenter)
anim.toGenericValue(NSValue(CGPoint:value),type)
addAnimate(anim)
}
}
}
public var frame: CGRect! {
didSet{
if let value = frame {
let anim = animator(kPOPViewFrame)
anim.toGenericValue(NSValue(CGRect:value),type)
addAnimate(anim)
}
}
}
public var tintColor: UIColor!{
didSet {
if let value = tintColor {
if self.type != .Decay {
let anim = animator(kPOPViewTintColor)
anim.toValue = value
addAnimate(anim)
}
}
}
}
// MARK: - Common
public var backgroundColor: UIColor!{
didSet {
if let value = backgroundColor {
var key = kPOPLayerBackgroundColor
if self.target is UIView {
key = kPOPViewBackgroundColor
}
let anim = animator(key)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var bounds: CGRect!{
didSet {
if let value = bounds {
var key = kPOPLayerBounds
if self.target is UIView {
key = kPOPViewBounds
}
let anim = animator(key)
anim.toGenericValue(NSValue(CGRect:value),type)
addAnimate(anim)
}
}
}
public var scaleX: CGFloat!{
didSet {
if let value = scaleX {
var key = kPOPLayerScaleX
if self.target is UIView {
key = kPOPViewScaleX
}
let anim = animator(key)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var scaleXY: CGSize!{
didSet {
if let value = scaleXY {
var key = kPOPLayerScaleXY
if self.target is UIView {
key = kPOPViewScaleXY
}
let anim = animator(key)
anim.toGenericValue(NSValue(CGSize:value),type)
addAnimate(anim)
}
}
}
public var scaleY: CGFloat!{
didSet {
if let value = scaleY {
var key = kPOPLayerScaleY
if self.target is UIView {
key = kPOPViewScaleY
}
let anim = animator(key)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var size: CGSize!{
didSet {
if let value = size {
var key = kPOPLayerSize
if self.target is UIView {
key = kPOPViewSize
}
let anim = animator(key)
anim.toGenericValue(NSValue(CGSize:value),type)
addAnimate(anim)
}
}
}
// MARK: - CALayer
public var cornerRadius: CGFloat!{
didSet {
if let value = cornerRadius {
let anim = animator(kPOPLayerCornerRadius)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var borderWidth: CGFloat!{
didSet {
if let value = borderWidth {
let anim = animator(kPOPLayerBorderWidth)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var borderColor: UIColor!{
didSet {
if let value = borderColor {
let anim = animator(kPOPLayerBorderColor)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var opacity: CGFloat!{
didSet {
if let value = opacity {
let anim = animator(kPOPLayerOpacity)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var position: CGPoint!{
didSet {
if let value = position {
let anim = animator(kPOPLayerPosition)
anim.toGenericValue(NSValue(CGPoint:value),type)
addAnimate(anim)
}
}
}
public var positionX: CGFloat!{
didSet {
if let value = positionX {
let anim = animator(kPOPLayerPositionX)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var positionY: CGFloat!{
didSet {
if let value = positionY {
let anim = animator(kPOPLayerPositionY)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var rotation: CGFloat!{
didSet {
if let value = rotation {
let anim = animator(kPOPLayerRotation)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var rotationX: CGFloat!{
didSet {
if let value = rotationX {
let anim = animator(kPOPLayerRotationX)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var rotationY: CGFloat!{
didSet {
if let value = rotationY {
let anim = animator(kPOPLayerRotationY)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var subscaleXY: CGSize!{
didSet {
if let value = subscaleXY {
let anim = animator(kPOPLayerSubscaleXY)
anim.toGenericValue(NSValue(CGSize:value),type)
addAnimate(anim)
}
}
}
public var subtranslationX: CGFloat!{
didSet {
if let value = subtranslationX {
let anim = animator(kPOPLayerSubtranslationX)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var subtranslationXY: CGSize!{
didSet {
if let value = subtranslationXY {
let anim = animator(kPOPLayerSubtranslationXY)
anim.toGenericValue(NSValue(CGSize:value),type)
addAnimate(anim)
}
}
}
public var subtranslationY: CGFloat!{
didSet {
if let value = subtranslationY {
let anim = animator(kPOPLayerSubtranslationY)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var subtranslationZ: CGFloat!{
didSet {
if let value = subtranslationZ {
let anim = animator(kPOPLayerSubtranslationZ)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var translationX: CGFloat!{
didSet {
if let value = translationX {
let anim = animator(kPOPLayerTranslationX)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var translationXY: CGSize!{
didSet {
if let value = translationXY {
let anim = animator(kPOPLayerTranslationXY)
anim.toGenericValue(NSValue(CGSize:value),type)
addAnimate(anim)
}
}
}
public var translationY: CGFloat!{
didSet {
if let value = translationY {
let anim = animator(kPOPLayerTranslationY)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var translationZ: CGFloat!{
didSet {
if let value = translationZ {
let anim = animator(kPOPLayerTranslationZ)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var zPosition: CGPoint!{
didSet {
if let value = zPosition {
let anim = animator(kPOPLayerZPosition)
anim.toGenericValue(NSValue(CGPoint:value),type)
addAnimate(anim)
}
}
}
public var shadowColor: UIColor!{
didSet {
if let value = shadowColor {
let anim = animator(kPOPLayerShadowColor)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var shadowOffset: CGSize!{
didSet {
if let value = shadowOffset {
let anim = animator(kPOPLayerShadowOffset)
anim.toGenericValue(NSValue(CGSize:value),type)
addAnimate(anim)
}
}
}
public var shadowOpacity: CGFloat!{
didSet {
if let value = shadowOpacity {
let anim = animator(kPOPLayerShadowOpacity)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
public var shadowRadius: CGFloat!{
didSet {
if let value = shadowRadius {
let anim = animator(kPOPLayerShadowRadius)
anim.toGenericValue(value,type)
addAnimate(anim)
}
}
}
typealias ApplyToProtocol = (AnyObject)->Void
var applyToBlock: ApplyToProtocol!
var doneBlock: NextAnimtionBlock!
// MARK: - private
var animateWhenSet: Bool = false
var animating: Bool = false
var animates = [AnyObject]()
var animatesQueue = [AnyObject]()
var delayTime: Double = 0
var type: AnimateType = .Spring
weak var target: NSObject!{
didSet{
self.associate()
}
}
var doneCount: Int = 0
func addAnimate(obj:AnyObject){
if animating && !animateWhenSet{
animatesQueue.insert(obj, atIndex: 0)
}else{
animates.append(obj)
if animateWhenSet{
if self.target != nil {
applyToBlock?(self.target)
}
}
}
}
}
// MARK: - Setter
extension BasicProperties {
// MARK: - Common
public func setAnimateBackgroundColor(value:UIColor){
backgroundColor = value
}
public func setAnimateBounds(value:NSValue){
bounds = value.CGRectValue()
}
public func setAnimateScaleX(value:CGFloat){
scaleX = value
}
public func setAnimateScaleXY(value:CGSize){
scaleXY = value
}
public func setAnimateScaleY(value:CGFloat){
scaleY = value
}
public func setAnimateSize(value:CGSize){
size = value
}
// MARK: - UIView
public func setAnimateAlpha(value:CGFloat){
alpha = value
}
public func setAnimateTintColor(value:UIColor){
tintColor = value
}
public func setAnimateFrame(value:NSValue){
frame = value.CGRectValue()
}
public func setAnimateCenter(value:NSValue){
center = value.CGPointValue()
}
// MARK: - CALayer
public func setAnimateCornerRadius(value:CGFloat){
cornerRadius = value
}
public func setAnimateBorderWidth(value:CGFloat){
borderWidth = value
}
public func setAnimateBorderColor(value:UIColor){
borderColor = value
}
public func setAnimateOpacity(value:CGFloat){
opacity = value
}
public func setAnimatePosition(value:CGPoint){
position = value
}
public func setAnimatePositionX(value:CGFloat){
positionX = value
}
public func setAnimatePositionY(value:CGFloat){
positionY = value
}
public func setAnimateRotation(value:CGFloat){
rotation = value
}
public func setAnimateRotationX(value:CGFloat){
rotationX = value
}
public func setAnimateRotationY(value:CGFloat){
rotationY = value
}
public func setAnimateSubscaleXY(value:CGSize){
subscaleXY = value
}
public func setAnimateSubtranslationX(value:CGFloat){
subtranslationX = value
}
public func setAnimateSubtranslationXY(value:CGSize){
subtranslationXY = value
}
public func setAnimateSubtranslationY(value:CGFloat){
subtranslationY = value
}
public func setAnimateSubtranslationZ(value:CGFloat){
subtranslationZ = value
}
public func setAnimateTranslationX(value:CGFloat){
translationX = value
}
public func setAnimateTranslationXY(value:CGSize){
translationXY = value
}
public func setAnimateTranslationY(value:CGFloat){
translationY = value
}
public func setAnimateTranslationZ(value:CGFloat){
translationZ = value
}
public func setAnimateZPosition(value:CGPoint){
zPosition = value
}
public func setAnimateShadowColor(value:UIColor){
shadowColor = value
}
public func setAnimateShadowOffset(value:CGSize){
shadowOffset = value
}
public func setAnimateShadowOpacity(value:CGFloat){
shadowOpacity = value
}
public func setAnimateShadowRadius(value:CGFloat){
shadowRadius = value
}
}
// MARK: - Private Function
extension BasicProperties: POPAnimationDelegate {
private func associate(){
if !self.target {
objc_setAssociatedObject(self.target, &AnimateAssociatedKeys.SelfRetain, self, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
private func animator(name:String!)->POPPropertyAnimation{
var anim: POPPropertyAnimation = POPSpringAnimation(propertyNamed: name)
switch type {
case .Basic:
anim = POPBasicAnimation(propertyNamed: name)
break
case .Decay:
anim = POPDecayAnimation(propertyNamed: name)
break
default:
break
}
return anim
}
func playNext(){
// debugPrint("play", appendNewline: true)
if animateWhenSet {
if self.animatesQueue.count > 0 {
let anim: AnyObject = self.animatesQueue.removeLast()
addAnimate(anim)
}
}else{
// debugPrint("delay:\(self.delayTime)", appendNewline: true)
if self.delayTime > 0 {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(self.delayTime
* Double(NSEC_PER_SEC))), dispatch_get_main_queue()) { () -> Void in
self.play()
}
}else{
play()
}
}
}
private func play(){
// debugPrint("next", appendNewline: true)
if self.target.AnimatePopQueue.count > 0 {
self.target.AnimatePopQueue.removeLastObject()
if self.target.AnimatePopQueue.count > 0 {
if let block = self.target.AnimatePopQueue.lastObject as? NSBlockOperation {
block.start()
}
}
}else{
!doneBlock ? doneBlock() : (debugPrint("no more animate"))
}
}
// MARK: - POPAnimationDelegate
public func pop_animationDidStop(anim: POPAnimation!, finished: Bool) {
self.animateStop(anim, finished: finished)
}
func animateStop(anim: POPAnimation!, finished: Bool) {
anim.delegate = nil
doneCount++
if doneCount == self.animates.count {
animating = false
if animateWhenSet {
self.animates.removeAll(keepCapacity: true)
}
doneCount = 0
self.playNext()
}
}
}
// MARK: - Public Function
public extension BasicProperties {
public func delay(delay:Double)->BasicProperties{
self.delayTime = delay
return self
}
public func done(done:NextAnimtionBlock){
self.doneBlock = done
}
}
| mit | 905008b75e5ecbaeea8525b987bc73ab | 26.357372 | 148 | 0.520298 | 5.403925 | false | false | false | false |
qiscus/qiscus-sdk-ios | Qiscus/Qiscus/Library/QToasterSwift.swift | 1 | 8720 | //
// QToasterSwift.swift
// QToasterSwift
//
// Created by Ahmad Athaullah on 6/30/16.
// Copyright © 2016 Ahmad Athaullah. All rights reserved.
//
import UIKit
public class QToasterSwift: NSObject {
/**
On touch action for your toaster, Default value: empty Void
*/
public var toastAction:()->Void = ({})
/**
The alignment of text inside your toaster, Default value: NSTextAlignment.Center
*/
public var textAlignment:NSTextAlignment = NSTextAlignment.center
/**
Font type used for toaster title, Default value: UIFont.systemFontOfSize(11.0, weight: 0.8)
*/
public var titleFont = QToasterConfig.titleFont
/**
Font type used for toaster text, Default value: UIFont.systemFontOfSize(11.0)
*/
public var textFont = QToasterConfig.textFont
/**
Your toaster title, can be nil, Default value: nil
*/
public var titleText:String?
/**
Your toaster message, Default value : "" (empty string)
*/
public var text:String = ""
/**
Your toaster icon, can be nil, Default value : nil
*/
public var iconImage:UIImage?
/**
Your toaster url icon, can be nil, Default value : nil
*/
public var iconURL:String?
/**
Your toaster background color, Default value : UIColor(red: 0, green: 0, blue: 0, alpha: 0.8)
*/
public var backgroundColor = QToasterConfig.backgroundColor
/**
Your toaster background color, Default value : UIColor.whiteColor()
*/
public var textColor = QToasterConfig.textColor
/**
Your toaster animation duration using NSTimeInterval class, Default value : 0.2
*/
public var animateDuration = QToasterConfig.animateDuration
/**
Your toaster delay duration before start to disappar, using NSTimeInterval class, Default value : 3.0
*/
public var delayDuration = QToasterConfig.delayDuration
/**
Your toaster badge size (always square), using CGFloat class, Default value : 35.0
*/
public var iconSquareSize = QToasterConfig.iconSquareSize
/**
Your toaster badge corner radius, using CGFloat class, if you want to set circle badge, just set it to half of your icon SquareSize
Default value : 3.0
*/
public var iconCornerRadius = QToasterConfig.iconCornerRadius
/**
Your toaster badge background color, using UIColor class,
can only shown when using icon badge url without placeholder image
Default value : UIColor(red: 0.8, green: 0.8, blue: 0.8, alpha: 1)
*/
public var iconBackgroundColor = QToasterConfig.iconBackgroundColor
/**
Toast message inside your **QToasterSwift** object
- Parameter target: The **UIViewController** where toaster will appear
- Parameter onTouch: **()->Void** as onTouch action for your toaster
*/
public func toast(target: UIViewController, onTouch:@escaping ()->Void = ({})){
if text != "" {
self.addAction(action: onTouch)
if let previousToast = QToasterSwift.otherToastExist(target: target){
previousToast.removeFromSuperview()
}
let toasterView = QToasterView()
toasterView.setupToasterView(toaster: self)
var previousToast: QToasterView?
if let lastToast = QToasterSwift.otherToastExist(target: target){
previousToast = lastToast
}
target.navigationController?.view.addSubview(toasterView)
target.navigationController?.view.isUserInteractionEnabled = true
if previousToast != nil {
previousToast?.hide(completion: {
toasterView.show()
})
}else{
toasterView.show()
}
}
}
/**
Class function to show toaster with configuration and without initiation.
- parameter target: The **UIViewController** where toaster will appear.
- parameter text: **String** message to show in toaster.
- parameter title: **String** text to show as toaster title.
- parameter iconURL: **String** URL of your icon toaster.
- parameter iconPlaceHolder: **UIImage** to show as icon toaster when loading iconURL.
- parameter backgroundColor: the **UIColor** as your toaster background color.
- parameter textColor: the **UIColor** as your toaster text color.
- parameter onTouch: **()->Void** as onTouch action for your toaster.
*/
public class func toast(target: UIViewController, text: String, title:String? = nil, iconURL:String? = nil, iconPlaceHolder:UIImage? = nil, backgroundColor:UIColor? = nil, textColor:UIColor? = nil, onTouch: @escaping ()->Void = ({})){
if text != "" {
let toaster = QToasterSwift()
toaster.text = text
toaster.titleText = title
toaster.iconURL = iconURL
toaster.iconImage = iconPlaceHolder
toaster.toastAction = onTouch
if backgroundColor != nil {
toaster.backgroundColor = backgroundColor!
}
if textColor != nil {
toaster.textColor = textColor!
}
var previousToast: QToasterView?
if let lastToast = QToasterSwift.otherToastExist(target: target){
previousToast = lastToast
}
let toastButton = QToasterView()
toastButton.setupToasterView(toaster: toaster)
target.navigationController?.view.addSubview(toastButton)
target.navigationController?.view.isUserInteractionEnabled = true
if previousToast != nil {
previousToast?.hide(completion: {
toastButton.show()
})
}else{
toastButton.show()
}
}
}
/**
Class function to show toaster with badge icon
- parameter target: The **UIViewController** where toaster will appear.
- parameter text: **String** message to show in toaster.
- parameter title: **String** text to show as toaster title.
- parameter icon: **UIImage** to show as badge icon toaster.
- parameter backgroundColor: the **UIColor** as your toaster background color.
- parameter textColor: the **UIColor** as your toaster text color.
- parameter onTouch: **()->Void** as onTouch action for your toaster.
*/
public class func toastWithIcon(target: UIViewController, text: String, icon:UIImage?, title:String? = nil, backgroundColor:UIColor? = nil, textColor:UIColor? = nil, onTouch: @escaping ()->Void = ({})){
if text != "" {
let toaster = QToasterSwift()
toaster.text = text
toaster.titleText = title
toaster.iconImage = icon
toaster.toastAction = onTouch
var previousToast: QToasterView?
if backgroundColor != nil {
toaster.backgroundColor = backgroundColor!
}
if textColor != nil {
toaster.textColor = textColor!
}
if let lastToast = QToasterSwift.otherToastExist(target: target){
previousToast = lastToast
}
let toastButton = QToasterView()
toastButton.setupToasterView(toaster: toaster)
target.navigationController?.view.addSubview(toastButton)
target.navigationController?.view.isUserInteractionEnabled = true
if previousToast != nil {
previousToast?.hide(completion: {
toastButton.show()
})
}else{
toastButton.show()
}
}
}
/**
Private methode executed on QToaster onTouch
*/
func touchAction(){ self.toastAction() }
/**
Add onTouch action to QToaster
- parameter action: **()->Void** as onTouch action for your toaster.
*/
public func addAction(action:@escaping ()->Void){ self.toastAction = action }
/**
Private function helper to check if other QToaster is shown
- parameter target: The **UIViewController** to check.
- returns: **QToasterView** object if QToaster is exist and nil if not.
*/
class func otherToastExist(target: UIViewController) -> QToasterView?{
return target.navigationController?.view.viewWithTag(1313) as? QToasterView
}
}
| mit | 4207b8bd5a6ca7289ddb98224bb208a4 | 36.102128 | 238 | 0.60351 | 5.439177 | false | false | false | false |
somedev/LocalNotificationScheduler | LocalNotificationScheduler/LocalNotificationScheduler/TimeOfDay.swift | 1 | 1237 | //
// Created by Eduard Panasiuk on 1/4/16.
// Copyright © 2016 somedev. All rights reserved.
//
import Foundation
public struct TimeOfDay{
static private let timeConstant:TimeInterval = 60
static public let oneDayTimeInterval:TimeInterval = 24 * timeConstant * timeConstant
private var _timeInterval:TimeInterval = 0
public var hour:Int {
get {return Int(_timeInterval / (TimeOfDay.timeConstant * TimeOfDay.timeConstant))}
}
public var minute:Int {
get {return Int((_timeInterval - TimeInterval(hour) * TimeOfDay.timeConstant * TimeOfDay.timeConstant) / TimeOfDay.timeConstant)}
}
public var second:Int {
get {return Int(_timeInterval - TimeInterval(hour) * TimeOfDay.timeConstant * TimeOfDay.timeConstant - TimeInterval(minute) * TimeOfDay.timeConstant)}
}
public var timeInterval:TimeInterval{
get {return _timeInterval}
}
public init(hours:Int = 0, minutes:Int = 0, seconds:Int = 0){
_timeInterval = 0
_timeInterval += TimeInterval(hours) * TimeOfDay.timeConstant * TimeOfDay.timeConstant
_timeInterval += TimeInterval(minutes) * TimeOfDay.timeConstant
_timeInterval += TimeInterval(seconds)
}
}
| mit | 056946f486b12e1d4667db71afd60453 | 33.333333 | 158 | 0.691748 | 4.681818 | false | false | false | false |
radical-experiments/AIMES-Swift | viveks_workflow/data.04.00128.004/vivek.swift | 10 | 6521 |
type file;
int N = 128;
int chunk_size = 8; # chunksize for stage 3
int n_chunks = 16; # number of chunks
int verb = 1;
# -----------------------------------------------------------------------------
#
# Stage 1
#
app (file output_1_1_i,
file output_1_2_i,
file output_1_3_i) stage_1 (int i,
file input_shared_1_1,
file input_shared_1_2,
file input_shared_1_3,
file input_shared_1_4,
file input_shared_1_5)
{
stage_1_exe i filename(input_shared_1_1)
filename(input_shared_1_2)
filename(input_shared_1_3)
filename(input_shared_1_4)
filename(input_shared_1_5);
}
file input_shared_1_1 <"input_shared_1_1.txt">;
file input_shared_1_2 <"input_shared_1_2.txt">;
file input_shared_1_3 <"input_shared_1_3.txt">;
file input_shared_1_4 <"input_shared_1_4.txt">;
file input_shared_1_5 <"input_shared_1_5.txt">;
file output_1_1[];
file output_1_2[];
file output_1_3[];
foreach i in [1:N] {
file output_1_1_i <single_file_mapper; file=strcat("output_1_1_",i,".txt")>;
file output_1_2_i <single_file_mapper; file=strcat("output_1_2_",i,".txt")>;
file output_1_3_i <single_file_mapper; file=strcat("output_1_3_",i,".txt")>;
if (verb == 1) {
tracef("trace stage 1: %d : %s : %s : %s : %s : %s -> %s : %s : %s\n", i,
filename(input_shared_1_1),
filename(input_shared_1_2),
filename(input_shared_1_3),
filename(input_shared_1_4),
filename(input_shared_1_5),
filename(output_1_1_i),
filename(output_1_2_i),
filename(output_1_3_i));
}
(output_1_1_i,
output_1_2_i,
output_1_3_i) = stage_1(i,
input_shared_1_1,
input_shared_1_2,
input_shared_1_3,
input_shared_1_4,
input_shared_1_5);
output_1_1[i] = output_1_1_i;
output_1_2[i] = output_1_2_i;
output_1_3[i] = output_1_3_i;
}
# -----------------------------------------------------------------------------
#
# Stage 2
#
app (file output_2_1_i,
file output_2_2_i,
file output_2_3_i,
file output_2_4_i) stage_2 (int i,
file input_shared_1_3,
file input_shared_1_4,
file output_1_1_i)
{
stage_2_exe i filename(input_shared_1_3)
filename(input_shared_1_4)
filename(output_1_1_i);
}
file output_2_1[];
file output_2_2[];
file output_2_3[];
file output_2_4[];
foreach i in [1:N] {
file output_2_1_i <single_file_mapper; file=strcat("output_2_1_",i,".txt")>;
file output_2_2_i <single_file_mapper; file=strcat("output_2_2_",i,".txt")>;
file output_2_3_i <single_file_mapper; file=strcat("output_2_3_",i,".txt")>;
file output_2_4_i <single_file_mapper; file=strcat("output_2_4_",i,".txt")>;
if (verb == 1) {
tracef("trace stage 2: %d : %s : %s : %s -> %s : %s : %s : %s\n", i,
filename(input_shared_1_3),
filename(input_shared_1_4),
filename(output_1_1[i]),
filename(output_2_1_i),
filename(output_2_2_i),
filename(output_2_3_i),
filename(output_2_4_i));
}
(output_2_1_i,
output_2_2_i,
output_2_3_i,
output_2_4_i) = stage_2(i,
input_shared_1_3,
input_shared_1_4,
output_1_1[i]);
output_2_1[i] = output_2_1_i;
output_2_2[i] = output_2_2_i;
output_2_3[i] = output_2_3_i;
output_2_4[i] = output_2_4_i;
}
# -----------------------------------------------------------------------------
#
# Stage 3
#
app (file[] output_3_1) stage_3 (int chunk,
int chunksize,
file input_shared_1_3,
file[] output_2_2)
{
# N cores
stage_3_exe chunk
chunksize
filename(input_shared_1_3)
@output_2_2;
}
# we run stage_3 in chunks of C cores each, so we nee dto subdivide the file
# list into such chunks
# string[] output_3_1_s; # output files for all chunks
# foreach i in [1:N] {
# output_3_1_s[i] = strcat("output_3_1_",i,".txt");
# }
file[] output_3_1;
# over all chunks
foreach c in [0:(n_chunks-1)] {
# file lists for chunk
file[] output_2_2_c; # input files for this chunk
string[] output_3_1_c_s; # output files for this chunk
# over all chunk elements
foreach i in [1:chunk_size] {
# global index
int j = c*chunk_size + i;
output_2_2_c[i] = output_2_2[j];
output_3_1_c_s[i] = strcat("output_3_1_",j,".txt");
}
# convert into file sets
file[] output_3_1_c <array_mapper; files=output_3_1_c_s>;
# run this chunk
if (verb == 1) {
tracef("stage 3: %d : %s : %s -> %s", c,
filename(input_shared_1_3),
strjoin(output_2_2_c, " "),
strjoin(output_3_1_c_s, " "));
}
output_3_1_c = stage_3(c, chunk_size,
input_shared_1_3,
output_2_2_c);
# now merge the received files from the chunk into the global thing
foreach i in [1:chunk_size] {
# global index
int j = c*chunk_size + i;
output_3_1[j] = output_3_1_c[i];
}
}
# -----------------------------------------------------------------------------
#
# Stage 4
#
app (file output_4_1) stage_4 (file input_shared_1_5,
file[] output_3_1)
{
# 1 core
stage_4_exe filename(input_shared_1_5)
@output_3_1;
}
if (1 == 1) {
file output_4_1 <"output_4_1.txt">;
if (verb == 1) {
tracef("stage 4: %s : %s -> %s",
filename(input_shared_1_5),
@output_3_1,
filename(output_4_1));
}
output_4_1 = stage_4(input_shared_1_5,
output_3_1);
}
# -----------------------------------------------------------------------------
| mit | dcebcd2f82680129663b9e375be61551 | 28.373874 | 81 | 0.442877 | 3.220247 | false | false | false | false |
AV8R-/SwiftUtils | UIView+Constrain.swift | 1 | 1587 | //
// UIView+Constrain.swift
// Jobok
//
// Created by Bogdan Manshilin on 26.04.17.
// Copyright © 2017 Jobok. All rights reserved.
//
import UIKit
enum UIError: Error {
case noSuperview
}
enum UIViewBounds {
case top(CGFloat), left(CGFloat), bottom(CGFloat), right(CGFloat)
func constrain(view: UIView, to: UIView) {
switch self {
case let .top(constant): view.topAnchor.constraint(equalTo: to.topAnchor, constant: constant).isActive = true
case let .left(constant): view.leadingAnchor.constraint(equalTo: to.leadingAnchor, constant: constant).isActive = true
case let .bottom(constant): view.bottomAnchor.constraint(equalTo: to.bottomAnchor, constant: -constant).isActive = true
case let .right(constant): view.trailingAnchor.constraint(equalTo: to.trailingAnchor, constant: -constant).isActive = true
}
}
}
extension UIViewBounds {
static let topMargin = UIViewBounds.top(0)
static let leftMargin = UIViewBounds.left(0)
static let bottomMargin = UIViewBounds.bottom(0)
static let rightMargin = UIViewBounds.right(0)
}
extension UIView {
func constrainSuperview(bounds: UIViewBounds...) throws {
guard let superview = superview else {
throw UIError.noSuperview
}
var bounds = bounds
if bounds.count == 0 {
bounds = [.topMargin, .leftMargin, .bottomMargin, .rightMargin]
}
translatesAutoresizingMaskIntoConstraints = false
bounds.forEach { $0.constrain(view: self, to: superview) }
}
}
| mit | 78d3717c4ffd4bd5045bba5ea1490e19 | 31.367347 | 131 | 0.672762 | 4.321526 | false | false | false | false |
Alchemistxxd/AXStylishNavigationBar | CarPro/RenditionCollectionViewController.swift | 1 | 1248 | //
// RenditionCollectionViewController.swift
// Final Car Pro
//
// Created by Xudong Xu on 1/12/21.
//
import Cocoa
class RenditionCollectionViewController: NSViewController {
private struct Layout {
static let width: CGFloat = 100
static let height: CGFloat = 120
static let minimumInteritemSpacing: CGFloat = 20
static let minimumLineSpacing: CGFloat = 20
}
@IBOutlet var collectionView: NSCollectionView! {
didSet {
let nib = NSNib(nibNamed: RenditionViewItem.nibName, bundle: nil)
collectionView.register(nib, forItemWithIdentifier: .renditionItem)
collectionView.collectionViewLayout = .flowLayout(
width: Layout.width,
height: Layout.height,
minimumInteritemSpacing: Layout.minimumInteritemSpacing,
minimumLineSpacing: Layout.minimumLineSpacing
)
}
}
var dataProvider: (NSCollectionViewDataSource & NSCollectionViewDelegate)! {
didSet {
collectionView.dataSource = dataProvider
collectionView.delegate = dataProvider
}
}
override func viewDidLoad() {
super.viewDidLoad()
}
}
| mit | fcdf5e301fc74582c9e670834164f0aa | 28.714286 | 80 | 0.635417 | 5.724771 | false | false | false | false |
shamanskyh/FluidQ | Shared Models/Instrument.swift | 1 | 16920 | //
// Instrument.swift
// FluidQ
//
// Created by Harry Shamansky on 11/10/15.
// Modified from Precircuiter: https://github.com/shamanskyh/Precircuiter
// Copyright © 2015 Harry Shamansky. All rights reserved.
//
#if os(iOS)
import UIKit
#else
import AppKit
#endif
// MARK: - Enumerations
enum DeviceType: Int {
case Light
case MovingLight
case Accessory
case StaticAccessory
case Device
case Practical
case SFX
case Power
case Other
var description: String {
switch self {
case Light: return "Light"
case MovingLight: return "MovingLight"
case Accessory: return "Accessory"
case StaticAccessory: return "StaticAccessory"
case Device: return "Device"
case Practical: return "Practical"
case SFX: return "SFX"
case Power: return "Power"
case Other: return "Other"
}
}
}
enum Dimension {
case X
case Y
case Z
}
// MARK: - Structs
struct Coordinate {
var x: Double
var y: Double
var z: Double
init(xPos: Double, yPos: Double, zPos: Double) {
x = xPos
y = yPos
z = zPos
}
}
// MARK: - Instrument Class
class Instrument: NSObject, NSCoding {
var deviceType: DeviceType? = nil
var instrumentType: String? = nil
var wattage: String? = nil
var purpose: String? = nil
var position: String? = nil
var unitNumber: String? = nil
var color: String? = nil
var dimmer: String? = nil
var channel: Int? = nil
var address: String? = nil
var universe: String? = nil
var uAddress: String? = nil
var uDimmer: String? = nil
var circuitNumber: String? = nil
var circuitName: String? = nil
var system: String? = nil
var userField1: String? = nil
var userField2: String? = nil
var userField3: String? = nil
var userField4: String? = nil
var userField5: String? = nil
var userField6: String? = nil
var numChannels: String? = nil
var frameSize: String? = nil
var fieldAngle: String? = nil
var fieldAngle2: String? = nil
var beamAngle: String? = nil
var beamAngle2: String? = nil
var weight: String? = nil
var gobo1: String? = nil
var gobo1Rotation: String? = nil
var gobo2: String? = nil
var gobo2Rotation: String? = nil
var goboShift: String? = nil
var mark: String? = nil
var drawBeam: Bool? = nil
var drawBeamAs3DSolid: Bool? = nil
var useVerticalBeam: Bool? = nil
var showBeamAt: String? = nil
var falloffDistance: String? = nil
var lampRotationAngle: String? = nil
var topShutterDepth: String? = nil
var topShutterAngle: String? = nil
var leftShutterDepth: String? = nil
var leftShutterAngle: String? = nil
var rightShutterDepth: String? = nil
var rightShutterAngle: String? = nil
var bottomShutterDepth: String? = nil
var bottomShutterAngle: String? = nil
var symbolName: String? = nil
var useLegend: Bool? = nil
var flipFrontBackLegendText: Bool? = nil
var flipLeftRightLegendText: Bool? = nil
var focus: String? = nil
var set3DOrientation: Bool? = nil
var xRotation: String? = nil
var yRotation: String? = nil
var location: Coordinate? = nil
var rawXLocation: String? = nil
var rawYLocation: String? = nil
var rawZLocation: String? = nil
var fixtureID: String? = nil
var UID: String
var accessories: String? = nil
// MARK: Swatch Color
private var savedSwatchColor: CGColor?
private var isClearColor: Bool {
return color?.stringByTrimmingCharactersInSet(.whitespaceCharacterSet()) == "N/C" ||
color?.stringByTrimmingCharactersInSet(.whitespaceCharacterSet()) == "NC"
}
internal var needsNewSwatchColor = false
internal var swatchColor: CGColor? {
if (savedSwatchColor == nil && color != nil) || needsNewSwatchColor {
needsNewSwatchColor = false
if let color = self.color?.toGelColor() {
savedSwatchColor = color
} else {
savedSwatchColor = nil
}
}
return savedSwatchColor
}
required init(UID: String?, location: Coordinate?) {
if let id = UID {
self.UID = id
} else {
self.UID = ""
}
self.location = location
}
// MARK: - NSCoding Protocol Conformance
required init(coder aDecoder: NSCoder) {
deviceType = DeviceType(rawValue: aDecoder.decodeIntegerForKey("deviceType"))
instrumentType = aDecoder.decodeObjectForKey("instrumentType") as? String
wattage = aDecoder.decodeObjectForKey("wattage") as? String
purpose = aDecoder.decodeObjectForKey("purpose") as? String
position = aDecoder.decodeObjectForKey("position") as? String
unitNumber = aDecoder.decodeObjectForKey("unitNumber") as? String
color = aDecoder.decodeObjectForKey("color") as? String
dimmer = aDecoder.decodeObjectForKey("dimmer") as? String
channel = aDecoder.decodeIntegerForKey("channel")
address = aDecoder.decodeObjectForKey("address") as? String
universe = aDecoder.decodeObjectForKey("universe") as? String
uAddress = aDecoder.decodeObjectForKey("uAddress") as? String
uDimmer = aDecoder.decodeObjectForKey("uDimmer") as? String
circuitNumber = aDecoder.decodeObjectForKey("circuitNumber") as? String
circuitName = aDecoder.decodeObjectForKey("circuitName") as? String
system = aDecoder.decodeObjectForKey("system") as? String
userField1 = aDecoder.decodeObjectForKey("userField1") as? String
userField2 = aDecoder.decodeObjectForKey("userField2") as? String
userField3 = aDecoder.decodeObjectForKey("userField3") as? String
userField4 = aDecoder.decodeObjectForKey("userField4") as? String
userField5 = aDecoder.decodeObjectForKey("userField5") as? String
userField6 = aDecoder.decodeObjectForKey("userField6") as? String
numChannels = aDecoder.decodeObjectForKey("numChannels") as? String
frameSize = aDecoder.decodeObjectForKey("frameSize") as? String
fieldAngle = aDecoder.decodeObjectForKey("fieldAngle") as? String
fieldAngle2 = aDecoder.decodeObjectForKey("fieldAngle2") as? String
beamAngle = aDecoder.decodeObjectForKey("beamAngle") as? String
beamAngle2 = aDecoder.decodeObjectForKey("beamAngle2") as? String
weight = aDecoder.decodeObjectForKey("weight") as? String
gobo1 = aDecoder.decodeObjectForKey("gobo1") as? String
gobo1Rotation = aDecoder.decodeObjectForKey("gobo1Rotation") as? String
gobo2 = aDecoder.decodeObjectForKey("gobo2") as? String
gobo2Rotation = aDecoder.decodeObjectForKey("gobo2Rotation") as? String
goboShift = aDecoder.decodeObjectForKey("goboShift") as? String
mark = aDecoder.decodeObjectForKey("mark") as? String
drawBeam = aDecoder.decodeBoolForKey("drawBeam")
drawBeamAs3DSolid = aDecoder.decodeBoolForKey("drawBeamAs3DSolid")
useVerticalBeam = aDecoder.decodeBoolForKey("useVerticalBeam")
showBeamAt = aDecoder.decodeObjectForKey("showBeamAt") as? String
falloffDistance = aDecoder.decodeObjectForKey("falloffDistance") as? String
lampRotationAngle = aDecoder.decodeObjectForKey("lampRotationAngle") as? String
topShutterDepth = aDecoder.decodeObjectForKey("topShutterDepth") as? String
topShutterAngle = aDecoder.decodeObjectForKey("topShutterAngle") as? String
leftShutterDepth = aDecoder.decodeObjectForKey("leftShutterDepth") as? String
leftShutterAngle = aDecoder.decodeObjectForKey("leftShutterAngle") as? String
rightShutterDepth = aDecoder.decodeObjectForKey("rightShutterDepth") as? String
rightShutterAngle = aDecoder.decodeObjectForKey("rightShutterAngle") as? String
bottomShutterDepth = aDecoder.decodeObjectForKey("bottomShutterDepth") as? String
bottomShutterAngle = aDecoder.decodeObjectForKey("bottomShutterAngle") as? String
symbolName = aDecoder.decodeObjectForKey("symbolName") as? String
useLegend = aDecoder.decodeBoolForKey("useLegend")
flipFrontBackLegendText = aDecoder.decodeBoolForKey("flipFrontBackLegendText")
flipLeftRightLegendText = aDecoder.decodeBoolForKey("flipLeftRightLegendText")
focus = aDecoder.decodeObjectForKey("focus") as? String
set3DOrientation = aDecoder.decodeBoolForKey("set3DOrientation")
xRotation = aDecoder.decodeObjectForKey("xRotation") as? String
yRotation = aDecoder.decodeObjectForKey("yRotation") as? String
location = Coordinate(xPos: aDecoder.decodeDoubleForKey("convertedXLocation"), yPos: aDecoder.decodeDoubleForKey("convertedYLocation"), zPos: aDecoder.decodeDoubleForKey("convertedZLocation"))
rawXLocation = aDecoder.decodeObjectForKey("rawXLocation") as? String
rawYLocation = aDecoder.decodeObjectForKey("rawYLocation") as? String
rawZLocation = aDecoder.decodeObjectForKey("rawZLocation") as? String
fixtureID = aDecoder.decodeObjectForKey("fixtureID") as? String
UID = aDecoder.decodeObjectForKey("UID") as! String
accessories = aDecoder.decodeObjectForKey("accessories") as? String
}
func encodeWithCoder(aCoder: NSCoder) {
if let devType = deviceType {
aCoder.encodeInteger(devType.rawValue, forKey: "deviceType")
}
aCoder.encodeObject(instrumentType, forKey: "instrumentType")
aCoder.encodeObject(wattage, forKey: "wattage")
aCoder.encodeObject(purpose, forKey: "purpose")
aCoder.encodeObject(position, forKey: "position")
aCoder.encodeObject(unitNumber, forKey: "unitNumber")
aCoder.encodeObject(color, forKey: "color")
aCoder.encodeObject(dimmer, forKey: "dimmer")
if let chan = channel {
aCoder.encodeInteger(chan, forKey: "channel")
}
aCoder.encodeObject(address, forKey: "address")
aCoder.encodeObject(universe, forKey: "universe")
aCoder.encodeObject(uAddress, forKey: "uAddress")
aCoder.encodeObject(uDimmer, forKey: "uDimmer")
aCoder.encodeObject(circuitNumber, forKey: "circuitNumber")
aCoder.encodeObject(circuitName, forKey: "circuitName")
aCoder.encodeObject(system, forKey: "system")
aCoder.encodeObject(userField1, forKey: "userField1")
aCoder.encodeObject(userField2, forKey: "userField2")
aCoder.encodeObject(userField3, forKey: "userField3")
aCoder.encodeObject(userField4, forKey: "userField4")
aCoder.encodeObject(userField5, forKey: "userField5")
aCoder.encodeObject(userField6, forKey: "userField6")
aCoder.encodeObject(numChannels, forKey: "numChannels")
aCoder.encodeObject(frameSize, forKey: "frameSize")
aCoder.encodeObject(fieldAngle, forKey: "fieldAngle")
aCoder.encodeObject(fieldAngle2, forKey: "fieldAngle2")
aCoder.encodeObject(beamAngle, forKey: "beamAngle")
aCoder.encodeObject(beamAngle2, forKey: "beamAngle2")
aCoder.encodeObject(weight, forKey: "weight")
aCoder.encodeObject(gobo1, forKey: "gobo1")
aCoder.encodeObject(gobo1Rotation, forKey: "gobo1Rotation")
aCoder.encodeObject(gobo2, forKey: "gobo2")
aCoder.encodeObject(gobo2Rotation, forKey: "gobo2Rotation")
aCoder.encodeObject(goboShift, forKey: "goboShift")
aCoder.encodeObject(mark, forKey: "mark")
aCoder.encodeObject(showBeamAt, forKey: "showBeamAt")
aCoder.encodeObject(falloffDistance, forKey: "falloffDistance")
aCoder.encodeObject(lampRotationAngle, forKey: "lampRotationAngle")
aCoder.encodeObject(topShutterDepth, forKey: "topShutterDepth")
aCoder.encodeObject(topShutterAngle, forKey: "topShutterAngle")
aCoder.encodeObject(leftShutterDepth, forKey: "leftShutterDepth")
aCoder.encodeObject(leftShutterAngle, forKey: "leftShutterAngle")
aCoder.encodeObject(rightShutterDepth, forKey: "rightShutterDepth")
aCoder.encodeObject(rightShutterAngle, forKey: "rightShutterAngle")
aCoder.encodeObject(bottomShutterDepth, forKey: "bottomShutterDepth")
aCoder.encodeObject(bottomShutterAngle, forKey: "bottomShutterAngle")
aCoder.encodeObject(symbolName, forKey: "symbolName")
aCoder.encodeObject(focus, forKey: "focus")
aCoder.encodeObject(xRotation, forKey: "xRotation")
aCoder.encodeObject(yRotation, forKey: "yRotation")
if let l = location {
aCoder.encodeDouble(l.x, forKey: "convertedXLocation")
aCoder.encodeDouble(l.y, forKey: "convertedYLocation")
aCoder.encodeDouble(l.z, forKey: "convertedZLocation")
}
aCoder.encodeObject(rawXLocation, forKey: "rawXLocation")
aCoder.encodeObject(rawYLocation, forKey: "rawYLocation")
aCoder.encodeObject(rawZLocation, forKey: "rawZLocation")
aCoder.encodeObject(fixtureID, forKey: "fixtureID")
aCoder.encodeObject(UID, forKey: "UID")
aCoder.encodeObject(accessories, forKey: "accessories")
}
func addCoordinateToLocation(type: Dimension, value: String) throws {
var coord = self.location
if coord == nil {
coord = Coordinate(xPos: 0.0, yPos: 0.0, zPos: 0.0)
}
var convertedValue: Double = 0.0;
do {
try convertedValue = value.unknownUnitToMeters()
} catch {
throw InstrumentError.UnrecognizedCoordinate
}
switch type {
case .X: coord!.x = convertedValue
case .Y: coord!.y = convertedValue
case .Z: coord!.z = convertedValue
}
self.location = coord!
}
}
// MARK: - NSCopying Protocol Conformance
extension Instrument: NSCopying {
func copyWithZone(zone: NSZone) -> AnyObject {
let copy = self.dynamicType.init(UID: self.UID, location: self.location)
copy.deviceType = self.deviceType
copy.instrumentType = self.instrumentType
copy.wattage = self.wattage
copy.purpose = self.purpose
copy.position = self.position
copy.unitNumber = self.unitNumber
copy.color = self.color
copy.dimmer = self.dimmer
copy.channel = self.channel
copy.address = self.address
copy.universe = self.universe
copy.uAddress = self.uAddress
copy.uDimmer = self.uDimmer
copy.circuitNumber = self.circuitNumber
copy.circuitName = self.circuitName
copy.system = self.system
copy.userField1 = self.userField1
copy.userField2 = self.userField2
copy.userField3 = self.userField3
copy.userField4 = self.userField4
copy.userField5 = self.userField5
copy.userField6 = self.userField6
copy.numChannels = self.numChannels
copy.frameSize = self.frameSize
copy.fieldAngle = self.fieldAngle
copy.fieldAngle2 = self.fieldAngle2
copy.beamAngle = self.beamAngle
copy.beamAngle2 = self.beamAngle2
copy.weight = self.weight
copy.gobo1 = self.gobo1
copy.gobo1Rotation = self.gobo1Rotation
copy.gobo2 = self.gobo2
copy.gobo2Rotation = self.gobo2Rotation
copy.goboShift = self.goboShift
copy.mark = self.mark
copy.drawBeam = self.drawBeam
copy.drawBeamAs3DSolid = self.drawBeamAs3DSolid
copy.useVerticalBeam = self.useVerticalBeam
copy.showBeamAt = self.showBeamAt
copy.falloffDistance = self.falloffDistance
copy.lampRotationAngle = self.lampRotationAngle
copy.topShutterDepth = self.topShutterDepth
copy.topShutterAngle = self.topShutterAngle
copy.leftShutterDepth = self.leftShutterDepth
copy.leftShutterAngle = self.leftShutterAngle
copy.rightShutterDepth = self.rightShutterDepth
copy.rightShutterAngle = self.rightShutterAngle
copy.bottomShutterDepth = self.bottomShutterDepth
copy.bottomShutterAngle = self.bottomShutterAngle
copy.symbolName = self.symbolName
copy.useLegend = self.useLegend
copy.flipFrontBackLegendText = self.flipFrontBackLegendText
copy.flipLeftRightLegendText = self.flipLeftRightLegendText
copy.focus = self.focus
copy.set3DOrientation = self.set3DOrientation
copy.xRotation = self.xRotation
copy.yRotation = self.yRotation
copy.rawXLocation = self.rawXLocation
copy.rawYLocation = self.rawYLocation
copy.rawZLocation = self.rawZLocation
copy.fixtureID = self.fixtureID
copy.accessories = self.accessories
return copy
}
}
| mit | 1a0814fe12d521fda237eea7a4e25d97 | 42.60567 | 200 | 0.679059 | 4.857594 | false | false | false | false |
dleonard00/firebase-user-signup | Pods/Material/Sources/TextField.swift | 1 | 19127 | /*
* Copyright (C) 2015 - 2016, Daniel Dahan and CosmicMind, Inc. <http://cosmicmind.io>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * 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.
*
* * Neither the name of Material 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 UIKit
public protocol TextFieldDelegate : UITextFieldDelegate {}
public class TextField : UITextField {
/**
This property is the same as clipsToBounds. It crops any of the view's
contents from bleeding past the view's frame.
*/
public var masksToBounds: Bool {
get {
return layer.masksToBounds
}
set(value) {
layer.masksToBounds = value
}
}
/// A property that accesses the backing layer's backgroundColor.
public override var backgroundColor: UIColor? {
didSet {
layer.backgroundColor = backgroundColor?.CGColor
}
}
/// A property that accesses the layer.frame.origin.x property.
public var x: CGFloat {
get {
return layer.frame.origin.x
}
set(value) {
layer.frame.origin.x = value
}
}
/// A property that accesses the layer.frame.origin.y property.
public var y: CGFloat {
get {
return layer.frame.origin.y
}
set(value) {
layer.frame.origin.y = value
}
}
/**
A property that accesses the layer.frame.origin.width property.
When setting this property in conjunction with the shape property having a
value that is not .None, the height will be adjusted to maintain the correct
shape.
*/
public var width: CGFloat {
get {
return layer.frame.size.width
}
set(value) {
layer.frame.size.width = value
if .None != shape {
layer.frame.size.height = value
}
}
}
/**
A property that accesses the layer.frame.origin.height property.
When setting this property in conjunction with the shape property having a
value that is not .None, the width will be adjusted to maintain the correct
shape.
*/
public var height: CGFloat {
get {
return layer.frame.size.height
}
set(value) {
layer.frame.size.height = value
if .None != shape {
layer.frame.size.width = value
}
}
}
/// A property that accesses the backing layer's shadowColor.
public var shadowColor: UIColor? {
didSet {
layer.shadowColor = shadowColor?.CGColor
}
}
/// A property that accesses the backing layer's shadowOffset.
public var shadowOffset: CGSize {
get {
return layer.shadowOffset
}
set(value) {
layer.shadowOffset = value
}
}
/// A property that accesses the backing layer's shadowOpacity.
public var shadowOpacity: Float {
get {
return layer.shadowOpacity
}
set(value) {
layer.shadowOpacity = value
}
}
/// A property that accesses the backing layer's shadowRadius.
public var shadowRadius: CGFloat {
get {
return layer.shadowRadius
}
set(value) {
layer.shadowRadius = value
}
}
/// A property that accesses the backing layer's shadowPath.
public var shadowPath: CGPath? {
get {
return layer.shadowPath
}
set(value) {
layer.shadowPath = value
}
}
/// Enables automatic shadowPath sizing.
public var shadowPathAutoSizeEnabled: Bool = true {
didSet {
if shadowPathAutoSizeEnabled {
layoutShadowPath()
} else {
shadowPath = nil
}
}
}
/**
A property that sets the shadowOffset, shadowOpacity, and shadowRadius
for the backing layer. This is the preferred method of setting depth
in order to maintain consitency across UI objects.
*/
public var depth: MaterialDepth = .None {
didSet {
let value: MaterialDepthType = MaterialDepthToValue(depth)
shadowOffset = value.offset
shadowOpacity = value.opacity
shadowRadius = value.radius
layoutShadowPath()
}
}
/**
A property that sets the cornerRadius of the backing layer. If the shape
property has a value of .Circle when the cornerRadius is set, it will
become .None, as it no longer maintains its circle shape.
*/
public var cornerRadiusPreset: MaterialRadius = .None {
didSet {
if let v: MaterialRadius = cornerRadiusPreset {
cornerRadius = MaterialRadiusToValue(v)
}
}
}
/// A property that accesses the layer.cornerRadius.
public var cornerRadius: CGFloat {
get {
return layer.cornerRadius
}
set(value) {
layer.cornerRadius = value
layoutShadowPath()
if .Circle == shape {
shape = .None
}
}
}
/**
A property that manages the overall shape for the object. If either the
width or height property is set, the other will be automatically adjusted
to maintain the shape of the object.
*/
public var shape: MaterialShape = .None {
didSet {
if .None != shape {
if width < height {
frame.size.width = height
} else {
frame.size.height = width
}
layoutShadowPath()
}
}
}
/// A preset property to set the borderWidth.
public var borderWidthPreset: MaterialBorder = .None {
didSet {
borderWidth = MaterialBorderToValue(borderWidthPreset)
}
}
/// A property that accesses the layer.borderWith.
public var borderWidth: CGFloat {
get {
return layer.borderWidth
}
set(value) {
layer.borderWidth = value
}
}
/// A property that accesses the layer.borderColor property.
public var borderColor: UIColor? {
get {
return nil == layer.borderColor ? nil : UIColor(CGColor: layer.borderColor!)
}
set(value) {
layer.borderColor = value?.CGColor
}
}
/// A property that accesses the layer.position property.
public var position: CGPoint {
get {
return layer.position
}
set(value) {
layer.position = value
}
}
/// A property that accesses the layer.zPosition property.
public var zPosition: CGFloat {
get {
return layer.zPosition
}
set(value) {
layer.zPosition = value
}
}
/// The UIImage for the clear icon.
public var clearButton: UIButton? {
didSet {
if let v: UIButton = clearButton {
clearButtonMode = .Never
rightViewMode = .WhileEditing
v.contentEdgeInsets = UIEdgeInsetsZero
v.addTarget(self, action: "handleClearButton", forControlEvents: .TouchUpInside)
} else {
clearButtonMode = .WhileEditing
rightViewMode = .Never
}
rightView = clearButton
reloadView()
}
}
/// The bottom border layer.
public private(set) lazy var bottomBorderLayer: CAShapeLayer = CAShapeLayer()
/**
A property that sets the distance between the textField and
bottomBorderLayer.
*/
public var bottomBorderLayerDistance: CGFloat = 4
/**
The title UILabel that is displayed when there is text. The
titleLabel text value is updated with the placeholder text
value before being displayed.
*/
public var titleLabel: UILabel? {
didSet {
prepareTitleLabel()
}
}
/// The color of the titleLabel text when the textField is not active.
public var titleLabelColor: UIColor? {
didSet {
titleLabel?.textColor = titleLabelColor
MaterialAnimation.animationDisabled { [unowned self] in
self.bottomBorderLayer.backgroundColor = self.titleLabelColor?.CGColor
}
}
}
/// The color of the titleLabel text when the textField is active.
public var titleLabelActiveColor: UIColor?
/**
A property that sets the distance between the textField and
titleLabel.
*/
public var titleLabelAnimationDistance: CGFloat = 8
/// An override to the text property.
public override var text: String? {
didSet {
textFieldDidChange()
}
}
/**
The detail UILabel that is displayed when the detailLabelHidden property
is set to false.
*/
public var detailLabel: UILabel? {
didSet {
prepareDetailLabel()
}
}
/**
The color of the detailLabel text when the detailLabelHidden property
is set to false.
*/
public var detailLabelActiveColor: UIColor? {
didSet {
if !detailLabelHidden {
detailLabel?.textColor = detailLabelActiveColor
MaterialAnimation.animationDisabled { [unowned self] in
self.bottomBorderLayer.backgroundColor = self.detailLabelActiveColor?.CGColor
}
}
}
}
/**
A property that sets the distance between the textField and
detailLabel.
*/
public var detailLabelAnimationDistance: CGFloat = 8
/**
A Boolean that indicates the detailLabel should hide
automatically when text changes.
*/
public var detailLabelAutoHideEnabled: Bool = true
/**
:name: detailLabelHidden
*/
public var detailLabelHidden: Bool = true {
didSet {
if detailLabelHidden {
detailLabel?.textColor = titleLabelColor
MaterialAnimation.animationDisabled { [unowned self] in
self.bottomBorderLayer.backgroundColor = self.editing ? self.titleLabelActiveColor?.CGColor : self.titleLabelColor?.CGColor
}
hideDetailLabel()
} else {
detailLabel?.textColor = detailLabelActiveColor
MaterialAnimation.animationDisabled { [unowned self] in
self.bottomBorderLayer.backgroundColor = self.detailLabelActiveColor?.CGColor
}
showDetailLabel()
}
}
}
/// A wrapper for searchBar.placeholder.
public override var placeholder: String? {
didSet {
if let v: String = placeholder {
attributedPlaceholder = NSAttributedString(string: v, attributes: [NSForegroundColorAttributeName: placeholderTextColor])
}
}
}
/// Placeholder textColor.
public var placeholderTextColor: UIColor = MaterialColor.black {
didSet {
if let v: String = placeholder {
attributedPlaceholder = NSAttributedString(string: v, attributes: [NSForegroundColorAttributeName: placeholderTextColor])
}
}
}
/**
An initializer that initializes the object with a NSCoder object.
- Parameter aDecoder: A NSCoder instance.
*/
public required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
prepareView()
}
/**
An initializer that initializes the object with a CGRect object.
If AutoLayout is used, it is better to initilize the instance
using the init() initializer.
- Parameter frame: A CGRect instance.
*/
public override init(frame: CGRect) {
super.init(frame: frame)
prepareView()
}
/// A convenience initializer.
public convenience init() {
self.init(frame: CGRectNull)
}
/// Overriding the layout callback for sublayers.
public override func layoutSublayersOfLayer(layer: CALayer) {
super.layoutSublayersOfLayer(layer)
if self.layer == layer {
bottomBorderLayer.frame = CGRectMake(0, bounds.height + bottomBorderLayerDistance, bounds.width, 1)
layoutShape()
layoutShadowPath()
}
}
/**
A method that accepts CAAnimation objects and executes them on the
view's backing layer.
- Parameter animation: A CAAnimation instance.
*/
public func animate(animation: CAAnimation) {
animation.delegate = self
if let a: CABasicAnimation = animation as? CABasicAnimation {
a.fromValue = (nil == layer.presentationLayer() ? layer : layer.presentationLayer() as! CALayer).valueForKeyPath(a.keyPath!)
}
if let a: CAPropertyAnimation = animation as? CAPropertyAnimation {
layer.addAnimation(a, forKey: a.keyPath!)
} else if let a: CAAnimationGroup = animation as? CAAnimationGroup {
layer.addAnimation(a, forKey: nil)
} else if let a: CATransition = animation as? CATransition {
layer.addAnimation(a, forKey: kCATransition)
}
}
/**
A delegation method that is executed when the backing layer starts
running an animation.
- Parameter anim: The currently running CAAnimation instance.
*/
public override func animationDidStart(anim: CAAnimation) {
(delegate as? MaterialAnimationDelegate)?.materialAnimationDidStart?(anim)
}
/**
A delegation method that is executed when the backing layer stops
running an animation.
- Parameter anim: The CAAnimation instance that stopped running.
- Parameter flag: A boolean that indicates if the animation stopped
because it was completed or interrupted. True if completed, false
if interrupted.
*/
public override func animationDidStop(anim: CAAnimation, finished flag: Bool) {
if let a: CAPropertyAnimation = anim as? CAPropertyAnimation {
if let b: CABasicAnimation = a as? CABasicAnimation {
if let v: AnyObject = b.toValue {
if let k: String = b.keyPath {
layer.setValue(v, forKeyPath: k)
layer.removeAnimationForKey(k)
}
}
}
(delegate as? MaterialAnimationDelegate)?.materialAnimationDidStop?(anim, finished: flag)
} else if let a: CAAnimationGroup = anim as? CAAnimationGroup {
for x in a.animations! {
animationDidStop(x, finished: true)
}
}
}
/**
Prepares the view instance when intialized. When subclassing,
it is recommended to override the prepareView method
to initialize property values and other setup operations.
The super.prepareView method should always be called immediately
when subclassing.
*/
public func prepareView() {
backgroundColor = MaterialColor.white
masksToBounds = false
clearButtonMode = .WhileEditing
prepareBottomBorderLayer()
}
/// Reloads the view.
public func reloadView() {
/// Prepare the clearButton.
if let v: UIButton = clearButton {
v.frame = CGRectMake(0, 0, height, height)
}
}
/// Clears the textField text.
internal func handleClearButton() {
text = ""
}
/// Ahdnler when text value changed.
internal func textFieldValueChanged() {
if detailLabelAutoHideEnabled && !detailLabelHidden {
detailLabelHidden = true
MaterialAnimation.animationDisabled { [unowned self] in
self.bottomBorderLayer.backgroundColor = self.titleLabelActiveColor?.CGColor
}
}
}
/// Handler for text editing began.
internal func textFieldDidBegin() {
titleLabel?.textColor = titleLabelActiveColor
MaterialAnimation.animationDisabled { [unowned self] in
self.bottomBorderLayer.backgroundColor = self.detailLabelHidden ? self.titleLabelActiveColor?.CGColor : self.detailLabelActiveColor?.CGColor
}
}
/// Handler for text changed.
internal func textFieldDidChange() {
if 0 < text?.utf16.count {
showTitleLabel()
} else if 0 == text?.utf16.count {
hideTitleLabel()
}
sendActionsForControlEvents(.ValueChanged)
}
/// Handler for text editing ended.
internal func textFieldDidEnd() {
if 0 < text?.utf16.count {
showTitleLabel()
} else if 0 == text?.utf16.count {
hideTitleLabel()
}
titleLabel?.textColor = titleLabelColor
MaterialAnimation.animationDisabled { [unowned self] in
self.bottomBorderLayer.backgroundColor = self.detailLabelHidden ? self.titleLabelColor?.CGColor : self.detailLabelActiveColor?.CGColor
}
}
/// Manages the layout for the shape of the view instance.
internal func layoutShape() {
if .Circle == shape {
let w: CGFloat = (width / 2)
if w != cornerRadius {
cornerRadius = w
}
}
}
/// Sets the shadow path.
internal func layoutShadowPath() {
if shadowPathAutoSizeEnabled {
if .None == depth {
shadowPath = nil
} else if nil == shadowPath {
shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).CGPath
} else {
animate(MaterialAnimation.shadowPath(UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).CGPath, duration: 0))
}
}
}
/// Prepares the titleLabel property.
private func prepareTitleLabel() {
if let v: UILabel = titleLabel {
v.hidden = true
addSubview(v)
if 0 < text?.utf16.count {
showTitleLabel()
} else {
v.alpha = 0
}
addTarget(self, action: "textFieldDidBegin", forControlEvents: .EditingDidBegin)
addTarget(self, action: "textFieldDidChange", forControlEvents: .EditingChanged)
addTarget(self, action: "textFieldDidEnd", forControlEvents: .EditingDidEnd)
}
}
/// Prepares the detailLabel property.
private func prepareDetailLabel() {
if let v: UILabel = detailLabel {
v.hidden = true
addSubview(v)
if detailLabelHidden {
v.alpha = 0
} else {
showDetailLabel()
}
if nil == titleLabel {
addTarget(self, action: "textFieldDidBegin", forControlEvents: .EditingDidBegin)
addTarget(self, action: "textFieldDidChange", forControlEvents: .EditingChanged)
addTarget(self, action: "textFieldDidEnd", forControlEvents: .EditingDidEnd)
}
addTarget(self, action: "textFieldValueChanged", forControlEvents: .ValueChanged)
}
}
/// Prepares the bottomBorderLayer property.
private func prepareBottomBorderLayer() {
layer.addSublayer(bottomBorderLayer)
}
/// Shows and animates the titleLabel property.
private func showTitleLabel() {
if let v: UILabel = titleLabel {
if v.hidden {
if let s: String = placeholder {
if 0 == v.text?.utf16.count || nil == v.text {
v.text = s
}
}
let h: CGFloat = ceil(v.font.lineHeight)
v.frame = CGRectMake(0, -h, bounds.width, h)
v.hidden = false
UIView.animateWithDuration(0.25, animations: { [unowned self] in
v.alpha = 1
v.frame.origin.y -= self.titleLabelAnimationDistance
})
}
}
}
/// Hides and animates the titleLabel property.
private func hideTitleLabel() {
if let v: UILabel = titleLabel {
UIView.animateWithDuration(0.25, animations: { [unowned self] in
v.alpha = 0
v.frame.origin.y += self.titleLabelAnimationDistance
}) { _ in
v.hidden = true
}
}
}
/// Shows and animates the detailLabel property.
private func showDetailLabel() {
if let v: UILabel = detailLabel {
if v.hidden {
let h: CGFloat = ceil(v.font.lineHeight)
v.frame = CGRectMake(0, bounds.height + bottomBorderLayerDistance, bounds.width, h)
v.hidden = false
UIView.animateWithDuration(0.25, animations: { [unowned self] in
v.frame.origin.y = self.frame.height + self.bottomBorderLayerDistance + self.detailLabelAnimationDistance
v.alpha = 1
})
}
}
}
/// Hides and animates the detailLabel property.
private func hideDetailLabel() {
if let v: UILabel = detailLabel {
UIView.animateWithDuration(0.25, animations: { [unowned self] in
v.alpha = 0
v.frame.origin.y -= self.detailLabelAnimationDistance
}) { _ in
v.hidden = true
}
}
}
} | mit | 41a802b71ebb17fb54dae7a9843ee752 | 26.522302 | 143 | 0.714644 | 3.925097 | false | false | false | false |
hejunbinlan/SwiftGraphics | SwiftGraphics_UnitTests/SwiftDocTests/CGPointSwiftDocTests.swift | 4 | 3219 | //
// CGPointSwiftDocTests.swift
// SOMETHING
//
// Created by SOMEONE on SOMEWHEN.
// Copyright (c) SOME STUFF. All rights reserved.
//
// *******************************************************************************************
// * These unit tests were automatically generated by: https://github.com/schwa/SwiftDocTest *
// *******************************************************************************************
import Cocoa
import XCTest
import SwiftGraphics
class CGPointSwiftDocTests: XCTestCase {
func test_23126dc80bdd3fdb985aee0b2234ff3ec00ecab6() {
let result = CGPoint(x:1, y:2) + CGPoint(x:10, y:20)
let expected_result = CGPoint(x:11, y:22)
XCTAssertEqual(result, expected_result)
}
func test_a9147ff57b6fc28170f2fd34010dcd805088553d() {
let result = CGPoint(x:11, y:22) - CGPoint(x:10, y:20)
let expected_result = CGPoint(x:1, y:2)
XCTAssertEqual(result, expected_result)
}
func test_5ae06e9ba2b24c91d5e85550b59bae6a9beaa17b() {
let result = CGPoint(x:0, y:0).isZero
let expected_result = true
XCTAssertEqual(result, expected_result)
}
func test_2ce3d4cb2d1f009553ca51dd2bf4982098687749() {
let result = CGPoint(x:1, y:0).isZero
let expected_result = false
XCTAssertEqual(result, expected_result)
}
func test_b8a1a3cfeef1e64f1cfbd8a3252890e16d397200() {
let result = CGPoint(x:50, y:50).clampedTo(CGRect(x:10, y:20, w:100, h:100))
let expected_result = CGPoint(x:50, y:50)
XCTAssertEqual(result, expected_result)
}
func test_0ccbe0a5a9a42bbbcf25eb107c1cf3d83a81dae9() {
let result = CGPoint(x:150, y:50).clampedTo(CGRect(x:10, y:20, w:100, h:100))
let expected_result = CGPoint(x:110, y:50)
XCTAssertEqual(result, expected_result)
}
func test_e7bd44171946f518cafde41445ef0993c3782132() {
let result = CGPoint(x:0, y:50).clampedTo(CGRect(x:10, y:20, w:100, h:100))
let expected_result = CGPoint(x:10, y:50)
XCTAssertEqual(result, expected_result)
}
func test_ed4f3f458ec7eb65cb43891e5fb41a5f9295b102() {
let result = CGPoint(x:50, y:00).clampedTo(CGRect(x:10, y:20, w:100, h:100))
let expected_result = CGPoint(x:50, y:20)
XCTAssertEqual(result, expected_result)
}
func test_ba0a788729712c63dbc83cbf9ba39ef96f6a3746() {
let result = floor(CGPoint(x:10.9, y:-10.5))
let expected_result = CGPoint(x:10, y:-11)
XCTAssertEqual(result, expected_result)
}
func test_c6cdf9945105f6f702b9d22d909d3c0c505ea2b7() {
let result = ceil(CGPoint(x:10.9, y:-10.5))
let expected_result = CGPoint(x:11, y:-10)
XCTAssertEqual(result, expected_result)
}
func test_e71dd9bf7127b87065bf7412149f4c625ceecd68() {
let result = round(CGPoint(x:10.9, y:-10.6))
let expected_result = CGPoint(x:11, y:-11)
XCTAssertEqual(result, expected_result)
}
func test_5097696df2ec6230b235df30db56741689018f69() {
let result = floor(CGPoint(x:10.09, y:-10.95))
let expected_result = CGPoint(x:10, y:-11)
XCTAssertEqual(result, expected_result)
}
} | bsd-2-clause | bc8ddd6f8f6a61c071ac43f343392757 | 39.759494 | 94 | 0.625349 | 3.110145 | false | true | false | false |
aschwaighofer/swift | test/Constraints/function_builder_diags.swift | 2 | 14261 | // RUN: %target-typecheck-verify-swift -disable-availability-checking
enum Either<T,U> {
case first(T)
case second(U)
}
@_functionBuilder
struct TupleBuilder { // expected-note 3{{struct 'TupleBuilder' declared here}}
static func buildBlock() -> () { }
static func buildBlock<T1>(_ t1: T1) -> T1 {
return t1
}
static func buildBlock<T1, T2>(_ t1: T1, _ t2: T2) -> (T1, T2) {
return (t1, t2)
}
static func buildBlock<T1, T2, T3>(_ t1: T1, _ t2: T2, _ t3: T3)
-> (T1, T2, T3) {
return (t1, t2, t3)
}
static func buildBlock<T1, T2, T3, T4>(_ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4)
-> (T1, T2, T3, T4) {
return (t1, t2, t3, t4)
}
static func buildBlock<T1, T2, T3, T4, T5>(
_ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4, _ t5: T5
) -> (T1, T2, T3, T4, T5) {
return (t1, t2, t3, t4, t5)
}
static func buildDo<T>(_ value: T) -> T { return value }
static func buildIf<T>(_ value: T?) -> T? { return value }
static func buildEither<T,U>(first value: T) -> Either<T,U> {
return .first(value)
}
static func buildEither<T,U>(second value: U) -> Either<T,U> {
return .second(value)
}
}
@_functionBuilder
struct TupleBuilderWithoutIf { // expected-note {{struct 'TupleBuilderWithoutIf' declared here}}
static func buildBlock() -> () { }
static func buildBlock<T1>(_ t1: T1) -> T1 {
return t1
}
static func buildBlock<T1, T2>(_ t1: T1, _ t2: T2) -> (T1, T2) {
return (t1, t2)
}
static func buildBlock<T1, T2, T3>(_ t1: T1, _ t2: T2, _ t3: T3)
-> (T1, T2, T3) {
return (t1, t2, t3)
}
static func buildBlock<T1, T2, T3, T4>(_ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4)
-> (T1, T2, T3, T4) {
return (t1, t2, t3, t4)
}
static func buildBlock<T1, T2, T3, T4, T5>(
_ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4, _ t5: T5
) -> (T1, T2, T3, T4, T5) {
return (t1, t2, t3, t4, t5)
}
static func buildDo<T>(_ value: T) -> T { return value }
}
func tuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) -> T) {
print(body(cond))
}
func tuplifyWithoutIf<T>(_ cond: Bool, @TupleBuilderWithoutIf body: (Bool) -> T) {
print(body(cond))
}
func testDiags() {
// For loop
tuplify(true) { _ in
17
for c in name { // expected-error{{closure containing control flow statement cannot be used with function builder 'TupleBuilder'}}
// expected-error@-1 {{cannot find 'name' in scope}}
}
}
// Declarations
tuplify(true) { _ in
17
let x = 17
let y: Int // expected-error{{closure containing a declaration cannot be used with function builder 'TupleBuilder'}}
x + 25
}
// Statements unsupported by the particular builder.
tuplifyWithoutIf(true) {
if $0 { // expected-error{{closure containing control flow statement cannot be used with function builder 'TupleBuilderWithoutIf'}}
"hello"
}
}
}
struct A { }
struct B { }
func overloadedTuplify<T>(_ cond: Bool, @TupleBuilder body: (Bool) -> T) -> A { // expected-note {{found this candidate}}
return A()
}
func overloadedTuplify<T>(_ cond: Bool, @TupleBuilderWithoutIf body: (Bool) -> T) -> B { // expected-note {{found this candidate}}
return B()
}
func testOverloading(name: String) {
let a1 = overloadedTuplify(true) { b in
if b {
"Hello, \(name)"
}
}
let _: A = a1
_ = overloadedTuplify(true) { b in // expected-error {{ambiguous use of 'overloadedTuplify(_:body:)'}}
b ? "Hello, \(name)" : "Goodbye"
42
overloadedTuplify(false) {
$0 ? "Hello, \(name)" : "Goodbye"
42
if $0 {
"Hello, \(name)"
}
}
}
}
protocol P {
associatedtype T
}
struct AnyP : P {
typealias T = Any
init<T>(_: T) where T : P {}
}
struct TupleP<U> : P {
typealias T = U
init(_: U) {}
}
@_functionBuilder
struct Builder {
static func buildBlock<S0, S1>(_ stmt1: S0, _ stmt2: S1) // expected-note {{required by static method 'buildBlock' where 'S1' = 'Label<_>.Type'}}
-> TupleP<(S0, S1)> where S0: P, S1: P {
return TupleP((stmt1, stmt2))
}
}
struct G<C> : P where C : P {
typealias T = C
init(@Builder _: () -> C) {}
}
struct Text : P {
typealias T = String
init(_: T) {}
}
struct Label<L> : P where L : P { // expected-note 2 {{'L' declared as parameter to type 'Label'}}
typealias T = L
init(@Builder _: () -> L) {} // expected-note {{'init(_:)' declared here}}
}
func test_51167632() -> some P {
AnyP(G { // expected-error {{type 'Label<_>.Type' cannot conform to 'P'; only struct/enum/class types can conform to protocols}}
Text("hello")
Label // expected-error {{generic parameter 'L' could not be inferred}}
// expected-note@-1 {{explicitly specify the generic arguments to fix this issue}} {{10-10=<<#L: P#>>}}
})
}
func test_56221372() -> some P {
AnyP(G {
Text("hello")
Label() // expected-error {{generic parameter 'L' could not be inferred}}
// expected-error@-1 {{missing argument for parameter #1 in call}}
// expected-note@-2 {{explicitly specify the generic arguments to fix this issue}} {{10-10=<<#L: P#>>}}
})
}
struct SR11440 {
typealias ReturnsTuple<T> = () -> (T, T)
subscript<T, U>(@TupleBuilder x: ReturnsTuple<T>) -> (ReturnsTuple<U>) -> Void { //expected-note {{in call to 'subscript(_:)'}}
return { _ in }
}
func foo() {
// This is okay, we apply the function builder for the subscript arg.
self[{
5
5
}]({
(5, 5)
})
// But we shouldn't perform the transform for the argument to the call
// made on the function returned from the subscript.
self[{ // expected-error {{generic parameter 'U' could not be inferred}}
5
5
}]({
5
5
})
}
}
func acceptInt(_: Int, _: () -> Void) { }
// SR-11350 crash due to improper recontextualization.
func erroneousSR11350(x: Int) {
tuplify(true) { b in
17
x + 25
Optional(tuplify(false) { b in
if b {
acceptInt(0) { }
}
}).domap(0) // expected-error{{value of type '()?' has no member 'domap'}}
}
}
func extraArg() {
tuplify(true) { _ in
1
2
3
4
5
6 // expected-error {{extra argument in call}}
}
}
// rdar://problem/53209000 - use of #warning and #error
tuplify(true) { x in
1
#error("boom") // expected-error{{boom}}
"hello"
#warning("oops") // expected-warning{{oops}}
3.14159
}
struct MyTuplifiedStruct {
var condition: Bool
@TupleBuilder var computed: some Any { // expected-note{{remove the attribute to explicitly disable the function builder}}{{3-17=}}
if condition {
return 17 // expected-warning{{application of function builder 'TupleBuilder' disabled by explicit 'return' statement}}
// expected-note@-1{{remove 'return' statements to apply the function builder}}{{7-14=}}{{12-19=}}
} else {
return 42
}
}
}
// Check that we're performing syntactic use diagnostics.
func acceptMetatype<T>(_: T.Type) -> Bool { true }
func syntacticUses<T>(_: T) {
tuplify(true) { x in
if x && acceptMetatype(T) { // expected-error{{expected member name or constructor call after type name}}
// expected-note@-1{{use '.self' to reference the type object}}
acceptMetatype(T) // expected-error{{expected member name or constructor call after type name}}
// expected-note@-1{{use '.self' to reference the type object}}
}
}
}
// Check custom diagnostics within "if" conditions.
struct HasProperty {
var property: Bool = false
}
func checkConditions(cond: Bool) {
var x = HasProperty()
tuplify(cond) { value in
if x.property = value { // expected-error{{use of '=' in a boolean context, did you mean '=='?}}
"matched it"
}
}
}
// Check that a closure with a single "return" works with function builders.
func checkSingleReturn(cond: Bool) {
tuplify(cond) { value in
return (value, 17)
}
tuplify(cond) { value in
(value, 17)
}
tuplify(cond) {
($0, 17)
}
}
// rdar://problem/59116520
func checkImplicitSelfInClosure() {
@_functionBuilder
struct Builder {
static func buildBlock(_ children: String...) -> Element { Element() }
}
struct Element {
static func nonEscapingClosure(@Builder closure: (() -> Element)) {}
static func escapingClosure(@Builder closure: @escaping (() -> Element)) {}
}
class C {
let identifier: String = ""
func testImplicitSelf() {
Element.nonEscapingClosure {
identifier // okay
}
Element.escapingClosure { // expected-note {{capture 'self' explicitly to enable implicit 'self' in this closure}}
identifier // expected-error {{reference to property 'identifier' in closure requires explicit use of 'self' to make capture semantics explicit}}
// expected-note@-1 {{reference 'self.' explicitly}}
}
}
}
}
// rdar://problem/59239224 - crash because some nodes don't have type
// information during solution application.
struct X<T> {
init(_: T) { }
}
@TupleBuilder func foo(cond: Bool) -> some Any {
if cond {
tuplify(cond) { x in
X(x)
}
}
}
// switch statements don't allow fallthrough
enum E {
case a
case b(Int, String?)
}
func testSwitch(e: E) {
tuplify(true) { c in
"testSwitch"
switch e {
case .a:
"a"
case .b(let i, let s?):
i * 2
s + "!"
fallthrough // expected-error{{closure containing control flow statement cannot be used with function builder 'TupleBuilder'}}
case .b(let i, nil):
"just \(i)"
}
}
}
// Ensure that we don't back-propagate constraints to the subject
// expression. This is a potential avenue for future exploration, but
// is currently not supported by switch statements outside of function
// builders. It's better to be consistent for now.
enum E2 {
case b(Int, String?) // expected-note{{'b' declared here}}
}
func getSomeEnumOverloaded(_: Double) -> E { return .a }
func getSomeEnumOverloaded(_: Int) -> E2 { return .b(0, nil) }
func testOverloadedSwitch() {
tuplify(true) { c in
// FIXME: Bad source location.
switch getSomeEnumOverloaded(17) { // expected-error{{type 'E2' has no member 'a'; did you mean 'b'?}}
case .a:
"a"
default:
"default"
}
}
}
// Check exhaustivity.
func testNonExhaustiveSwitch(e: E) {
tuplify(true) { c in
"testSwitch"
switch e { // expected-error{{switch must be exhaustive}}
// expected-note @-1{{add missing case: '.b(_, .none)'}}
case .a:
"a"
case .b(let i, let s?):
i * 2
s + "!"
}
}
}
// rdar://problem/59856491
struct TestConstraintGenerationErrors {
@TupleBuilder var buildTupleFnBody: String {
String(nothing) // expected-error {{cannot find 'nothing' in scope}}
}
func buildTupleClosure() {
tuplify(true) { _ in
String(nothing) // expected-error {{cannot find 'nothing' in scope}}
}
}
}
// Check @unknown
func testUnknownInSwitchSwitch(e: E) {
tuplify(true) { c in
"testSwitch"
switch e {
@unknown case .a: // expected-error{{'@unknown' is only supported for catch-all cases ("case _")}}
"a"
case .b(let i, let s?):
i * 2
s + "!"
default:
"nothing"
}
}
}
// Check for mutability mismatches when there are multiple case items
// referring to same-named variables.
enum E3 {
case a(Int, String)
case b(String, Int)
case c(String, Int)
}
func testCaseMutabilityMismatches(e: E3) {
tuplify(true) { c in
"testSwitch"
switch e {
case .a(let x, var y),
.b(let y, // expected-error{{'let' pattern binding must match previous 'var' pattern binding}}
var x), // expected-error{{'var' pattern binding must match previous 'let' pattern binding}}
.c(let y, // expected-error{{'let' pattern binding must match previous 'var' pattern binding}}
var x): // expected-error{{'var' pattern binding must match previous 'let' pattern binding}}
x
y += "a"
}
}
}
// Check for type equivalence among different case variables with the same name.
func testCaseVarTypes(e: E3) {
// FIXME: Terrible diagnostic
tuplify(true) { c in // expected-error{{type of expression is ambiguous without more context}}
"testSwitch"
switch e {
case .a(let x, let y),
.c(let x, let y):
x
y + "a"
}
}
}
// Test for buildFinalResult.
@_functionBuilder
struct WrapperBuilder {
static func buildBlock() -> () { }
static func buildBlock<T1>(_ t1: T1) -> T1 {
return t1
}
static func buildBlock<T1, T2>(_ t1: T1, _ t2: T2) -> (T1, T2) {
return (t1, t2)
}
static func buildBlock<T1, T2, T3>(_ t1: T1, _ t2: T2, _ t3: T3)
-> (T1, T2, T3) {
return (t1, t2, t3)
}
static func buildBlock<T1, T2, T3, T4>(_ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4)
-> (T1, T2, T3, T4) {
return (t1, t2, t3, t4)
}
static func buildBlock<T1, T2, T3, T4, T5>(
_ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4, _ t5: T5
) -> (T1, T2, T3, T4, T5) {
return (t1, t2, t3, t4, t5)
}
static func buildDo<T>(_ value: T) -> T { return value }
static func buildIf<T>(_ value: T?) -> T? { return value }
static func buildEither<T,U>(first value: T) -> Either<T,U> {
return .first(value)
}
static func buildEither<T,U>(second value: U) -> Either<T,U> {
return .second(value)
}
static func buildFinalResult<T>(_ value: T) -> Wrapper<T> {
return Wrapper(value: value)
}
}
struct Wrapper<T> {
var value: T
}
func wrapperify<T>(_ cond: Bool, @WrapperBuilder body: (Bool) -> T) -> T{
return body(cond)
}
func testWrapperBuilder() {
let x = wrapperify(true) { c in
3.14159
"hello"
}
let _: Int = x // expected-error{{cannot convert value of type 'Wrapper<(Double, String)>' to specified type 'Int'}}
}
// rdar://problem/61347993 - empty function builder doesn't compile
func rdar61347993() {
struct Result {}
@_functionBuilder
struct Builder {
static func buildBlock() -> Result {
Result()
}
}
func test_builder<T>(@Builder _: () -> T) {}
test_builder {} // Ok
func test_closure(_: () -> Result) {}
test_closure {} // expected-error {{cannot convert value of type '()' to closure result type 'Result'}}
}
| apache-2.0 | 0014799ebc0a5abfdb7eebeaa591213a | 24.466071 | 153 | 0.602763 | 3.276131 | false | false | false | false |
bermudadigitalstudio/Rope | Tests/RopeTests/RopeQueryJSONTests.swift | 1 | 2387 | import XCTest
import Rope
final class RopeQueryJSONTests: XCTestCase {
let creds = TestCredentials.getCredentials()
var conn: Rope? // auto-tested optional db connection
let insertQuery = "INSERT INTO json (json) VALUES " +
"('{\"due_in_seconds\":0,\"method\":\"POST\",\"headers\":{},\"url\":\"http://localhost\"}') " +
"RETURNING id;"
override func setUp() {
super.setUp()
// create connection
conn = try? Rope.connect(credentials: creds)
XCTAssertNotNil(conn)
guard let dropRes = try? conn?.query("DROP TABLE IF EXISTS json") else {
XCTFail("res should not be nil"); return
}
XCTAssertNotNil(dropRes)
// create a table with different types as test, payload can be nil
let sql = "CREATE TABLE IF NOT EXISTS json (id SERIAL PRIMARY KEY, json JSONB);"
guard let createRes = try? conn?.query(sql) else {
XCTFail("res should not be nil"); return
}
XCTAssertNotNil(createRes)
}
override func tearDown() {
super.tearDown()
}
func testQueryInsertStatement() {
guard let res = try? conn?.query(insertQuery) else {
XCTFail("res should not be nil"); return
}
XCTAssertEqual(res?.rows().count, 1)
guard let row = res?.rows().first else {
XCTFail("res should not be nil"); return
}
let id = row["id"] as? Int
XCTAssertNotNil(id)
XCTAssertEqual(id, 1)
}
func testQuerySelectStatement() {
guard let _ = try? conn?.query(insertQuery),
let select = try? conn?.query("SELECT * FROM json")
else {
XCTFail("res should not be nil"); return
}
guard let row = select?.rows().first else {
XCTFail("res should not be nil"); return
}
let payload = row["json"] as? [String: Any]
XCTAssertNotNil(payload)
guard let method = payload?["method"] as? String,
let dueInSeconds = payload?["due_in_seconds"] as? Int,
let urlString = payload?["url"] as? String
else {
XCTFail("res should not be nil"); return
}
XCTAssertEqual(urlString, "http://localhost")
XCTAssertEqual(method, "POST")
XCTAssertEqual(dueInSeconds, 0)
}
}
| apache-2.0 | 9c1f1bc8d2d2ff609844b826d3d38239 | 30.407895 | 117 | 0.568915 | 4.564054 | false | true | false | false |
manavgabhawala/CAEN-Lecture-Scraper | CAEN Lecture Scraper/GenericExtensions.swift | 1 | 1310 | //
// GenericExtensions.swift
// CAEN Lecture Scraper
//
// Created by Manav Gabhawala on 6/3/15.
// Copyright (c) 2015 Manav Gabhawala. All rights reserved.
//
import Foundation
extension String
{
init?(data: NSData?)
{
if let data = data
{
if let some = NSString(data: data, encoding: NSUTF8StringEncoding)
{
self = some as String
return
}
return nil
}
return nil
}
func textBetween(start: String, end: String) -> String?
{
let startIndex = self.rangeOfString(start)?.endIndex
if (startIndex == nil)
{
return nil
}
let endIndex = self.rangeOfString(end, range: Range(start: startIndex!, end: self.endIndex))?.startIndex
if startIndex != nil && endIndex != nil
{
return self.substringWithRange(Range(start: startIndex!, end: endIndex!))
}
return nil
}
mutating func safeString()
{
self = self.safeString()
}
func safeString() -> String
{
return self.stringByReplacingOccurrencesOfString("Lecture recorded on ", withString: "").stringByReplacingOccurrencesOfString("/", withString: "-")
}
}
/*
let fileManager = NSFileManager.defaultManager()
if !fileManager.fileExistsAtPath(directory.absoluteString!)
{
fileManager.createDirectoryAtPath(directory.absoluteString!, withIntermediateDirectories: true, attributes: nil, error: nil)
}
*/ | mit | 511e62e75284eeda0465e3d4937d9418 | 22 | 149 | 0.707634 | 3.775216 | false | false | false | false |
eugeneego/utilities-ios | Sources/Network/Http/Serializers/UrlEncodedHttpSerializer.swift | 1 | 2221 | //
// UrlEncodedHttpSerializer
// Legacy
//
// Copyright (c) 2015 Eugene Egorov.
// License: MIT, https://github.com/eugeneego/legacy/blob/master/LICENSE
//
import Foundation
public struct UrlEncodedHttpSerializer: HttpSerializer {
public typealias Value = [String: String]
public let contentType: String = "application/x-www-form-urlencoded"
public init() {}
public func serialize(_ value: Value?) -> Result<Data, HttpSerializationError> {
guard let value = value else { return .success(Data()) }
let data = serialize(value).data(using: String.Encoding.utf8)
return Result(data, HttpSerializationError.noData)
}
public func deserialize(_ data: Data?) -> Result<Value, HttpSerializationError> {
guard let data = data, !data.isEmpty else { return .success([:]) }
let value = String(data: data, encoding: String.Encoding.utf8).map(deserialize)
return Result(value, HttpSerializationError.noData)
}
public func serialize(_ value: Value) -> String {
let result = value
.map { name, value in
UrlEncodedHttpSerializer.encode(name) + "=" + UrlEncodedHttpSerializer.encode("\(value)")
}
.joined(separator: "&")
return result
}
public func deserialize(_ string: String) -> Value {
var params: Value = [:]
let cmp = string.components(separatedBy: "&")
cmp.forEach { param in
let parts = param.components(separatedBy: "=")
if parts.count == 2 {
let name = UrlEncodedHttpSerializer.decode(parts[0])
let value = UrlEncodedHttpSerializer.decode(parts[1])
params[name] = value
}
}
return params
}
private static var characters: CharacterSet = {
var characters = CharacterSet.alphanumerics
characters.insert(charactersIn: "-_.")
return characters
}()
public static func encode(_ string: String) -> String {
string.addingPercentEncoding(withAllowedCharacters: characters) ?? ""
}
public static func decode(_ string: String) -> String {
string.removingPercentEncoding ?? ""
}
}
| mit | d56e755093dc24787db4fb05f5ee927e | 31.661765 | 105 | 0.625394 | 4.90287 | false | false | false | false |
xiandan/diaobaoweibo-swift | XWeibo-swift/Classes/Module/XUserAccount.swift | 1 | 3802 | //
// XUserAccount.swift
// XWeibo-swift
//
// Created by Apple on 15/10/31.
// Copyright © 2015年 Apple. All rights reserved.
//
import UIKit
class XUserAccount: NSObject, NSCoding {
//记录用户是否登录
class func isUserLogin() -> Bool {
return XUserAccount.loadAccount() != nil
}
//MARK: - 属性
//用户的access_token
var access_token: String?
//用户的expires_in的生命周期
var expires_in: NSTimeInterval = 0 {
didSet {
expires_date = NSDate(timeIntervalSinceNow: expires_in)
}
}
//用户的uid
var uid: String?
//过期时间
var expires_date: NSDate?
//友好显示名称
var name: String?
//头像
var avatar_large: String?
//MARK: - 构造方法 字典转模型
init(dic: [String:AnyObject]) {
super.init()
setValuesForKeysWithDictionary(dic)
}
override func setValue(value: AnyObject?, forUndefinedKey key: String){}
//MARK: - 加载用户数据
func loadUserInfo(finish: (error: NSError?) -> ()) {
XNetWorkTool.sharedInstance.loadUserInfo { (result, error) -> () in
if result == nil || error != nil
{
finish(error: error)
return
}
//加载成功
self.name = result!["name"] as? String
self.avatar_large = result!["avatar_large"] as? String
//保存数据
self.saveAccount()
//同步到内存中
XUserAccount.userAccount = self
finish(error: nil)
}
}
//沙盒路径
static let savePath = NSSearchPathForDirectoriesInDomains( NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true).last! + "/Account.plist"
//MARK; - 把数据保存到沙盒中
func saveAccount() {
NSKeyedArchiver.archiveRootObject(self, toFile: XUserAccount.savePath)
print(XUserAccount.savePath)
}
//MARK: - 从内存中取出用户数据
private static var userAccount: XUserAccount?
//MARK: - 从内存中加载用户数据
class func loadAccount() -> XUserAccount? {
//如果内存中没有数据
if userAccount == nil {
userAccount = NSKeyedUnarchiver.unarchiveObjectWithFile(savePath) as? XUserAccount
}
//判断账号是否有效
if userAccount != nil && userAccount?.expires_date?.compare(NSDate()) == NSComparisonResult.OrderedDescending {
print("账号有效")
return userAccount
}
return nil
}
// MARK: - 归档和解档
func encodeWithCoder(aCoder: NSCoder) {
aCoder.encodeObject(access_token, forKey: "access_token")
aCoder.encodeDouble(expires_in, forKey: "expires_in")
aCoder.encodeObject(uid, forKey: "uid")
aCoder.encodeObject(expires_date, forKey: "expires_date")
aCoder.encodeObject(name, forKey: "name")
aCoder.encodeObject(avatar_large, forKey: "avatar_large")
}
required init?(coder aDecoder: NSCoder) {
access_token = aDecoder.decodeObjectForKey("access_token") as? String
expires_in = aDecoder.decodeDoubleForKey("expires_in")
uid = aDecoder.decodeObjectForKey("uid") as? String
expires_date = aDecoder.decodeObjectForKey("expires_date") as? NSDate
name = aDecoder.decodeObjectForKey("name") as? String
avatar_large = aDecoder.decodeObjectForKey("avatar_large") as? String
}
}
| apache-2.0 | 6e92cc797ff6010d57edc0a6a2389c55 | 25.699248 | 174 | 0.568854 | 4.884457 | false | false | false | false |
apple/swift-nio | Tests/NIOFoundationCompatTests/ByteBufferView+MutableDataProtocolTest+XCTest.swift | 1 | 1197 | //===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// ByteBufferView+MutableDataProtocolTest+XCTest.swift
//
import XCTest
///
/// NOTE: This file was generated by generate_linux_tests.rb
///
/// Do NOT edit this file directly as it will be regenerated automatically when needed.
///
extension ByteBufferViewDataProtocolTests {
@available(*, deprecated, message: "not actually deprecated. Just deprecated to allow deprecated tests (which test deprecated functionality) without warnings")
static var allTests : [(String, (ByteBufferViewDataProtocolTests) -> () throws -> Void)] {
return [
("testResetBytes", testResetBytes),
("testCreateDataFromBuffer", testCreateDataFromBuffer),
]
}
}
| apache-2.0 | 99cced90f9910ea005fa19453bb88cc6 | 33.2 | 162 | 0.617377 | 5.115385 | false | true | false | false |
RameshRM/swift-tapper | swift-tapper/swift-tapper/AppDelegate.swift | 1 | 7067 | //
// AppDelegate.swift
// swift-tapper
//
// Created by Mahadevan, Ramesh on 7/13/14.
// Copyright (c) 2014 Mahadevan, Ramesh. All rights reserved.
//
import UIKit
import CoreData
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(application: UIApplication!, didFinishLaunchingWithOptions launchOptions: NSDictionary!) -> 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()
}
func saveContext () {
var error: NSError? = nil
let managedObjectContext = self.managedObjectContext
if managedObjectContext != nil {
if managedObjectContext.hasChanges && !managedObjectContext.save(&error) {
// 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.
//println("Unresolved error \(error), \(error.userInfo)")
abort()
}
}
}
// #pragma mark - Core Data stack
// Returns the managed object context for the application.
// If the context doesn't already exist, it is created and bound to the persistent store coordinator for the application.
var managedObjectContext: NSManagedObjectContext {
if !_managedObjectContext {
let coordinator = self.persistentStoreCoordinator
if coordinator != nil {
_managedObjectContext = NSManagedObjectContext()
_managedObjectContext!.persistentStoreCoordinator = coordinator
}
}
return _managedObjectContext!
}
var _managedObjectContext: NSManagedObjectContext? = nil
// Returns the managed object model for the application.
// If the model doesn't already exist, it is created from the application's model.
var managedObjectModel: NSManagedObjectModel {
if !_managedObjectModel {
let modelURL = NSBundle.mainBundle().URLForResource("swift_tapper", withExtension: "momd")
_managedObjectModel = NSManagedObjectModel(contentsOfURL: modelURL)
}
return _managedObjectModel!
}
var _managedObjectModel: NSManagedObjectModel? = nil
// Returns the persistent store coordinator for the application.
// If the coordinator doesn't already exist, it is created and the application's store added to it.
var persistentStoreCoordinator: NSPersistentStoreCoordinator {
if !_persistentStoreCoordinator {
let storeURL = self.applicationDocumentsDirectory.URLByAppendingPathComponent("swift_tapper.sqlite")
var error: NSError? = nil
_persistentStoreCoordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
if _persistentStoreCoordinator!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: storeURL, options: nil, error: &error) == nil {
/*
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.
Typical reasons for an error here include:
* The persistent store is not accessible;
* The schema for the persistent store is incompatible with current managed object model.
Check the error message to determine what the actual problem was.
If the persistent store is not accessible, there is typically something wrong with the file path. Often, a file URL is pointing into the application's resources directory instead of a writeable directory.
If you encounter schema incompatibility errors during development, you can reduce their frequency by:
* Simply deleting the existing store:
NSFileManager.defaultManager().removeItemAtURL(storeURL, error: nil)
* Performing automatic lightweight migration by passing the following dictionary as the options parameter:
[NSMigratePersistentStoresAutomaticallyOption: true, NSInferMappingModelAutomaticallyOption: true]
Lightweight migration will only work for a limited set of schema changes; consult "Core Data Model Versioning and Data Migration Programming Guide" for details.
*/
//println("Unresolved error \(error), \(error!.userInfo)")
abort()
}
}
return _persistentStoreCoordinator!
}
var _persistentStoreCoordinator: NSPersistentStoreCoordinator? = nil
// #pragma mark - Application's Documents directory
// Returns the URL to the application's Documents directory.
var applicationDocumentsDirectory: NSURL {
let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
return urls[urls.count-1] as NSURL
}
}
| apache-2.0 | c496402d286a683ed2e378e41880c88f | 51.348148 | 285 | 0.700722 | 6.150566 | false | false | false | false |
vadymmarkov/Faker | Tests/Fakery/Generators/NameSpec.swift | 3 | 1336 | import Quick
import Nimble
@testable import Fakery
final class NameSpec: QuickSpec {
override func spec() {
describe("Name") {
var name: Faker.Name!
beforeEach {
let parser = Parser(locale: "en-TEST")
name = Faker.Name(parser: parser)
}
describe("#name") {
it("returns the correct text") {
let text = name.name()
expect(text).to(equal("Mr. Vadym Markov"))
}
}
describe("#firstName") {
it("returns the correct text") {
let firstName = name.firstName()
expect(firstName).to(equal("Vadym"))
}
}
describe("#lastName") {
it("returns the correct text") {
let lastName = name.lastName()
expect(lastName).to(equal("Markov"))
}
}
describe("#prefix") {
it("returns the correct text") {
let prefix = name.prefix()
expect(prefix).to(equal("Mr."))
}
}
describe("#suffix") {
it("returns the correct text") {
let suffix = name.suffix()
expect(suffix).to(equal("I"))
}
}
describe("#title") {
it("returns the correct text") {
let title = name.title()
expect(title).to(equal("Lead Mobility Engineer"))
}
}
}
}
}
| mit | 1546e4250fec4265624364449d410727 | 22.034483 | 59 | 0.509731 | 4.254777 | false | false | false | false |
Samarkin/PixelEditor | PixelEditor/ViewController.swift | 1 | 2636 | import Cocoa
class ViewController: NSViewController {
@IBOutlet var colorSelectorView: ColorSelectorView!
@IBOutlet var selectedColorView: SolidColorView!
@IBOutlet var selectedAltColorView: SolidColorView!
@IBOutlet var canvasView: CanvasView!
override func viewDidLoad() {
super.viewDidLoad()
colorSelectorView.colorSelected = { [weak self] in
self?.selectedColorView?.backgroundColor = $0
}
colorSelectorView.altColorSelected = { [weak self] in
self?.selectedAltColorView?.backgroundColor = $0
}
canvasView.delegate = { [weak self] in
let colorMap: [CanvasColor : NSColor?] = [
.Main : self?.selectedColorView?.backgroundColor,
.Alternative : self?.selectedAltColorView?.backgroundColor
]
// TODO: Is there a better way to unwrap a double optional?
if let color = colorMap[$2], let c = color {
self?.document?.setPixel(i: $0, j: $1, color: c)
}
}
}
var document: Document? {
didSet {
oldValue?.removeObserver(self, forKeyPath: "pixels")
if let document = document {
canvasView.loadImage(document.pixels)
document.addObserver(self, forKeyPath: "pixels", options: NSKeyValueObservingOptions.New, context: nil)
}
}
}
override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) {
if let document = document
where object as? Document == document {
if keyPath == "pixels" {
// TODO: better changes tracking, don't reload the whole image every single time it changes
canvasView.loadImage(document.pixels)
}
}
}
func export(sender: AnyObject?) {
guard let window = self.view.window else {
return
}
let panel = NSSavePanel()
panel.allowedFileTypes = ["png"]
if let fileName = self.document?.displayName {
panel.nameFieldStringValue = fileName
}
panel.canSelectHiddenExtension = true
panel.beginSheetModalForWindow(window) {
guard $0 == NSFileHandlingPanelOKButton, let url = panel.URL else {
return
}
print("exporting to \(url)...")
self.document?.export().writeToURL(url, atomically: true)
}
}
deinit {
document?.removeObserver(self, forKeyPath: "pixels")
}
}
| mit | 90fb5e1906864ca722674351c5fe4ae3 | 34.621622 | 157 | 0.594461 | 5.168627 | false | false | false | false |
shiguredo/sora-ios-sdk | Sora/VideoFrame.swift | 1 | 2274 | import CoreMedia
import Foundation
import WebRTC
/**
映像フレームの種別です。
現在の実装では次の映像フレームに対応しています。
- ネイティブの映像フレーム (`RTCVideoFrame`)
- `CMSampleBuffer` (映像のみ、音声は非対応。 `RTCVideoFrame` に変換されます)
*/
public enum VideoFrame {
// MARK: - 定義
/// ネイティブの映像フレーム。
/// `CMSampleBuffer` から生成した映像フレームは、ネイティブの映像フレームに変換されます。
case native(capturer: RTCVideoCapturer?, frame: RTCVideoFrame)
// MARK: - プロパティ
/// 映像フレームの幅
public var width: Int {
switch self {
case .native(capturer: _, frame: let frame):
return Int(frame.width)
}
}
/// 映像フレームの高さ
public var height: Int {
switch self {
case .native(capturer: _, frame: let frame):
return Int(frame.height)
}
}
/// 映像フレームの生成時刻
public var timestamp: CMTime? {
switch self {
case .native(capturer: _, frame: let frame):
return CMTimeMake(value: frame.timeStampNs, timescale: 1_000_000_000)
}
}
// MARK: - 初期化
/**
初期化します。
指定されたサンプルバッファーからピクセル画像データを取得できなければ
`nil` を返します。
音声データを含むサンプルバッファーには対応していません。
- parameter sampleBuffer: ピクセルバッファーを含むサンプルバッファー
*/
public init?(from sampleBuffer: CMSampleBuffer) {
guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
return nil
}
let timeStamp = CMTimeGetSeconds(CMSampleBufferGetPresentationTimeStamp(sampleBuffer))
let timeStampNs = Int64(timeStamp * 1_000_000_000)
let frame = RTCVideoFrame(buffer: RTCCVPixelBuffer(pixelBuffer: pixelBuffer),
rotation: RTCVideoRotation._0,
timeStampNs: timeStampNs)
self = .native(capturer: nil, frame: frame)
}
}
| apache-2.0 | 6f578083d164a6bc72e803b18c872393 | 25.147059 | 94 | 0.613611 | 3.799145 | false | false | false | false |
matthewpurcell/firefox-ios | Client/Frontend/Browser/TabTrayController.swift | 1 | 41135 | /* 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 UIKit
import SnapKit
import Storage
import ReadingList
struct TabTrayControllerUX {
static let CornerRadius = CGFloat(4.0)
static let BackgroundColor = UIConstants.AppBackgroundColor
static let CellBackgroundColor = UIColor(red:0.95, green:0.95, blue:0.95, alpha:1)
static let TextBoxHeight = CGFloat(32.0)
static let FaviconSize = CGFloat(18.0)
static let Margin = CGFloat(15)
static let ToolbarBarTintColor = UIConstants.AppBackgroundColor
static let ToolbarButtonOffset = CGFloat(10.0)
static let CloseButtonSize = CGFloat(18.0)
static let CloseButtonMargin = CGFloat(6.0)
static let CloseButtonEdgeInset = CGFloat(10)
static let NumberOfColumnsThin = 1
static let NumberOfColumnsWide = 3
static let CompactNumberOfColumnsThin = 2
// Moved from UIConstants temporarily until animation code is merged
static var StatusBarHeight: CGFloat {
if UIScreen.mainScreen().traitCollection.verticalSizeClass == .Compact {
return 0
}
return 20
}
}
struct LightTabCellUX {
static let TabTitleTextColor = UIColor.blackColor()
}
struct DarkTabCellUX {
static let TabTitleTextColor = UIColor.whiteColor()
}
protocol TabCellDelegate: class {
func tabCellDidClose(cell: TabCell)
}
class TabCell: UICollectionViewCell {
enum Style {
case Light
case Dark
}
static let Identifier = "TabCellIdentifier"
var style: Style = .Light {
didSet {
applyStyle(style)
}
}
let backgroundHolder = UIView()
let background = UIImageViewAligned()
let titleText: UILabel
let innerStroke: InnerStrokedView
let favicon: UIImageView = UIImageView()
let closeButton: UIButton
var title: UIVisualEffectView!
var animator: SwipeAnimator!
weak var delegate: TabCellDelegate?
// Changes depending on whether we're full-screen or not.
var margin = CGFloat(0)
override init(frame: CGRect) {
self.backgroundHolder.backgroundColor = UIColor.whiteColor()
self.backgroundHolder.layer.cornerRadius = TabTrayControllerUX.CornerRadius
self.backgroundHolder.clipsToBounds = true
self.backgroundHolder.backgroundColor = TabTrayControllerUX.CellBackgroundColor
self.background.contentMode = UIViewContentMode.ScaleAspectFill
self.background.clipsToBounds = true
self.background.userInteractionEnabled = false
self.background.alignLeft = true
self.background.alignTop = true
self.favicon.backgroundColor = UIColor.clearColor()
self.favicon.layer.cornerRadius = 2.0
self.favicon.layer.masksToBounds = true
self.titleText = UILabel()
self.titleText.textAlignment = NSTextAlignment.Left
self.titleText.userInteractionEnabled = false
self.titleText.numberOfLines = 1
self.titleText.font = DynamicFontHelper.defaultHelper.DefaultSmallFontBold
self.closeButton = UIButton()
self.closeButton.setImage(UIImage(named: "stop"), forState: UIControlState.Normal)
self.closeButton.tintColor = UIColor.lightGrayColor()
self.closeButton.imageEdgeInsets = UIEdgeInsetsMake(TabTrayControllerUX.CloseButtonEdgeInset, TabTrayControllerUX.CloseButtonEdgeInset, TabTrayControllerUX.CloseButtonEdgeInset, TabTrayControllerUX.CloseButtonEdgeInset)
self.innerStroke = InnerStrokedView(frame: self.backgroundHolder.frame)
self.innerStroke.layer.backgroundColor = UIColor.clearColor().CGColor
super.init(frame: frame)
self.opaque = true
self.animator = SwipeAnimator(animatingView: self.backgroundHolder, container: self)
self.closeButton.addTarget(self, action: "SELclose", forControlEvents: UIControlEvents.TouchUpInside)
contentView.addSubview(backgroundHolder)
backgroundHolder.addSubview(self.background)
backgroundHolder.addSubview(innerStroke)
// Default style is light
applyStyle(style)
self.accessibilityCustomActions = [
UIAccessibilityCustomAction(name: NSLocalizedString("Close", comment: "Accessibility label for action denoting closing a tab in tab list (tray)"), target: self.animator, selector: "SELcloseWithoutGesture")
]
}
private func applyStyle(style: Style) {
self.title?.removeFromSuperview()
let title: UIVisualEffectView
switch style {
case .Light:
title = UIVisualEffectView(effect: UIBlurEffect(style: .ExtraLight))
self.titleText.textColor = LightTabCellUX.TabTitleTextColor
case .Dark:
title = UIVisualEffectView(effect: UIBlurEffect(style: .Dark))
self.titleText.textColor = DarkTabCellUX.TabTitleTextColor
}
titleText.backgroundColor = UIColor.clearColor()
title.layer.shadowColor = UIColor.blackColor().CGColor
title.layer.shadowOpacity = 0.2
title.layer.shadowOffset = CGSize(width: 0, height: 0.5)
title.layer.shadowRadius = 0
title.addSubview(self.closeButton)
title.addSubview(self.titleText)
title.addSubview(self.favicon)
backgroundHolder.addSubview(title)
self.title = title
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func layoutSubviews() {
super.layoutSubviews()
let w = frame.width
let h = frame.height
backgroundHolder.frame = CGRect(x: margin,
y: margin,
width: w,
height: h)
background.frame = CGRect(origin: CGPointMake(0, 0), size: backgroundHolder.frame.size)
title.frame = CGRect(x: 0,
y: 0,
width: backgroundHolder.frame.width,
height: TabTrayControllerUX.TextBoxHeight)
favicon.frame = CGRect(x: 6,
y: (TabTrayControllerUX.TextBoxHeight - TabTrayControllerUX.FaviconSize)/2,
width: TabTrayControllerUX.FaviconSize,
height: TabTrayControllerUX.FaviconSize)
let titleTextLeft = favicon.frame.origin.x + favicon.frame.width + 6
titleText.frame = CGRect(x: titleTextLeft,
y: 0,
width: title.frame.width - titleTextLeft - margin - TabTrayControllerUX.CloseButtonSize - TabTrayControllerUX.CloseButtonMargin * 2,
height: title.frame.height)
innerStroke.frame = background.frame
closeButton.snp_makeConstraints { make in
make.size.equalTo(title.snp_height)
make.trailing.centerY.equalTo(title)
}
let top = (TabTrayControllerUX.TextBoxHeight - titleText.bounds.height) / 2.0
titleText.frame.origin = CGPoint(x: titleText.frame.origin.x, y: max(0, top))
}
override func prepareForReuse() {
// Reset any close animations.
backgroundHolder.transform = CGAffineTransformIdentity
backgroundHolder.alpha = 1
self.titleText.font = DynamicFontHelper.defaultHelper.DefaultSmallFontBold
}
override func accessibilityScroll(direction: UIAccessibilityScrollDirection) -> Bool {
var right: Bool
switch direction {
case .Left:
right = false
case .Right:
right = true
default:
return false
}
animator.close(right: right)
return true
}
@objc
func SELclose() {
self.animator.SELcloseWithoutGesture()
}
}
@available(iOS 9, *)
struct PrivateModeStrings {
static let toggleAccessibilityLabel = NSLocalizedString("Private Mode", tableName: "PrivateBrowsing", comment: "Accessibility label for toggling on/off private mode")
static let toggleAccessibilityHint = NSLocalizedString("Turns private mode on or off", tableName: "PrivateBrowsing", comment: "Accessiblity hint for toggling on/off private mode")
static let toggleAccessibilityValueOn = NSLocalizedString("On", tableName: "PrivateBrowsing", comment: "Toggled ON accessibility value")
static let toggleAccessibilityValueOff = NSLocalizedString("Off", tableName: "PrivateBrowsing", comment: "Toggled OFF accessibility value")
}
protocol TabTrayDelegate: class {
func tabTrayDidDismiss(tabTray: TabTrayController)
func tabTrayDidAddBookmark(tab: Browser)
func tabTrayDidAddToReadingList(tab: Browser) -> ReadingListClientRecord?
func tabTrayRequestsPresentationOf(viewController viewController: UIViewController)
}
class TabTrayController: UIViewController {
let tabManager: TabManager
let profile: Profile
weak var delegate: TabTrayDelegate?
var collectionView: UICollectionView!
var navBar: UIView!
var addTabButton: UIButton!
var settingsButton: UIButton!
var collectionViewTransitionSnapshot: UIView?
private(set) internal var privateMode: Bool = false {
didSet {
if #available(iOS 9, *) {
togglePrivateMode.selected = privateMode
togglePrivateMode.accessibilityValue = privateMode ? PrivateModeStrings.toggleAccessibilityValueOn : PrivateModeStrings.toggleAccessibilityValueOff
tabDataSource.tabs = tabsToDisplay
collectionView?.reloadData()
}
}
}
private var tabsToDisplay: [Browser] {
return self.privateMode ? tabManager.privateTabs : tabManager.normalTabs
}
@available(iOS 9, *)
lazy var togglePrivateMode: ToggleButton = {
let button = ToggleButton()
button.setImage(UIImage(named: "smallPrivateMask"), forState: UIControlState.Normal)
button.addTarget(self, action: "SELdidTogglePrivateMode", forControlEvents: .TouchUpInside)
button.accessibilityLabel = PrivateModeStrings.toggleAccessibilityLabel
button.accessibilityHint = PrivateModeStrings.toggleAccessibilityHint
button.accessibilityValue = self.privateMode ? PrivateModeStrings.toggleAccessibilityValueOn : PrivateModeStrings.toggleAccessibilityValueOff
return button
}()
@available(iOS 9, *)
private lazy var emptyPrivateTabsView: EmptyPrivateTabsView = {
let emptyView = EmptyPrivateTabsView()
emptyView.learnMoreButton.addTarget(self, action: "SELdidTapLearnMore", forControlEvents: UIControlEvents.TouchUpInside)
return emptyView
}()
private lazy var tabDataSource: TabManagerDataSource = {
return TabManagerDataSource(tabs: self.tabsToDisplay, cellDelegate: self)
}()
private lazy var tabLayoutDelegate: TabLayoutDelegate = {
let delegate = TabLayoutDelegate(profile: self.profile, traitCollection: self.traitCollection)
delegate.tabSelectionDelegate = self
return delegate
}()
init(tabManager: TabManager, profile: Profile) {
self.tabManager = tabManager
self.profile = profile
super.init(nibName: nil, bundle: nil)
}
convenience init(tabManager: TabManager, profile: Profile, tabTrayDelegate: TabTrayDelegate) {
self.init(tabManager: tabManager, profile: profile)
self.delegate = tabTrayDelegate
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func viewDidDisappear(animated: Bool) {
super.viewDidDisappear(animated)
self.tabManager.removeDelegate(self)
}
override func viewWillAppear(animated: Bool) {
super.viewWillAppear(animated)
tabManager.addDelegate(self)
}
deinit {
NSNotificationCenter.defaultCenter().removeObserver(self, name: UIApplicationWillResignActiveNotification, object: nil)
NSNotificationCenter.defaultCenter().removeObserver(self, name: UIApplicationWillEnterForegroundNotification, object: nil)
NSNotificationCenter.defaultCenter().removeObserver(self, name: NotificationDynamicFontChanged, object: nil)
}
func SELDynamicFontChanged(notification: NSNotification) {
guard notification.name == NotificationDynamicFontChanged else { return }
self.collectionView.reloadData()
}
// MARK: View Controller Callbacks
override func viewDidLoad() {
super.viewDidLoad()
view.accessibilityLabel = NSLocalizedString("Tabs Tray", comment: "Accessibility label for the Tabs Tray view.")
navBar = UIView()
navBar.backgroundColor = TabTrayControllerUX.BackgroundColor
addTabButton = UIButton()
addTabButton.setImage(UIImage(named: "add"), forState: .Normal)
addTabButton.addTarget(self, action: "SELdidClickAddTab", forControlEvents: .TouchUpInside)
addTabButton.accessibilityLabel = NSLocalizedString("Add Tab", comment: "Accessibility label for the Add Tab button in the Tab Tray.")
settingsButton = UIButton()
settingsButton.setImage(UIImage(named: "settings"), forState: .Normal)
settingsButton.addTarget(self, action: "SELdidClickSettingsItem", forControlEvents: .TouchUpInside)
settingsButton.accessibilityLabel = NSLocalizedString("Settings", comment: "Accessibility label for the Settings button in the Tab Tray.")
let flowLayout = TabTrayCollectionViewLayout()
collectionView = UICollectionView(frame: view.frame, collectionViewLayout: flowLayout)
collectionView.dataSource = tabDataSource
collectionView.delegate = tabLayoutDelegate
collectionView.registerClass(TabCell.self, forCellWithReuseIdentifier: TabCell.Identifier)
collectionView.backgroundColor = TabTrayControllerUX.BackgroundColor
view.addSubview(collectionView)
view.addSubview(navBar)
view.addSubview(addTabButton)
view.addSubview(settingsButton)
makeConstraints()
if #available(iOS 9, *) {
view.addSubview(togglePrivateMode)
togglePrivateMode.snp_makeConstraints { make in
make.right.equalTo(addTabButton.snp_left).offset(-10)
make.size.equalTo(UIConstants.ToolbarHeight)
make.centerY.equalTo(self.navBar)
}
view.insertSubview(emptyPrivateTabsView, aboveSubview: collectionView)
emptyPrivateTabsView.alpha = privateMode && tabManager.privateTabs.count == 0 ? 1 : 0
emptyPrivateTabsView.snp_makeConstraints { make in
make.edges.equalTo(self.view)
}
if let tab = tabManager.selectedTab where tab.isPrivate {
privateMode = true
}
// register for previewing delegate to enable peek and pop if force touch feature available
if traitCollection.forceTouchCapability == .Available {
registerForPreviewingWithDelegate(self, sourceView: view)
}
}
NSNotificationCenter.defaultCenter().addObserver(self, selector: "SELappWillResignActiveNotification", name: UIApplicationWillResignActiveNotification, object: nil)
NSNotificationCenter.defaultCenter().addObserver(self, selector: "SELappDidBecomeActiveNotification", name: UIApplicationDidBecomeActiveNotification, object: nil)
NSNotificationCenter.defaultCenter().addObserver(self, selector: "SELDynamicFontChanged:", name: NotificationDynamicFontChanged, object: nil)
}
override func traitCollectionDidChange(previousTraitCollection: UITraitCollection?) {
super.traitCollectionDidChange(previousTraitCollection)
// Update the trait collection we reference in our layout delegate
tabLayoutDelegate.traitCollection = traitCollection
}
override func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {
super.viewWillTransitionToSize(size, withTransitionCoordinator: coordinator)
coordinator.animateAlongsideTransition({ _ in
self.collectionView.collectionViewLayout.invalidateLayout()
}, completion: nil)
}
override func preferredStatusBarStyle() -> UIStatusBarStyle {
return UIStatusBarStyle.LightContent
}
private func makeConstraints() {
navBar.snp_makeConstraints { make in
make.top.equalTo(snp_topLayoutGuideBottom)
make.height.equalTo(UIConstants.ToolbarHeight)
make.left.right.equalTo(self.view)
}
addTabButton.snp_makeConstraints { make in
make.trailing.bottom.equalTo(self.navBar)
make.size.equalTo(UIConstants.ToolbarHeight)
}
settingsButton.snp_makeConstraints { make in
make.leading.bottom.equalTo(self.navBar)
make.size.equalTo(UIConstants.ToolbarHeight)
}
collectionView.snp_makeConstraints { make in
make.top.equalTo(navBar.snp_bottom)
make.left.right.bottom.equalTo(self.view)
}
}
// MARK: Selectors
func SELdidClickDone() {
presentingViewController!.dismissViewControllerAnimated(true, completion: nil)
}
func SELdidClickSettingsItem() {
let settingsTableViewController = AppSettingsTableViewController()
settingsTableViewController.profile = profile
settingsTableViewController.tabManager = tabManager
settingsTableViewController.settingsDelegate = self
let controller = SettingsNavigationController(rootViewController: settingsTableViewController)
controller.popoverDelegate = self
controller.modalPresentationStyle = UIModalPresentationStyle.FormSheet
presentViewController(controller, animated: true, completion: nil)
}
func SELdidClickAddTab() {
openNewTab()
}
@available(iOS 9, *)
func SELdidTapLearnMore() {
let appVersion = NSBundle.mainBundle().objectForInfoDictionaryKey("CFBundleShortVersionString") as! String
if let langID = NSLocale.preferredLanguages().first {
let learnMoreRequest = NSURLRequest(URL: "https://support.mozilla.org/1/mobile/\(appVersion)/iOS/\(langID)/private-browsing-ios".asURL!)
openNewTab(learnMoreRequest)
}
}
@available(iOS 9, *)
func SELdidTogglePrivateMode() {
let scaleDownTransform = CGAffineTransformMakeScale(0.9, 0.9)
let fromView: UIView
if privateTabsAreEmpty() {
fromView = emptyPrivateTabsView
} else {
let snapshot = collectionView.snapshotViewAfterScreenUpdates(false)
snapshot.frame = collectionView.frame
view.insertSubview(snapshot, aboveSubview: collectionView)
fromView = snapshot
}
privateMode = !privateMode
// If we are exiting private mode and we have the close private tabs option selected, make sure
// we clear out all of the private tabs
if !privateMode && profile.prefs.boolForKey("settings.closePrivateTabs") ?? false {
tabManager.removeAllPrivateTabsAndNotify(false)
}
togglePrivateMode.setSelected(privateMode, animated: true)
collectionView.layoutSubviews()
let toView: UIView
if privateTabsAreEmpty() {
toView = emptyPrivateTabsView
} else {
let newSnapshot = collectionView.snapshotViewAfterScreenUpdates(true)
newSnapshot.frame = collectionView.frame
view.insertSubview(newSnapshot, aboveSubview: fromView)
collectionView.alpha = 0
toView = newSnapshot
}
toView.alpha = 0
toView.transform = scaleDownTransform
UIView.animateWithDuration(0.2, delay: 0, options: [], animations: { () -> Void in
fromView.transform = scaleDownTransform
fromView.alpha = 0
toView.transform = CGAffineTransformIdentity
toView.alpha = 1
}) { finished in
if fromView != self.emptyPrivateTabsView {
fromView.removeFromSuperview()
}
if toView != self.emptyPrivateTabsView {
toView.removeFromSuperview()
}
self.collectionView.alpha = 1
}
}
@available(iOS 9, *)
private func privateTabsAreEmpty() -> Bool {
return privateMode && tabManager.privateTabs.count == 0
}
@available(iOS 9, *)
func changePrivacyMode(isPrivate: Bool) {
if isPrivate != privateMode {
guard let _ = collectionView else {
privateMode = isPrivate
return
}
SELdidTogglePrivateMode()
}
}
private func openNewTab(request: NSURLRequest? = nil) {
if #available(iOS 9, *) {
if privateMode {
emptyPrivateTabsView.hidden = true
}
}
// We're only doing one update here, but using a batch update lets us delay selecting the tab
// until after its insert animation finishes.
self.collectionView.performBatchUpdates({ _ in
var tab: Browser
if #available(iOS 9, *) {
tab = self.tabManager.addTab(request, isPrivate: self.privateMode)
} else {
tab = self.tabManager.addTab(request)
}
self.tabManager.selectTab(tab)
}, completion: { finished in
if finished {
self.navigationController?.popViewControllerAnimated(true)
}
})
}
}
// MARK: - App Notifications
extension TabTrayController {
func SELappWillResignActiveNotification() {
if privateMode {
collectionView.alpha = 0
}
}
func SELappDidBecomeActiveNotification() {
// Re-show any components that might have been hidden because they were being displayed
// as part of a private mode tab
UIView.animateWithDuration(0.2, delay: 0, options: UIViewAnimationOptions.CurveEaseInOut, animations: {
self.collectionView.alpha = 1
},
completion: nil)
}
}
extension TabTrayController: TabSelectionDelegate {
func didSelectTabAtIndex(index: Int) {
let tab = tabsToDisplay[index]
tabManager.selectTab(tab)
self.navigationController?.popViewControllerAnimated(true)
}
}
extension TabTrayController: PresentingModalViewControllerDelegate {
func dismissPresentedModalViewController(modalViewController: UIViewController, animated: Bool) {
dismissViewControllerAnimated(animated, completion: { self.collectionView.reloadData() })
}
}
extension TabTrayController: TabManagerDelegate {
func tabManager(tabManager: TabManager, didSelectedTabChange selected: Browser?, previous: Browser?) {
}
func tabManager(tabManager: TabManager, didCreateTab tab: Browser) {
}
func tabManager(tabManager: TabManager, didAddTab tab: Browser) {
// Get the index of the added tab from it's set (private or normal)
guard let index = tabsToDisplay.indexOf(tab) else { return }
tabDataSource.addTab(tab)
self.collectionView?.performBatchUpdates({ _ in
self.collectionView.insertItemsAtIndexPaths([NSIndexPath(forItem: index, inSection: 0)])
}, completion: { finished in
if finished {
tabManager.selectTab(tab)
// don't pop the tab tray view controller if it is not in the foreground
if self.presentedViewController == nil {
self.navigationController?.popViewControllerAnimated(true)
}
}
})
}
func tabManager(tabManager: TabManager, didRemoveTab tab: Browser) {
let removedIndex = tabDataSource.removeTab(tab)
self.collectionView.deleteItemsAtIndexPaths([NSIndexPath(forItem: removedIndex, inSection: 0)])
// Workaround: On iOS 8.* devices, cells don't get reloaded during the deletion but after the
// animation has finished which causes cells that animate from above to suddenly 'appear'. This
// is fixed on iOS 9 but for iOS 8 we force a reload on non-visible cells during the animation.
if (floor(NSFoundationVersionNumber) <= NSFoundationVersionNumber_iOS_8_3) {
let visibleCount = collectionView.indexPathsForVisibleItems().count
var offscreenIndexPaths = [NSIndexPath]()
for i in 0..<(tabsToDisplay.count - visibleCount) {
offscreenIndexPaths.append(NSIndexPath(forItem: i, inSection: 0))
}
self.collectionView.reloadItemsAtIndexPaths(offscreenIndexPaths)
}
if #available(iOS 9, *) {
if privateTabsAreEmpty() {
emptyPrivateTabsView.alpha = 1
}
}
}
func tabManagerDidAddTabs(tabManager: TabManager) {
}
func tabManagerDidRestoreTabs(tabManager: TabManager) {
}
}
extension TabTrayController: UIScrollViewAccessibilityDelegate {
func accessibilityScrollStatusForScrollView(scrollView: UIScrollView) -> String? {
var visibleCells = collectionView.visibleCells() as! [TabCell]
var bounds = collectionView.bounds
bounds = CGRectOffset(bounds, collectionView.contentInset.left, collectionView.contentInset.top)
bounds.size.width -= collectionView.contentInset.left + collectionView.contentInset.right
bounds.size.height -= collectionView.contentInset.top + collectionView.contentInset.bottom
// visible cells do sometimes return also not visible cells when attempting to go past the last cell with VoiceOver right-flick gesture; so make sure we have only visible cells (yeah...)
visibleCells = visibleCells.filter { !CGRectIsEmpty(CGRectIntersection($0.frame, bounds)) }
let cells = visibleCells.map { self.collectionView.indexPathForCell($0)! }
let indexPaths = cells.sort { $0.section < $1.section || ($0.section == $1.section && $0.row < $1.row) }
if indexPaths.count == 0 {
return NSLocalizedString("No tabs", comment: "Message spoken by VoiceOver to indicate that there are no tabs in the Tabs Tray")
}
let firstTab = indexPaths.first!.row + 1
let lastTab = indexPaths.last!.row + 1
let tabCount = collectionView.numberOfItemsInSection(0)
if (firstTab == lastTab) {
let format = NSLocalizedString("Tab %@ of %@", comment: "Message spoken by VoiceOver saying the position of the single currently visible tab in Tabs Tray, along with the total number of tabs. E.g. \"Tab 2 of 5\" says that tab 2 is visible (and is the only visible tab), out of 5 tabs total.")
return String(format: format, NSNumber(integer: firstTab), NSNumber(integer: tabCount))
} else {
let format = NSLocalizedString("Tabs %@ to %@ of %@", comment: "Message spoken by VoiceOver saying the range of tabs that are currently visible in Tabs Tray, along with the total number of tabs. E.g. \"Tabs 8 to 10 of 15\" says tabs 8, 9 and 10 are visible, out of 15 tabs total.")
return String(format: format, NSNumber(integer: firstTab), NSNumber(integer: lastTab), NSNumber(integer: tabCount))
}
}
}
extension TabTrayController: SwipeAnimatorDelegate {
func swipeAnimator(animator: SwipeAnimator, viewDidExitContainerBounds: UIView) {
let tabCell = animator.container as! TabCell
if let indexPath = collectionView.indexPathForCell(tabCell) {
let tab = tabsToDisplay[indexPath.item]
tabManager.removeTab(tab)
UIAccessibilityPostNotification(UIAccessibilityAnnouncementNotification, NSLocalizedString("Closing tab", comment: ""))
}
}
}
extension TabTrayController: TabCellDelegate {
func tabCellDidClose(cell: TabCell) {
let indexPath = collectionView.indexPathForCell(cell)!
let tab = tabsToDisplay[indexPath.item]
tabManager.removeTab(tab)
}
}
extension TabTrayController: SettingsDelegate {
func settingsOpenURLInNewTab(url: NSURL) {
let request = NSURLRequest(URL: url)
openNewTab(request)
}
}
private class TabManagerDataSource: NSObject, UICollectionViewDataSource {
unowned var cellDelegate: protocol<TabCellDelegate, SwipeAnimatorDelegate>
private var tabs: [Browser]
init(tabs: [Browser], cellDelegate: protocol<TabCellDelegate, SwipeAnimatorDelegate>) {
self.cellDelegate = cellDelegate
self.tabs = tabs
super.init()
}
/**
Removes the given tab from the data source
- parameter tab: Tab to remove
- returns: The index of the removed tab, -1 if tab did not exist
*/
func removeTab(tabToRemove: Browser) -> Int {
var index: Int = -1
for (i, tab) in tabs.enumerate() {
if tabToRemove === tab {
index = i
break
}
}
tabs.removeAtIndex(index)
return index
}
/**
Adds the given tab to the data source
- parameter tab: Tab to add
*/
func addTab(tab: Browser) {
tabs.append(tab)
}
@objc func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
let tabCell = collectionView.dequeueReusableCellWithReuseIdentifier(TabCell.Identifier, forIndexPath: indexPath) as! TabCell
tabCell.animator.delegate = cellDelegate
tabCell.delegate = cellDelegate
let tab = tabs[indexPath.item]
tabCell.style = tab.isPrivate ? .Dark : .Light
tabCell.titleText.text = tab.displayTitle
if !tab.displayTitle.isEmpty {
tabCell.accessibilityLabel = tab.displayTitle
} else {
tabCell.accessibilityLabel = AboutUtils.getAboutComponent(tab.url)
}
tabCell.isAccessibilityElement = true
tabCell.accessibilityHint = NSLocalizedString("Swipe right or left with three fingers to close the tab.", comment: "Accessibility hint for tab tray's displayed tab.")
if let favIcon = tab.displayFavicon {
tabCell.favicon.sd_setImageWithURL(NSURL(string: favIcon.url)!)
} else {
var defaultFavicon = UIImage(named: "defaultFavicon")
if tab.isPrivate {
defaultFavicon = defaultFavicon?.imageWithRenderingMode(.AlwaysTemplate)
tabCell.favicon.image = defaultFavicon
tabCell.favicon.tintColor = UIColor.whiteColor()
} else {
tabCell.favicon.image = defaultFavicon
}
}
tabCell.background.image = tab.screenshot
return tabCell
}
@objc func collectionView(collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return tabs.count
}
}
@objc protocol TabSelectionDelegate: class {
func didSelectTabAtIndex(index :Int)
}
private class TabLayoutDelegate: NSObject, UICollectionViewDelegateFlowLayout {
weak var tabSelectionDelegate: TabSelectionDelegate?
private var traitCollection: UITraitCollection
private var profile: Profile
private var numberOfColumns: Int {
let compactLayout = profile.prefs.boolForKey("CompactTabLayout") ?? true
// iPhone 4-6+ portrait
if traitCollection.horizontalSizeClass == .Compact && traitCollection.verticalSizeClass == .Regular {
return compactLayout ? TabTrayControllerUX.CompactNumberOfColumnsThin : TabTrayControllerUX.NumberOfColumnsThin
} else {
return TabTrayControllerUX.NumberOfColumnsWide
}
}
init(profile: Profile, traitCollection: UITraitCollection) {
self.profile = profile
self.traitCollection = traitCollection
super.init()
}
private func cellHeightForCurrentDevice() -> CGFloat {
let compactLayout = profile.prefs.boolForKey("CompactTabLayout") ?? true
let shortHeight = (compactLayout ? TabTrayControllerUX.TextBoxHeight * 6 : TabTrayControllerUX.TextBoxHeight * 5)
if self.traitCollection.verticalSizeClass == UIUserInterfaceSizeClass.Compact {
return shortHeight
} else if self.traitCollection.horizontalSizeClass == UIUserInterfaceSizeClass.Compact {
return shortHeight
} else {
return TabTrayControllerUX.TextBoxHeight * 8
}
}
@objc func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, minimumInteritemSpacingForSectionAtIndex section: Int) -> CGFloat {
return TabTrayControllerUX.Margin
}
@objc func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAtIndexPath indexPath: NSIndexPath) -> CGSize {
let cellWidth = floor((collectionView.bounds.width - TabTrayControllerUX.Margin * CGFloat(numberOfColumns + 1)) / CGFloat(numberOfColumns))
return CGSizeMake(cellWidth, self.cellHeightForCurrentDevice())
}
@objc func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, insetForSectionAtIndex section: Int) -> UIEdgeInsets {
return UIEdgeInsetsMake(TabTrayControllerUX.Margin, TabTrayControllerUX.Margin, TabTrayControllerUX.Margin, TabTrayControllerUX.Margin)
}
@objc func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, minimumLineSpacingForSectionAtIndex section: Int) -> CGFloat {
return TabTrayControllerUX.Margin
}
@objc func collectionView(collectionView: UICollectionView, didSelectItemAtIndexPath indexPath: NSIndexPath) {
tabSelectionDelegate?.didSelectTabAtIndex(indexPath.row)
}
}
// There seems to be a bug with UIKit where when the UICollectionView changes its contentSize
// from > frame.size to <= frame.size: the contentSet animation doesn't properly happen and 'jumps' to the
// final state.
// This workaround forces the contentSize to always be larger than the frame size so the animation happens more
// smoothly. This also makes the tabs be able to 'bounce' when there are not enough to fill the screen, which I
// think is fine, but if needed we can disable user scrolling in this case.
private class TabTrayCollectionViewLayout: UICollectionViewFlowLayout {
private override func collectionViewContentSize() -> CGSize {
var calculatedSize = super.collectionViewContentSize()
let collectionViewHeight = collectionView?.bounds.size.height ?? 0
if calculatedSize.height < collectionViewHeight && collectionViewHeight > 0 {
calculatedSize.height = collectionViewHeight + 1
}
return calculatedSize
}
}
struct EmptyPrivateTabsViewUX {
static let TitleColor = UIColor.whiteColor()
static let TitleFont = UIFont.systemFontOfSize(22, weight: UIFontWeightMedium)
static let DescriptionColor = UIColor.whiteColor()
static let DescriptionFont = UIFont.systemFontOfSize(17)
static let LearnMoreFont = UIFont.systemFontOfSize(15, weight: UIFontWeightMedium)
static let TextMargin: CGFloat = 18
static let LearnMoreMargin: CGFloat = 30
static let MaxDescriptionWidth: CGFloat = 250
}
// View we display when there are no private tabs created
private class EmptyPrivateTabsView: UIView {
private lazy var titleLabel: UILabel = {
let label = UILabel()
label.textColor = EmptyPrivateTabsViewUX.TitleColor
label.font = EmptyPrivateTabsViewUX.TitleFont
label.textAlignment = NSTextAlignment.Center
return label
}()
private var descriptionLabel: UILabel = {
let label = UILabel()
label.textColor = EmptyPrivateTabsViewUX.DescriptionColor
label.font = EmptyPrivateTabsViewUX.DescriptionFont
label.textAlignment = NSTextAlignment.Center
label.numberOfLines = 0
label.preferredMaxLayoutWidth = EmptyPrivateTabsViewUX.MaxDescriptionWidth
return label
}()
private var learnMoreButton: UIButton = {
let button = UIButton(type: .System)
button.setTitle(
NSLocalizedString("Learn More", tableName: "PrivateBrowsing", comment: "Text button displayed when there are no tabs open while in private mode"),
forState: .Normal)
button.setTitleColor(UIConstants.PrivateModeTextHighlightColor, forState: .Normal)
button.titleLabel?.font = EmptyPrivateTabsViewUX.LearnMoreFont
return button
}()
private var iconImageView: UIImageView = {
let imageView = UIImageView(image: UIImage(named: "largePrivateMask"))
return imageView
}()
override init(frame: CGRect) {
super.init(frame: frame)
titleLabel.text = NSLocalizedString("Private Browsing",
tableName: "PrivateBrowsing", comment: "Title displayed for when there are no open tabs while in private mode")
descriptionLabel.text = NSLocalizedString("Firefox won't remember any of your history or cookies, but new bookmarks will be saved.",
tableName: "PrivateBrowsing", comment: "Description text displayed when there are no open tabs while in private mode")
addSubview(titleLabel)
addSubview(descriptionLabel)
addSubview(iconImageView)
addSubview(learnMoreButton)
titleLabel.snp_makeConstraints { make in
make.center.equalTo(self)
}
iconImageView.snp_makeConstraints { make in
make.bottom.equalTo(titleLabel.snp_top).offset(-EmptyPrivateTabsViewUX.TextMargin)
make.centerX.equalTo(self)
}
descriptionLabel.snp_makeConstraints { make in
make.top.equalTo(titleLabel.snp_bottom).offset(EmptyPrivateTabsViewUX.TextMargin)
make.centerX.equalTo(self)
}
learnMoreButton.snp_makeConstraints { (make) -> Void in
make.top.equalTo(descriptionLabel.snp_bottom).offset(EmptyPrivateTabsViewUX.LearnMoreMargin)
make.centerX.equalTo(self)
}
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
}
@available(iOS 9.0, *)
extension TabTrayController: TabPeekDelegate {
func tabPeekDidAddBookmark(tab: Browser) {
delegate?.tabTrayDidAddBookmark(tab)
}
func tabPeekDidAddToReadingList(tab: Browser) -> ReadingListClientRecord? {
return delegate?.tabTrayDidAddToReadingList(tab)
}
func tabPeekDidCloseTab(tab: Browser) {
if let index = self.tabDataSource.tabs.indexOf(tab),
let cell = self.collectionView?.cellForItemAtIndexPath(NSIndexPath(forItem: index, inSection: 0)) as? TabCell {
cell.SELclose()
}
}
func tabPeekRequestsPresentationOf(viewController viewController: UIViewController) {
delegate?.tabTrayRequestsPresentationOf(viewController: viewController)
}
}
@available(iOS 9.0, *)
extension TabTrayController: UIViewControllerPreviewingDelegate {
func previewingContext(previewingContext: UIViewControllerPreviewing, viewControllerForLocation location: CGPoint) -> UIViewController? {
guard let collectionView = collectionView else { return nil }
let convertedLocation = self.view.convertPoint(location, toView: collectionView)
guard let indexPath = collectionView.indexPathForItemAtPoint(convertedLocation),
let cell = collectionView.cellForItemAtIndexPath(indexPath) else { return nil }
let tab = tabDataSource.tabs[indexPath.row]
let tabVC = TabPeekViewController(tab: tab, delegate: self)
if let browserProfile = profile as? BrowserProfile {
tabVC.setState(withProfile: browserProfile, clientPickerDelegate: self)
}
previewingContext.sourceRect = self.view.convertRect(cell.frame, fromView: collectionView)
return tabVC
}
func previewingContext(previewingContext: UIViewControllerPreviewing, commitViewController viewControllerToCommit: UIViewController) {
guard let tpvc = viewControllerToCommit as? TabPeekViewController else { return }
tabManager.selectTab(tpvc.tab)
self.navigationController?.popViewControllerAnimated(true)
delegate?.tabTrayDidDismiss(self)
}
}
extension TabTrayController: ClientPickerViewControllerDelegate {
func clientPickerViewController(clientPickerViewController: ClientPickerViewController, didPickClients clients: [RemoteClient]) {
if let item = clientPickerViewController.shareItem {
self.profile.sendItems([item], toClients: clients)
}
clientPickerViewController.dismissViewControllerAnimated(true, completion: nil)
}
func clientPickerViewControllerDidCancel(clientPickerViewController: ClientPickerViewController) {
clientPickerViewController.dismissViewControllerAnimated(true, completion: nil)
}
} | mpl-2.0 | 992dbdf0571bc4ff3161f6f035306a70 | 39.728713 | 304 | 0.693521 | 5.686342 | false | false | false | false |
steve-holmes/music-app-2 | MusicApp/AppDelegate.swift | 1 | 1149 | //
// AppDelegate.swift
// MusicApp
//
// Created by Hưng Đỗ on 6/9/17.
// Copyright © 2017 HungDo. All rights reserved.
//
import UIKit
import GoogleMobileAds
import AlamofireNetworkActivityIndicator
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
let module = ModuleContainer()
var musicNotification: MusicNotification!
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
GADMobileAds.configure(withApplicationID: "ca-app-pub-3982247659947570~8380730445")
NetworkActivityIndicatorManager.shared.isEnabled = true
let musicModule = self.module.musicModule
musicNotification = musicModule.container.resolve(MusicNotification.self)!
window = UIWindow()
let mainModule = module.mainModule
let mainController = mainModule.container.resolve(MainViewController.self)!
window?.rootViewController = mainController
window?.makeKeyAndVisible()
return true
}
}
| mit | 4d15ad9d7d865055457a9f822afdc2af | 27.6 | 144 | 0.710664 | 5.271889 | false | false | false | false |
TheNounProject/CollectionView | CollectionView/DataStructures/IndexedSet.swift | 1 | 5294 | //
// IndexedSet.swift
// CollectionView
//
// Created by Wes Byrne on 1/20/17.
// Copyright © 2017 Noun Project. All rights reserved.
//
import Foundation
public struct IndexedSet<Index: Hashable, Value: Hashable>: Sequence, CustomDebugStringConvertible, ExpressibleByDictionaryLiteral {
// var table = MapTab
fileprivate var byValue = [Value: Index]()
fileprivate var byIndex = [Index: Value]()
// fileprivate var _sequenced = OrderedSet<Value>()
public var indexes: [Index] {
return Array(byIndex.keys)
}
public var indexSet: Set<Index> {
return Set(byIndex.keys)
}
public var dictionary: [Index: Value] {
return byIndex
}
public var values: [Value] {
return Array(byIndex.values)
}
public var valuesSet: Set<Value> {
return Set(byIndex.values)
}
public var count: Int {
return byValue.count
}
public var isEmpty: Bool {
return byValue.isEmpty
}
public func value(for index: Index) -> Value? {
return byIndex[index]
}
public func index(of value: Value) -> Index? {
return byValue[value]
}
public init() { }
public init(dictionaryLiteral elements: (Index, Value)...) {
for e in elements {
self.insert(e.1, for: e.0)
}
}
public init(_ dictionary: [Index: Value]) {
for e in dictionary {
self.insert(e.1, for: e.0)
}
}
public subscript(index: Index) -> Value? {
get { return value(for: index) }
set(newValue) {
if let v = newValue { insert(v, for: index) } else { _ = removeValue(for: index) }
}
}
public var debugDescription: String {
var str = "\(type(of: self)) [\n"
for i in self {
str += "\(i.index) : \(i.value)\n"
}
str += "]"
return str
}
public func contains(_ object: Value) -> Bool {
return byValue[object] != nil
}
public func containsValue(for index: Index) -> Bool {
return byIndex[index] != nil
}
/// Set the value-index pair removing any existing entries for either
///
/// - Parameter value: The value
/// - Parameter index: The index
public mutating func set(_ value: Value, for index: Index) {
self.removeValue(for: index)
self.remove(value)
byValue[value] = index
byIndex[index] = value
}
/// Insert value for the given index if the value does not exist.
///
/// - Parameter value: A value
/// - Parameter index: An index
public mutating func insert(_ value: Value, for index: Index) {
self.set(value, for: index)
}
@discardableResult public mutating func removeValue(for index: Index) -> Value? {
guard let value = byIndex.removeValue(forKey: index) else {
return nil
}
byValue.removeValue(forKey: value)
return value
}
@discardableResult public mutating func remove(_ value: Value) -> Index? {
guard let index = byValue.removeValue(forKey: value) else {
return nil
}
byIndex.removeValue(forKey: index)
return index
}
public mutating func removeAll() {
byValue.removeAll()
byIndex.removeAll()
}
public typealias Iterator = AnyIterator<(index: Index, value: Value)>
public func makeIterator() -> Iterator {
var it = byIndex.makeIterator()
return AnyIterator {
if let val = it.next() {
return (val.key, val.value)
}
return nil
}
}
}
extension IndexedSet {
func union(_ other: IndexedSet) -> IndexedSet {
var new = self
for e in other.byIndex {
new.insert(e.value, for: e.key)
}
return new
}
}
extension Array where Element: Hashable {
public var indexedSet: IndexedSet<Int, Element> {
var set = IndexedSet<Int, Element>()
for (idx, v) in self.enumerated() {
set.insert(v, for: idx)
}
return set
}
}
extension Collection where Iterator.Element: Hashable {
public var indexedSet: IndexedSet<Int, Iterator.Element> {
var set = IndexedSet<Int, Iterator.Element>()
for (idx, v) in self.enumerated() {
set.insert(v, for: idx)
}
return set
}
}
extension IndexedSet where Index: Comparable {
var orderedIndexes: [Index] {
return self.byIndex.keys.sorted()
}
func ordered() -> [Iterator.Element] {
return self.makeIterator().sorted { (a, b) -> Bool in
return a.index < b.index
}
}
func orderedLog() -> String {
var str = "\(type(of: self)) [\n"
for i in self.ordered() {
str += "\(i.index) : \(i.value)\n"
}
str += "]"
return str
}
var orderedValues: [Value] {
let sorted = self.byIndex.sorted(by: { (v1, v2) -> Bool in
return v1.key < v2.key
})
var res = [Value]()
for element in sorted {
res.append(element.value)
}
return res
}
}
| mit | 96a6f2324166470da5ad4ed498e532c1 | 25.465 | 132 | 0.553561 | 4.271994 | false | false | false | false |
garynewby/GLNPianoView | Source/Extensions.swift | 1 | 5942 | //
// Extensions.swift
// PianoView
//
// Created by Gary Newby on 23/09/2017.
//
import UIKit
import QuartzCore
extension UIImage {
static func keyImage(_ aSize: CGSize, blackKey: Bool, keyDown: Bool, keyCornerRadius: CGFloat, noteNumber: Int) -> UIImage? {
let scale = UIScreen.main.scale
var size: CGSize = aSize
size.width *= scale
size.height *= scale
UIGraphicsBeginImageContext(size)
if let context = UIGraphicsGetCurrentContext() {
let colorSpace = CGColorSpaceCreateDeviceRGB()
if blackKey {
let strokeColor1 = UIColor(red: 0, green: 0, blue: 0, alpha: 0.951)
let strokeColor2 = UIColor(red: 0.379, green: 0.379, blue: 0.379, alpha: 1)
let gradientColors = [strokeColor1.cgColor, strokeColor2.cgColor]
let gradientLocations: [CGFloat] = [0.11, 1.0]
if let gradient = CGGradient(colorsSpace: colorSpace, colors: gradientColors as CFArray, locations: gradientLocations) {
let frame = CGRect(x: 0, y: 0, width: size.width, height: size.height)
let rectanglePath = UIBezierPath(rect: CGRect(x: frame.minX, y: frame.minY, width: size.width, height: size.height))
strokeColor1.setFill()
rectanglePath.fill()
let border = size.width * 0.15
let width = size.width * 0.7
var topRectHeight = size.height * 0.86
var bottomRectOffset = size.height * 0.875
let bottomRectHeight = size.height * 0.125
if keyDown {
topRectHeight = size.height * 0.91
bottomRectOffset = size.height * 0.925
}
let roundedRectangleRect = CGRect(x: frame.minX + border, y: frame.minY, width: width, height: topRectHeight)
let roundedRectanglePath = UIBezierPath(roundedRect: roundedRectangleRect, cornerRadius: keyCornerRadius)
context.saveGState()
roundedRectanglePath.addClip()
context.drawLinearGradient(gradient,
start: CGPoint(x: roundedRectangleRect.midX, y: roundedRectangleRect.minY),
end: CGPoint(x: roundedRectangleRect.midX, y: roundedRectangleRect.maxY),
options: [])
context.restoreGState()
let roundedRectangle2Rect = CGRect(x: frame.minX + border, y: frame.minY + bottomRectOffset, width: width, height: bottomRectHeight)
let roundedRectangle2Path = UIBezierPath(roundedRect: roundedRectangle2Rect, cornerRadius: keyCornerRadius)
context.saveGState()
roundedRectangle2Path.addClip()
context.drawLinearGradient(gradient,
start: CGPoint(x: roundedRectangle2Rect.midX, y: roundedRectangle2Rect.maxY),
end: CGPoint(x: roundedRectangle2Rect.midX, y: roundedRectangle2Rect.minY),
options: [])
}
} else {
// White key
let strokeColor1 = UIColor(red: 1.0, green: 1.0, blue: 1.0, alpha: 0.0)
var strokeColor2 = UIColor(red: 0.1, green: 0.1, blue: 0.1, alpha: 0.20)
if keyDown {
strokeColor2 = UIColor.noteColourFor(midiNumber: noteNumber, alpha: 0.75)
// Background
let frame = CGRect(x: 0, y: 0, width: size.width, height: size.height)
context.setFillColor(UIColor.noteColourFor(midiNumber: noteNumber, alpha: 0.30).cgColor)
context.fill(frame)
}
let gradientColors = [strokeColor1.cgColor, strokeColor2.cgColor]
let gradientLocations: [CGFloat] = [0.1, 1.0]
if let gradient = CGGradient(colorsSpace: colorSpace, colors: gradientColors as CFArray, locations: gradientLocations) {
let rectanglePath = UIBezierPath(rect: CGRect(x: 0, y: 0, width: size.width, height: size.height))
context.saveGState()
rectanglePath.addClip()
context.drawRadialGradient(gradient,
startCenter: CGPoint(x: size.width / 2.0, y: size.height / 2.0),
startRadius: size.height * 0.01,
endCenter: CGPoint(x: size.width / 2.0, y: size.height / 2.0),
endRadius: size.height * 0.6,
options: [.drawsBeforeStartLocation, .drawsAfterEndLocation])
}
}
context.restoreGState()
}
let image = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
return image
}
}
extension UIColor {
static func noteColourFor(midiNumber: Int, alpha: Float) -> UIColor {
let hue = (CGFloat(midiNumber).truncatingRemainder(dividingBy: 12.0) / 12.0)
return UIColor(hue: hue, saturation: 0.0, brightness: 0.40, alpha: CGFloat(alpha))
}
}
extension Int {
func clamp(min: Int, max: Int) -> Int {
let r = self < min ? min : self
return r > max ? max : r
}
func isWhiteKey() -> Bool {
let k = self % 12
return (k == 0 || k == 2 || k == 4 || k == 5 || k == 7 || k == 9 || k == 11)
}
}
extension CGFloat {
func clamp(min: CGFloat, max: CGFloat) -> CGFloat {
let r = self < min ? min : self
return r > max ? max : r
}
}
| mit | 9d1b3892d17b801680fa9dbf4bd376f9 | 46.919355 | 152 | 0.5345 | 4.935216 | false | false | false | false |
zirinisp/SlackKit | SlackKit/Sources/AttachmentField.swift | 1 | 1856 | //
// AttachmentField.swift
//
// Copyright © 2016 Peter Zignego. 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.
public struct AttachmentField {
public let title: String?
public let value: String?
public let short: Bool?
internal init(field: [String: Any]?) {
title = field?["title"] as? String
value = field?["value"] as? String
short = field?["short"] as? Bool
}
public init(title:String, value:String, short: Bool? = nil) {
self.title = title
self.value = value.slackFormatEscaping
self.short = short
}
internal var dictionary: [String: Any] {
var field = [String: Any]()
field["title"] = title
field["value"] = value
field["short"] = short
return field
}
}
| mit | 828b0899e622f4556aab82048b1c2b32 | 36.857143 | 80 | 0.686792 | 4.46988 | false | false | false | false |
blstream/TOZ_iOS | TOZ_iOS/SignUpRequest.swift | 1 | 1065 | //
// SignUpRequest.swift
// TOZ_iOS
//
// Created by patronage on 28.04.2017.
// Copyright © 2017 intive. All rights reserved.
//
import Foundation
final class SignUpRequest: BackendAPIRequest {
private let name: String
private let surname: String
private let phoneNumber: String
private let email: String
private let roles: [Role]
init(name: String, surname: String,
phoneNumber: String, email: String, roles: [Role]) {
self.name = name
self.surname = surname
self.phoneNumber = phoneNumber
self.email = email
self.roles = roles
}
var endpoint: String {
return "/users"
}
var method: NetworkService.Method {
return .POST
}
var parameters: [String: Any]? {
return [
"name": name,
"surname": surname,
"phoneNumber": phoneNumber,
"email": email,
"roles": roles.map {$0.rawValue}
]
}
var headers: [String: String]? {
return defaultJSONHeaders()
}
}
| apache-2.0 | 72e24bdb38bf2e80e716c16fc0d13171 | 22.644444 | 61 | 0.581767 | 4.256 | false | false | false | false |
haibtdt/NotifiOS-Cumulation | NotifiOSCumulation/DefaultNotificationsTableViewController.swift | 1 | 2618 | //
// DefaultNotificationsTableViewController.swift
// NotifiOSCumulation
//
// Created by SB 8 on 9/29/15.
// Copyright © 2015 Bui Hai. All rights reserved.
//
import UIKit
public class DefaultNotificationsTableViewController: UITableViewController {
@IBOutlet var clearAllButton: UIBarButtonItem!
@IBOutlet var markAllAsReadButton: UIBarButtonItem!
var notificationCumulationCenter_ : NotifiOSCumulationCenter? = nil
public var notificationCumulationCenter : NotifiOSCumulationCenter? {
get {
return notificationCumulationCenter_
}
set {
notificationCumulationCenter_ = newValue
refreshViewData()
}
}
public func refreshViewData () {
allNotifications_ = notificationCumulationCenter_?.allNotifications ?? []
tableView?.reloadData()
}
var allNotifications_ : [NCNotification] = []
public var allNotifcations : [NCNotification] {
get {
return allNotifications_
}
}
@IBAction func markAllAsRead(sender: AnyObject) {
notificationCumulationCenter!.onceMarkAsRead(allNotifcations) { (_) -> Void in
dispatch_async(dispatch_get_main_queue(), { () -> Void in
self.tableView.reloadData()
})
}
}
@IBAction func clearAllNotifications(sender: AnyObject) {
notificationCumulationCenter!.removeAll { (_) -> Void in
dispatch_async(dispatch_get_main_queue(), { () -> Void in
self.refreshViewData()
})
}
}
override public func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
// #warning Incomplete implementation, return the number of rows
return allNotifcations.count
}
let cellID = "vn.haibui.NCNotificationCell"
override public func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier(cellID, forIndexPath: indexPath) as! NCNotificationTableViewCell
// Configure the cell...
cell.notif = allNotifcations[indexPath.row]
return cell
}
}
| mit | 5d36297be4d727c257f47174d5e830a9 | 23.92381 | 127 | 0.562476 | 6.367397 | false | false | false | false |
onevcat/CotEditor | CotEditor/Sources/SyntaxParser.swift | 1 | 13243 | //
// SyntaxParser.swift
//
// CotEditor
// https://coteditor.com
//
// Created by 1024jp on 2018-04-28.
//
// ---------------------------------------------------------------------------
//
// © 2004-2007 nakamuxu
// © 2014-2022 1024jp
//
// 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
//
// https://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 Combine
import Foundation
import AppKit.NSTextStorage
private extension NSAttributedString.Key {
static let syntaxType = NSAttributedString.Key("CotEditor.SyntaxType")
}
// MARK: -
final class SyntaxParser {
private struct Cache {
var styleName: String
var string: String
var highlights: [SyntaxType: [NSRange]]
}
// MARK: Public Properties
let textStorage: NSTextStorage
var style: SyntaxStyle
@Published private(set) var outlineItems: [OutlineItem]?
// MARK: Private Properties
private var outlineParseTask: Task<Void, Error>?
private var highlightParseTask: Task<Void, Error>?
private var highlightCache: Cache? // results cache of the last whole string highlights
private var textEditingObserver: AnyCancellable?
// MARK: -
// MARK: Lifecycle
init(textStorage: NSTextStorage, style: SyntaxStyle = SyntaxStyle()) {
self.textStorage = textStorage
self.style = style
// give up if the string is changed while parsing
self.textEditingObserver = NotificationCenter.default.publisher(for: NSTextStorage.willProcessEditingNotification, object: textStorage)
.map { $0.object as! NSTextStorage }
.filter { $0.editedMask.contains(.editedCharacters) }
.sink { [weak self] _ in self?.highlightParseTask?.cancel() }
}
deinit {
self.invalidateCurrentParse()
}
// MARK: Public Methods
/// Whether syntax should be parsed.
var canParse: Bool {
return UserDefaults.standard[.enableSyntaxHighlight] && !self.style.isNone
}
/// Cancel all syntax parse including ones in the queues.
func invalidateCurrentParse() {
self.highlightCache = nil
self.outlineParseTask?.cancel()
self.highlightParseTask?.cancel()
}
}
// MARK: - Outline
extension SyntaxParser {
/// Parse outline.
func invalidateOutline() {
self.outlineParseTask?.cancel()
guard
self.canParse,
!self.style.outlineExtractors.isEmpty,
!self.textStorage.range.isEmpty
else {
self.outlineItems = []
return
}
self.outlineItems = nil
let extractors = self.style.outlineExtractors
let string = self.textStorage.string.immutable
let range = self.textStorage.range
self.outlineParseTask = Task.detached(priority: .utility) { [weak self] in
self?.outlineItems = try await withThrowingTaskGroup(of: [OutlineItem].self) { group in
for extractor in extractors {
_ = group.addTaskUnlessCancelled { try await extractor.items(in: string, range: range) }
}
return try await group.reduce(into: []) { $0 += $1 }
.sorted(\.range.location)
}
}
}
}
// MARK: - Syntax Highlight
extension SyntaxParser {
/// Update highlights around passed-in range.
///
/// - Parameters:
/// - editedRange: The character range that was edited, or highlight whole range if `nil` is passed in.
/// - Returns: The progress of the async highlight task if performed.
@MainActor func highlight(around editedRange: NSRange? = nil) -> Progress? {
assert(Thread.isMainThread)
guard UserDefaults.standard[.enableSyntaxHighlight] else { return nil }
guard !self.textStorage.string.isEmpty else { return nil }
// in case that wholeRange length is changed from editedRange
guard editedRange.flatMap({ $0.upperBound > self.textStorage.length }) != true else {
assertionFailure("Invalid range \(editedRange?.description ?? "nil") is passed in to \(#function)")
return nil
}
let wholeRange = self.textStorage.range
let highlightRange: NSRange = {
guard let editedRange = editedRange, editedRange != wholeRange else { return wholeRange }
// highlight whole if string is enough short
let bufferLength = UserDefaults.standard[.coloringRangeBufferLength]
if wholeRange.length <= bufferLength {
return wholeRange
}
// highlight whole visible area if edited point is visible
var highlightRange = self.textStorage.layoutManagers
.compactMap(\.textViewForBeginningOfSelection?.visibleRange)
.filter { $0.intersects(editedRange) }
.reduce(into: editedRange) { $0.formUnion($1) }
highlightRange = (self.textStorage.string as NSString).lineRange(for: highlightRange)
// expand highlight area if the character just before/after the highlighting area is the same syntax type
if let layoutManager = self.textStorage.layoutManagers.first {
if highlightRange.lowerBound > 0,
let effectiveRange = layoutManager.effectiveRange(of: .syntaxType, at: highlightRange.lowerBound)
{
highlightRange = NSRange(location: effectiveRange.lowerBound,
length: highlightRange.upperBound - effectiveRange.lowerBound)
}
if highlightRange.upperBound < wholeRange.upperBound,
let effectiveRange = layoutManager.effectiveRange(of: .syntaxType, at: highlightRange.upperBound)
{
highlightRange.length = effectiveRange.upperBound - highlightRange.location
}
}
if highlightRange.upperBound < bufferLength {
return NSRange(location: 0, length: highlightRange.upperBound)
}
return highlightRange
}()
guard !highlightRange.isEmpty else { return nil }
// just clear current highlight and return if no coloring needs
guard self.style.hasHighlightDefinition else {
self.textStorage.apply(highlights: [:], range: highlightRange)
return nil
}
// use cache if the content of the whole document is the same as the last
if
highlightRange == wholeRange,
let cache = self.highlightCache,
cache.styleName == self.style.name,
cache.string == self.textStorage.string
{
self.textStorage.apply(highlights: cache.highlights, range: highlightRange)
return nil
}
// make sure that string is immutable
// -> `string` of NSTextStorage is actually a mutable object
// and it can cause crash when a mutable string is given to NSRegularExpression instance.
// (2016-11, macOS 10.12.1 SDK)
let string = self.textStorage.string.immutable
return self.highlight(string: string, range: highlightRange)
}
// MARK: Private Methods
/// perform highlighting
private func highlight(string: String, range highlightRange: NSRange) -> Progress {
assert(Thread.isMainThread)
assert(!(string as NSString).className.contains("MutableString"))
assert(!highlightRange.isEmpty)
assert(!self.style.isNone)
let definition = HighlightParser.Definition(extractors: self.style.highlightExtractors,
nestablePaires: self.style.nestablePaires,
inlineCommentDelimiter: self.style.inlineCommentDelimiter,
blockCommentDelimiters: self.style.blockCommentDelimiters)
let parser = HighlightParser(definition: definition, string: string, range: highlightRange)
let progress = Progress(totalUnitCount: 10)
let task = Task.detached(priority: .userInitiated) { [weak self, styleName = self.style.name] in
progress.localizedDescription = "Parsing text…".localized
progress.addChild(parser.progress, withPendingUnitCount: 9)
let highlights = try await parser.parse()
if highlightRange == string.nsRange {
self?.highlightCache = Cache(styleName: styleName, string: string, highlights: highlights)
}
try Task.checkCancellation()
progress.localizedDescription = "Applying colors to text…".localized
try await Task.sleep(nanoseconds: 10_000_000) // wait 0.01 seconds for GUI update
await self?.textStorage.apply(highlights: highlights, range: highlightRange)
progress.completedUnitCount += 1
}
progress.cancellationHandler = { task.cancel() }
self.highlightParseTask?.cancel()
self.highlightParseTask = task
return progress
}
}
private extension NSTextStorage {
/// apply highlights to the document
@MainActor func apply(highlights: [SyntaxType: [NSRange]], range highlightRange: NSRange) {
assert(Thread.isMainThread)
guard self.length > 0 else { return }
let hasHighlight = highlights.values.contains { !$0.isEmpty }
for layoutManager in self.layoutManagers {
// skip if never colorlized yet to avoid heavy `layoutManager.invalidateDisplay(forCharacterRange:)`
guard hasHighlight || layoutManager.hasTemporaryAttribute(.syntaxType, in: highlightRange) else { continue }
let theme = (layoutManager.firstTextView as? any Themable)?.theme
layoutManager.groupTemporaryAttributesUpdate(in: highlightRange) {
layoutManager.removeTemporaryAttribute(.foregroundColor, forCharacterRange: highlightRange)
layoutManager.removeTemporaryAttribute(.syntaxType, forCharacterRange: highlightRange)
for type in SyntaxType.allCases {
guard
let ranges = highlights[type]?.compactMap({ $0.intersection(highlightRange) }),
!ranges.isEmpty else { continue }
for range in ranges {
layoutManager.addTemporaryAttribute(.syntaxType, value: type, forCharacterRange: range)
}
if let color = theme?.style(for: type)?.color {
for range in ranges {
layoutManager.addTemporaryAttribute(.foregroundColor, value: color, forCharacterRange: range)
}
} else {
for range in ranges {
layoutManager.removeTemporaryAttribute(.foregroundColor, forCharacterRange: range)
}
}
}
}
}
}
}
extension NSLayoutManager {
/// Apply the theme based on the current `syntaxType` attributes.
///
/// - Parameter theme: The theme to apply.
/// - Parameter range: The range to invalidate. If `nil`, whole string will be invalidated.
@MainActor func invalidateHighlight(theme: Theme, range: NSRange? = nil) {
assert(Thread.isMainThread)
let wholeRange = range ?? self.attributedString().range
self.groupTemporaryAttributesUpdate(in: wholeRange) {
self.enumerateTemporaryAttribute(.syntaxType, in: wholeRange) { (type, range, _) in
guard let type = type as? SyntaxType else { return }
if let color = theme.style(for: type)?.color {
self.addTemporaryAttribute(.foregroundColor, value: color, forCharacterRange: range)
} else {
self.removeTemporaryAttribute(.foregroundColor, forCharacterRange: range)
}
}
}
}
}
| apache-2.0 | 91355cd5fb3be7611cced6c0dc124b80 | 35.166667 | 143 | 0.588653 | 5.582876 | false | false | false | false |
sschiau/swift | test/stdlib/Accelerate_vDSPFourierTransform.swift | 6 | 30371 | // RUN: %target-run-simple-swift
// REQUIRES: executable_test
// REQUIRES: rdar50301438
// REQUIRES: objc_interop
// UNSUPPORTED: OS=watchos
import StdlibUnittest
import Accelerate
var Accelerate_vDSPFourierTransformTests = TestSuite("Accelerate_vDSPFourierTransform")
//===----------------------------------------------------------------------===//
//
// vDSP discrete Fourier transform tests; single-precision
//
//===----------------------------------------------------------------------===//
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
let n = 2048
let tau: Float = .pi * 2
let frequencies: [Float] = [1, 5, 25, 30, 75, 100,
300, 500, 512, 1023]
let inputReal: [Float] = (0 ..< n).map { index in
frequencies.reduce(0) { accumulator, frequency in
let normalizedIndex = Float(index) / Float(n)
return accumulator + sin(normalizedIndex * frequency * tau)
}
}
let inputImag: [Float] = (0 ..< n).map { index in
frequencies.reduce(0) { accumulator, frequency in
let normalizedIndex = Float(index) / Float(n)
return accumulator + sin(normalizedIndex * 1/frequency * tau)
}
}
Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionForwardComplexComplex") {
let fwdDFT = vDSP.DFT(count: n,
direction: .forward,
transformType: .complexComplex,
ofType: Float.self)!
var outputReal = [Float](repeating: 0, count: n)
var outputImag = [Float](repeating: 0, count: n)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zop_CreateSetup(nil,
vDSP_Length(n),
.FORWARD)!
var legacyOutputReal = [Float](repeating: -1, count: n)
var legacyOutputImag = [Float](repeating: -1, count: n)
vDSP_DFT_Execute(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionInverseComplexComplex") {
let fwdDFT = vDSP.DFT(count: n,
direction: .inverse,
transformType: .complexComplex,
ofType: Float.self)!
var outputReal = [Float](repeating: 0, count: n)
var outputImag = [Float](repeating: 0, count: n)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zop_CreateSetup(nil,
vDSP_Length(n),
.INVERSE)!
var legacyOutputReal = [Float](repeating: -1, count: n)
var legacyOutputImag = [Float](repeating: -1, count: n)
vDSP_DFT_Execute(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionForwardComplexReal") {
let fwdDFT = vDSP.DFT(count: n,
direction: .forward,
transformType: .complexReal,
ofType: Float.self)!
var outputReal = [Float](repeating: 0, count: n / 2)
var outputImag = [Float](repeating: 0, count: n / 2)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zrop_CreateSetup(nil,
vDSP_Length(n),
.FORWARD)!
var legacyOutputReal = [Float](repeating: -1, count: n / 2)
var legacyOutputImag = [Float](repeating: -1, count: n / 2)
vDSP_DFT_Execute(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionInverseComplexReal") {
let fwdDFT = vDSP.DFT(count: n,
direction: .inverse,
transformType: .complexReal,
ofType: Float.self)!
var outputReal = [Float](repeating: 0, count: n / 2)
var outputImag = [Float](repeating: 0, count: n / 2)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zrop_CreateSetup(nil,
vDSP_Length(n),
.INVERSE)!
var legacyOutputReal = [Float](repeating: -1, count: n / 2)
var legacyOutputImag = [Float](repeating: -1, count: n / 2)
vDSP_DFT_Execute(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
}
//===----------------------------------------------------------------------===//
//
// vDSP discrete Fourier transform tests; double-precision
//
//===----------------------------------------------------------------------===//
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
let n = 2048
let tau: Double = .pi * 2
let frequencies: [Double] = [1, 5, 25, 30, 75, 100,
300, 500, 512, 1023]
let inputReal: [Double] = (0 ..< n).map { index in
frequencies.reduce(0) { accumulator, frequency in
let normalizedIndex = Double(index) / Double(n)
return accumulator + sin(normalizedIndex * frequency * tau)
}
}
let inputImag: [Double] = (0 ..< n).map { index in
frequencies.reduce(0) { accumulator, frequency in
let normalizedIndex = Double(index) / Double(n)
return accumulator + sin(normalizedIndex * 1/frequency * tau)
}
}
Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionForwardComplexComplex") {
let fwdDFT = vDSP.DFT(count: n,
direction: .forward,
transformType: .complexComplex,
ofType: Double.self)!
var outputReal = [Double](repeating: 0, count: n)
var outputImag = [Double](repeating: 0, count: n)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zop_CreateSetupD(nil,
vDSP_Length(n),
.FORWARD)!
var legacyOutputReal = [Double](repeating: -1, count: n)
var legacyOutputImag = [Double](repeating: -1, count: n)
vDSP_DFT_ExecuteD(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionInverseComplexComplex") {
let fwdDFT = vDSP.DFT(count: n,
direction: .inverse,
transformType: .complexComplex,
ofType: Double.self)!
var outputReal = [Double](repeating: 0, count: n)
var outputImag = [Double](repeating: 0, count: n)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zop_CreateSetupD(nil,
vDSP_Length(n),
.INVERSE)!
var legacyOutputReal = [Double](repeating: -1, count: n)
var legacyOutputImag = [Double](repeating: -1, count: n)
vDSP_DFT_ExecuteD(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionForwardComplexReal") {
let fwdDFT = vDSP.DFT(count: n,
direction: .forward,
transformType: .complexReal,
ofType: Double.self)!
var outputReal = [Double](repeating: 0, count: n / 2)
var outputImag = [Double](repeating: 0, count: n / 2)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zrop_CreateSetupD(nil,
vDSP_Length(n),
.FORWARD)!
var legacyOutputReal = [Double](repeating: -1, count: n / 2)
var legacyOutputImag = [Double](repeating: -1, count: n / 2)
vDSP_DFT_ExecuteD(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionInverseComplexReal") {
let fwdDFT = vDSP.DFT(count: n,
direction: .inverse,
transformType: .complexReal,
ofType: Double.self)!
var outputReal = [Double](repeating: 0, count: n / 2)
var outputImag = [Double](repeating: 0, count: n / 2)
fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag,
outputReal: &outputReal,
outputImaginary: &outputImag)
// legacy...
let legacySetup = vDSP_DFT_zrop_CreateSetupD(nil,
vDSP_Length(n),
.INVERSE)!
var legacyOutputReal = [Double](repeating: -1, count: n / 2)
var legacyOutputImag = [Double](repeating: -1, count: n / 2)
vDSP_DFT_ExecuteD(legacySetup,
inputReal,
inputImag,
&legacyOutputReal,
&legacyOutputImag)
expectTrue(outputReal.elementsEqual(legacyOutputReal))
expectTrue(outputImag.elementsEqual(legacyOutputImag))
let returnedResult = fwdDFT.transform(inputReal: inputReal,
inputImaginary: inputImag)
expectTrue(outputReal.elementsEqual(returnedResult.real))
expectTrue(outputImag.elementsEqual(returnedResult.imaginary))
}
}
//===----------------------------------------------------------------------===//
//
// vDSP Fast Fourier Transform Tests
//
//===----------------------------------------------------------------------===//
if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
Accelerate_vDSPFourierTransformTests.test("vDSP/SinglePrecisionComplexConversions") {
func convert(splitComplexVector: DSPSplitComplex,
toInterleavedComplexVector interleavedComplexVector: inout [DSPComplex]) {
withUnsafePointer(to: splitComplexVector) {
vDSP_ztoc($0, 1,
&interleavedComplexVector, 2,
vDSP_Length(interleavedComplexVector.count))
}
}
func convert(interleavedComplexVector: [DSPComplex],
toSplitComplexVector splitComplexVector: inout DSPSplitComplex) {
vDSP_ctoz(interleavedComplexVector, 2,
&splitComplexVector, 1,
vDSP_Length(interleavedComplexVector.count))
}
var realSrc: [Float] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
var imagSrc: [Float] = realSrc.reversed()
let splitSrc = DSPSplitComplex(realp: &realSrc,
imagp: &imagSrc)
var interleavedDest = [DSPComplex](repeating: DSPComplex(),
count: realSrc.count)
convert(splitComplexVector: splitSrc,
toInterleavedComplexVector: &interleavedDest)
var realDest = [Float](repeating: .nan, count: realSrc.count)
var imagDest = [Float](repeating: .nan, count: realSrc.count)
var splitDest = DSPSplitComplex(realp: &realDest,
imagp: &imagDest)
convert(interleavedComplexVector: interleavedDest,
toSplitComplexVector: &splitDest)
expectTrue(realSrc.elementsEqual(realDest))
expectTrue(imagSrc.elementsEqual(imagDest))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/DoublePrecisionComplexConversions") {
func convert(splitComplexVector: DSPDoubleSplitComplex,
toInterleavedComplexVector interleavedComplexVector: inout [DSPDoubleComplex]) {
withUnsafePointer(to: splitComplexVector) {
vDSP_ztocD($0, 1,
&interleavedComplexVector, 2,
vDSP_Length(interleavedComplexVector.count))
}
}
func convert(interleavedComplexVector: [DSPDoubleComplex],
toSplitComplexVector splitComplexVector: inout DSPDoubleSplitComplex) {
vDSP_ctozD(interleavedComplexVector, 2,
&splitComplexVector, 1,
vDSP_Length(interleavedComplexVector.count))
}
var realSrc: [Double] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
var imagSrc: [Double] = realSrc.reversed()
let splitSrc = DSPDoubleSplitComplex(realp: &realSrc,
imagp: &imagSrc)
var interleavedDest = [DSPDoubleComplex](repeating: DSPDoubleComplex(),
count: realSrc.count)
convert(splitComplexVector: splitSrc,
toInterleavedComplexVector: &interleavedDest)
var realDest = [Double](repeating: .nan, count: realSrc.count)
var imagDest = [Double](repeating: .nan, count: realSrc.count)
var splitDest = DSPDoubleSplitComplex(realp: &realDest,
imagp: &imagDest)
convert(interleavedComplexVector: interleavedDest,
toSplitComplexVector: &splitDest)
expectTrue(realSrc.elementsEqual(realDest))
expectTrue(imagSrc.elementsEqual(imagDest))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/2DSinglePrecision") {
let width = 256
let height = 256
let pixelCount = width * height
let n = pixelCount / 2
let pixels: [Float] = (0 ..< pixelCount).map { i in
return abs(sin(Float(i) * 0.001 * 2))
}
var sourceImageReal = [Float](repeating: 0, count: n)
var sourceImageImaginary = [Float](repeating: 0, count: n)
var sourceImage = DSPSplitComplex(fromInputArray: pixels,
realParts: &sourceImageReal,
imaginaryParts: &sourceImageImaginary)
let pixelsRecreated = [Float](fromSplitComplex: sourceImage,
scale: 1, count: pixelCount)
expectTrue(pixelsRecreated.elementsEqual(pixels))
// Create FFT2D object
let fft2D = vDSP.FFT2D(width: 256,
height: 256,
ofType: DSPSplitComplex.self)!
// New style transform
var transformedImageReal = [Float](repeating: 0,
count: n)
var transformedImageImaginary = [Float](repeating: 0,
count: n)
var transformedImage = DSPSplitComplex(
realp: &transformedImageReal,
imagp: &transformedImageImaginary)
fft2D.transform(input: sourceImage,
output: &transformedImage,
direction: .forward)
// Legacy 2D FFT
let log2n = vDSP_Length(log2(Float(width * height)))
let legacySetup = vDSP_create_fftsetup(
log2n,
FFTRadix(kFFTRadix2))!
var legacyTransformedImageReal = [Float](repeating: -1,
count: n)
var legacyTransformedImageImaginary = [Float](repeating: -1,
count: n)
var legacyTransformedImage = DSPSplitComplex(
realp: &legacyTransformedImageReal,
imagp: &legacyTransformedImageImaginary)
vDSP_fft2d_zrop(legacySetup,
&sourceImage, 1, 0,
&legacyTransformedImage, 1, 0,
vDSP_Length(log2(Float(width))),
vDSP_Length(log2(Float(height))),
FFTDirection(kFFTDirection_Forward))
expectTrue(transformedImageReal.elementsEqual(legacyTransformedImageReal))
expectTrue(transformedImageImaginary.elementsEqual(legacyTransformedImageImaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/2DDoublePrecision") {
let width = 256
let height = 256
let pixelCount = width * height
let n = pixelCount / 2
let pixels: [Double] = (0 ..< pixelCount).map { i in
return abs(sin(Double(i) * 0.001 * 2))
}
var sourceImageReal = [Double](repeating: 0, count: n)
var sourceImageImaginary = [Double](repeating: 0, count: n)
var sourceImage = DSPDoubleSplitComplex(fromInputArray: pixels,
realParts: &sourceImageReal,
imaginaryParts: &sourceImageImaginary)
let pixelsRecreated = [Double](fromSplitComplex: sourceImage,
scale: 1, count: pixelCount)
expectTrue(pixelsRecreated.elementsEqual(pixels))
// Create FFT2D object
let fft2D = vDSP.FFT2D(width: width,
height: height,
ofType: DSPDoubleSplitComplex.self)!
// New style transform
var transformedImageReal = [Double](repeating: 0,
count: n)
var transformedImageImaginary = [Double](repeating: 0,
count: n)
var transformedImage = DSPDoubleSplitComplex(
realp: &transformedImageReal,
imagp: &transformedImageImaginary)
fft2D.transform(input: sourceImage,
output: &transformedImage,
direction: .forward)
// Legacy 2D FFT
let log2n = vDSP_Length(log2(Float(width * height)))
let legacySetup = vDSP_create_fftsetupD(
log2n,
FFTRadix(kFFTRadix2))!
var legacyTransformedImageReal = [Double](repeating: -1,
count: n)
var legacyTransformedImageImaginary = [Double](repeating: -1,
count: n)
var legacyTransformedImage = DSPDoubleSplitComplex(
realp: &legacyTransformedImageReal,
imagp: &legacyTransformedImageImaginary)
vDSP_fft2d_zropD(legacySetup,
&sourceImage, 1, 0,
&legacyTransformedImage, 1, 0,
vDSP_Length(log2(Float(width))),
vDSP_Length(log2(Float(height))),
FFTDirection(kFFTDirection_Forward))
expectTrue(transformedImageReal.elementsEqual(legacyTransformedImageReal))
expectTrue(transformedImageImaginary.elementsEqual(legacyTransformedImageImaginary))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/1DSinglePrecision") {
let n = vDSP_Length(2048)
let frequencies: [Float] = [1, 5, 25, 30, 75, 100,
300, 500, 512, 1023]
let tau: Float = .pi * 2
let signal: [Float] = (0 ... n).map { index in
frequencies.reduce(0) { accumulator, frequency in
let normalizedIndex = Float(index) / Float(n)
return accumulator + sin(normalizedIndex * frequency * tau)
}
}
let halfN = Int(n / 2)
var forwardInputReal = [Float](repeating: 0, count: halfN)
var forwardInputImag = [Float](repeating: 0, count: halfN)
var forwardInput = DSPSplitComplex(fromInputArray: signal,
realParts: &forwardInputReal,
imaginaryParts: &forwardInputImag)
let log2n = vDSP_Length(log2(Float(n)))
// New API
guard let fft = vDSP.FFT(log2n: log2n,
radix: .radix2,
ofType: DSPSplitComplex.self) else {
fatalError("Can't create FFT.")
}
var outputReal = [Float](repeating: 0, count: halfN)
var outputImag = [Float](repeating: 0, count: halfN)
var forwardOutput = DSPSplitComplex(realp: &outputReal,
imagp: &outputImag)
fft.transform(input: forwardInput,
output: &forwardOutput,
direction: .forward)
// Legacy Style
let legacySetup = vDSP_create_fftsetup(log2n,
FFTRadix(kFFTRadix2))!
var legacyoutputReal = [Float](repeating: -1, count: halfN)
var legacyoutputImag = [Float](repeating: -1, count: halfN)
var legacyForwardOutput = DSPSplitComplex(realp: &legacyoutputReal,
imagp: &legacyoutputImag)
vDSP_fft_zrop(legacySetup,
&forwardInput, 1,
&legacyForwardOutput, 1,
log2n,
FFTDirection(kFFTDirection_Forward))
expectTrue(outputReal.elementsEqual(legacyoutputReal))
expectTrue(outputImag.elementsEqual(legacyoutputImag))
}
Accelerate_vDSPFourierTransformTests.test("vDSP/1DDoublePrecision") {
let n = vDSP_Length(2048)
let frequencies: [Double] = [1, 5, 25, 30, 75, 100,
300, 500, 512, 1023]
let tau: Double = .pi * 2
let signal: [Double] = (0 ... n).map { index in
frequencies.reduce(0) { accumulator, frequency in
let normalizedIndex = Double(index) / Double(n)
return accumulator + sin(normalizedIndex * frequency * tau)
}
}
let halfN = Int(n / 2)
var forwardInputReal = [Double](repeating: 0, count: halfN)
var forwardInputImag = [Double](repeating: 0, count: halfN)
var forwardInput = DSPDoubleSplitComplex(fromInputArray: signal,
realParts: &forwardInputReal,
imaginaryParts: &forwardInputImag)
let log2n = vDSP_Length(log2(Double(n)))
// New API
guard let fft = vDSP.FFT(log2n: log2n,
radix: .radix2,
ofType: DSPDoubleSplitComplex.self) else {
fatalError("Can't create FFT.")
}
var outputReal = [Double](repeating: 0, count: halfN)
var outputImag = [Double](repeating: 0, count: halfN)
var forwardOutput = DSPDoubleSplitComplex(realp: &outputReal,
imagp: &outputImag)
fft.transform(input: forwardInput,
output: &forwardOutput,
direction: .forward)
// Legacy Style
let legacySetup = vDSP_create_fftsetupD(log2n,
FFTRadix(kFFTRadix2))!
var legacyoutputReal = [Double](repeating: 0, count: halfN)
var legacyoutputImag = [Double](repeating: 0, count: halfN)
var legacyForwardOutput = DSPDoubleSplitComplex(realp: &legacyoutputReal,
imagp: &legacyoutputImag)
vDSP_fft_zropD(legacySetup,
&forwardInput, 1,
&legacyForwardOutput, 1,
log2n,
FFTDirection(kFFTDirection_Forward))
expectTrue(outputReal.elementsEqual(legacyoutputReal))
expectTrue(outputImag.elementsEqual(legacyoutputImag))
}
}
runAllTests()
| apache-2.0 | 7e97050e1b2b0fc8cdcdb9ac72d7184b | 40.097429 | 101 | 0.505383 | 6.034373 | false | false | false | false |
gxf2015/DYZB | DYZB/DYZB/Classes/Home/Controller/RecommendViewController.swift | 1 | 5421 | //
// RecommendViewController.swift
// DYZB
//
// Created by guo xiaofei on 2017/8/11.
// Copyright © 2017年 guo xiaofei. All rights reserved.
//
import UIKit
fileprivate let kItemMargin : CGFloat = 10
fileprivate let kItemW = (kScreenW - 3 * kItemMargin) / 2
fileprivate let kNormalItemH = kItemW * 3 / 4
fileprivate let kPrettyItemH = kItemW * 4 / 3
fileprivate let kHeaderViewH : CGFloat = 50
fileprivate let kCycleViewH = kScreenW * 3 / 8
fileprivate let kGameViewH : CGFloat = 90
fileprivate let kNormalCellID = "kNormalCellID"
fileprivate let kPrettyCellID = "kPrettyCellID"
fileprivate let kHeaderViewID = "kHeaderViewID"
class RecommendViewController: UIViewController {
//
fileprivate lazy var recommendVM :RecommendViewModel = RecommendViewModel()
fileprivate lazy var cycleView : RecommendCycleView = {
let cycleView = RecommendCycleView.recommendCycleView()
cycleView.frame = CGRect(x: 0, y: -(kCycleViewH + kGameViewH), width: kScreenW, height: kCycleViewH)
return cycleView
}()
fileprivate lazy var gameView : RecommendGameView = {
let gameView = RecommendGameView.recommendGameView()
gameView.frame = CGRect(x: 0, y: -kGameViewH, width: kScreenW, height: kGameViewH)
return gameView
}()
//
fileprivate lazy var collectionView : UICollectionView = {[unowned self] in
let layout = UICollectionViewFlowLayout()
layout.itemSize = CGSize(width: kItemW, height: kNormalItemH)
layout.minimumLineSpacing = 0
layout.minimumInteritemSpacing = kItemMargin
layout.headerReferenceSize = CGSize(width: kScreenW, height: kHeaderViewH)
layout.sectionInset = UIEdgeInsets(top: 0, left: kItemMargin, bottom: 0, right: kItemMargin)
let collectionView = UICollectionView(frame: self.view.bounds, collectionViewLayout: layout)
collectionView.dataSource = self
collectionView.delegate = self
collectionView.register(UINib(nibName: "CollectionNormalCell", bundle: nil), forCellWithReuseIdentifier: kNormalCellID)
collectionView.register(UINib(nibName: "CollectionPrettyCell", bundle: nil), forCellWithReuseIdentifier: kPrettyCellID)
collectionView.register(UINib(nibName: "CollectionHeaderView", bundle: nil), forSupplementaryViewOfKind: UICollectionElementKindSectionHeader, withReuseIdentifier: kHeaderViewID)
collectionView.autoresizingMask = [.flexibleHeight, .flexibleWidth]
collectionView.backgroundColor = UIColor.white
return collectionView
}()
//
override func viewDidLoad() {
super.viewDidLoad()
//1
setupUI()
//2
loadData()
}
}
extension RecommendViewController {
fileprivate func setupUI(){
view.addSubview(collectionView)
collectionView.addSubview(cycleView)
collectionView.addSubview(gameView)
collectionView.contentInset = UIEdgeInsets(top: kCycleViewH + kGameViewH, left: 0, bottom: 0, right: 0)
}
}
extension RecommendViewController{
fileprivate func loadData(){
recommendVM.requestData {
self.collectionView.reloadData()
self.gameView.groups = self.recommendVM.ancnorGroups
}
recommendVM.requestCycleData {
self.cycleView.cycleModels = self.recommendVM.cycleModels
}
}
}
extension RecommendViewController : UICollectionViewDataSource, UICollectionViewDelegateFlowLayout{
func numberOfSections(in collectionView: UICollectionView) -> Int {
return recommendVM.ancnorGroups.count
}
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
let group = recommendVM.ancnorGroups[section]
return group.room_list!.count
}
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
let group = recommendVM.ancnorGroups[indexPath.section]
let anchor = group.room_list?[indexPath.item]
var cell : CollectionBaseCell!
if indexPath.section == 1{
cell = collectionView.dequeueReusableCell(withReuseIdentifier: kPrettyCellID, for: indexPath) as! CollectionPrettyCell
}else{
cell = collectionView.dequeueReusableCell(withReuseIdentifier: kNormalCellID, for: indexPath) as! CollectionNormalCell
}
cell.anchor = anchor
return cell
}
func collectionView(_ collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, at indexPath: IndexPath) -> UICollectionReusableView {
let hearderView = collectionView.dequeueReusableSupplementaryView(ofKind: kind, withReuseIdentifier: kHeaderViewID, for: indexPath) as! CollectionHeaderView
hearderView.group = recommendVM.ancnorGroups[indexPath.section]
return hearderView
}
func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
if indexPath.section == 1 {
return CGSize(width: kItemW, height: kPrettyItemH)
}else{
return CGSize(width: kItemW, height: kNormalItemH)
}
}
}
| mit | 9c95bd4bd3243f92a2c7b3ee1ee1ab11 | 34.880795 | 186 | 0.694906 | 5.857297 | false | false | false | false |
Daltron/BigBoard | Example/BigBoard/ExampleAddStockView.swift | 1 | 4136 | //
// ExampleAddStockView.swift
// BigBoard
//
// Created by Dalton Hinterscher on 5/20/16.
// Copyright © 2016 CocoaPods. All rights reserved.
//
import UIKit
import SnapKit
import ChameleonFramework
protocol ExampleAddStockViewDelegate : class {
func numberOfSearchResultStocks() -> Int
func searchResultStockAtIndex(_ index:Int) -> BigBoardSearchResultStock
func searchTermChanged(searchTerm:String)
func stockResultSelectedAtIndex(_ index:Int)
}
class ExampleAddStockView: UIView, UITableViewDataSource, UITableViewDelegate {
weak var delegate:ExampleAddStockViewDelegate?
var searchTextField:UITextField!
var stocksTableView:UITableView!
init(delegate:ExampleAddStockViewDelegate) {
super.init(frame: CGRect.zero)
self.delegate = delegate
self.backgroundColor = UIColor.white
let searchBarView = UIView()
addSubview(searchBarView)
searchTextField = UITextField()
searchTextField.borderStyle = .roundedRect
searchTextField.textAlignment = .center
searchTextField.placeholder = "Search:"
searchTextField.addTarget(self, action: #selector(searchTermChanged), for: .allEditingEvents)
searchBarView.addSubview(searchTextField)
stocksTableView = UITableView(frame: CGRect.zero, style: .plain)
stocksTableView.dataSource = self
stocksTableView.delegate = self
stocksTableView.rowHeight = 50.0
addSubview(stocksTableView)
searchBarView.snp.makeConstraints { (make) in
make.top.equalTo(self.snp.top)
make.left.equalTo(self.snp.left)
make.right.equalTo(self.snp.right)
make.height.equalTo(50)
}
searchTextField.snp.makeConstraints { (make) in
make.top.equalTo(searchBarView).offset(10)
make.left.equalTo(searchBarView).offset(10)
make.right.equalTo(searchBarView).offset(-10)
make.bottom.equalTo(searchBarView).offset(-10)
}
stocksTableView.snp.makeConstraints { (make) in
make.top.equalTo(searchBarView.snp.bottom)
make.left.equalTo(self)
make.right.equalTo(self)
make.bottom.equalTo(self)
}
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
func searchTermChanged() {
delegate!.searchTermChanged(searchTerm: searchTextField.text!)
}
// MARK: UITableViewDataSource and UITableViewDataSource Implementation
func numberOfSections(in tableView: UITableView) -> Int {
return 1
}
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return delegate!.numberOfSearchResultStocks()
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let reuseIdentifier = "ExampleCell"
var cell = tableView.dequeueReusableCell(withIdentifier: reuseIdentifier) as UITableViewCell?
if cell == nil {
cell = UITableViewCell(style: .subtitle, reuseIdentifier: reuseIdentifier)
let exchangeLabel = UILabel(frame: CGRect(x: 0, y: 0, width: 150, height: 25))
exchangeLabel.textAlignment = .right
cell?.accessoryView = exchangeLabel
}
return cell!
}
func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
let stock = delegate!.searchResultStockAtIndex((indexPath as NSIndexPath).row)
cell.textLabel?.text = stock.name!
cell.detailTextLabel?.text = stock.symbol!
let exchangeLabel = cell.accessoryView as! UILabel!
exchangeLabel?.text = stock.exch!
}
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
tableView.deselectRow(at: indexPath, animated: false)
delegate!.stockResultSelectedAtIndex((indexPath as NSIndexPath).row)
}
}
| mit | c6740a32b9c28d24ab7c2b122d0606b5 | 34.34188 | 112 | 0.665296 | 5.188206 | false | false | false | false |
quire-io/SwiftyChrono | Sources/Parsers/DE/DEMorgenTimeParser.swift | 1 | 1624 | //
// DEMorgenTimeParser.swift
// SwiftyChrono
//
// Created by Jerry Chen on 2/18/17.
// Copyright © 2017 Potix. All rights reserved.
//
import Foundation
/* this is a white list for morning cases
* e.g.
* this morning => heute Morgen
* tomorrow morning => Morgen früh
* friday morning => Freitag Morgen
* last morning => letzten Morgen
*/
private let PATTERN = "(\\W|^)((?:heute|letzten)\\s*Morgen|Morgen\\s*früh|\(DE_WEEKDAY_WORDS_PATTERN)\\s*Morgen)"
private let timeMatch = 2
public class DEMorgenTimeParser: Parser {
override var pattern: String { return PATTERN }
override var language: Language { return .german }
override public func extract(text: String, ref: Date, match: NSTextCheckingResult, opt: [OptionType: Int]) -> ParsedResult? {
let (matchText, index) = matchTextAndIndex(from: text, andMatchResult: match)
var result = ParsedResult(ref: ref, index: index, text: matchText)
result.start.imply(.hour, to: opt[.morning] ?? 6)
let time = match.string(from: text, atRangeIndex: timeMatch).lowercased()
if time.hasPrefix("letzten") {
result.start.imply(.day, to: ref.day - 1)
} else if time.hasSuffix("früh") {
result.start.imply(.day, to: ref.day + 1)
} else {
if let weekday = DE_WEEKDAY_OFFSET[time.substring(from: 0, to: time.count - "Morgen".count).trimmed()] {
result.start.assign(.weekday, value: weekday)
}
}
result.tags[.deMorgenTimeParser] = true
return result
}
}
| mit | 6925c0dd0b8978e75d3bd5e9db8137f0 | 33.468085 | 129 | 0.619136 | 3.857143 | false | false | false | false |
nua-schroers/mvvm-frp | 30_MVVM-App/MatchGame/MatchGame/Controller/MainViewController.swift | 1 | 3323 | //
// ViewController.swift
// MatchGame
//
// Created by Dr. Wolfram Schroers on 5/26/16.
// Copyright © 2016 Wolfram Schroers. All rights reserved.
//
import UIKit
/// The view controller of the first screen responsible for the game.
class MainViewController: MVVMViewController, MainTakeAction {
// MARK: The corresponding view model (view first)
/// The main screen view model.
var viewModel: MainViewModel
// MARK: Lifecycle/workflow management
required init?(coder aDecoder: NSCoder) {
self.viewModel = MainViewModel()
super.init(coder: aDecoder)
self.viewModel.delegate = self
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
self.viewModel.viewWillAppear()
}
// MARK: Data Model -- THIS IS NO MORE!
// MARK: User Interface
/// The label at the top displaying the current game state.
@IBOutlet weak var gameStateLabel: UILabel!
/// The move report label beneath the game state label.
@IBOutlet weak var moveReportLabel: UILabel!
/// The graphical match pile.
@IBOutlet weak var matchPileView: MatchPileView!
/// The "Take 2" button. It can be disabled if needed.
@IBOutlet weak var takeTwoButton: UIButton!
/// The "Take 3" button. It can be disabled if needed.
@IBOutlet weak var takeThreeButton: UIButton!
/// Response to user tapping "Take 1".
@IBAction func userTappedTakeOne(_ sender: AnyObject) {
self.viewModel.userTappedTake(1)
}
/// Response to user tapping "Take 2".
@IBAction func userTappedTakeTwo(_ sender: AnyObject) {
self.viewModel.userTappedTake(2)
}
/// Response to user tapping "Take 3".
@IBAction func userTappedTakeThree(_ sender: AnyObject) {
self.viewModel.userTappedTake(3)
}
/// Response to user tapping "Info".
@IBAction func userTappedInfo(_ sender: AnyObject) {
self.viewModel.userTappedInfo()
}
// MARK: MainTakeAction
func transitionToSettings() {
// Instantiate the settings screen view controller and configure the UI transition.
let settingsController = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "SettingsViewController") as! SettingsViewController
settingsController.modalPresentationStyle = .currentContext
settingsController.modalTransitionStyle = .flipHorizontal
// Set the data context.
settingsController.configure(self.viewModel.createContext(),
contextDelegate: self.viewModel)
// Perform the transition.
self.present(settingsController,
animated: true,
completion: nil)
}
func updateLabelsAndButtonStates() {
self.gameStateLabel.text = self.viewModel.gameState
self.moveReportLabel.text = self.viewModel.moveReport
self.takeTwoButton.isEnabled = self.viewModel.buttonTwoEnabled
self.takeThreeButton.isEnabled = self.viewModel.buttonThreeEnabled
}
func setMatchesInPileView(_ count:Int) {
self.matchPileView.setMatches(count)
}
func removeMatchesInPileView(_ count:Int) {
self.matchPileView.removeMatches(count)
}
}
| mit | 5fe5ab244c09c8dd463a3f29f2acade4 | 30.638095 | 167 | 0.672185 | 4.885294 | false | false | false | false |
google/flatbuffers | swift/Sources/FlatBuffers/Constants.swift | 2 | 3103 | /*
* Copyright 2021 Google Inc. 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.
*/
#if !os(WASI)
#if os(Linux)
import CoreFoundation
#else
import Foundation
#endif
#else
import SwiftOverlayShims
#endif
/// A boolean to see if the system is littleEndian
let isLitteEndian: Bool = {
let number: UInt32 = 0x12345678
return number == number.littleEndian
}()
/// Constant for the file id length
let FileIdLength = 4
/// Type aliases
public typealias Byte = UInt8
public typealias UOffset = UInt32
public typealias SOffset = Int32
public typealias VOffset = UInt16
/// Maximum size for a buffer
public let FlatBufferMaxSize = UInt32
.max << ((MemoryLayout<SOffset>.size * 8 - 1) - 1)
/// Protocol that All Scalars should conform to
///
/// Scalar is used to conform all the numbers that can be represented in a FlatBuffer. It's used to write/read from the buffer.
public protocol Scalar: Equatable {
associatedtype NumericValue
var convertedEndian: NumericValue { get }
}
extension Scalar where Self: Verifiable {}
extension Scalar where Self: FixedWidthInteger {
/// Converts the value from BigEndian to LittleEndian
///
/// Converts values to little endian on machines that work with BigEndian, however this is NOT TESTED yet.
public var convertedEndian: NumericValue {
self as! Self.NumericValue
}
}
extension Double: Scalar, Verifiable {
public typealias NumericValue = UInt64
public var convertedEndian: UInt64 {
bitPattern.littleEndian
}
}
extension Float32: Scalar, Verifiable {
public typealias NumericValue = UInt32
public var convertedEndian: UInt32 {
bitPattern.littleEndian
}
}
extension Bool: Scalar, Verifiable {
public var convertedEndian: UInt8 {
self == true ? 1 : 0
}
public typealias NumericValue = UInt8
}
extension Int: Scalar, Verifiable {
public typealias NumericValue = Int
}
extension Int8: Scalar, Verifiable {
public typealias NumericValue = Int8
}
extension Int16: Scalar, Verifiable {
public typealias NumericValue = Int16
}
extension Int32: Scalar, Verifiable {
public typealias NumericValue = Int32
}
extension Int64: Scalar, Verifiable {
public typealias NumericValue = Int64
}
extension UInt8: Scalar, Verifiable {
public typealias NumericValue = UInt8
}
extension UInt16: Scalar, Verifiable {
public typealias NumericValue = UInt16
}
extension UInt32: Scalar, Verifiable {
public typealias NumericValue = UInt32
}
extension UInt64: Scalar, Verifiable {
public typealias NumericValue = UInt64
}
public func FlatBuffersVersion_22_11_23() {}
| apache-2.0 | e47716c072def0ef55fffe4a2d564b3b | 24.434426 | 127 | 0.745085 | 4.297784 | false | false | false | false |
Polidea/RxBluetoothKit | Source/CentralManagerRestoredState.swift | 1 | 2942 | import Foundation
import CoreBluetooth
/// It should be deleted when `RestoredState` will be deleted
protocol CentralManagerRestoredStateType {
var restoredStateData: [String: Any] { get }
var centralManager: CentralManager { get }
var peripherals: [Peripheral] { get }
var scanOptions: [String: AnyObject]? { get }
var services: [Service] { get }
}
/// Convenience class which helps reading state of restored CentralManager.
public struct CentralManagerRestoredState: CentralManagerRestoredStateType {
/// Restored state dictionary.
public let restoredStateData: [String: Any]
public unowned let centralManager: CentralManager
/// Creates restored state information based on CoreBluetooth's dictionary
/// - parameter restoredStateDictionary: Core Bluetooth's restored state data
/// - parameter centralManager: `CentralManager` instance of which state has been restored.
init(restoredStateDictionary: [String: Any], centralManager: CentralManager) {
restoredStateData = restoredStateDictionary
self.centralManager = centralManager
}
/// Array of `Peripheral` objects which have been restored.
/// These are peripherals that were connected to the central manager (or had a connection pending)
/// at the time the app was terminated by the system.
public var peripherals: [Peripheral] {
let objects = restoredStateData[CBCentralManagerRestoredStatePeripheralsKey] as? [AnyObject]
guard let arrayOfAnyObjects = objects else { return [] }
#if swift(>=4.1)
let cbPeripherals = arrayOfAnyObjects.compactMap { $0 as? CBPeripheral }
#else
let cbPeripherals = arrayOfAnyObjects.flatMap { $0 as? CBPeripheral }
#endif
return cbPeripherals.map { centralManager.retrievePeripheral(for: $0) }
}
/// Dictionary that contains all of the peripheral scan options that were being used
/// by the central manager at the time the app was terminated by the system.
public var scanOptions: [String: AnyObject]? {
return restoredStateData[CBCentralManagerRestoredStatePeripheralsKey] as? [String: AnyObject]
}
/// Array of `Service` objects which have been restored.
/// These are all the services the central manager was scanning for at the time the app
/// was terminated by the system.
public var services: [Service] {
let objects = restoredStateData[CBCentralManagerRestoredStateScanServicesKey] as? [AnyObject]
guard let arrayOfAnyObjects = objects else { return [] }
#if swift(>=4.1)
let cbServices = arrayOfAnyObjects.compactMap { $0 as? CBService }
#else
let cbServices = arrayOfAnyObjects.flatMap { $0 as? CBService }
#endif
return cbServices.map { Service(peripheral: centralManager.retrievePeripheral(for: $0.peripheral),
service: $0) }
}
}
| apache-2.0 | c528673fca289ea1410e085c84a43eb5 | 43.575758 | 106 | 0.704623 | 5.244207 | false | false | false | false |
ericwastaken/Xcode_Playgrounds | Playgrounds/Binary Tree Search Implementation.playground/Contents.swift | 1 | 2173 | // Binary Search Tree
// A node can contain at most 2 children
// The tree is always in order
public class BinarySearchTree<T>: CustomStringConvertible {
var value: T
var leftTree: BinarySearchTree<T>?
var rightTree: BinarySearchTree<T>?
init(_ value: T) {
self.value = value
}
public var description: String {
let value = "\(self.value)"
let leftTree = self.leftTree == nil ? "nil" : "\(self.leftTree!)"
let rightTree = self.rightTree == nil ? "nil" : "\(self.rightTree!)"
return "\(value): [\(leftTree) , \(rightTree)]"
}
public var count: Int {
var counter = 0
if let leftCount = self.leftTree?.count {
counter += leftCount
}
if let rightCount = self.rightTree?.count {
counter += rightCount
}
return counter + 1 // +1 for itself
}
}
// Insert
public func insert<T: Comparable>(intoTree: BinarySearchTree<T>, value: T) -> BinarySearchTree<T> {
// decide if we go left or right
if value < intoTree.value {
if let leftTree = intoTree.leftTree {
// We replace the left tree, with a future left tree (recursively)
intoTree.leftTree = insert(intoTree: leftTree, value: value)
} else {
// no left tree, so insert into left
let newNode = BinarySearchTree<T>(value)
intoTree.leftTree = newNode
return intoTree
}
}
// We replace the right tree, with a future right tree (recursively)
if let rightTree = intoTree.rightTree {
// We replace the left tree, with a future left tree (recursively)
intoTree.rightTree = insert(intoTree: rightTree, value: value)
} else {
// no left tree, so insert into left
let newNode = BinarySearchTree<T>(value)
intoTree.rightTree = newNode
return intoTree
}
return intoTree
}
var myTree = BinarySearchTree<Int>(5)
myTree = insert(intoTree: myTree, value: 7)
myTree = insert(intoTree: myTree, value: 3)
myTree = insert(intoTree: myTree, value: 13)
print("myTree: \(myTree)")
| unlicense | 34abf872f9a7f3de07773fa6817d17c0 | 29.605634 | 99 | 0.600092 | 4.425662 | false | false | false | false |
albinekcom/BitBay-Ticker-iOS | Codebase/Data Repository/Remote/RemoteDataRepository.swift | 1 | 4303 | import Foundation
private enum Endpoint: String {
case currencies = "https://raw.githubusercontent.com/albinekcom/Zonda-API-Tools/main/v1/currencies.json"
case ticker = "https://api.zonda.exchange/rest/trading/ticker"
case stats = "https://api.zonda.exchange/rest/trading/stats"
var url: URL? {
URL(string: rawValue)
}
}
private enum RemoteDataRepositoryError: Error {
case wrongURL
}
final class RemoteDataRepository {
private let urlSession: URLSession
private var cachedCurrenciesNamesAPIResponse: CurrenciesNamesAPIResponse?
init(urlSession: URLSession = URLSession.shared) {
self.urlSession = urlSession
}
func fetch() async throws -> [Ticker] {
async let tickersValuesAPIResponse = fetch(TickersValuesAPIResponse.self, from: .ticker)
async let tickersStatisticsAPIResponse = fetch(TickersStatisticsAPIResponse.self, from: .stats)
let currenciesNamesAPIResponse: CurrenciesNamesAPIResponse
if let cachedCurrenciesNamesAPIResponse = cachedCurrenciesNamesAPIResponse {
currenciesNamesAPIResponse = cachedCurrenciesNamesAPIResponse
} else {
currenciesNamesAPIResponse = try await fetch(CurrenciesNamesAPIResponse.self, from: .currencies)
cachedCurrenciesNamesAPIResponse = currenciesNamesAPIResponse
}
return try await tickers(
tickersValuesAPIResponse: tickersValuesAPIResponse,
tickersStatisticsAPIResponse: tickersStatisticsAPIResponse
)
}
// MARK: - Helpers
private func fetch<T: Decodable>(_ type: T.Type, from endpoint: Endpoint) async throws -> T {
guard let url = endpoint.url else { throw RemoteDataRepositoryError.wrongURL }
return try JSONDecoder().decode(
T.self,
from: try await urlSession.data(from: url).0
)
}
private func tickers(tickersValuesAPIResponse: TickersValuesAPIResponse,
tickersStatisticsAPIResponse: TickersStatisticsAPIResponse) -> [Ticker] {
tickersValuesAPIResponse.items.values.compactMap {
guard let tickerStatisticsAPIResponseItem = tickersStatisticsAPIResponse.items[$0.market.code] else { return nil }
return Ticker(
tickerValuesAPIResponseItem: $0,
tickerStatisticsAPIResponseItem: tickerStatisticsAPIResponseItem,
firstCurrencyName: cachedCurrenciesNamesAPIResponse?.names[$0.market.first.currency.lowercased()],
secondCurrencyName: cachedCurrenciesNamesAPIResponse?.names[$0.market.second.currency.lowercased()]
)
}
.sorted()
}
}
private extension Ticker {
init(tickerValuesAPIResponseItem: TickersValuesAPIResponse.Item,
tickerStatisticsAPIResponseItem: TickersStatisticsAPIResponse.Item,
firstCurrencyName: String?,
secondCurrencyName: String?) {
id = tickerValuesAPIResponseItem.market.code.lowercased()
highestBid = tickerValuesAPIResponseItem.highestBid.double
lowestAsk = tickerValuesAPIResponseItem.lowestAsk.double
rate = tickerValuesAPIResponseItem.rate.double
previousRate = tickerValuesAPIResponseItem.previousRate.double
highestRate = tickerStatisticsAPIResponseItem.h.double
lowestRate = tickerStatisticsAPIResponseItem.l.double
volume = tickerStatisticsAPIResponseItem.v.double
average = tickerStatisticsAPIResponseItem.r24h.double
firstCurrency = .init(
id: tickerValuesAPIResponseItem.market.first.currency.lowercased(),
name: firstCurrencyName,
precision: tickerValuesAPIResponseItem.market.first.scale
)
secondCurrency = .init(
id: tickerValuesAPIResponseItem.market.second.currency.lowercased(),
name: secondCurrencyName,
precision: tickerValuesAPIResponseItem.market.second.scale
)
}
}
private extension Optional where Wrapped == String {
var double: Double? {
guard let self = self else { return nil }
return Double(self)
}
}
| mit | 4a7c9f8857fcb746ec08e184b61cce6d | 35.466102 | 126 | 0.67697 | 5.94337 | false | false | false | false |
nanthi1990/SwiftCharts | SwiftCharts/ChartPoint/ChartPoint.swift | 7 | 565 | //
// ChartPoint.swift
// swift_charts
//
// Created by ischuetz on 01/03/15.
// Copyright (c) 2015 ivanschuetz. All rights reserved.
//
import UIKit
public class ChartPoint: Equatable {
public let x: ChartAxisValue
public let y: ChartAxisValue
public init(x: ChartAxisValue, y: ChartAxisValue) {
self.x = x
self.y = y
}
public var text: String {
return "\(self.x.text), \(self.y.text)"
}
}
public func ==(lhs: ChartPoint, rhs: ChartPoint) -> Bool {
return lhs.x == rhs.x && lhs.y == rhs.y
} | apache-2.0 | 1efe24ae11038ce8b5edd3345b9a9da8 | 19.214286 | 58 | 0.6 | 3.598726 | false | false | false | false |
wbaumann/SmartReceiptsiOS | SmartReceipts/Common/Exchange/ExchangeRateCalculator.swift | 2 | 1052 | //
// ExchangeRateCalculator.swift
// SmartReceipts
//
// Created by Bogdan Evsenev on 19/07/2019.
// Copyright © 2019 Will Baumann. All rights reserved.
//
import Foundation
import RxSwift
class ExchangeRateCalculator {
let exchangeRateUpdate = PublishSubject<Double>()
let baseCurrencyPriceUpdate = PublishSubject<Double>()
private let bag = DisposeBag()
init(price: Double = 0, exchangeRate: Double = 0) {
self.price = price
self.exchangeRate = exchangeRate
}
var price: Double = 0 {
didSet {
let result = price*exchangeRate
baseCurrencyPriceUpdate.onNext(result)
}
}
var exchangeRate: Double = 0 {
didSet {
let result = price*exchangeRate
baseCurrencyPriceUpdate.onNext(result)
}
}
var baseCurrencyPrice: Double = 0 {
didSet {
if price == 0 { return }
let result = baseCurrencyPrice/price
exchangeRateUpdate.onNext(result)
}
}
}
| agpl-3.0 | 5a9dd3ca58b761f1cfd4c6fef535f0de | 23.44186 | 58 | 0.604186 | 4.799087 | false | false | false | false |
rnystrom/GitHawk | Classes/Issues/Comments/Markdown/ViewMarkdownViewController.swift | 1 | 1548 | //
// ViewMarkdownViewController.swift
// Freetime
//
// Created by Ryan Nystrom on 5/19/18.
// Copyright © 2018 Ryan Nystrom. All rights reserved.
//
import UIKit
final class ViewMarkdownViewController: UIViewController {
private let markdown: String
private let textView = UITextView()
init(markdown: String) {
self.markdown = markdown
super.init(nibName: nil, bundle: nil)
title = NSLocalizedString("Markdown", comment: "")
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func viewDidLoad() {
super.viewDidLoad()
navigationItem.rightBarButtonItem = UIBarButtonItem(
barButtonSystemItem: .done,
target: self,
action: #selector(onDismiss)
)
textView.isEditable = false
textView.text = markdown
textView.font = Styles.Text.code.preferredFont
textView.textColor = Styles.Colors.Gray.dark.color
textView.textContainerInset = UIEdgeInsets(
top: Styles.Sizes.rowSpacing,
left: Styles.Sizes.columnSpacing,
bottom: Styles.Sizes.rowSpacing,
right: Styles.Sizes.columnSpacing
)
view.addSubview(textView)
}
override func viewWillLayoutSubviews() {
super.viewWillLayoutSubviews()
textView.frame = view.bounds
}
// MARK: Private API
@objc func onDismiss() {
dismiss(animated: trueUnlessReduceMotionEnabled)
}
}
| mit | 570b50711499859e370d8071e0423a32 | 25.220339 | 60 | 0.639948 | 4.942492 | false | false | false | false |
yaobanglin/viossvc | viossvc/Scenes/Share/Tour/TourShareListViewController.swift | 2 | 2791 | //
// ShareListViewController.swift
// viossvc
//
// Created by yaowang on 2016/10/28.
// Copyright © 2016年 ywwlcom.yundian. All rights reserved.
//
import UIKit
class TourShareListViewController: BasePageListTableViewController , OEZTableViewDelegate {
// var listType:Int = 0;
// var typeName: String
var typeModel : TourShareTypeModel = TourShareTypeModel()
// var typeNames:[String] = ["美食","住宿","景点","娱乐"];
override func viewDidLoad() {
super.viewDidLoad();
// listType = listType < typeNames.count ? listType : 0 ;
title = typeModel.type_title;
tableView.registerNib(TourShareCell.self, forCellReuseIdentifier: "TourShareListCell");
switch typeModel.type_title {
case "美食":
MobClick.event(AppConst.Event.share_eat)
break
case "娱乐":
MobClick.event(AppConst.Event.share_fun)
break
case "住宿":
MobClick.event(AppConst.Event.share_hotel)
break
case "景点":
MobClick.event(AppConst.Event.share_travel)
break
default:
break
}
}
override func isCalculateCellHeight() -> Bool {
return true;
}
override func tableView(tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
let view:TableViewHeaderView? = TableViewHeaderView.loadFromNib();
view?.titleLabel.text = typeModel.type_title + "分享";
return view;
}
override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
let model = dataSource?[indexPath.row] as? TourShareModel
let viewController:TourShareDetailViewController = storyboardViewController()
viewController.share_id = model!.share_id
viewController.title = model!.share_theme
self.navigationController?.pushViewController(viewController, animated: true);
}
func tableView(tableView: UITableView!, rowAtIndexPath indexPath: NSIndexPath!, didAction action: Int, data: AnyObject!) {
if UInt(action) == AppConst.Action.CallPhone.rawValue {
let model = self.tableView(tableView, cellDataForRowAtIndexPath: indexPath) as? TourShareModel
if model?.telephone != nil {
didActionTel(model!.telephone)
}
}
}
override func didRequest(pageIndex: Int) {
let last_id:Int = pageIndex == 1 ? 0 : (dataSource?.last as! TourShareModel).share_id
AppAPIHelper.tourShareAPI().list(last_id, count: AppConst.DefaultPageSize, type: typeModel.type_id, complete: completeBlockFunc(), error: errorBlockFunc())
}
}
| apache-2.0 | b618e1816526409a1b0f41c8a678c6bf | 32.975309 | 164 | 0.637355 | 4.82807 | false | false | false | false |
SuPair/firefox-ios | AccountTests/LiveAccountTest.swift | 4 | 7178 | /* 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/. */
@testable import Account
import Foundation
import FxA
import Shared
import Deferred
import SwiftyJSON
import XCTest
// Note: All live account tests have been disabled. Please see https://bugzilla.mozilla.org/show_bug.cgi?id=1332028.
/*
* A base test type for tests that need a live Firefox Account.
*/
open class LiveAccountTest: XCTestCase {
lazy var signedInUser: JSON? = {
if let path = Bundle(for: type(of: self)).path(forResource: "signedInUser.json", ofType: nil) {
if let contents = try? String(contentsOfFile: path, encoding: .utf8) {
let json = JSON(parseJSON: contents)
if json.isError() {
return nil
}
if let email = json["email"].string {
return json
} else {
// This is the standard case: signedInUser.json is {}.
return nil
}
}
}
XCTFail("Expected to read signedInUser.json!")
return nil
}()
// It's not easy to have an optional resource, so we always include signedInUser.json in the test bundle.
// If signedInUser.json contains an email address, we use that email address.
// Since there's no way to get the corresponding password (from any client!), we assume that any
// test account has password identical to its email address.
fileprivate func withExistingAccount(_ mustBeVerified: Bool, completion: (Data, Data) -> Void) {
// If we don't create at least one expectation, waitForExpectations fails.
// So we unconditionally create one, even though the callback may not execute.
self.expectation(description: "withExistingAccount").fulfill()
if let json = self.signedInUser {
if mustBeVerified {
XCTAssertTrue(json["verified"].bool ?? false)
}
let email = json["email"].stringValue
let password = json["password"].stringValue
let emailUTF8 = email.utf8EncodedData
let passwordUT8 = password.utf8EncodedData
let stretchedPW = FxAClient10.quickStretchPW(emailUTF8, password: passwordUT8)
completion(emailUTF8, stretchedPW)
} else {
// This is the standard case: signedInUser.json is {}.
NSLog("Skipping test because signedInUser.json does not include email address.")
}
}
func withVerifiedAccount(_ completion: (Data, Data) -> Void) {
withExistingAccount(true, completion: completion)
}
// Helper function that waits for expectations to clear
func withVerifiedAccountNoExpectations(_ completion: (Data, Data) -> Void) {
withExistingAccount(true, completion: completion)
self.waitForExpectations(timeout: 10, handler: nil)
}
func withCertificate(_ completion: @escaping (XCTestExpectation, Data, KeyPair, String) -> Void) {
withVerifiedAccount { emailUTF8, quickStretchedPW in
let expectation = self.expectation(description: "withCertificate")
let keyPair = RSAKeyPair.generate(withModulusSize: 1024)!
let client = FxAClient10()
let login: Deferred<Maybe<FxALoginResponse>> = client.login(emailUTF8, quickStretchedPW: quickStretchedPW, getKeys: true)
let sign: Deferred<Maybe<FxASignResponse>> = login.bind { (result: Maybe<FxALoginResponse>) in
switch result {
case let .failure(error):
expectation.fulfill()
return Deferred(value: .failure(error))
case let .success(loginResponse):
return client.sign(loginResponse.sessionToken, publicKey: keyPair.publicKey)
}
}
sign.upon { result in
if let response = result.successValue {
XCTAssertNotNil(response.certificate)
completion(expectation, emailUTF8, keyPair, response.certificate)
} else {
XCTAssertEqual(result.failureValue!.description, "")
expectation.fulfill()
}
}
}
}
public enum AccountError: MaybeErrorType {
case badParameters
case noSignedInUser
case unverifiedSignedInUser
public var description: String {
switch self {
case .badParameters: return "Bad account parameters (email, password, or a derivative thereof)."
case .noSignedInUser: return "No signedInUser.json (missing, no email, etc)."
case .unverifiedSignedInUser: return "signedInUser.json describes an unverified account."
}
}
}
// Internal helper.
func account(_ email: String, password: String, deviceName: String, configuration: FirefoxAccountConfiguration) -> Deferred<Maybe<FirefoxAccount>> {
let client = FxAClient10(authEndpoint: configuration.authEndpointURL)
let emailUTF8 = email.utf8EncodedData
let passwordUTF8 = password.utf8EncodedData
let quickStretchedPW = FxAClient10.quickStretchPW(emailUTF8, password: passwordUTF8)
let login = client.login(emailUTF8, quickStretchedPW: quickStretchedPW, getKeys: true)
return login.bind { result in
if let response = result.successValue {
let unwrapkB = FxAClient10.computeUnwrapKey(quickStretchedPW)
return Deferred(value: Maybe(success: FirefoxAccount.from(configuration, andLoginResponse: response, unwrapkB: unwrapkB, deviceName: deviceName)))
} else {
return Deferred(value: Maybe(failure: result.failureValue!))
}
}
}
func getTestAccount() -> Deferred<Maybe<FirefoxAccount>> {
// TODO: Use signedInUser.json here. It's hard to include the same resource file in two Xcode targets.
return self.account("[email protected]", password: "[email protected]", deviceName: "My iPhone",
configuration: ProductionFirefoxAccountConfiguration())
}
open func getAuthState(_ now: Timestamp) -> Deferred<Maybe<SyncAuthState>> {
let account = self.getTestAccount()
print("Got test account.")
return account.map { result in
print("Result was successful? \(result.isSuccess)")
if let account = result.successValue {
return Maybe(success: account.syncAuthState)
}
return Maybe(failure: result.failureValue!)
}
}
open func syncAuthState(_ now: Timestamp) -> Deferred<Maybe<(token: TokenServerToken, forKey: Data)>> {
return getAuthState(now).bind { result in
if let authState = result.successValue {
return authState.token(now, canBeExpired: false)
}
return Deferred(value: Maybe(failure: result.failureValue!))
}
}
}
| mpl-2.0 | d383efd2a2c4db60012827626347b385 | 44.43038 | 162 | 0.631931 | 5.062059 | false | true | false | false |
APUtils/APExtensions | APExtensions/Classes/Core/_Extensions/_Foundation/NotificationCenter+Utils.swift | 1 | 3658 | //
// NotificationCenter+Utils.swift
// APExtensions
//
// Created by Anton Plebanovich on 8/15/17.
// Copyright © 2019 Anton Plebanovich. All rights reserved.
//
import Foundation
// ******************************* MARK: - Day Start Notifications
public extension Notification.Name {
/// Post on 0:00:00 every day so app can refresh it's data. For example change `Today` to `Yesterday` date formatter string.
static let DayDidStart = Notification.Name("DayDidStart")
}
private var dayTimer: Timer?
private var fireDate: Date?
public extension NotificationCenter {
/// Start day notifications that post on 0:00:00 every day so app can refresh it's data. For example change `Today` to `Yesterday` date formatter string.
func startDayNotifications() {
guard fireDate == nil else { return }
fireDate = Date.tomorrow
// No need to start timer if application is not active, it'll be started when app becomes active
if UIApplication.shared.applicationState == .active {
startTimer()
}
g.sharedNotificationCenter.addObserver(self, selector: #selector(self.onDidBecomeActive(_:)), name: UIApplication.didBecomeActiveNotification, object: nil)
g.sharedNotificationCenter.addObserver(self, selector: #selector(self.onWillResignActive(_:)), name: UIApplication.willResignActiveNotification, object: nil)
}
func stopDayNotifications() {
g.sharedNotificationCenter.removeObserver(self, name: UIApplication.didBecomeActiveNotification, object: nil)
g.sharedNotificationCenter.removeObserver(self, name: UIApplication.willResignActiveNotification, object: nil)
stopTimer()
fireDate = nil
}
// ******************************* MARK: - Timer
private func startTimer() {
g.performInMain {
guard let fireDate = fireDate else { return }
dayTimer = Timer(fireAt: fireDate, interval: 0, target: self, selector: #selector(self.onTimer(_:)), userInfo: nil, repeats: false)
RunLoop.main.add(dayTimer!, forMode: .default)
}
}
private func restartTimer() {
g.performInMain {
self.stopTimer()
fireDate = Date.tomorrow
self.startTimer()
}
}
private func stopTimer() {
g.performInMain {
dayTimer?.invalidate()
dayTimer = nil
}
}
@objc private func onTimer(_ timer: Timer) {
g.sharedNotificationCenter.post(name: .DayDidStart, object: self)
restartTimer()
}
// ******************************* MARK: - Notifications
@objc private func onDidBecomeActive(_ notification: Notification) {
if let fireDate = fireDate, fireDate < Date() {
g.sharedNotificationCenter.post(name: .DayDidStart, object: self)
}
restartTimer()
}
@objc private func onWillResignActive(_ notification: Notification) {
stopTimer()
}
}
// ******************************* MARK: - Perform Once
public extension NotificationCenter {
/// Observes notification once and then removes observer.
func observeOnce(forName: NSNotification.Name?, object: Any?, queue: OperationQueue?, using: @escaping (Notification) -> Void) {
var token: NSObjectProtocol!
token = addObserver(forName: forName, object: object, queue: queue, using: { [weak self] notification in
if let token = token { self?.removeObserver(token) }
using(notification)
})
}
}
| mit | 82cdd064180e5228ca2edbce3680356f | 33.17757 | 165 | 0.619087 | 5.079167 | false | false | false | false |
samantharachelb/todolist | todolist/Extensions/AddBordersToUIView.swift | 1 | 994 | //
// AddBordersToUIView.swift
// todolist
//
// Created by Samantha Emily-Rachel Belnavis on 2017-10-16.
// Copyright © 2017 Samantha Emily-Rachel Belnavis. All rights reserved.
//
import Foundation
import UIKit
extension UIView {
enum ViewSide {
case Left, Right, Top, Bottom
}
func addBorder(toSide side: ViewSide, withColour color: CGColor, andThickness thickness: CGFloat) {
let border = CALayer()
border.backgroundColor = color
switch side {
case .Left: border.frame = CGRect(x: frame.minX, y: frame.minY, width: thickness, height: frame.height); break
case .Right: border.frame = CGRect(x: frame.minX, y: frame.minY, width: thickness, height: frame.height); break
case .Top: border.frame = CGRect(x: frame.minX, y: frame.minY, width: thickness, height: frame.height); break
case .Bottom: border.frame = CGRect(x: frame.minX, y: frame.minY, width: thickness, height: frame.height); break
}
layer.addSublayer(border)
}
}
| mit | 32e0c5490a89ad6af0f47d100b62dba8 | 32.1 | 116 | 0.695871 | 3.610909 | false | false | false | false |
edx/edx-app-ios | Pods/FBSDKLoginKit/FBSDKLoginKit/FBSDKLoginKit/Swift/LoginManager.swift | 1 | 7534 | // Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
//
// You are hereby granted a non-exclusive, worldwide, royalty-free license to use,
// copy, modify, and distribute this software in source code or binary form for use
// in connection with the web services and APIs provided by Facebook.
//
// As with any software that integrates with the Facebook platform, your use of
// this software is subject to the Facebook Developer Principles and Policies
// [http://developers.facebook.com/policy/]. This copyright 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 BUCK
import FacebookCore
#endif
import FBSDKCoreKit
import UIKit
/// Login Result Block
@available(tvOS, unavailable)
public typealias LoginResultBlock = (LoginResult) -> Void
/**
Describes the result of a login attempt.
*/
@available(tvOS, unavailable)
public enum LoginResult {
/// User succesfully logged in. Contains granted, declined permissions and access token.
case success(granted: Set<Permission>, declined: Set<Permission>, token: FBSDKCoreKit.AccessToken?)
/// Login attempt was cancelled by the user.
case cancelled
/// Login attempt failed.
case failed(Error)
internal init(result: LoginManagerLoginResult?, error: Error?) {
guard let result = result, error == nil else {
self = .failed(error ?? LoginError(.unknown))
return
}
guard !result.isCancelled else {
self = .cancelled
return
}
let granted: Set<Permission> = Set(result.grantedPermissions.map { Permission(stringLiteral: $0) })
let declined: Set<Permission> = Set(result.declinedPermissions.map { Permission(stringLiteral: $0) })
self = .success(granted: granted, declined: declined, token: result.token)
}
}
/**
This class provides methods for logging the user in and out.
It works directly with `AccessToken.current` and
sets the "current" token upon successful authorizations (or sets `nil` in case of `logOut`).
You should check `AccessToken.current` before calling `logIn()` to see if there is
a cached token available (typically in your `viewDidLoad`).
If you are managing your own token instances outside of `AccessToken.current`, you will need to set
`current` before calling `logIn()` to authorize further permissions on your tokens.
*/
@available(tvOS, unavailable)
public extension LoginManager {
/**
Initialize an instance of `LoginManager.`
- parameter defaultAudience: Optional default audience to use. Default: `.Friends`.
*/
convenience init(defaultAudience: DefaultAudience = .friends) {
self.init()
self.defaultAudience = defaultAudience
}
/**
Logs the user in or authorizes additional permissions.
Use this method when asking for permissions. You should only ask for permissions when they
are needed and the value should be explained to the user. You can inspect the result's `declinedPermissions` to also
provide more information to the user if they decline permissions.
This method will present a UI to the user. To reduce unnecessary app switching, you should typically check if
`AccessToken.current` already contains the permissions you need. If it does, you probably
do not need to call this method.
You can only perform one login call at a time. Calling a login method before the completion handler is called
on a previous login will result in an error.
- parameter permissions: Array of read permissions. Default: `[.PublicProfile]`
- parameter viewController: Optional view controller to present from. Default: topmost view controller.
- parameter completion: Optional callback.
*/
func logIn(
permissions: [Permission] = [.publicProfile],
viewController: UIViewController? = nil,
completion: LoginResultBlock? = nil
) {
self.logIn(permissions: permissions.map { $0.name }, from: viewController, handler: sdkCompletion(completion))
}
/**
Logs the user in or authorizes additional permissions.
Use this method when asking for permissions. You should only ask for permissions when they
are needed and the value should be explained to the user. You can inspect the result's `declinedPermissions` to also
provide more information to the user if they decline permissions.
This method will present a UI to the user. To reduce unnecessary app switching, you should typically check if
`AccessToken.current` already contains the permissions you need. If it does, you probably
do not need to call this method.
You can only perform one login call at a time. Calling a login method before the completion handler is called
on a previous login will result in an error.
- parameter viewController: Optional view controller to present from. Default: topmost view controller.
- parameter configuration the login configuration to use.
- parameter completion: Optional callback.
*/
func logIn(
viewController: UIViewController? = nil,
configuration: LoginConfiguration,
completion: @escaping LoginResultBlock
) {
let legacyCompletion = { (result: LoginManagerLoginResult?, error: Error?) in
let result = LoginResult(result: result, error: error)
completion(result)
}
self.__logIn(from: viewController, configuration: configuration, completion: legacyCompletion)
}
/**
Logs the user in or authorizes additional permissions.
Use this method when asking for permissions. You should only ask for permissions when they
are needed and the value should be explained to the user. You can inspect the result's `declinedPermissions` to also
provide more information to the user if they decline permissions.
This method will present a UI to the user. To reduce unnecessary app switching, you should typically check if
`AccessToken.current` already contains the permissions you need. If it does, you probably
do not need to call this method.
You can only perform one login call at a time. Calling a login method before the completion handler is called
on a previous login will result in an error.
- parameter configuration the login configuration to use.
- parameter completion: Optional callback.
*/
func logIn(
configuration: LoginConfiguration,
completion: @escaping LoginResultBlock
) {
let legacyCompletion = { (result: LoginManagerLoginResult?, error: Error?) in
let result = LoginResult(result: result, error: error)
completion(result)
}
self.__logIn(from: nil, configuration: configuration, completion: legacyCompletion)
}
private func sdkCompletion(_ completion: LoginResultBlock?) -> LoginManagerLoginResultBlock? {
guard let original = completion else {
return nil
}
return convertedResultHandler(original)
}
private func convertedResultHandler(_ original: @escaping LoginResultBlock) -> LoginManagerLoginResultBlock {
return { (result: LoginManagerLoginResult?, error: Error?) in
let result = LoginResult(result: result, error: error)
original(result)
}
}
}
| apache-2.0 | a0c0ec2f5cca781d4650c800a44cbc04 | 40.855556 | 119 | 0.745553 | 4.801785 | false | true | false | false |
damicreabox/Git2Swift | Sources/Git2Swift/tree/Tree.swift | 1 | 2214 | //
// Tree.swift
// Git2Swift
//
// Created by Damien Giron on 01/08/2016.
//
//
import Foundation
import CLibgit2
/// Tree Definition
public class Tree {
let repository : Repository
/// Internal libgit2 tree
internal let tree : UnsafeMutablePointer<OpaquePointer?>
/// Init with libgit2 tree
///
/// - parameter repository: Git2Swift repository
/// - parameter tree: Libgit2 tree pointer
///
/// - returns: Tree
init(repository: Repository, tree : UnsafeMutablePointer<OpaquePointer?>) {
self.tree = tree
self.repository = repository
}
deinit {
if let ptr = tree.pointee {
git_tree_free(ptr)
}
tree.deinitialize()
tree.deallocate(capacity: 1)
}
/// Find entry by path.
///
/// - parameter byPath: Path of file
///
/// - throws: GitError
///
/// - returns: TreeEntry or nil
public func entry(byPath: String) throws -> TreeEntry? {
// Entry
let treeEntry = UnsafeMutablePointer<OpaquePointer?>.allocate(capacity: 1)
// Find tree entry
let error = git_tree_entry_bypath(treeEntry, tree.pointee, byPath)
switch error {
case 0:
return TreeEntry(pointer: treeEntry)
case GIT_ENOTFOUND.rawValue:
return nil
default:
throw GitError.unknownError(msg: "", code: error, desc: git_error_message())
}
}
/// Diff
///
/// - parameter other: Other tree
///
/// - returns: Diff
public func diff(other: Tree) throws -> Diff {
// Create diff
let diff = UnsafeMutablePointer<OpaquePointer?>.allocate(capacity: 1)
// Create diff
let error = git_diff_tree_to_tree(diff, repository.pointer.pointee,
tree.pointee,
other.tree.pointee, nil)
if (error == 0) {
return Diff(pointer: diff)
} else {
throw GitError.unknownError(msg: "diff", code: error, desc: git_error_message())
}
}
}
| apache-2.0 | 75b23aa9b78d786973bc037fff3cf935 | 24.448276 | 92 | 0.536134 | 4.593361 | false | false | false | false |
SwiftKitz/Appz | Appz/Appz/Apps/Podcasts.swift | 1 | 1009 | //
// Podcasts.swift
// Appz
//
// Created by MARYAM ALJAME on 2/20/18.
// Copyright © 2018 kitz. All rights reserved.
//
public extension Applications {
struct Podcasts: ExternalApplication {
public typealias ActionType = Applications.Podcasts.Action
public let scheme = "podcasts:"
public let fallbackURL = "https://itunes.apple.com/us/app/podcasts/id525463029?mt=8"
public let appStoreId = "525463029"
public init() {}
}
}
// MARK: - Actions
public extension Applications.Podcasts {
enum Action {
case open
}
}
extension Applications.Podcasts.Action: ExternalApplicationAction {
public var paths: ActionPaths {
switch self {
case .open:
return ActionPaths(
app: Path(
pathComponents: ["app"],
queryParameters: [:]
),
web: Path()
)
}
}
}
| mit | 68889bea6caf792990b9b4211bfe4e2f | 20 | 92 | 0.542659 | 4.754717 | false | false | false | false |
swift-server/http | Sources/HTTP/PoCSocket/PoCSocket.swift | 1 | 12565 | // This source file is part of the Swift.org Server APIs open source project
//
// Copyright (c) 2017 Swift Server API project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
//
import Foundation
import Dispatch
import ServerSecurity
///:nodoc:
public enum PoCSocketError: Error {
case SocketOSError(errno: Int32)
case InvalidSocketError
case InvalidReadLengthError
case InvalidWriteLengthError
case InvalidBufferError
}
/// Simple Wrapper around the `socket(2)` functions we need for Proof of Concept testing
/// Intentionally a thin layer over `recv(2)`/`send(2)` so uses the same argument types.
/// Note that no method names here are the same as any system call names.
/// This is because we expect the caller might need functionality we haven't implemented here.
internal class PoCSocket: ConnectionDelegate {
/// hold the file descriptor for the socket supplied by the OS. `-1` is invalid socket
internal var socketfd: Int32 = -1
/// The TCP port the server is actually listening on. Set after system call completes
internal var listeningPort: Int32 = -1
/// Track state between `listen(2)` and `shutdown(2)`
private let _isListeningLock = DispatchSemaphore(value: 1)
private var _isListening: Bool = false
internal private(set) var isListening: Bool {
get {
_isListeningLock.wait()
defer {
_isListeningLock.signal()
}
return _isListening
}
set {
_isListeningLock.wait()
defer {
_isListeningLock.signal()
}
_isListening = newValue
}
}
/// Track state between `accept(2)/bind(2)` and `close(2)`
private let _isConnectedLock = DispatchSemaphore(value: 1)
private var _isConnected: Bool = false
internal private(set) var isConnected: Bool {
get {
_isConnectedLock.wait()
defer {
_isConnectedLock.signal()
}
return _isConnected
}
set {
_isConnectedLock.wait()
defer {
_isConnectedLock.signal()
}
_isConnected = newValue
}
}
/// track whether a shutdown is in progress so we can suppress error messages
private let _isShuttingDownLock = DispatchSemaphore(value: 1)
private var _isShuttingDown: Bool = false
private var isShuttingDown: Bool {
get {
_isShuttingDownLock.wait()
defer {
_isShuttingDownLock.signal()
}
return _isShuttingDown
}
set {
_isShuttingDownLock.wait()
defer {
_isShuttingDownLock.signal()
}
_isShuttingDown = newValue
}
}
/// Delegate that provides the TLS implementation
public var TLSdelegate: TLSServiceDelegate? = nil
/// Return the file descriptor as a connection endpoint for ConnectionDelegate.
public var endpoint: ConnectionType {
get {
return ConnectionType.socket(self.socketfd)
}
}
/// track whether a the socket has already been closed.
private let _hasClosedLock = DispatchSemaphore(value: 1)
private var _hasClosed: Bool = false
private var hasClosed: Bool {
get {
_hasClosedLock.wait()
defer {
_hasClosedLock.signal()
}
return _hasClosed
}
set {
_hasClosedLock.wait()
defer {
_hasClosedLock.signal()
}
_hasClosed = newValue
}
}
/// Call recv(2) with buffer allocated by our caller and return the output
///
/// - Parameters:
/// - readBuffer: Buffer to read into. Note this needs to be `inout` because we're modfying it and we want Swift4+'s ownership checks to make sure no one else is at the same time
/// - maxLength: Max length that can be read. Buffer *must* be at least this big!!!
/// - Returns: Number of bytes read or -1 on failure as per `recv(2)`
/// - Throws: PoCSocketError if sanity checks fail
internal func socketRead(into readBuffer: inout UnsafeMutablePointer<Int8>, maxLength: Int) throws -> Int {
if maxLength <= 0 || maxLength > Int(Int32.max) {
throw PoCSocketError.InvalidReadLengthError
}
if socketfd <= 0 {
throw PoCSocketError.InvalidSocketError
}
//Make sure no one passed a nil pointer to us
let readBufferPointer: UnsafeMutablePointer<Int8>! = readBuffer
if readBufferPointer == nil {
throw PoCSocketError.InvalidBufferError
}
//Make sure data isn't re-used
readBuffer.initialize(to: 0x0, count: maxLength)
let read: Int
if let tls = self.TLSdelegate {
// HTTPS
read = try tls.willReceive(into: readBuffer, bufSize: maxLength)
} else {
// HTTP
read = recv(self.socketfd, readBuffer, maxLength, Int32(0))
}
//Leave this as a local variable to facilitate Setting a Watchpoint in lldb
return read
}
/// Pass buffer passed into to us into send(2).
///
/// - Parameters:
/// - buffer: buffer containing data to write.
/// - bufSize: number of bytes to write. Buffer must be this long
/// - Returns: number of bytes written or -1. See `send(2)`
/// - Throws: PoCSocketError if sanity checks fail
@discardableResult internal func socketWrite(from buffer: UnsafeRawPointer, bufSize: Int) throws -> Int {
if socketfd <= 0 {
throw PoCSocketError.InvalidSocketError
}
if bufSize < 0 || bufSize > Int(Int32.max) {
throw PoCSocketError.InvalidWriteLengthError
}
// Make sure we weren't handed a nil buffer
let writeBufferPointer: UnsafeRawPointer! = buffer
if writeBufferPointer == nil {
throw PoCSocketError.InvalidBufferError
}
let sent: Int
if let tls = self.TLSdelegate {
// HTTPS
sent = try tls.willSend(buffer: buffer, bufSize: Int(bufSize))
} else {
// HTTP
sent = send(self.socketfd, buffer, Int(bufSize), Int32(0))
}
//Leave this as a local variable to facilitate Setting a Watchpoint in lldb
return sent
}
/// Calls `shutdown(2)` and `close(2)` on a socket
internal func shutdownAndClose() {
self.isShuttingDown = true
if let tls = self.TLSdelegate {
tls.willDestroy()
}
if socketfd < 1 {
//Nothing to do. Maybe it was closed already
return
}
if hasClosed {
//Nothing to do. It was closed already
return
}
if self.isListening || self.isConnected {
_ = shutdown(self.socketfd, Int32(SHUT_RDWR))
self.isListening = false
}
self.isConnected = false
close(self.socketfd)
self.hasClosed = true
}
/// Thin wrapper around `accept(2)`
///
/// - Returns: PoCSocket object for newly connected socket or nil if we've been told to shutdown
/// - Throws: PoCSocketError on sanity check fails or if accept fails after several retries
internal func acceptClientConnection() throws -> PoCSocket? {
if socketfd <= 0 || !isListening {
throw PoCSocketError.InvalidSocketError
}
let retVal = PoCSocket()
var maxRetryCount = 100
var acceptFD: Int32 = -1
repeat {
var acceptAddr = sockaddr_in()
var addrSize = socklen_t(MemoryLayout<sockaddr_in>.size)
acceptFD = withUnsafeMutablePointer(to: &acceptAddr) { pointer in
return accept(self.socketfd, UnsafeMutableRawPointer(pointer).assumingMemoryBound(to: sockaddr.self), &addrSize)
}
if acceptFD < 0 && errno != EINTR {
//fail
if (isShuttingDown) {
return nil
}
maxRetryCount = maxRetryCount - 1
print("Could not accept on socket \(socketfd). Error is \(errno). Will retry.")
}
}
while acceptFD < 0 && maxRetryCount > 0
if acceptFD < 0 {
throw PoCSocketError.SocketOSError(errno: errno)
}
retVal.isConnected = true
retVal.socketfd = acceptFD
// TLS delegate does post accept handling and verification
if let tls = self.TLSdelegate {
try tls.didAccept(connection: retVal)
}
return retVal
}
/// call `bind(2)` and `listen(2)`
///
/// - Parameters:
/// - port: `sin_port` value, see `bind(2)`
/// - maxBacklogSize: backlog argument to `listen(2)`
/// - Throws: PoCSocketError
internal func bindAndListen(on port: Int = 0, maxBacklogSize: Int32 = 100) throws {
#if os(Linux)
socketfd = socket(Int32(AF_INET), Int32(SOCK_STREAM.rawValue), Int32(IPPROTO_TCP))
#else
socketfd = socket(Int32(AF_INET), Int32(SOCK_STREAM), Int32(IPPROTO_TCP))
#endif
if socketfd <= 0 {
throw PoCSocketError.InvalidSocketError
}
// Initialize delegate
if let tls = self.TLSdelegate {
try tls.didCreateServer()
}
var on: Int32 = 1
// Allow address reuse
if setsockopt(self.socketfd, SOL_SOCKET, SO_REUSEADDR, &on, socklen_t(MemoryLayout<Int32>.size)) < 0 {
throw PoCSocketError.SocketOSError(errno: errno)
}
// Allow port reuse
if setsockopt(self.socketfd, SOL_SOCKET, SO_REUSEPORT, &on, socklen_t(MemoryLayout<Int32>.size)) < 0 {
throw PoCSocketError.SocketOSError(errno: errno)
}
#if os(Linux)
var addr = sockaddr_in(
sin_family: sa_family_t(AF_INET),
sin_port: htons(UInt16(port)),
sin_addr: in_addr(s_addr: in_addr_t(0)),
sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
#else
var addr = sockaddr_in(
sin_len: UInt8(MemoryLayout<sockaddr_in>.stride),
sin_family: UInt8(AF_INET),
sin_port: (Int(OSHostByteOrder()) != OSLittleEndian ? UInt16(port) : _OSSwapInt16(UInt16(port))),
sin_addr: in_addr(s_addr: in_addr_t(0)),
sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
#endif
_ = withUnsafePointer(to: &addr) {
bind(self.socketfd, UnsafePointer<sockaddr>(OpaquePointer($0)), socklen_t(MemoryLayout<sockaddr_in>.size))
}
_ = listen(self.socketfd, maxBacklogSize)
isListening = true
var addr_in = sockaddr_in()
listeningPort = try withUnsafePointer(to: &addr_in) { pointer in
var len = socklen_t(MemoryLayout<sockaddr_in>.size)
if getsockname(socketfd, UnsafeMutablePointer(OpaquePointer(pointer)), &len) != 0 {
throw PoCSocketError.SocketOSError(errno: errno)
}
#if os(Linux)
return Int32(ntohs(addr_in.sin_port))
#else
return Int32(Int(OSHostByteOrder()) != OSLittleEndian ? addr_in.sin_port.littleEndian : addr_in.sin_port.bigEndian)
#endif
}
}
/// Check to see if socket is being used
///
/// - Returns: whether socket is listening or connected
internal func isOpen() -> Bool {
return isListening || isConnected
}
/// Sets the socket to Blocking or non-blocking mode.
///
/// - Parameter mode: true for blocking, false for nonBlocking
/// - Returns: `fcntl(2)` flags
/// - Throws: PoCSocketError if `fcntl` fails
@discardableResult internal func setBlocking(mode: Bool) throws -> Int32 {
let flags = fcntl(self.socketfd, F_GETFL)
if flags < 0 {
//Failed
throw PoCSocketError.SocketOSError(errno: errno)
}
let newFlags = mode ? flags & ~O_NONBLOCK : flags | O_NONBLOCK
let result = fcntl(self.socketfd, F_SETFL, newFlags)
if result < 0 {
//Failed
throw PoCSocketError.SocketOSError(errno: errno)
}
return result
}
}
| apache-2.0 | 694f3ef13982a0750f4b61114f9eeb70 | 33.806094 | 184 | 0.583287 | 4.664068 | false | false | false | false |
Headmast/openfights | MoneyHelper/Library/BaseClasses/Network/ServerPart/ServerRequests/ServerRequest.swift | 1 | 9321 | //
// Serverrequest.swift
// MoneyHelper
//
// Created by Kirill Klebanov on 16/09/2017.
// Copyright © 2017 Surf. All rights reserved.
//
import Foundation
import Alamofire
@objc
class ServerRequest: NSObject {
typealias PerformedRequest = (DataRequest) -> Void
typealias Completion = (ServerResponse) -> Void
enum Method {
case get
case post
case put
case delete
var alamofire: Alamofire.HTTPMethod {
switch self {
case .get: return .get
case .post: return .post
case .put: return .put
case .delete: return .delete
}
}
}
enum Encoding {
case defaultJson
case defaultUrl
case queryStringUrl
var alamofire: Alamofire.ParameterEncoding {
switch self {
case .defaultJson:
return JSONEncoding.default
case .defaultUrl:
return URLEncoding.default
case .queryStringUrl:
return URLEncoding.queryString
}
}
}
/// Метод API
let path: String
/// Результирующий URL запроса - включает baseUrl и path
let url: URL
/// Метод (get, post, delete...)
let method: Method
/// Токен для хедера
let token: String?
/// Хидеры запроса
let headers: HTTPHeaders?
/// Параметры запроса
var parameters: ServerRequestParameter
/// serverOnly by default
var cachePolicy: CachePolicy
let customEncoding: Encoding?
fileprivate var currentRequest: DataRequest? = nil
init(method: Method, relativeUrl: String, baseUrl: String, token: String? = nil, headers: HTTPHeaders? = nil, parameters: ServerRequestParameter, customEncoding: Encoding? = nil) {
self.method = method
self.token = token
self.headers = headers
self.path = relativeUrl
self.url = (URL(string: baseUrl)?.appendingPathComponent(self.path))!
self.parameters = parameters
self.cachePolicy = .serverIfFailReadFromCahce
self.customEncoding = customEncoding
super.init()
}
func perform(with completion: @escaping (ServerResponse) -> Void) {
let requests = self.createRequestWithPolicy(with: completion)
switch self.parameters {
case .simpleParams(let params):
let request = self.createSingleParamRequest(params)
requests.forEach({ $0(request) })
}
}
func createRequestWithPolicy(with completion: @escaping Completion) -> [PerformedRequest] {
switch self.cachePolicy {
case .cacheOnly:
return [self.readFromCache(completion: completion)]
case .serverOnly, .serverIfFailReadFromCahce:
return [self.sendRequest(completion: completion)]
case .firstCacheThenRefreshFromServer:
let cacheRequest = self.readFromCache(completion: completion)
let serverRequest = self.sendRequest(completion: completion)
return [cacheRequest, serverRequest]
}
}
/// Этот метод используется для отмены текущего запроса
func cancel() {
currentRequest?.cancel()
}
// MARK: - Helps
/// Возвращает хедеры, которые необходимы для данного запроса.
func createHeaders() -> HTTPHeaders {
var headers: HTTPHeaders = self.headers ?? [:]
if let tokenString = token {
headers["Authorization"] = tokenString
}
headers ["Content-Type"] = "Application/json"
return headers
}
}
// MARK: - Work witch URLCache
extension ServerRequest {
/// Извлекает из кэш из URLCache для конкретного запроса
func extractCachedUrlResponse() -> CachedURLResponse? {
guard let urlRequest = self.currentRequest?.request else {
return nil
}
if let response = URLCache.shared.cachedResponse(for: urlRequest) {
return response
}
return nil
}
func extractCachedUrlResponse(request: URLRequest?) -> CachedURLResponse? {
guard let urlRequest = request else {
return nil
}
if let response = URLCache.shared.cachedResponse(for: urlRequest) {
return response
}
return nil
}
/// Сохраняет запрос в кэш
func store(cachedUrlResponse: CachedURLResponse, for request: URLRequest?) {
guard let urlRequest = request else {
return
}
URLCache.shared.storeCachedResponse(cachedUrlResponse, for: urlRequest)
}
}
extension ServerRequest {
enum MultipartRequestCompletion {
case succes(DataRequest)
case failure(ServerResponse)
}
func createSingleParamRequest(_ params: [String: Any]?) -> DataRequest {
let headers = self.createHeaders()
let manager = ServerRequestsManager.shared.manager
let paramEncoding = {() -> ParameterEncoding in
if let custom = self.customEncoding {
return custom.alamofire
}
return self.method.alamofire == .get ? URLEncoding.default : JSONEncoding.default
}()
let request = manager.request(
url,
method: method.alamofire,
parameters: params,
encoding: paramEncoding,
headers: headers
)
return request
}
func createDataRequest() {
}
}
// MARK: - Requests
extension ServerRequest {
func sendRequest(completion: @escaping Completion) -> PerformedRequest {
let performRequest = { (request: DataRequest) -> Void in
self.currentRequest = request
request.response { afResponse in
self.log(afResponse)
var response = ServerResponse(dataResponse: afResponse, dataResult: .success(afResponse.data, false))
if (response.notModified || response.connectionFailed) && self.cachePolicy == .serverIfFailReadFromCahce {
response = self.readCache(with: request.request, response: response)
}
if response.result.value != nil, let urlResponse = afResponse.response, let data = afResponse.data, self.cachePolicy != .serverOnly {
self.store(cachedUrlResponse: CachedURLResponse(response: urlResponse, data: data, storagePolicy: .allowed), for: request.request)
}
completion(response)
}
}
return performRequest
}
func readFromCache(completion: @escaping Completion) -> PerformedRequest {
let performRequest = { (request: DataRequest) -> Void in
completion(self.readCache(with: request.request))
}
return performRequest
}
func readCache(with request: URLRequest?, response: ServerResponse? = nil) -> ServerResponse {
let result = response ?? ServerResponse()
if let cachedResponse = self.extractCachedUrlResponse(request: request),
let resultResponse = cachedResponse.response as? HTTPURLResponse {
result.httpResponse = resultResponse
result.result = { () -> ResponseResult<Any> in
do {
let object = try JSONSerialization.jsonObject(with: cachedResponse.data, options: .allowFragments)
return .success(object, true)
} catch {
return .failure(BaseCacheError.cantLoadFromCache)
}
}()
}
return result
}
}
// MARK: - Supported methods
extension ServerRequest {
func log(_ afResponse: DefaultDataResponse) {
#if DEBUG
let url: String = afResponse.request?.url?.absoluteString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? ""
let type: String = afResponse.request?.httpMethod ?? ""
let headers: String = afResponse.request?.allHTTPHeaderFields?.description ?? ""
let body = String(data: afResponse.request?.httpBody ?? Data(), encoding: String.Encoding.utf8) ?? ""
let statusCode: String = "\(afResponse.response?.statusCode ?? 0)"
let reponseHeaders: String = afResponse.response?.allHeaderFields.description ?? ""
var responseBody: String = ""
if let data = afResponse.data {
responseBody = "\(String(data: data, encoding: .utf8) ?? "nil")"
}
debugPrint("URL: \(url)")
debugPrint("REQUEST: \(type)")
debugPrint("HEADERS: \(headers)")
NSLog("BODY: %@", body)
debugPrint("RESPONSE: \(statusCode)")
debugPrint("HEADERS: \(reponseHeaders)")
NSLog("BODY: %@", responseBody)
debugPrint("TIMELINE: \(afResponse.timeline)")
debugPrint("DiskCache: \(URLCache.shared.currentDiskUsage) of \(URLCache.shared.diskCapacity)")
debugPrint("MemoryCache: \(URLCache.shared.currentMemoryUsage) of \(URLCache.shared.memoryCapacity)")
#else
#endif
}
}
| apache-2.0 | f1c5359fa2b15e0e88916ec196b5533e | 31.45 | 184 | 0.612041 | 5.078815 | false | false | false | false |
3lvis/Fragments | Source/Tailor.swift | 2 | 1242 | import UIKit
class Tailor : UIViewController {
init() {
super.init(nibName: nil, bundle: nil)
}
required init(coder aDecoder: NSCoder) {
fatalError("Tailor doesn't support Storyboards or Interface Builder")
}
override func viewDidLoad() {
super.viewDidLoad()
self.view.backgroundColor = .whiteColor()
let label = UILabel(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
label.text = "Hi there, what are you doing to do today in this beautiful day?"
label.font = UIFont.boldSystemFontOfSize(18.0)
label.setTranslatesAutoresizingMaskIntoConstraints(false)
label.backgroundColor = .redColor()
self.view.addSubview(label)
self.view.addConstraint(
NSLayoutConstraint(
item: label,
attribute: .CenterX,
relatedBy: .Equal,
toItem: self.view,
attribute: .CenterX,
multiplier: 1.0,
constant: 1.0))
self.view.addConstraint(
NSLayoutConstraint(
item: label,
attribute: .Top,
relatedBy: .Equal,
toItem: self.view,
attribute: .Bottom,
multiplier: 0.05,
constant: 0.0))
}
override func viewDidAppear(animated: Bool) {
super.viewDidAppear(animated)
}
}
| mit | 180e811445b582d8a338ad5393b95205 | 24.346939 | 82 | 0.643317 | 4.282759 | false | false | false | false |
digdoritos/RestfulAPI-Example | RestfulAPI-Example/MemberViewController.swift | 1 | 2502 | //
// MemberViewController.swift
// RestfulAPI-Example
//
// Created by Chun-Tang Wang on 27/03/2017.
// Copyright © 2017 Chun-Tang Wang. All rights reserved.
//
import UIKit
import Alamofire
import SwiftyJSON
import KeychainAccess
class MemberViewController: UIViewController {
@IBOutlet weak var tableView: UITableView!
var members = [Member]()
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
}
override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
requestMembers()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
@IBAction func dismiss(_ sender: UIBarButtonItem) {
dismissWithBackAnimation()
}
// MARK: - Data Request
func requestMembers() {
guard let token = TokenManager.keychain["token"] else {
showAlert(title:"Warning", message: "Wrong session token")
return
}
let api: Service = .getMember
let headers: HTTPHeaders = [
"Authorization": token
]
Alamofire.request(api.url(),
method: api.method(),
encoding: JSONEncoding.default,
headers: headers)
.validate()
.responseJSON { response in
switch response.result {
case .success(let data):
let json = JSON(data)
self.members = Members(json: json["data"]).members
self.tableView.reloadData()
case .failure(let error):
self.showAlert(title:"Error", message: error.localizedDescription)
}
}
}
}
// MARK: - TableView Delegate
extension MemberViewController: UITableViewDataSource, UITableViewDelegate {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return members.count
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
guard let cell = tableView.dequeueReusableCell(withIdentifier: "MemberCell") else {
return UITableViewCell()
}
cell.textLabel?.text = members[indexPath.row].name
return cell
}
}
| mit | ec4763d782c5f5e4f7f6b1031ef561ff | 27.747126 | 100 | 0.586166 | 5.448802 | false | false | false | false |
mrdepth/Neocom | Legacy/Neocom/Neocom/WalletJournalPagePresenter.swift | 2 | 2414 | //
// WalletJournalPagePresenter.swift
// Neocom
//
// Created by Artem Shimanski on 11/12/18.
// Copyright © 2018 Artem Shimanski. All rights reserved.
//
import Foundation
import Futures
import CloudData
import TreeController
import EVEAPI
class WalletJournalPagePresenter: TreePresenter {
typealias View = WalletJournalPageViewController
typealias Interactor = WalletJournalPageInteractor
struct Presentation {
var sections: [Tree.Item.Section<Tree.Content.Section, Tree.Item.Row<ESI.Wallet.WalletJournalItem>>]
var balance: String?
}
weak var view: View?
lazy var interactor: Interactor! = Interactor(presenter: self)
var content: Interactor.Content?
var presentation: Presentation?
var loading: Future<Presentation>?
required init(view: View) {
self.view = view
}
func configure() {
view?.tableView.register([Prototype.TreeSectionCell.default,
Prototype.WalletJournalCell.default])
interactor.configure()
applicationWillEnterForegroundObserver = NotificationCenter.default.addNotificationObserver(forName: UIApplication.willEnterForegroundNotification, object: nil, queue: .main) { [weak self] (note) in
self?.applicationWillEnterForeground()
}
}
private var applicationWillEnterForegroundObserver: NotificationObserver?
func presentation(for content: Interactor.Content) -> Future<Presentation> {
let treeController = view?.treeController
return DispatchQueue.global(qos: .utility).async { () -> Presentation in
let dateFormatter = DateFormatter()
dateFormatter.dateStyle = .medium
dateFormatter.timeStyle = .none
dateFormatter.doesRelativeDateFormatting = true
let items = content.value.walletJournal.sorted{$0.date > $1.date}
let calendar = Calendar(identifier: .gregorian)
let sections = Dictionary(grouping: items, by: { (i) -> Date in
let components = calendar.dateComponents([.year, .month, .day], from: i.date)
return calendar.date(from: components) ?? i.date
}).sorted {$0.key > $1.key}.map {
Tree.Item.Section(Tree.Content.Section(title: dateFormatter.string(from: $0.key).uppercased()), diffIdentifier: $0.key, treeController: treeController, children: $0.value.map{Tree.Item.Row($0)})
}
let balance = content.value.balance.map {UnitFormatter.localizedString(from: $0, unit: .isk, style: .long)}
return Presentation(sections: sections, balance: balance)
}
}
}
| lgpl-2.1 | 581c5bed4eb0b77cae2fe2fdb69a600f | 32.513889 | 200 | 0.745545 | 4.103741 | false | false | false | false |
LeLuckyVint/MessageKit | Sources/Views/MessageInputBar.swift | 1 | 18102 | /*
MIT License
Copyright (c) 2017 MessageKit
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
open class MessageInputBar: UIView {
public enum UIStackViewPosition {
case left, right, bottom
}
// MARK: - Properties
open weak var delegate: MessageInputBarDelegate?
/// A background view that adds a blur effect. Shown when 'isTransparent' is set to TRUE. Hidden by default.
open let blurView: UIView = {
let blurEffect = UIBlurEffect(style: .extraLight)
let view = UIVisualEffectView(effect: blurEffect)
view.translatesAutoresizingMaskIntoConstraints = false
view.isHidden = true
return view
}()
/// When set to true, the blurView in the background is shown and the backgroundColor is set to .clear. Default is FALSE
open var isTranslucent: Bool = false {
didSet {
blurView.isHidden = !isTranslucent
backgroundColor = isTranslucent ? .clear : .white
}
}
/// A boarder line anchored to the top of the view
open let separatorLine = SeparatorLine()
/**
The InputStackView at the InputStackView.left position
## Important Notes ##
1. It's axis is initially set to .horizontal
*/
open let leftStackView = InputStackView(axis: .horizontal, spacing: 0)
/**
The InputStackView at the InputStackView.right position
## Important Notes ##
1. It's axis is initially set to .horizontal
*/
open let rightStackView = InputStackView(axis: .horizontal, spacing: 0)
/**
The InputStackView at the InputStackView.bottom position
## Important Notes ##
1. It's axis is initially set to .horizontal
2. It's spacing is initially set to 15
*/
open let bottomStackView = InputStackView(axis: .horizontal, spacing: 15)
open lazy var inputTextView: InputTextView = { [weak self] in
let textView = InputTextView()
textView.translatesAutoresizingMaskIntoConstraints = false
textView.messageInputBar = self
return textView
}()
/// The padding around the textView that separates it from the stackViews
open var textViewPadding: UIEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 8) {
didSet {
textViewLayoutSet?.bottom?.constant = -textViewPadding.bottom
textViewLayoutSet?.left?.constant = textViewPadding.left
textViewLayoutSet?.right?.constant = -textViewPadding.right
bottomStackViewLayoutSet?.top?.constant = textViewPadding.bottom
}
}
open var sendButton: InputBarButtonItem = {
return InputBarButtonItem()
.configure {
$0.setSize(CGSize(width: 52, height: 28), animated: false)
$0.isEnabled = false
$0.title = "Send"
$0.titleLabel?.font = UIFont.preferredFont(forTextStyle: .headline)
}.onTouchUpInside {
$0.messageInputBar?.didSelectSendButton()
}
}()
/// The anchor contants used by the UIStackViews and InputTextView to create padding within the InputBarAccessoryView
open var padding: UIEdgeInsets = UIEdgeInsets(top: 6, left: 12, bottom: 6, right: 12) {
didSet {
updateViewContraints()
}
}
open override var intrinsicContentSize: CGSize {
let maxSize = CGSize(width: inputTextView.bounds.width, height: .greatestFiniteMagnitude)
let sizeToFit = inputTextView.sizeThatFits(maxSize)
var heightToFit = sizeToFit.height.rounded() + padding.top + padding.bottom
if heightToFit >= maxHeight {
if !isOverMaxHeight {
textViewHeightAnchor?.isActive = true
inputTextView.isScrollEnabled = true
isOverMaxHeight = true
}
heightToFit = maxHeight
} else {
if isOverMaxHeight {
textViewHeightAnchor?.isActive = false
inputTextView.isScrollEnabled = false
isOverMaxHeight = false
}
}
inputTextView.invalidateIntrinsicContentSize()
let size = CGSize(width: bounds.width, height: heightToFit)
if previousIntrinsicContentSize != size {
delegate?.messageInputBar(self, didChangeIntrinsicContentTo: size)
}
previousIntrinsicContentSize = size
return size
}
private(set) var isOverMaxHeight = false
/// The maximum intrinsicContentSize height. When reached the delegate 'didChangeIntrinsicContentTo' will be called.
open var maxHeight: CGFloat = UIScreen.main.bounds.height / 3 {
didSet {
textViewHeightAnchor?.constant = maxHeight
invalidateIntrinsicContentSize()
}
}
/// The fixed widthAnchor constant of the leftStackView
private(set) var leftStackViewWidthContant: CGFloat = 0 {
didSet {
leftStackViewLayoutSet?.width?.constant = leftStackViewWidthContant
}
}
/// The fixed widthAnchor constant of the rightStackView
private(set) var rightStackViewWidthContant: CGFloat = 52 {
didSet {
rightStackViewLayoutSet?.width?.constant = rightStackViewWidthContant
}
}
/// The InputBarItems held in the leftStackView
private(set) var leftStackViewItems: [InputBarButtonItem] = []
/// The InputBarItems held in the rightStackView
private(set) var rightStackViewItems: [InputBarButtonItem] = []
/// The InputBarItems held in the bottomStackView
private(set) var bottomStackViewItems: [InputBarButtonItem] = []
/// The InputBarItems held to make use of their hooks but they are not automatically added to a UIStackView
open var nonStackViewItems: [InputBarButtonItem] = []
/// Returns a flatMap of all the items in each of the UIStackViews
public var items: [InputBarButtonItem] {
return [leftStackViewItems, rightStackViewItems, bottomStackViewItems, nonStackViewItems].flatMap { $0 }
}
// MARK: - Auto-Layout Management
private var textViewLayoutSet: NSLayoutConstraintSet?
private var textViewHeightAnchor: NSLayoutConstraint?
private var leftStackViewLayoutSet: NSLayoutConstraintSet?
private var rightStackViewLayoutSet: NSLayoutConstraintSet?
private var bottomStackViewLayoutSet: NSLayoutConstraintSet?
private var previousIntrinsicContentSize: CGSize?
// MARK: - Initialization
public convenience init() {
self.init(frame: .zero)
}
public override init(frame: CGRect) {
super.init(frame: frame)
setup()
}
required public init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
setup()
}
deinit {
NotificationCenter.default.removeObserver(self)
}
// MARK: - Setup
open func setup() {
backgroundColor = .inputBarGray
autoresizingMask = [.flexibleHeight]
setupSubviews()
setupConstraints()
setupObservers()
}
private func setupSubviews() {
addSubview(blurView)
addSubview(inputTextView)
addSubview(leftStackView)
addSubview(rightStackView)
addSubview(bottomStackView)
addSubview(separatorLine)
setStackViewItems([sendButton], forStack: .right, animated: false)
}
private func setupConstraints() {
separatorLine.addConstraints(topAnchor, left: leftAnchor, right: rightAnchor, heightConstant: 0.5)
blurView.fillSuperview()
textViewLayoutSet = NSLayoutConstraintSet(
top: inputTextView.topAnchor.constraint(equalTo: topAnchor, constant: padding.top),
bottom: inputTextView.bottomAnchor.constraint(equalTo: bottomStackView.topAnchor, constant: -textViewPadding.bottom),
left: inputTextView.leftAnchor.constraint(equalTo: leftStackView.rightAnchor, constant: textViewPadding.left),
right: inputTextView.rightAnchor.constraint(equalTo: rightStackView.leftAnchor, constant: -textViewPadding.right)
).activate()
textViewHeightAnchor = inputTextView.heightAnchor.constraint(equalToConstant: maxHeight)
leftStackViewLayoutSet = NSLayoutConstraintSet(
top: inputTextView.topAnchor.constraint(equalTo: topAnchor, constant: padding.top),
bottom: leftStackView.bottomAnchor.constraint(equalTo: inputTextView.bottomAnchor, constant: 0),
left: leftStackView.leftAnchor.constraint(equalTo: leftAnchor, constant: padding.left),
width: leftStackView.widthAnchor.constraint(equalToConstant: leftStackViewWidthContant)
).activate()
rightStackViewLayoutSet = NSLayoutConstraintSet(
top: inputTextView.topAnchor.constraint(equalTo: topAnchor, constant: padding.top),
bottom: rightStackView.bottomAnchor.constraint(equalTo: inputTextView.bottomAnchor, constant: 0),
right: rightStackView.rightAnchor.constraint(equalTo: rightAnchor, constant: -padding.right),
width: rightStackView.widthAnchor.constraint(equalToConstant: rightStackViewWidthContant)
).activate()
bottomStackViewLayoutSet = NSLayoutConstraintSet(
top: bottomStackView.topAnchor.constraint(equalTo: inputTextView.bottomAnchor),
bottom: bottomStackView.bottomAnchor.constraint(equalTo: layoutMarginsGuide.bottomAnchor, constant: -padding.bottom),
left: bottomStackView.leftAnchor.constraint(equalTo: leftAnchor, constant: padding.left),
right: bottomStackView.rightAnchor.constraint(equalTo: rightAnchor, constant: -padding.right)
).activate()
}
private func updateViewContraints() {
textViewLayoutSet?.top?.constant = padding.top
leftStackViewLayoutSet?.top?.constant = padding.top
leftStackViewLayoutSet?.left?.constant = padding.left
rightStackViewLayoutSet?.top?.constant = padding.top
rightStackViewLayoutSet?.right?.constant = -padding.right
bottomStackViewLayoutSet?.left?.constant = padding.left
bottomStackViewLayoutSet?.right?.constant = -padding.right
bottomStackViewLayoutSet?.bottom?.constant = -padding.bottom
}
private func setupObservers() {
NotificationCenter.default.addObserver(self,
selector: #selector(MessageInputBar.orientationDidChange),
name: .UIDeviceOrientationDidChange, object: nil)
NotificationCenter.default.addObserver(self,
selector: #selector(MessageInputBar.textViewDidChange),
name: .UITextViewTextDidChange, object: nil)
NotificationCenter.default.addObserver(self,
selector: #selector(MessageInputBar.textViewDidBeginEditing),
name: .UITextViewTextDidBeginEditing, object: nil)
NotificationCenter.default.addObserver(self,
selector: #selector(MessageInputBar.textViewDidEndEditing),
name: .UITextViewTextDidEndEditing, object: nil)
}
// MARK: - Layout Helper Methods
/// Layout the given UIStackView's
///
/// - Parameter positions: The UIStackView's to layout
public func layoutStackViews(_ positions: [InputStackView.Position] = [.left, .right, .bottom]) {
for position in positions {
switch position {
case .left:
leftStackView.setNeedsLayout()
leftStackView.layoutIfNeeded()
case .right:
rightStackView.setNeedsLayout()
rightStackView.layoutIfNeeded()
case .bottom:
bottomStackView.setNeedsLayout()
bottomStackView.layoutIfNeeded()
}
}
}
/// Performs layout changes over the main thread
///
/// - Parameters:
/// - animated: If the layout should be animated
/// - animations: Code
internal func performLayout(_ animated: Bool, _ animations: @escaping () -> Void) {
textViewLayoutSet?.deactivate()
leftStackViewLayoutSet?.deactivate()
rightStackViewLayoutSet?.deactivate()
bottomStackViewLayoutSet?.deactivate()
if animated {
DispatchQueue.main.async {
UIView.animate(withDuration: 0.3, animations: animations)
}
} else {
UIView.performWithoutAnimation { animations() }
}
textViewLayoutSet?.activate()
leftStackViewLayoutSet?.activate()
rightStackViewLayoutSet?.activate()
bottomStackViewLayoutSet?.activate()
}
// MARK: - UIStackView InputBarItem Methods
/// Removes all of the arranged subviews from the UIStackView and adds the given items. Sets the inputBarAccessoryView property of the InputBarButtonItem
///
/// - Parameters:
/// - items: New UIStackView arranged views
/// - position: The targeted UIStackView
/// - animated: If the layout should be animated
open func setStackViewItems(_ items: [InputBarButtonItem], forStack position: InputStackView.Position, animated: Bool) {
func setNewItems() {
switch position {
case .left:
leftStackView.arrangedSubviews.forEach { $0.removeFromSuperview() }
leftStackViewItems = items
leftStackViewItems.forEach {
$0.messageInputBar = self
$0.parentStackViewPosition = position
leftStackView.addArrangedSubview($0)
}
leftStackView.layoutIfNeeded()
case .right:
rightStackView.arrangedSubviews.forEach { $0.removeFromSuperview() }
rightStackViewItems = items
rightStackViewItems.forEach {
$0.messageInputBar = self
$0.parentStackViewPosition = position
rightStackView.addArrangedSubview($0)
}
rightStackView.layoutIfNeeded()
case .bottom:
bottomStackView.arrangedSubviews.forEach { $0.removeFromSuperview() }
bottomStackViewItems = items
bottomStackViewItems.forEach {
$0.messageInputBar = self
$0.parentStackViewPosition = position
bottomStackView.addArrangedSubview($0)
}
bottomStackView.layoutIfNeeded()
}
}
performLayout(animated) {
setNewItems()
}
}
/// Sets the leftStackViewWidthConstant
///
/// - Parameters:
/// - newValue: New widthAnchor constant
/// - animated: If the layout should be animated
open func setLeftStackViewWidthConstant(to newValue: CGFloat, animated: Bool) {
performLayout(animated) {
self.leftStackViewWidthContant = newValue
self.layoutStackViews([.left])
self.layoutIfNeeded()
}
}
/// Sets the rightStackViewWidthConstant
///
/// - Parameters:
/// - newValue: New widthAnchor constant
/// - animated: If the layout should be animated
open func setRightStackViewWidthConstant(to newValue: CGFloat, animated: Bool) {
performLayout(animated) {
self.rightStackViewWidthContant = newValue
self.layoutStackViews([.right])
self.layoutIfNeeded()
}
}
// MARK: - Notifications/Hooks
@objc open func orientationDidChange() {
invalidateIntrinsicContentSize()
}
@objc open func textViewDidChange() {
let trimmedText = inputTextView.text.trimmingCharacters(in: .whitespacesAndNewlines)
sendButton.isEnabled = !trimmedText.isEmpty
inputTextView.placeholderLabel.isHidden = !inputTextView.text.isEmpty
items.forEach { $0.textViewDidChangeAction(with: inputTextView) }
delegate?.messageInputBar(self, textViewTextDidChangeTo: trimmedText)
invalidateIntrinsicContentSize()
}
@objc open func textViewDidBeginEditing() {
self.items.forEach { $0.keyboardEditingBeginsAction() }
}
@objc open func textViewDidEndEditing() {
self.items.forEach { $0.keyboardEditingEndsAction() }
}
// MARK: - User Actions
open func didSelectSendButton() {
delegate?.messageInputBar(self, didPressSendButtonWith: inputTextView.text)
textViewDidChange()
}
}
| mit | b0f43e1aaec0cf9427661a4b3b67cec8 | 38.784615 | 157 | 0.64131 | 5.888744 | false | false | false | false |
Subsets and Splits