text stringlengths 8 1.32M |
|---|
//
// WFAdModel.swift
// niinfor
//
// Created by 王孝飞 on 2017/9/28.
// Copyright © 2017年 孝飞. All rights reserved.
//
import UIKit
class WFAdModel: NSObject {
var id : String?
var name : String?
var url : String?
var image : String?
var imageString : String{
return (image ?? "")//Photo_Path + (image ?? "")//
}
override var description: String{
return yy_modelDescription()
}
}
|
//
// Enums.swift
// Apps Challenge
//
// Created by Francisco Javier Sarasua Galan on 03/05/2021.
//
import Foundation
enum MoveTable {
case open
case close
}
enum PickerState {
case category
case subcategory
}
enum TextFieldID: String {
case name
case phone
case email
case description
case location
case category
case subcategory
}
enum ErrorType: String {
case service
case JSONParser
case none
}
|
import Foundation
class DisjointSet {
var parent: [Int]
var rank: [Int]
init(_ n: Int) {
parent = [Int](1...n)
rank = [Int](repeating: 1, count: n)
}
func find(_ u: Int) -> Int {
if (u == parent[u]) { return u }
parent[u] = find(parent[u])
return parent[u]
}
func merge (_ u: Int, _ v: Int) {
var u = find(u)
var v = find(v)
if (u == v) { return }
if (rank[u] > rank[v]) { swap(&u, &v) }
parent[u] = v
if (rank[u] == rank[v]) { rank[v] += 1 }
}
}
|
//
// Provider.swift
// MonoProvider
//
// Created by Alexander Kravchenko on 03.08.2019.
//
import Vapor
public struct MonoPublicConfig: Service {}
public struct MonoPersonalConfig: Service {
public let xToken: String
public init(xToken: String) {
self.xToken = xToken
}
}
public final class MonoPublicProvider: Provider {
public func register(_ services: inout Services) throws {
services.register { container -> MonoPublicClient in
let httpClient = try container.make(Client.self)
return MonoPublicClient(client: httpClient)
}
}
public func didBoot(_ container: Container) throws -> EventLoopFuture<Void> {
return .done(on: container)
}
}
public final class MonoPersonalProvider: Provider {
public func register(_ services: inout Services) throws {
services.register { container -> MonoPersonalClient in
let httpClient = try container.make(Client.self)
let config = try container.make(MonoPersonalConfig.self)
let xToken = config.xToken
return MonoPersonalClient(xToken: xToken, client: httpClient)
}
}
public func didBoot(_ container: Container) throws -> EventLoopFuture<Void> {
return .done(on: container)
}
}
public class MonoPublicClient: Service {
public var currencies: MonoCurrencyRoutes
init(client: Client) {
let apiRequest = MonoPublicAPIRequest(httpClient: client)
currencies = MonoCurrencyRoutes(request: apiRequest)
}
}
public final class MonoPersonalClient: MonoPublicClient {
public var personal: MonoPersonalRoutes
init(xToken: String, client: Client) {
let apiRequest = MonoPersonalAPIRequest(httpClient: client, xToken: xToken)
personal = MonoPersonalRoutes(request: apiRequest)
super.init(client: client)
}
}
|
//
// Converter.swift
// Conversion Master_dev
//
// Created by Seth Cohen on 1/8/17.
// Copyright © 2017 Seth Cohen. All rights reserved.
//
protocol Converter {
init(dataMap: [String: Any])
func convert(value: Double, fromUnit: String, toUnit: String) -> Double
}
|
//
// FirstViewController.swift
// ToDoList
//
// Created by David Poulos on 10/6/15.
// Copyright © 2015 David Poulos. All rights reserved.
//
import UIKit
//SuperClass. //Protocols.
class FirstViewController: UIViewController, UITableViewDelegate, UITableViewDataSource
{
@IBOutlet weak var tblTasks: UITableView!
//NUMBER OF ROWS.
func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int
{
return taskMgr.tasks.count
}
//NUMBER OF CELLS IN ROW.
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell
{
let cell: UITableViewCell = UITableViewCell(style: UITableViewCellStyle.Subtitle, reuseIdentifier: "test")
cell.textLabel!.text = taskMgr.tasks[indexPath.row].taskName
cell.detailTextLabel!.text = taskMgr.tasks[indexPath.row].taskDesc
return cell
}
override func viewWillAppear(animated: Bool) {
tblTasks.reloadData()
}
func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
if (editingStyle == UITableViewCellEditingStyle.Delete)
{
taskMgr.tasks.removeAtIndex(indexPath.row)
tblTasks.reloadData()
}
}
}
|
//
// SWBFeaturesTableViewElement.swift
// SweepBright
//
// Created by Kaio Henrique on 3/29/16.
// Copyright © 2016 madewithlove. All rights reserved.
//
import UIKit
class SWBFeaturesTableView: UITableView {
var service: SWBFeaturesServiceDelegate? {
didSet {
if let ds = self.dataSource as? SWBFeaturesDatasourceProtocol {
ds.service = self.service
}
}
}
override init(frame: CGRect, style: UITableViewStyle) {
super.init(frame: frame, style: style)
self.initialize()
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
self.initialize()
}
func initialize() {
//The cells will be loaded from SWBFeaturesCell nib file on UI/SWBEdit/SWBFeatures
let nib = UINib(nibName: "SWBFeaturesCell", bundle: NSBundle.mainBundle())
self.registerNib(nib, forCellReuseIdentifier: "featureCell")
self.delegate = self
}
}
extension SWBFeaturesTableView: UITableViewDelegate {
func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
tableView.deselectRowAtIndexPath(indexPath, animated: true)
}
}
|
//
// Gradient.swift
// Canvas
//
// Created by Russell Gordon on 5/26/17.
// Copyright © 2017 Royal St. George's College. All rights reserved.
//
import Foundation
class Gradient {
var canvas : Canvas
init(on the : Canvas) {
canvas = the
}
/**
Draws a horizontal gradient from the lower left corner given, from the hue provided to the second hue provided. Will always span entire width of screen.
- parameter lowerLeftX: The x position of the lower left corner.
- parameter lowerLeftY: The y position of the lower left corner.
- parameter from: The hue to start from
- parameter to: The hue to end at
*/
public func makeGradient(lowerLeftX : Int, lowerLeftY : Int, from : Float, to: Float, brightness : Float = 90) {
// Get height of sky
let height : Float = Float(canvas.height - lowerLeftY)
// Get increment for the hue
let increment = (from - to) / height
// Set the starting point for the hue
var currentHue : Float = 0
if increment > 0 {
currentHue = from
} else {
currentHue = to
}
// Draw the lines to make a gradient
for y in stride(from: lowerLeftY, through: canvas.height, by: 1) {
// Set the line color
canvas.lineColor = Color(hue: currentHue, saturation: 80, brightness: brightness, alpha: 100)
currentHue += increment
// Draw the line
canvas.drawLine(fromX: 0, fromY: y, toX: canvas.width, toY: y)
}
}
}
|
//
// ExampleNavigationInteractor.swift
// Template
//
// Created Domagoj Kulundzic on 27/05/2019.
//
import Foundation
protocol ExampleNavigationBusinessLogic: AnyObject { }
class ExampleNavigationInteractor {
weak var presenter: ExampleNavigationBusinessPresentingLogic?
}
// MARK: - ExampleNavigationBusinessLogic
extension ExampleNavigationInteractor: ExampleNavigationBusinessLogic { }
|
import Foundation
import HTTPClient
final class AlamofireUploadMultipartFormDataOperationBuilder: UploadMultipartFormDataRequestOperationBuilder {
private let uploader: AlamofireUploader
init(uploader: AlamofireUploader) {
self.uploader = uploader
}
func buildOperation<R: UploadMultipartFormDataRequest>(
request: R,
dataProvider: DataProvider,
onProgressChange: ((Progress) -> ())?,
completion: @escaping DataResult<R.Result, RequestError<R.ErrorResponse>>.Completion
) -> Operation
{
return AlamofireUploadMultipartFormDataRequestOperation(
request: request,
dataProvider: dataProvider,
uploader: uploader,
onProgressChange: onProgressChange,
completion: completion
)
}
}
|
//
// AsyncViewController.swift
// FlaskNav
//
// Created by hassan uriostegui on 9/21/18.
// Copyright © 2018 eonflux. All rights reserved.
//
import UIKit
class AsyncViewController: UIViewController, FlaskNavViewControllerProtocol {
typealias NavInfoType = NavInfo
var navContext: NavContext?
var navInfo: NavInfo?
func setupEmptyState() {
let colors:[UIColor] = [.red, .green, . blue, .yellow, .white, .purple, .orange, .cyan, .magenta]
let colorIndex = navContext!.contextId % colors.count
print("setupEmptyState colorIndex:\(colorIndex)")
let color = colors[colorIndex]
self.view.backgroundColor = color
}
func setupContent(with completionHandle: @escaping FlaskNavCompletionBlock) {
// print("payload = \(String(describing: navInfo))")
// print("frame = \(String(describing: view.frame))")
DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
completionHandle()
}
navInfo?.callback("callback from controller")
}
}
|
//
// GlobalSettings.swift
// GameFramework
//
// Created by apple on 1/16/15.
// Copyright (c) 2015 apple. All rights reserved.
//
import Foundation
import UIColor_Hex_Swift
class GlobalSettings {
class func addUserDefaults(){
GlobalVariables.globalUserDefaults.setInteger(0, forKey: GlobalVariables.user_defaults_app_iteration_number_key)
GlobalVariables.globalUserDefaults.setBool(false, forKey: GlobalVariables.user_defaults_app_purchased_flag_key)
GlobalVariables.globalUserDefaults.setInteger(-1,forKey:GlobalVariables.user_defaults_match_id_key)
GlobalVariables.globalUserDefaults.setInteger(-1,forKey:GlobalVariables.user_defaults_location_id_key)
GlobalVariables.globalUserDefaults.setInteger(-1,forKey:GlobalVariables.user_defaults_tournment_id_key)
GlobalVariables.globalUserDefaults.setBool(false,forKey:GlobalVariables.user_defaults_remember_me_key)
GlobalVariables.globalUserDefaults.setBool(false,forKey:GlobalVariables.user_defaults_signed_in_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_session_id_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_username_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_password_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_city_id_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_course_id_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_user_id_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_role_id_key)
GlobalVariables.globalUserDefaults.setValue("", forKey: GlobalVariables.user_defaults_name_key)
GlobalVariables.globalUserDefaults.setBool(GlobalVariables.isPurchased, forKey: GlobalVariables.user_defaults_isPurchased_key)
GlobalVariables.globalUserDefaults.setBool(GlobalVariables.isPurchased, forKey: GlobalVariables.user_grid_view_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func increaseAppIterationNumber(){
var iterationNumber = GlobalVariables.globalUserDefaults.integerForKey(GlobalVariables.user_defaults_app_iteration_number_key)
iterationNumber = iterationNumber+1;
GlobalVariables.globalUserDefaults.setInteger(iterationNumber, forKey: GlobalVariables.user_defaults_app_iteration_number_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func isPurchased() -> Bool{
let isPurchased = GlobalVariables.globalUserDefaults.boolForKey(GlobalVariables.user_defaults_isPurchased_key)
return isPurchased
}
class func setIsPurchased(value: Bool){
GlobalVariables.globalUserDefaults.setBool(value, forKey: GlobalVariables.user_defaults_isPurchased_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func isGridView() -> Bool{
let value = GlobalVariables.globalUserDefaults.boolForKey(GlobalVariables.user_grid_view_key)
return value
}
class func setGridView(value: Bool){
GlobalVariables.globalUserDefaults.setBool(value, forKey: GlobalVariables.user_grid_view_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func udateSessionId(value:NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_session_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateRoleIdDefaultValue(value : NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_role_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func getNewMatchId() -> Int{
var currentValue = GlobalVariables.globalUserDefaults.integerForKey(GlobalVariables.user_defaults_match_id_key)
currentValue = currentValue+1;
GlobalVariables.globalUserDefaults.setInteger(currentValue, forKey: GlobalVariables.user_defaults_match_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
return GlobalVariables.globalUserDefaults.integerForKey(GlobalVariables.user_defaults_match_id_key)
}
class func getNewLocationId() -> Int{
var currentValue = GlobalVariables.globalUserDefaults.integerForKey(GlobalVariables.user_defaults_location_id_key)
currentValue = currentValue+1;
GlobalVariables.globalUserDefaults.setInteger(currentValue, forKey: GlobalVariables.user_defaults_location_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
return GlobalVariables.globalUserDefaults.integerForKey(GlobalVariables.user_defaults_location_id_key)
}
class func updateRemeberMeDefaultValue(boolValue : Bool){
GlobalVariables.globalUserDefaults.setBool(boolValue, forKey: GlobalVariables.user_defaults_remember_me_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateSignedInDefaultValue(boolValue : Bool){
GlobalVariables.globalUserDefaults.setBool(boolValue, forKey: GlobalVariables.user_defaults_signed_in_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateUsernameDefaultValue(value : NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_username_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateCityDefaultValue(value : NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_city_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateCourseDefaultValue(value : NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_course_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateUsername(value : NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_name_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateUserIdDefaultValue(value : NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_user_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateFromYearDefaultValue(value : Int){
GlobalVariables.globalUserDefaults.setInteger(value, forKey: GlobalVariables.user_defaults_from_year_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateToYearDefaultValue(value : Int){
GlobalVariables.globalUserDefaults.setInteger(value, forKey: GlobalVariables.user_defaults_to_year_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateFromMonthDefaultValue(value : Int){
GlobalVariables.globalUserDefaults.setInteger(value, forKey: GlobalVariables.user_defaults_from_month_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updateToMonthDefaultValue(value : Int){
GlobalVariables.globalUserDefaults.setInteger(value, forKey: GlobalVariables.user_defaults_to_month_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func updatePasswordDefaultValue(value : NSString){
GlobalVariables.globalUserDefaults.setValue(value, forKey: GlobalVariables.user_defaults_password_key)
NSUserDefaults.standardUserDefaults().synchronize()
}
class func getNewTournmentId()-> Int{
var currentValue = GlobalVariables.globalUserDefaults.integerForKey(GlobalVariables.user_defaults_tournment_id_key)
currentValue = currentValue+1;
GlobalVariables.globalUserDefaults.setInteger(currentValue, forKey: GlobalVariables.user_defaults_tournment_id_key)
NSUserDefaults.standardUserDefaults().synchronize()
return GlobalVariables.globalUserDefaults.integerForKey(GlobalVariables.user_defaults_tournment_id_key)
}
class func setButtonProperties(button:UIButton){
button.layer.cornerRadius = 8
button.layer.borderWidth = 4
button.layer.borderColor = UIColor.whiteColor().CGColor
button.backgroundColor = UIColor.clearColor()
}
class func setScoreboardButtonProperties(button:UIButton){
button.layer.cornerRadius = 4
button.layer.borderWidth = 1
button.layer.borderColor = UIColor.blackColor().CGColor
button.backgroundColor = UIColor.whiteColor()
}
class func setTextfiledProperties(textFiled:UITextField){
textFiled.layer.borderColor = UIColor.clearColor().CGColor
//textFiled.floatingPlaceholderEnabled = true
//textFiled.tintColor = UIColor.MKColor.Green
//textFiled.rippleLocation = .Right
//textFiled.cornerRadius = 0
//textFiled.bottomBorderEnabled = true
}
enum TableViewCellEnum : Int {
case kTimerCell = 0
case kTriesCell = 1
case kGoalsCell = 2
case kPenaltiesCell = 3
case kConversionsCell = 4
case kTotalCell = 5
case kMenuCell = 6
}
// MARK: Colours functions
class func RGBA(r r:CGFloat, g:CGFloat, b:CGFloat, a:CGFloat)->UIColor{
let color: UIColor = UIColor( red: CGFloat(r/255.0), green: CGFloat(g/255.0), blue: CGFloat(b/255.0), alpha: CGFloat(a) )
return color
}
/*class func saveImageToDirectory(photo_url:NSString) {
let fileUrl = NSURL(string: photo_url as String)
let request: NSURLRequest = NSURLRequest(URL: fileUrl!)
let mainQueue = NSOperationQueue.mainQueue()
NSURLConnection.sendAsynchronousRequest(request, queue: mainQueue, completionHandler: { (response, data, error) -> Void in
if error == nil {
let image = UIImage(data: data!)
dispatch_async(dispatch_get_main_queue(), {
let imagePath = fileUrl?.lastPathComponent
let imageToSave:NSData = UIImagePNGRepresentation(image!)!
let path = NSTemporaryDirectory() + imagePath!
imageToSave.writeToFile(path, atomically: true)
})
}
})
}*/
class func isImageAvailable(photo_url:NSString) -> Bool {
let fileUrl = NSURL(string: photo_url as String)
let fileManager = NSFileManager.defaultManager()
let imagePath = fileUrl?.lastPathComponent
let path = NSTemporaryDirectory() + imagePath!
if (fileManager.fileExistsAtPath(path)){
return true
}else{
return false
}
}
/*class func getImageFromPath(photo_url:NSString) -> UIImage {
let fileUrl = NSURL(string: photo_url as String)
let fileManager = NSFileManager.defaultManager()
let imagePath = fileUrl?.lastPathComponent
let path = NSTemporaryDirectory() + imagePath!
return UIImage(contentsOfFile: path)!
}
class func removeImageFromPath(photo_url:NSString) {
let fileUrl = NSURL(string: photo_url as String)
let fileManager = NSFileManager.defaultManager()
let imagePath = fileUrl?.lastPathComponent
let path = NSTemporaryDirectory() + imagePath!
if (fileManager.fileExistsAtPath(path)){
var error:NSError?
fileManager.removeItemAtPath(path)
}
}*/
class func setNavigationBarProperties() {
//Navigation bar settings
let navbarFont = UIFont(name: "Ubuntu", size: 17) ?? UIFont.systemFontOfSize(17)
//let barbuttonFont = UIFont(name: "Ubuntu-Light", size: 15) ?? UIFont.systemFontOfSize(15)
UINavigationBar.appearance().titleTextAttributes = [NSFontAttributeName: navbarFont, NSForegroundColorAttributeName:UIColor.whiteColor()]
//UINavigationBar.appearance().barTintColor = UIColor(rgba: GlobalVariables.appColor)
UINavigationBar.appearance().tintColor = UIColor.whiteColor()
}
class func getPath(fileName: String) -> String {
let documentsURL = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0]
let fileURL = documentsURL.URLByAppendingPathComponent(fileName)
return fileURL.path!
}
class func copyFile(fileName: NSString) -> Bool {
let dbPath: String = getPath(fileName as String)
let fileManager = NSFileManager.defaultManager()
if !fileManager.fileExistsAtPath(dbPath) {
let documentsURL = NSBundle.mainBundle().resourceURL
let fromPath = documentsURL!.URLByAppendingPathComponent(fileName as String)
var error : NSError?
do {
try fileManager.copyItemAtPath(fromPath.path!, toPath: dbPath)
} catch let error1 as NSError {
error = error1
}
if (error == nil) {
return true
}else {
return false
}
}else{
return false
}
}
class func downloadImageFrom(link:String, contentMode: UIViewContentMode, imageView:UIImageView) {
NSURLSession.sharedSession().dataTaskWithURL( NSURL(string:link)!, completionHandler: {
(data, response, error) -> Void in
dispatch_async(dispatch_get_main_queue()) {
imageView.contentMode = contentMode
if let data = data {
imageView.image = UIImage(data: data)
}
}
}).resume()
}
} |
//: [Previous](@previous)
/*:
# Exercise: Swift 3 Loops & Arrays
[http://blog.devslopes.com/p/3b84fc52-1d82-4980-bcf8-8c1941f4bfa5/](http://blog.devslopes.com/p/3b84fc52-1d82-4980-bcf8-8c1941f4bfa5/)
**Requirements:**
Create a new Xcode Playground
## Exercise Loops
Create an empty array of type Int called oddNumbers
*/
/*:
Using a standard for-in loop add all odd numbers less than or equal to 100 to the oddNumbers array
*/
/*:
Create a second array called sums of type Int
*/
/*:
Using a for-in, iterate through oddNumbers array and add the current iteration value + 5 to the sums array
*/
/*:
Using a repeat while loop, iterate through the sums array and print "The sum is: x" where x is the current value of the iteration (ie The sum is: 15)
*/
|
//
// MessageDetailViewController.swift
// Message Board
//
// Created by Samantha Gatt on 8/8/18.
// Copyright © 2018 Samantha Gatt. All rights reserved.
//
import UIKit
class MessageDetailViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
}
// MARK: - Actions
@IBAction func send(_ sender: Any) {
guard let thisMessageThread = messageThread,
let sender = textField.text,
let text = textView.text else { return }
messageThreadController?.createMessage(fromThread: thisMessageThread, text: text, sender: sender, completion: { (error) in
DispatchQueue.main.async {
self.navigationController?.popViewController(animated: true)
}
})
}
// MARK: - Properties
var messageThread: MessageThread?
var messageThreadController: MessageThreadController?
// MARK: - Outlets
@IBOutlet weak var textField: UITextField!
@IBOutlet weak var textView: UITextView!
}
|
//
// GColorGBRFilter.swift
// MetalImageFilter
//
// Created by LEE CHUL HYUN on 4/10/19.
// Copyright © 2019 LEE CHUL HYUN. All rights reserved.
//
import Foundation
import Metal
import simd
struct RGBUniforms {
var rotation: matrix_float4x4
}
class GColorGBRFilter: GImageFilter {
var _rotation: Float = 0
var rotation: Float {
get {
return _rotation
}
set {
self.isDirty = true
_rotation = newValue
}
}
var uniforms: UnsafeMutablePointer<RGBUniforms>
override init?(context: GContext, filterType: GImageFilterType) {
guard let buffer = context.device.makeBuffer(length: MemoryLayout<RGBUniforms>.size, options: [MTLResourceOptions.init(rawValue: 0)]) else { return nil }
uniforms = UnsafeMutableRawPointer(buffer.contents()).bindMemory(to:RGBUniforms.self, capacity:1)
super.init(functionName: "gbr", context: context, filterType: filterType )
uniformBuffer = buffer
}
func radians_from_degrees(_ degrees: Float) -> Float {
return (degrees / 180) * .pi
}
override func configureArgumentTable(commandEncoder: MTLComputeCommandEncoder) {
let rotationAxis = float3(1, 1, 1)
uniforms[0].rotation = matrix4x4_rotation(radians: radians_from_degrees(rotation), axis: rotationAxis)
commandEncoder.setBuffer(self.uniformBuffer, offset: 0, index: 0)
}
override func setValue(_ value: Float) {
rotation = value
}
func matrix4x4_rotation(radians: Float, axis: float3) -> matrix_float4x4 {
let unitAxis = normalize(axis)
let ct = cosf(radians)
let st = sinf(radians)
let ci = 1 - ct
let x = unitAxis.x, y = unitAxis.y, z = unitAxis.z
return matrix_float4x4.init(columns:(vector_float4( ct + x * x * ci, y * x * ci + z * st, z * x * ci - y * st, 0),
vector_float4(x * y * ci - z * st, ct + y * y * ci, z * y * ci + x * st, 0),
vector_float4(x * z * ci + y * st, y * z * ci - x * st, ct + z * z * ci, 0),
vector_float4( 0, 0, 0, 1)))
}
}
|
//
// RobotoTests.swift
// Swift Kit
//
// Created by Aris Koxaras on 24/10/16.
// Copyright © 2016 Aris Koxaras. All rights reserved.
//
import XCTest
@testable import Swift_Kit
class RobotoTests: XCTestCase {
override func setUp() {
super.setUp()
// Put setup code here. This method is called before the invocation of each test method in the class.
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class.
super.tearDown()
}
func testRobotoFontsIsLoaded() {
XCTAssertNotNil(Roboto.familyName())
XCTAssertNotNil(Roboto.Regular(15))
XCTAssertNotNil(Roboto.Italic(15))
XCTAssertNotNil(Roboto.Thin(15))
XCTAssertNotNil(Roboto.ThinItalic(15))
XCTAssertNotNil(Roboto.Light(15))
XCTAssertNotNil(Roboto.LightItalic(15))
XCTAssertNotNil(Roboto.Medium(15))
XCTAssertNotNil(Roboto.MediumItalic(15))
XCTAssertNotNil(Roboto.Bold(15))
XCTAssertNotNil(Roboto.BoldItalic(15))
}
}
|
//
// AddNewOyster.swift
// BucketListUI
//
// Created by Максим Нуждин on 13.07.2021.
//
import SwiftUI
import MapKit
struct AddNewOyster: View {
var annotationArray: [MKPointAnnotation]
var body: some View {
Text(/*@START_MENU_TOKEN@*/"Hello, World!"/*@END_MENU_TOKEN@*/)
}
}
struct AddNewOyster_Previews: PreviewProvider {
static var previews: some View {
AddNewOyster(annotationArray: [])
}
}
|
//
// PlayerInputControllerFactory.swift
// SailingThroughHistory
//
// Created by Herald on 20/4/19.
// Copyright © 2019 Sailing Through History Team. All rights reserved.
//
class PlayerInputControllerFactory: GenericPlayerInputControllerFactory {
func create(network: GenericTurnSystemNetwork, data: GenericTurnSystemState)
-> GenericPlayerInputController {
return PlayerInputController(network: network, data: data)
}
}
|
//
// DSAnnotation.swift
// GarbageManager
//
// Created by stanley jin on 16/09/2016.
// Copyright © 2016 PASS. All rights reserved.
//
import MapKit
class DSAnnotation: NSObject, MKAnnotation {
var latitude: Double
var longitude: Double
var title: String?
var subtitle: String?
// computing property transforming override double type coordinate to CLLocationCoordinate2D
var coordinate: CLLocationCoordinate2D
{
return CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
}
override init()
{
latitude = 0.0
longitude = 0.0
}
init(latitude: Double, longitude: Double)
{
self.latitude = latitude
self.longitude = longitude
}
init(coordinate: CLLocationCoordinate2D, title: String, subtitle: String)
{
latitude = coordinate.latitude
longitude = coordinate.longitude
self.title = title
self.subtitle = subtitle
}
}
|
//
// TweetDetailViewController.swift
// twitter_alamofire_demo
//
// Created by Nancy Gomez on 3/10/18.
// Copyright © 2018 Charles Hieger. All rights reserved.
//
import UIKit
import AlamofireImage
class TweetDetailViewController: UIViewController {
@IBOutlet weak var userImg: UIImageView!
@IBOutlet weak var username: UILabel!
@IBOutlet weak var screenName: UILabel!
@IBOutlet weak var tweet: UILabel!
@IBOutlet weak var createdAt: UILabel!
@IBOutlet weak var retweetCount: UILabel!
@IBOutlet weak var favCount: UILabel!
@IBOutlet weak var favoriteButton: UIButton!
@IBOutlet weak var retweetButton: UIButton!
var tweetInfo = Tweet()
// var tweetInfo: Tweet! {
// didSet {
// tweetInfo = Tweet()
// refreshData()
// }
// }
func refreshData() {
// check favorited
if(tweetInfo.favorited == true) {
favoriteButton.setImage(UIImage(named: "favor-icon-red.png"), for:[])
} else {
favoriteButton.setImage(UIImage(named: "favor-icon.png"), for:[])
}
// check retweeted
if(tweetInfo.retweeted == true) {
retweetButton.setImage(UIImage(named: "retweet-icon-green.png"), for:[])
} else {
retweetButton.setImage(UIImage(named: "retweet-icon.png"), for:[])
}
username.text = tweetInfo.user.name
let url = URL(string: tweetInfo.user.profileURL)!
userImg.af_setImage(withURL: url)
screenName.text = tweetInfo.user.screenName
tweet.text = tweetInfo.text
createdAt.text = tweetInfo.createdAtString
retweetCount.text = String(describing: tweetInfo.retweetCount) + " Retweets"
if(tweetInfo.favoriteCount != nil) {
let count = tweetInfo.favoriteCount!
favCount.text = String(count) + " Favorites"
} else {
favCount.text = "0 Favorites"
}
}
override func viewDidLoad() {
super.viewDidLoad()
refreshData()
}
@IBAction func onRetweet(_ sender: Any) {
if(tweetInfo.retweeted == false)
{
tweetInfo.retweeted = true
tweetInfo.retweetCount += 1
retweetButton.setImage(UIImage(named: "retweet-icon-green.png"), for:[])
APIManager.shared.retweet(tweetInfo) { (tweet: Tweet?, error: Error?) in
if let error = error {
print("Error retweeting tweet: \(error.localizedDescription)")
} else if let tweet = tweet {
print("Successfully retweeted the following Tweet: \n\(tweet.text)")
}
}
self.refreshData()
} else {
tweetInfo.retweeted = false
tweetInfo.retweetCount -= 1
retweetButton.setImage(UIImage(named: "retweet-icon.png"), for:[])
APIManager.shared.unRetweet(tweetInfo) { (tweet: Tweet?, error: Error?) in
if let error = error {
print("Error unretweeting tweet: \(error.localizedDescription)")
} else if let tweet = tweet {
print("Successfully unRetweeted the following Tweet: \n\(tweet.text)")
}
}
self.refreshData()
}
}
@IBAction func onFavorite(_ sender: Any) {
if(tweetInfo.favorited == false){
tweetInfo.favorited = true
tweetInfo.favoriteCount! += 1
favoriteButton.setImage(UIImage(named: "favor-icon-red.png"), for:[])
APIManager.shared.favorite(tweetInfo) { (tweet: Tweet?, error: Error?) in
if let error = error {
print("Error favoriting tweet: \(error.localizedDescription)")
} else if let tweet = tweet {
print("Successfully favorited the following Tweet: \n\(tweet.text)")
}
}
self.refreshData()
} else {
tweetInfo.favorited = false
tweetInfo.favoriteCount! -= 1
favoriteButton.setImage(UIImage(named: "favor-icon.png"), for:[])
APIManager.shared.unFavorite(tweetInfo) { (tweet: Tweet?, error: Error?) in
if let error = error {
print("Error unFavoriting tweet: \(error.localizedDescription)")
} else if let tweet = tweet {
print("Successfully unFavorited the following Tweet: \n\(tweet.text)")
}
}
self.refreshData()
}
}
override func viewWillAppear(_ animated: Bool) {
navigationItem.title = "Tweet"
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
|
//
// SocialMediaVC.swift
// FreeMason Replica
//
// Created by Naheed Shamim on 22/09/17.
// Copyright © 2017 Naheed Shamim. All rights reserved.
//
import UIKit
class SocialMediaVC: UIViewController, UICollectionViewDelegate, UICollectionViewDataSource {
@IBOutlet weak var collectionView: UICollectionView!
var socialMediaArr = Array<MenuItems>()
override func viewDidLoad() {
super.viewDidLoad()
self.title = "Social Media"
Utility.addSideMenuOn(vc: self)
socialMediaArr = Constants.getSocialMediaArray()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
// MARK: - UICollectionViewDataSource protocol
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return socialMediaArr.count
}
// MARK: - UICollectionViewDelegate protocol
func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "sMediaCell", for: indexPath) as! SocialMediaCollectionViewCell
// set the attrib here
cell.titleLbl.text = socialMediaArr[indexPath.row].name
cell.img.image = UIImage(named:socialMediaArr[indexPath.row].imgName)
return cell
}
func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath)
{
print("You selected cell \(socialMediaArr[indexPath.row].name)!")
}
// MARK: - UICollectionViewDelegateFlowLayout
func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize
{
let cellSize : CGFloat = UIScreen.main.bounds.size.width/2 - 8
return CGSize(width: cellSize, height: cellSize)
}
@IBAction func backAction(_ sender: Any) {
_ = navigationController?.popViewController(animated: true)
}
}
|
//
// Created by Daniel Heredia on 2/27/18.
// Copyright © 2018 Daniel Heredia. All rights reserved.
//
// Langton's Ant
import Foundation
// MARK: - Orientation structure
enum Orientation {
case right
case left
case up
case down
var stringValue: String {
switch self {
case .right:
return "➡️"
case .left:
return "⬅️"
case .up:
return "⬆️"
case .down:
return "⬇️"
}
}
}
// MARK: - Position structure
struct Position: Hashable {
let row: Int
let column: Int
var hashValue: Int {
return row ^ column
}
static func ==(lhs: Position, rhs: Position) -> Bool{
return lhs.column == rhs.column && lhs.row == rhs.row
}
}
// MARK: - Board class
class Board {
private(set) var ant: Ant
private var whites: Set<Position>
private var topLeftPos: Position
private var bottomRightPos: Position
init() {
let origin = Position(row: 0, column: 0)
self.ant = Ant(position: origin, orientation: .right)
self.whites = Set<Position>()
self.topLeftPos = origin
self.bottomRightPos = origin
}
func move() {
self.ant.turn(self.isWhite(self.ant.position))
self.flip(position: self.ant.position)
self.ant.move()
self.checkBoardSize(forPosition: self.ant.position)
}
func isWhite(_ position: Position) -> Bool{
return self.whites.contains(position)
}
var stringValue: String {
var representation = ""
for row in (self.topLeftPos.row...self.bottomRightPos.row) {
for column in (self.topLeftPos.column...self.bottomRightPos.column) {
let position = Position(row: row, column: column)
if self.ant.position == position {
representation.append(self.ant.orientation.stringValue)
} else {
representation.append(self.getStringValue(forPosition: position))
}
}
representation.append("\n")
}
representation.append("Ant's position color: \(self.getStringValue(forPosition: self.ant.position)) \n")
return representation
}
private func getStringValue(forPosition position: Position) -> String {
if self.whites.contains(position) {
return "⚪️"
} else {
return "⚫️"
}
}
private func flip(position: Position) {
if self.whites.contains(position) {
self.whites.remove(position)
} else {
self.whites.insert(position)
}
}
private func checkBoardSize(forPosition position: Position) {
var newTopRow = self.topLeftPos.row
var newLeftColumn = self.topLeftPos.column
var newBottomRow = self.bottomRightPos.row
var newRightColumn = self.bottomRightPos.column
if position.column < self.topLeftPos.column {
newLeftColumn = position.column
}
if position.row < self.topLeftPos.row {
newTopRow = position.row
}
if position.column > self.bottomRightPos.column {
newRightColumn = position.column
}
if position.row > self.bottomRightPos.row {
newBottomRow = position.row
}
self.topLeftPos = Position(row: newTopRow, column: newLeftColumn)
self.bottomRightPos = Position(row: newBottomRow, column: newRightColumn)
}
}
// MARK: - Ant class
class Ant {
private(set) var position: Position
private(set) var orientation: Orientation
init(position: Position, orientation: Orientation) {
self.position = position
self.orientation = orientation
}
func turn(_ clockWise: Bool) {
var newOrientation: Orientation!
switch self.orientation {
case .right:
newOrientation = clockWise ? .down : .up
case .down:
newOrientation = clockWise ? .left : .right
case .left:
newOrientation = clockWise ? .up : .down
case .up:
newOrientation = clockWise ? .right : .left
}
self.orientation = newOrientation
}
func move() {
var row = self.position.row
var column = self.position.column
switch self.orientation {
case .right:
column += 1
case .down:
row += 1
case .left:
column -= 1
case .up:
row -= 1
}
self.position = Position(row: row, column: column)
}
}
// MARK: - Test
let board = Board()
let k = 100
for _ in 0..<k {
board.move()
}
print("Board state after \(k) movements:")
print(board.stringValue)
|
//
// Decodable+Load.swift
// RIDB
//
// Created by Guerson on 2020-05-23.
// Copyright © 2020 rise. All rights reserved.
//
import Foundation
import CodableUtils
extension Decodable {
static var dbName: String {
return self.className
}
//TODO: Add support for single element DB
// static func loadDB() -> Self? {
// guard let data = RIArchiever.load(fileName: Self.dbName) as? Data else { return nil }
// do {
// return try JSONDecoder().decode(Self.self, from: data)
// } catch {
// print("DBDecodErr: \(String(describing: Self.dbName)) \(error)")
// }
// return nil
// }
}
extension Array where Element: Decodable {
static func loadDB() -> Self? {
let fileName = Element.dbName
return self.loadDB(fileName)
}
static func loadDB(_ name: String) -> Self? {
guard let data = RIArchiever.load(fileName: name) as? Data else { return nil }
do {
return try JSONDecoder().decode(Self.self, from: data)
} catch {
print("DBDecodErr: \(String(describing: name)) \(error)")
}
return nil
}
}
extension Array where Element == [String: Any] {
static func loadDB(_ name: String) -> Self? {
guard let data = RIArchiever.load(fileName: name) as? Data else { return nil }
do {
return try JSONSerialization.jsonObject(with: data, options: []) as? [[String: Any]]
} catch {
print("DBDecodErr: \(String(describing: name)) \(error)")
}
return nil
}
}
|
//
// JobOrInterest.swift
// BeeHive
//
// Created by HyperDesign-Gehad on 7/19/18.
// Copyright © 2018 HyperDesign-Gehad. All rights reserved.
//
import Foundation
class JobOrInterest : Codable{
var count : Int?
var id : Int?
var name : String?
var status : Int?
}
|
var age = 34
assert(age<18, "若果你小於18歲就不是大叔了")
|
// swift-tools-version:5.4
import PackageDescription
let package = Package(
name: "OpenSubtitles",
products: [
.library(
name: "OpenSubtitles",
targets: ["OpenSubtitles"])
],
dependencies: [
.package(name: "HTTP"),
.package(name: "RPC"),
.package(name: "Radix"),
.package(name: "FileSystem"),
.package(name: "DCompression"),
.package(name: "Test")
],
targets: [
.target(
name: "OpenSubtitles",
dependencies: [
"HTTP",
"DCompression",
"FileSystem",
.product(name: "XMLRPC", package: "RPC"),
.product(name: "Base64", package: "Radix")],
swiftSettings: [
.unsafeFlags(["-Xfrontend", "-disable-availability-checking"]),
.unsafeFlags(["-Xfrontend", "-enable-experimental-concurrency"])
]),
.executableTarget(
name: "Tests/OpenSubtitles",
dependencies: ["OpenSubtitles", "Test"],
path: "Tests/OpenSubtitles",
swiftSettings: [
.unsafeFlags(["-Xfrontend", "-disable-availability-checking"]),
.unsafeFlags(["-Xfrontend", "-enable-experimental-concurrency"])
]),
]
)
// MARK: - custom package source
#if canImport(ObjectiveC)
import Darwin.C
#else
import Glibc
#endif
extension Package.Dependency {
enum Source: String {
case local, remote, github
static var `default`: Self { .github }
var baseUrl: String {
switch self {
case .local: return "../"
case .remote: return "https://swiftstack.io/"
case .github: return "https://github.com/mahadshahib/"
}
}
func url(for name: String) -> String {
return self == .local
? baseUrl + name.lowercased()
: baseUrl + name.lowercased() + ".git"
}
}
static func package(name: String) -> Package.Dependency {
guard let pointer = getenv("SWIFTSTACK") else {
return .package(name: name, source: .default)
}
guard let source = Source(rawValue: String(cString: pointer)) else {
fatalError("Invalid source. Use local, remote or github")
}
return .package(name: name, source: source)
}
static func package(name: String, source: Source) -> Package.Dependency {
return source == .local
? .package(name: name, path: source.url(for: name))
: .package(name: name, url: source.url(for: name), .branch("dev"))
}
}
|
//
// MergeSort.swift
// Algorithms
//
// Created by Admin on 3/30/17.
// Copyright © 2017 LocTran. All rights reserved.
//
import UIKit
import Foundation
class MergeSort{
var arrayAction: [MergeStep]!
var arrayElement: [MergeStep]!
var eleInitital: [Int]!
init(arrayInput:[Int] ) {
arrayAction = [MergeStep]()
arrayElement = [MergeStep]()
eleInitital = [Int]()
for i in 0..<arrayInput.count{
eleInitital.append(i)
}
mergeSort(array: arrayInput, eleArray: eleInitital, level: 2, isLeft: true)
}
func merge(leftArray: [Int], rightArray: [Int],currentLevel: Int) -> [Int] {
let _stepSplit = getStepSplit()
var _eleArray = [Int]()
var leftIndex = 0
var rightIndex = 0
var sortedArray = [Int]()
// Compare the elements and add them to the sorted array *in order*
// so sanh 2 phan tu trong left and right neu phan tu nao be hon thi xep truoc
self.arrayElement.append(MergeStep(act: "eleMerge", root: leftArray + rightArray, left: leftArray, right: rightArray, level: currentLevel,stepSplit: _stepSplit,relation: nil, merge: nil))
while leftIndex < leftArray.count && rightIndex < rightArray.count {
if leftArray[leftIndex] < rightArray[rightIndex] {
sortedArray.append(leftArray[leftIndex])
leftIndex += 1
} else if leftArray[leftIndex] > rightArray[rightIndex] {
sortedArray.append(rightArray[rightIndex])
rightIndex += 1
} else {
sortedArray.append(leftArray[leftIndex])
leftIndex += 1
sortedArray.append(rightArray[rightIndex])
rightIndex += 1
}
}
// At this point, the elements were compared and sorted properly,
// so we just need to append the rest of the items to the array
// doan code nay la xep lai nhung phan tu du thua
while leftIndex < leftArray.count {
sortedArray.append(leftArray[leftIndex])
_eleArray.append(self.arrayElement[_stepSplit].left[leftIndex])
leftIndex += 1
}
while rightIndex < rightArray.count {
sortedArray.append(rightArray[rightIndex])
_eleArray.append(self.arrayElement[_stepSplit].right[rightIndex])
rightIndex += 1
}
_eleArray = [Int]()
_eleArray = self.sortElement(arr: self.arrayAction[_stepSplit].left + self.arrayAction[_stepSplit].right, _stepSplit: _stepSplit)
self.arrayElement[self.arrayElement.count-1].merge = _eleArray
self.arrayAction.append(MergeStep(act: "Merge", root: leftArray + rightArray, left: leftArray, right: rightArray, level: currentLevel,stepSplit: _stepSplit,relation: nil, merge: sortedArray))
return sortedArray
}
func sortElement(arr: [Int],_stepSplit: Int)->[Int]{
var sortEle = [Int]()
var arrMerge: [Int] = self.arrayElement[_stepSplit].merge
sortEle = arr
for i in (0..<sortEle.count-1){
var minAt = i
for j in (i+1)..<sortEle.count{
if(sortEle[minAt]>sortEle[j]){
minAt = j
}
}
var temp = sortEle[i]
sortEle[i] = sortEle[minAt]
sortEle[minAt] = temp
temp = arrMerge[i]
arrMerge[i] = arrMerge[minAt]
arrMerge[minAt] = temp
}
return arrMerge
}
func getStepSplit()->Int{
var _step: Int!
for ele in (0..<self.arrayAction.count).reversed(){
if(self.arrayAction[ele].act=="Split" && self.arrayAction[ele].relation == false){
self.arrayAction[ele].relation = true
_step = ele
break
}
}
return _step
}
func getElement(eL: Int,eR: Int,eleArray: [Int])->[Int]{
var arr = [Int]()
for ele in eL..<eR{
arr.append(eleArray[ele])
}
return arr
}
func mergeSort(array: [Int],eleArray: [Int],level: Int,isLeft: Bool) -> [Int] {
let currentLevel = level
guard array.count > 1 else {
return array
}
let middleIndex = Int(ceil(Double(array.count)/2))
// Recursively sort the left and right parts of the array
self.arrayAction.append(MergeStep(act: "Split", root: array, left: Array(array[0..<middleIndex]), right: Array(array[middleIndex..<array.count]), level: currentLevel,stepSplit: nil,relation: false, merge: nil))
self.arrayElement.append(MergeStep(act: "eleSplit", root: nil, left: Array(eleArray[0..<middleIndex]), right: Array(eleArray[middleIndex..<array.count]), level: currentLevel,stepSplit: nil,relation: nil, merge: self.getElement(eL: 0, eR: array.count,eleArray: eleArray)))
let leftArray = mergeSort(array: Array(array[0..<middleIndex]),eleArray: Array(eleArray[0..<middleIndex]),level: currentLevel+1,isLeft: true)
let rightArray = mergeSort(array: Array(array[middleIndex..<array.count]),eleArray: Array(eleArray[middleIndex..<array.count]),level:currentLevel+1,isLeft: false)
let sort = merge(leftArray: leftArray, rightArray: rightArray,currentLevel: currentLevel-1)
return sort
}
}
|
//
// TableViewController.swift
// Course2Week3Task2
//
// Copyright © 2018 e-Legion. All rights reserved.
//
import UIKit
class TableViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
@IBOutlet weak var photoTableView: UITableView!
var cells: [Photo] = []
// MARK: - UIViewController
override func viewDidLoad() {
super.viewDidLoad()
let photoProvider = PhotoProvider()
photoProvider.photos().forEach{ cells.append($0) }
photoTableView.register(UINib(nibName: String(describing: PhotoTableViewCell.self), bundle: nil), forCellReuseIdentifier: String(describing: PhotoTableViewCell.self))
photoTableView.delegate = self
photoTableView.dataSource = self
}
override func viewDidLayoutSubviews() {
photoTableView.frame = view.frame
}
// MARK: - UITableViewDataSource
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return cells.count
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let photoCell = tableView.dequeueReusableCell(withIdentifier: String(describing: PhotoTableViewCell.self)) as! PhotoTableViewCell
photoCell.setPhoto(pic: cells[indexPath.row].image, description: cells[indexPath.row].name)
return photoCell
}
// MARK: - UITableViewDelegate
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
return 60.0
}
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
tableView.deselectRow(at: indexPath, animated: true)
print("Row \(indexPath.row) selected")
}
func tableView(_ tableView: UITableView, accessoryButtonTappedForRowWith indexPath: IndexPath) {
print("Accessory at row \(indexPath.row) selected")
}
}
|
//
// ViewController.swift
// MMAds
//
// Created by L.D. Deurman on 08/09/2018.
// Copyright © 2018 deurman. All rights reserved.
//
import UIKit
import GoogleMobileAds
class ViewController: UIViewController, GADAppEventDelegate, GADBannerViewDelegate {
override func viewDidLoad() {
super.viewDidLoad()
let themeColor = "#B40808";
UITabBar.appearance().tintColor = UIColor(hexString: themeColor);
UINavigationBar.appearance().barTintColor = UIColor(hexString: themeColor)
UINavigationBar.appearance().tintColor = UIColor.white // for titles, buttons, etc.
let navigationTitleFont = UIFont(name: "Avenir", size: 20)!
UINavigationBar.appearance().titleTextAttributes = [NSAttributedStringKey.font: navigationTitleFont, NSAttributedStringKey.foregroundColor: UIColor.white]
UIToolbar.appearance().backgroundColor = UIColor(hexString: themeColor);
UIToolbar.appearance().tintColor = UIColor.white;
UIToolbar.appearance().barTintColor = UIColor(hexString: themeColor);
//bannerView.loadAd(dfpRequest: DFPRequest());
}
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
if let destination = segue.destination as? DemoBannerViewController {
if let identifier = segue.identifier {
switch (identifier){
case "carouselAd":
print("carouselAd");
destination.adUnitId = "/35445201/dmsads_native_carousel_ad";
break;
case "splitAd":
print("splitAd");
destination.adUnitId = "/35445201/dmsads_native_video_ad";
break;
default:
destination.adUnitId = "/35445201/dmads_banner_demo";
break;
}
}
}
}
func getDemoDictionary() -> NSDictionary {
let dictionary:NSDictionary = [
"url": "https://www.funda.nl",
"image_src": "https://images.tedbakerimages.com/us%2Fc%2FPIK-Crew-neck-cotton-T-shirt--Navy%2FTS7M_PIK_NAVY_2.jpg.jpg?o=a18iizmF@eIJ3PRrH2OW6jlyncUj&V=OZ60&w=564%26h=705%26q=85",
"content_mode": 2,
"title": "Ted Baker",
"sub_title": "MALTTEA TEXTURED CREW NECK - Trui",
"price": [
"price_from": "£65.50",
"price_to": "£32.50"
],
"bottom_image": [
"width": 50,
"height": 50,
"image_src": "https://www.incsmart.biz/assets/images/discountart.png"
],
"brand_image": [
"width": 65,
"height": 35,
"image_src": "https://cdn.shopify.com/s/files/1/1567/7015/collections/TED_BAKER_1_1024x1024.png?v=1491319979"
]
]
return dictionary;
}
override func viewWillLayoutSubviews() {
super.viewWillLayoutSubviews();
}
override func viewWillAppear(_ animated: Bool) {
self.navigationController?.setNavigationBarHidden(true, animated: true);
}
override func viewWillDisappear(_ animated: Bool) {
self.navigationController?.setNavigationBarHidden(false, animated: true);
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated);
//let vc = DemoArticleController();
//present(vc, animated: true, completion: nil);
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
|
//
// IndexingCommandsTests.swift
//
//
// Created by Vladislav Fitc on 26/03/2020.
//
import Foundation
import XCTest
@testable import AlgoliaSearchClient
class IndexingCommandsTests: XCTestCase, AlgoliaCommandTest {
func testSaveObject() {
let command = Command.Indexing.SaveObject(indexName: test.indexName, record: test.record, requestOptions: test.requestOptions)
check(command: command,
callType: .write,
method: .post,
urlPath: "/1/indexes/testIndex",
queryItems: [.init(name: "testParameter", value: "testParameterValue")],
body: test.record.httpBody,
requestOptions: test.requestOptions)
}
func testGetObject() {
let command = Command.Indexing.GetObject(indexName: test.indexName, objectID: test.objectID, attributesToRetrieve: test.attributes, requestOptions: test.requestOptions)
check(command: command,
callType: .read,
method: .get,
urlPath: "/1/indexes/testIndex/testObjectID",
queryItems: [.init(name: "testParameter", value: "testParameterValue"), .init(name: "attributesToRetreive", value: "attr1,attr2")],
body: nil,
requestOptions: test.requestOptions)
}
func testReplaceObject() {
let command = Command.Indexing.ReplaceObject(indexName: test.indexName, objectID: test.objectID, replacementObject: test.record, requestOptions: test.requestOptions)
check(command: command,
callType: .write,
method: .put,
urlPath: "/1/indexes/testIndex/testObjectID",
queryItems: [.init(name: "testParameter", value: "testParameterValue")],
body: test.record.httpBody,
requestOptions: test.requestOptions)
}
func testBatch() {
let command = Command.Index.Batch(indexName: test.indexName, batchOperations: test.batchOperations, requestOptions: test.requestOptions)
let body = RequestsWrapper(test.batchOperations).httpBody
check(command: command,
callType: .write,
method: .post,
urlPath: "/1/indexes/testIndex/batch",
queryItems: [.init(name: "testParameter", value: "testParameterValue")],
body: body,
requestOptions: test.requestOptions)
}
func testDelete() {
let command = Command.Index.DeleteIndex(indexName: test.indexName, requestOptions: test.requestOptions)
check(command: command,
callType: .write,
method: .delete,
urlPath: "/1/indexes/testIndex",
queryItems: [.init(name: "testParameter", value: "testParameterValue")],
body: nil,
requestOptions: test.requestOptions)
}
}
|
//
// Copyright © 2020 Tasuku Tozawa. All rights reserved.
//
import UIKit
public protocol ListSectionHeaderDelegate: AnyObject {
func didTapAdd(_ header: ListSectionHeader)
}
public class ListSectionHeader: UICollectionReusableView {
public static var nib: UINib {
return UINib(nibName: "ListSectionHeader", bundle: Bundle(for: Self.self))
}
public var identifier: String?
public var title: String? {
get {
self.titleLabel.text
}
set {
self.titleLabel.text = newValue
}
}
public var visibleAddButton: Bool {
get {
!self.addButtonContainer.isHidden
}
set {
self.addButtonContainer.isHidden = !newValue
}
}
public weak var delegate: ListSectionHeaderDelegate?
@IBOutlet var titleLabel: UILabel!
@IBOutlet var addButtonContainer: UIView!
@IBOutlet var separator: UIView!
// MARK: - IBAction
@IBAction func didTapAdd(_ sender: UIButton) {
self.delegate?.didTapAdd(self)
}
// MARK: - Methods
override public func awakeFromNib() {
super.awakeFromNib()
self.setupAppearance()
}
private func setupAppearance() {
self.separator.backgroundColor = .separator
self.visibleAddButton = false
}
}
|
//
// Heartbeat.swift
// Buildasaur
//
// Created by Honza Dvorsky on 17/09/2015.
// Copyright © 2015 Honza Dvorsky. All rights reserved.
//
import Foundation
import ekgclient
import BuildaUtils
public protocol HeartbeatManagerDelegate {
func numberOfRunningSyncers() -> Int
}
//READ: https://github.com/czechboy0/Buildasaur/tree/master#heartpulse-heartbeat
@objc public class HeartbeatManager: NSObject {
public var delegate: HeartbeatManagerDelegate?
private let client: EkgClient
private let creationTime: Double
private var timer: NSTimer?
private let interval: Double = 24 * 60 * 60 //send heartbeat once in 24 hours
public init(server: String) {
let bundle = NSBundle.mainBundle()
let appIdentifier = EkgClientHelper.pullAppIdentifierFromBundle(bundle) ?? "Unknown app"
let version = EkgClientHelper.pullVersionFromBundle(bundle) ?? "?"
let buildNumber = EkgClientHelper.pullBuildNumberFromBundle(bundle) ?? "?"
let appInfo = AppInfo(appIdentifier: appIdentifier, version: version, build: buildNumber)
let host = NSURL(string: server)!
let serverInfo = ServerInfo(host: host)
let userDefaults = NSUserDefaults.standardUserDefaults()
self.creationTime = NSDate().timeIntervalSince1970
let client = EkgClient(userDefaults: userDefaults, appInfo: appInfo, serverInfo: serverInfo)
self.client = client
}
deinit {
self.stop()
}
public func start() {
self.sendLaunchedEvent()
self.startSendingHeartbeat()
}
public func stop() {
self.stopSendingHeartbeat()
}
private func sendEvent(event: Event) {
var sendReal = true
#if DEBUG
sendReal = false
#endif
guard sendReal else {
Log.info("Not sending events in debug environment")
return
}
Log.info("Sending heartbeat event \(event.jsonify())")
self.client.sendEvent(event) {
if let error = $0 {
Log.error("Failed to send a heartbeat event. Error \(error)")
}
}
}
private func sendLaunchedEvent() {
self.sendEvent(LaunchEvent())
}
private func sendHeartbeatEvent() {
let uptime = NSDate().timeIntervalSince1970 - self.creationTime
let numberOfRunningSyncers = self.delegate?.numberOfRunningSyncers() ?? 0
self.sendEvent(HeartbeatEvent(uptime: uptime, numberOfRunningSyncers: numberOfRunningSyncers))
}
func _timerFired(timer: NSTimer?=nil) {
self.sendHeartbeatEvent()
}
private func startSendingHeartbeat() {
//send once now
self._timerFired()
self.timer?.invalidate()
self.timer = NSTimer.scheduledTimerWithTimeInterval(
self.interval,
target: self,
selector: "_timerFired:",
userInfo: nil,
repeats: true)
}
private func stopSendingHeartbeat() {
timer?.invalidate()
}
}
|
import Foundation
import SmartyStreets
class USAutocompleteProExample {
func run() -> String {
// The appropriate license values to be used for your subscriptions
// can be found on the Subscriptions page of the account dashboard.
// https://www.smartystreets.com/docs/cloud/licensing
// We recommend storing your authentication credentials in environment variables.
// for server-to-server requests, use this code:
//let authId = getEnvironmentVar("SMARTY_AUTH_ID") ?? ""
//let authToken = getEnvironmentVar("SMARTY_AUTH_TOKEN") ?? ""
//let client = ClientBuilder(authId:authId, authToken:authToken).withLicenses(licenses:["us-autocomplete-pro-cloud"]).buildUSAutocompleteProApiClient()
// for client-side requests (browser/mobile), use this code:
let id = getEnvironmentVar("SMARTY_AUTH_WEB") ?? ""
let hostname = getEnvironmentVar("SMARTY_AUTH_REFERER") ?? ""
let client = ClientBuilder(id: id, hostname: hostname).withLicenses(licenses:["us-autocomplete-pro-cloud"]).buildUSAutocompleteProApiClient()
// Documentation for input fields can be found at:
// https://smartystreets.com/docs/cloud/us-autocomplete-api#pro-http-request-input-fields
var lookup = USAutocompleteProLookup().withSearch(search: "1042 W Center")
var error:NSError! = nil
_ = client.sendLookup(lookup: &lookup, error: &error)
if let error = error {
let output = """
Domain: \(error.domain)
Error Code: \(error.code)
Description:\n\(error.userInfo[NSLocalizedDescriptionKey] as! NSString)
"""
return output
}
var output = "Result:\n"
if let result = lookup.result, let suggestions = result.suggestions {
for suggestion in suggestions {
output.append("\(buildAddress(suggestion: suggestion))\n")
}
}
output.append("\nResult with filters:\n")
////////////////////// Can be sent with or without the following fields //////////////////////
lookup.addCityFilter(city: "Denver")
lookup.addCityFilter(city: "Orem")
lookup.addStateFilter(state: "UT")
lookup.addStateFilter(state: "CO")
lookup.addPreferCity(city: "Orem")
lookup.addPreferState(state: "UT")
lookup.maxResults = 5
lookup.preferGeolocation = GeolocateType(name: "none")
lookup.preferRatio = 33
lookup.selected = "1042 W Center St Apt A (24) Orem UT 84057"
lookup.source = "all"
///////////////////////////////////////////////////////////////////////////////////////////////
_ = client.sendLookup(lookup: &lookup, error: &error)
if let error = error {
let output = """
Domain: \(error.domain)
Error Code: \(error.code)
Description:\n\(error.userInfo[NSLocalizedDescriptionKey] as! NSString)
"""
return output
}
if let result = lookup.result, let suggestions = result.suggestions {
for suggestion in suggestions {
output.append("\(buildAddress(suggestion: suggestion))\n")
}
}
return output
}
func buildAddress(suggestion: USAutocompleteProSuggestion) -> String {
var whiteSpace = ""
if let entries = suggestion.entries {
if entries > 1 {
whiteSpace.append(" (\(entries) entries)")
}
}
return "\(suggestion.streetLine ?? "") \(suggestion.secondary ?? "") \(whiteSpace) \(suggestion.city ?? ""), \(suggestion.state ?? "") \(suggestion.zipcode ?? "")"
}
}
|
//
// HopperAPIUpdateHopperRequest.swift
// Cryptohopper-iOS-SDK
//
// Created by Kaan Baris Bayrak on 26/10/2020.
//
import Foundation
import UIKit
class HopperAPIUpdateHopperRequest: HopperAPIRequest<HopperCommonMessageResponse> {
convenience init(hopperId : String ,name : String?, enabled : Int?, apiConfig : HopperConfigAPIConfig? ) {
self.init()
self.changeUrlPath(path: "/v1" + "/hopper/\(hopperId)")
if(name != nil){
addBodyItem(name: "name", value: name!)
}
if(enabled != nil){
addBodyItem(name: "enabled", value: enabled!)
}
if(apiConfig != nil){
addBodyItem(name: "api_config", value: apiConfig!)
}
}
override var httpMethod: HopperAPIHttpMethod {
return .PATCH
}
override var needsAuthentication: Bool {
return true
}
}
|
//
// CanTargetPlayer.swift
// Session1
//
// Created by Developer on 11/19/16.
// Copyright © 2016 Developer. All rights reserved.
//
import SpriteKit
import Foundation
protocol CanTargetPlayer {
var isTargetingPlayer: Bool { get set }
}
|
//
// Int.swift
// Vmee
//
// Created by Micha Volin on 2017-02-23.
// Copyright © 2017 Vmee. All rights reserved.
//
extension Int {
static postfix func ++ (value: inout Int) {
value += 1
}
static prefix func ++ (value: inout Int) {
value += 1
}
}
|
//
// Book.swift
// HackerBooksEV
//
// Created by usuario on 2/3/17.
// Copyright © 2017 evizcloud. All rights reserved.
//
import Foundation
class Book {
//MARK: - Aliases
typealias tagType = [Tag]
//MARK: - StoredProperties
let title : String
let authors : [String]
var tags : tagType
let imageUrl : AsyncData
let pdfUrl : AsyncData
weak var delegate : BookDelegate?
//MARK: - Initialization
init(title: String,
authors: [String],
tags: tagType,
image_url: AsyncData,
pdf_url: AsyncData)
{
self.title = title
self.authors = authors
self.tags = tags
self.imageUrl = image_url
self.pdfUrl = pdf_url
// Set delegate
self.imageUrl.delegate = self
self.pdfUrl.delegate = self
}
//MARK: - Proxies
func proxieForEquality() -> String {
return "\(title)"
}
func proxyForComparison() -> String {
return proxieForEquality()
}
}
//MARK: - Favorites
extension Book{
private func hasFavoriteTag() -> Bool{
let tagFav = Tag(name: "Favorite")
return tags.contains(tagFav)
}
private func addFavoriteTag(){
let tagFav = Tag(name: "Favorite")
tags.append(tagFav)
}
private func removeFavoriteTag() {
let tagFav = Tag(name: "Favorite")
tags.remove(at: tags.index(of: tagFav)!)
}
var isFavorite : Bool{
get{
return hasFavoriteTag()
}
set{
if newValue == true{
addFavoriteTag()
sendNotification(name: BookDidChange)
}else{
removeFavoriteTag()
sendNotification(name: BookDidChange)
}
}
}
}
//MARK: - Protocols
extension Book: Equatable {
public static func ==(lhs: Book, rhs: Book) -> Bool {
return (lhs.proxieForEquality() == rhs.proxieForEquality())
}
}
extension Book : Comparable {
public static func <(lhs: Book,
rhs: Book) -> Bool {
return (lhs.proxyForComparison() < rhs.proxyForComparison())
}
}
//MARK: - Communication - delegate
protocol BookDelegate: class{
func bookDidChange(sender:Book)
func bookCoverImageDidDownload(sender: Book)
func bookPDFDidDownload(sender: Book)
}
// Default implementation of delegate methods
extension BookDelegate{
func bookDidChange(sender:Book){}
func bookCoverImageDidDownload(sender: Book){}
func bookPDFDidDownload(sender: Book){}
}
let BookDidChange = Notification.Name(rawValue: "io.keepCoding.BookDidChange")
let BookKey = "io.keepCoding.BookDidChange.BookKey"
let BookCoverImageDidDownload = Notification.Name(rawValue: "io.keepCoding.BookCoverImageDidDownload")
let BookPDFDidDownload = Notification.Name(rawValue: "io.keepCoding.BookPDFDidDownload")
extension Book{
func sendNotification(name: Notification.Name){
let n = Notification(name: name, object: self, userInfo: [BookKey:self])
let nc = NotificationCenter.default
nc.post(n)
}
}
//MARK: - AsyncDataDelegate
extension Book: AsyncDataDelegate{
func asyncData(_ sender: AsyncData, didEndLoadingFrom url: URL) {
let notificationName : Notification.Name
switch sender {
case imageUrl:
notificationName = BookCoverImageDidDownload
delegate?.bookCoverImageDidDownload(sender: self)
case pdfUrl:
notificationName = BookPDFDidDownload
delegate?.bookPDFDidDownload(sender: self)
default:
fatalError("Should never get here")
}
sendNotification(name: notificationName)
}
func asyncData(_ sender: AsyncData, shouldStartLoadingFrom url: URL) -> Bool {
return true
}
func asyncData(_ sender: AsyncData, willStartLoadingFrom url: URL) {
print("Starting with \(url)")
}
func asyncData(_ sender: AsyncData, didFailLoadingFrom url: URL, error: NSError){
print("Error loading \(url).\n \(error)")
}
}
|
//
// InformationVM.swift
// CryptocurrencyNews
//
// Created by Kristijan Delivuk on 23/10/2017.
// Copyright © 2017 Kristijan Delivuk. All rights reserved.
//
import RxSwift
import Defines
enum InformationVMState {
case loading
case finished
case error
}
final class InformationVM: InformationVMProtocol {
let disposeBag: DisposeBag
let _state: Variable<InformationVMState>
lazy var stateObservable: Observable<InformationVMState> = self._state.asObservable().throttle(0.5, scheduler: MainScheduler.instance)
private var currency: Cryptocurrency
private let cryptocurrencyManager: CryptocurrencyManagerProtocol
private var concurrencyInformation: [ConcurrencyInformation]
var title: String {
return currency.name
}
var numberOfItems: Int {
return concurrencyInformation.count
}
init(currency: Cryptocurrency, cryptocurrencyManager: CryptocurrencyManagerProtocol) {
self.disposeBag = DisposeBag()
self.currency = currency
self._state = Variable(InformationVMState.finished)
self.cryptocurrencyManager = cryptocurrencyManager
self.concurrencyInformation = [.rank, .name, .symbol, .priceInFiat(cryptocurrencyManager.fiatCurrency), .priceInBitcoin, .changeIn1h, .changeIn24h, .changeIn7d, .availableSupply, .totalSupply]
self.cryptocurrencyManager
.fiatCurrencyObservable
.subscribe(onNext: { [weak self] currency in
guard let weakself = self else { return }
weakself.refresh()
}).disposed(by: disposeBag)
}
func title(for indexPath: IndexPath) -> String {
return concurrencyInformation[indexPath.row].title()
}
func value(for indexPath: IndexPath) -> String {
return concurrencyInformation[indexPath.row].value(for: currency)
}
func refresh() {
_state.value = .loading
cryptocurrencyManager
.currency(for: currency.id)
.subscribe({ (currency) in
switch currency {
case .next(let currency):
self.concurrencyInformation = [.rank, .name, .symbol, .priceInFiat(self.cryptocurrencyManager.fiatCurrency), .priceInBitcoin, .changeIn1h, .changeIn24h, .changeIn1h, .availableSupply, .totalSupply]
self.currency = currency
case .error(_):
self._state.value = .error
case .completed:
self._state.value = .finished
}
}).disposed(by: disposeBag)
}
deinit {
print("\(self) DEINIT")
}
}
extension ConcurrencyInformation {
func title() -> String {
switch self {
case .rank:
return NSLocalizedString("Rank", comment: "ConcurrencyInformation.rank")
case .name:
return NSLocalizedString("Name", comment: "ConcurrencyInformation.name")
case .symbol:
return NSLocalizedString("Symbol", comment: "ConcurrencyInformation.symbol")
case .priceInFiat(let fiatCurrency):
return NSLocalizedString("Price in \(fiatCurrency.title())", comment: "ConcurrencyInformation.symbol")
case .priceInBitcoin:
return NSLocalizedString("Price in Bitcoin", comment: "ConcurrencyInformation.priceInBitcion")
case .changeIn1h:
return NSLocalizedString("Change in 1 hour", comment: "ConcurrencyInformation.changeIn1h")
case .changeIn7d:
return NSLocalizedString("Change in 7 days", comment: "ConcurrencyInformation.changeIn7d")
case .changeIn24h:
return NSLocalizedString("Change in 24 hours", comment: "ConcurrencyInformation.changeIn24h")
case .availableSupply:
return NSLocalizedString("Available supply", comment: "ConcurrencyInformation.availableSupply")
case .totalSupply:
return NSLocalizedString("Total supply", comment: "ConcurrencyInformation.totalSupply")
}
}
}
extension ConcurrencyInformation {
func value(for currency: Cryptocurrency) -> String {
switch self {
case .rank:
return currency.rank
case .name:
return currency.name
case .symbol:
return currency.symbol
case .priceInFiat:
return currency.priceInFiat
case .priceInBitcoin:
return currency.priceInBtc
case .changeIn1h:
return "\(currency.changeIn1h*100)%"
case .changeIn7d:
return "\(currency.changeIn7d*100)%"
case .changeIn24h:
return "\(currency.changeIn24h*100)%"
case .availableSupply:
return currency.availableSupply
case .totalSupply:
return currency.totalSupply
}
}
}
|
//
// ForgotPasswordViewController.swift
// Fearless
//
// Created by Water Flower on 2019/4/23.
// Copyright © 2019 Water Flower. All rights reserved.
//
import UIKit
class ForgotPasswordViewController: UIViewController, UITextFieldDelegate {
@IBOutlet weak var scrollview: UIScrollView!
@IBOutlet weak var emailTextField: UITextField!
@IBOutlet weak var passwordTextField: UITextField!
@IBOutlet weak var confirmTextField: UITextField!
/////// for activity indicator //////////
var activityIndicator: UIActivityIndicatorView = UIActivityIndicatorView();
var overlayView:UIView = UIView();
override func viewDidLoad() {
super.viewDidLoad()
self.navigationItem.title = "Forgot Password"
NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name:UIResponder.keyboardWillShowNotification, object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name:UIResponder.keyboardWillHideNotification, object: nil)
//// dismiss keyboard ///////
let tap: UITapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(self.dismissKeyboard))
view.addGestureRecognizer(tap)
tap.cancelsTouchesInView = false
}
@objc func dismissKeyboard() {
view.endEditing(true)
}
@objc func keyboardWillShow(notification:NSNotification){
var userInfo = notification.userInfo!
var keyboardFrame:CGRect = (userInfo[UIResponder.keyboardFrameBeginUserInfoKey] as! NSValue).cgRectValue
keyboardFrame = self.view.convert(keyboardFrame, from: nil)
var contentInset:UIEdgeInsets = self.scrollview.contentInset
contentInset.bottom = keyboardFrame.size.height
scrollview.contentInset = contentInset
}
@objc func keyboardWillHide(notification:NSNotification){
let contentInset:UIEdgeInsets = UIEdgeInsets.zero
scrollview.contentInset = contentInset
}
func textFieldShouldReturn(_ textField: UITextField) -> Bool {
textField.resignFirstResponder()
return true
}
@IBAction func changeButtonAction(_ sender: Any) {
self.createAlert(title: "Success!", message: "Password has been changed.", type: true)
let email = self.emailTextField.text!
let password = self.passwordTextField.text!
let confirm = self.confirmTextField.text!
if email == "" {
createAlert(title: "Warning!", message: "Please input Email.", type: false)
return
}
if !isValidEmail(email_str: email) {
createAlert(title: "Warning!", message: "Please input valid email address.", type: false)
return
}
if password == "" {
createAlert(title: "Warning!", message: "Please input Password.", type: false)
return
}
if password != confirm {
createAlert(title: "Warning!", message: "Password doesn't match.", type: false)
return
}
startActivityIndicator();
var apiString = Global.base_url + "changePwd.php"
apiString += "?email=" + email + "&pass=" + password
apiString = apiString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
var api_url = URLRequest(url: URL(string: apiString)!)
api_url.httpMethod = "GET"
var succ_bool: Bool = false
let task_forgotpassword = URLSession.shared.dataTask(with: api_url) {
(data, response, error) in
if error == nil {
let jsonData = try? JSONSerialization.jsonObject(with: data!, options: .mutableContainers);
if let responseDic = jsonData as? Dictionary<String, AnyObject> {
if let result_status = responseDic["status"] as? String {
if result_status == "success" {
succ_bool = true
}
}
}
}
DispatchQueue.main.async {
self.stopActivityIndicator()
if succ_bool {
self.createAlert(title: "Success!", message: "Password has been changed.", type: true)
} else {
self.createAlert(title: "Warning!", message: "Error occured. Please try again.", type: false)
}
}
}
task_forgotpassword.resume();
}
func isValidEmail(email_str: String) -> Bool {
let regExp = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
let emailTest = NSPredicate(format: "SELF MATCHES %@", regExp)
return emailTest.evaluate(with: email_str)
}
func createAlert(title: String, message: String, type: Bool) {
let alert = UIAlertController(title: title, message:message, preferredStyle: UIAlertController.Style.alert)
alert.addAction(UIAlertAction(title: "OK", style: UIAlertAction.Style.default, handler: {(action) in alert.dismiss(animated: true, completion: nil)
if type {
var mainStoryboard = UIStoryboard()
if UIDevice.current.userInterfaceIdiom == .pad {
mainStoryboard = UIStoryboard(name: "MainiPad", bundle: nil)
} else {
mainStoryboard = UIStoryboard(name: "Main", bundle: nil)
}
let signinVC = mainStoryboard.instantiateViewController(withIdentifier: "SignInViewController") as! SignInViewController
self.navigationController?.pushViewController(signinVC, animated: true)
}
}))
self.present(alert, animated: true, completion: nil)
}
func startActivityIndicator() {
activityIndicator.center = self.view.center;
activityIndicator.hidesWhenStopped = true;
activityIndicator.style = UIActivityIndicatorView.Style.whiteLarge;
view.addSubview(activityIndicator);
activityIndicator.startAnimating();
overlayView = UIView(frame:view.frame);
view.addSubview(overlayView);
UIApplication.shared.beginIgnoringInteractionEvents();
}
func stopActivityIndicator() {
self.activityIndicator.stopAnimating();
self.overlayView.removeFromSuperview();
if UIApplication.shared.isIgnoringInteractionEvents {
UIApplication.shared.endIgnoringInteractionEvents();
}
}
}
|
// Add your code below 📝
// if you are not going to use the iterator inside the loop you can use a _ instead
/*
for _ in 1...10 {
print("I will not write smelly code.")
}
*/
for _ in 1...15 {
print("Buy eggs from the market")
} |
//
// getcards.swift
// newblackjack
//
// Created by Kohei Nakai on 2017/03/06.
// Copyright © 2017年 NakaiKohei. All rights reserved.
//
import UIKit
enum gameState {
case end,waiting,start,ready,p1turn,p2turn,judge,br
}
enum gameMode {
case com,pvp,netp1,netp2,scom,spvp,snetp1,snetp2
}
class Game{ //カードや得点の管理、勝敗判定などを行うクラス
//クラスプロパティ（クラス自身が保持する値）
static var pcards:[Card] = [] //手札(各カードは1から52の通し番号)
static var ccards:[Card] = []
static var deckCards:[Card] = [] //(山札,得点)
static var state:gameState = .end //end,waiting（1人が待っている状態）,start(配り終えた情報を送信するまで),ready(配り終えた情報を相手が受信するまで),p1turn,p2turn,judge,endと推移
static var mode:gameMode = .com //com,pvp,netp1,netp2,scom(shadowjackモード),spvp,snetp1,snetp2
static var pBP = 0
static var cBP = 0
static var pPoint = 0
static var cPoint = 0
static var cardSum = 0 //カードの合計枚数
static var maxCardVariety = 0 //カードの種類
static var firstDealed = false
static var adjustPoints:(pp:Int, cp:Int) = (0, 0)
@discardableResult //結果を使わなくてもいいよ
func setCards() -> (pcards:[Card], ccards:[Card], pp:String, cp:String){
Game.cardSum = 0
if Game.mode == .com || Game.mode == .pvp || Game.mode == .netp1 || Game.mode == .netp2{
Game.maxCardVariety = 52
}else{
Game.maxCardVariety = 60
}
for i in 1...Game.maxCardVariety{
if i==53 || i==56{//サタンとゼウスは禁止カード
continue
}
if i<53{
Game.deckCards.append(Trump(cardNum: i)!)
Game.cardSum += 1
}else{//特殊カード
for _ in 1...4{
Game.deckCards.append(SpecialCard(cardNum: i)!)
Game.cardSum += 1
}
}
}
//ゴッドフェス
if Game.mode == .scom{
for _ in 1...30{
// Game.deckCards.append(SpecialCard(cardNum: 60)!)//ダリス
// Game.cardSum += 1
// Game.deckCards.append(SpecialCard(cardNum: 55)!)//バハ
// Game.cardSum += 1
// Game.deckCards.append(SpecialCard(cardNum: 58)!)//ルシフェル
// Game.cardSum += 1
}
}
//Fisher–Yatesシャッフルアルゴルズム
for i in 0...Game.cardSum-1{
let j = Int(arc4random_uniform(UInt32(Game.cardSum-1)))%Game.cardSum //上限をつけないとiPhone5では動かない。。。
let t = Game.deckCards[i]
Game.deckCards[i] = Game.deckCards[j]
Game.deckCards[j] = t
}
//カードを配る
self.pHit()
self.pHit()
self.cHit()
self.cRecversedHit()
let (pp,cp) = getpoints()
return (Game.pcards, Game.ccards, pp!, cp!)
}
func getpoints() ->(pp:String?,cp:String?){
let (ppoint,cpoint,_,_) = calculatepoints()
//ppoint,cpointはそれぞれ(noA:Int,inA:Int)、pAとcAはAを持っているか(Bool)
//得点をcp,ppにまとめた後、ラベルに表示（ラベルはオプショナルだから足し算できない）
var cp,pp:String
cp=String(cpoint.noA)
if cpoint.noA>21{
cp+=" Bust!!"
}
pp=String(ppoint.noA)
if ppoint.noA>21{
pp+=" Bust!!"
}
return (pp,cp)
}//ラベル用のポイントを返す
@discardableResult
func pHit() -> (pcards:[Card],pp:String){//pcardsにcards[0]を配る
Game.pcards.append(Game.deckCards[0])
Game.deckCards.removeFirst()
//描写予約及びファンファーレ、場のエフェクト
if Game.pcards.last! is Trump{//トランプ
GameScene.makePaintResevation(sound: .card, x: GameScene.cwidth/2+GameScene.cwidth*CGFloat(Game.pcards.count-1), y: GameScene.cheight/2, card: Game.pcards.last!)
}else if let SC = Game.pcards.last! as? SpecialCard{//引いたのが特殊カード
SC.fanfare(cardPlace: .p1, index: Game.pcards.count-1)
}
for j in Game.pcards{//場にある分の効果を確認
guard j !== Game.pcards.last! else{//最後に引いたものは除く
break
}
if let SC2 = j as? SpecialCard{
SC2.drawEffect(drawPlayer: .p1)
}
}
for j in Game.ccards{//場にある分の効果を確認
if let SC2 = j as? SpecialCard{
SC2.drawEffect(drawPlayer: .p1)
}
}
let (pp,_)=getpoints()
return (Game.pcards, pp!)
}
@discardableResult
func cHit() -> (ccards:[Card],cp:String){
Game.ccards.append(Game.deckCards[0])
Game.deckCards.removeFirst()
if Game.ccards.last! is Trump{
GameScene.makePaintResevation(sound: .card, x: GameScene.cwidth/2+GameScene.cwidth*CGFloat(Game.ccards.count-1), y: GameScene.frameHeight-GameScene.cheight/2, card: Game.ccards.last!)
}else if let SC = Game.ccards.last! as? SpecialCard{
SC.fanfare(cardPlace: .com, index: Game.ccards.count-1)
}
for j in Game.pcards{//場にある分の効果を確認
if let SC2 = j as? SpecialCard{
SC2.drawEffect(drawPlayer: .com)
}
}
for j in Game.ccards{//場にある分の効果を確認
guard j !== Game.ccards.last! else{//最後に引いたものは除く
break
}
if let SC2 = j as? SpecialCard{
SC2.drawEffect(drawPlayer: .com)
}
}
let (_,cp)=getpoints()
return (Game.ccards, cp!)
}
func cRecversedHit(){
Game.ccards.append(Game.deckCards[0])
Game.deckCards.removeFirst()
GameScene.makePaintResevation(sound: .card, x: GameScene.cwidth/2+GameScene.cwidth, y: GameScene.frameHeight-GameScene.cheight/2, card: GameScene.backCard)
Game.ccards.last!.isReversed = true
}
func judge(_ i:Int) -> Int{
//iを0で受けるとBJの判定を行い、他で受けると行わない
// 0:同数
// 1:pが多い
// 2:cが多い
// 3:pが勝ち
// 4:cが勝ち
// 5:引き分け
let (ppoint,cpoint,pA,cA) = calculatepoints()
//BJの判定
if i==0{
if ppoint.noA==21 && pA==true && cpoint.noA==21 && cA==true{
return 5
}else if ppoint.noA==21 && pA==true{
return 3
}else if cpoint.noA==21 && cA==true{
return 4
}
}
//バスト判定
if ppoint.noA > 21{
return 4
}
if cpoint.noA > 21{
return 3
}
//得点判定
if ppoint.inA<22 && pA==true{
if cpoint.inA<22 && cA==true{
if ppoint.inA>cpoint.inA {
return 1
}else if ppoint.inA<cpoint.inA{
return 2
}else{
return 0
}
}else{
if ppoint.inA>cpoint.noA {
return 1
}else if ppoint.inA<cpoint.noA{
return 2
}else{
return 0
}
}
}else{
if cpoint.inA<22 && cA==true{
if ppoint.noA>cpoint.inA {
return 1
}else if ppoint.noA<cpoint.inA{
return 2
}else{
return 0
}
}else{
if ppoint.noA>cpoint.noA {
return 1
}else if ppoint.noA<cpoint.noA{
return 2
}else{
return 0
}
}
}
}
func calculatepoints() -> (pp:(noA:Int,inA:Int),cp:(noA:Int,inA:Int),pA:Bool,cA:Bool){
//初期化
var ppoint=(noA:0,inA:10)
var cpoint=(noA:0,inA:10)//inAは、もし今のポイントに、更に１０点加えたら...の値
for i in Game.pcards{
ppoint.inA+=i.point
ppoint.noA+=i.point
}
for i in Game.ccards{
cpoint.inA+=i.point
cpoint.noA+=i.point
}
ppoint.inA += Game.adjustPoints.pp
ppoint.noA += Game.adjustPoints.pp
cpoint.inA += Game.adjustPoints.cp
cpoint.noA += Game.adjustPoints.cp
if ppoint.inA < 0{
ppoint.inA = 0
}
if ppoint.noA < 0{
ppoint.noA = 0
}
if cpoint.inA < 0{
cpoint.inA = 0
}
if cpoint.noA < 0{
cpoint.noA = 0
}
//Aを持っているかの判定
var pA = false, cA = false
for i in Game.pcards{
if i.cardNum % 13 == 1 && i.cardNum < 53{
pA = true
}
}
for i in Game.ccards{
if i.cardNum % 13 == 1 && i.cardNum < 53{
cA = true
}
}
return (ppoint,cpoint,pA,cA)
}
}
|
//
// MorseCodeConverter.swift
// Morse Chat
//
// Created by Daniel Zhang on 5/01/2016.
// Copyright © 2016 Daniel Zhang. All rights reserved.
//
import Foundation
class MorseCodeConverter {
init () {
initConversionTable()
createMorseCodeToStringDict()
}
var stringToMorseCodeDict = [String:String]()
var morseCodeToStringDict = [String:String]()
func convertStringToMorseCode(string: String?) -> [String] {
var convertedMorseCodeArray = [String]()
let inputString = string!.lowercaseString
//there may be a better way to implement this algorithm...
for i in 0..<inputString.characters.count {
// Get Each Character From inputString One at a time
let substring = inputString[inputString.startIndex.advancedBy(i) ..< inputString.startIndex.advancedBy(i+1)]
// Get the corresponding Morse code for each alphanumeric character
let morseCodeCharacterString = stringToMorseCodeDict[substring]!
// Add each individual morse code character into an array. One morseCodeCharacter per array element.
for character in morseCodeCharacterString.characters {
convertedMorseCodeArray.append(String(character))
}
// Add a space between every "character" in inputString. This means that there is actually FIVE spaces between two words.
if (i < (inputString.characters.count - 1)) {
convertedMorseCodeArray.append(",")
}
}
let convertedString = convertedMorseCodeArray.reduce("") { $0 + $1 }
print(convertedString)
return convertedMorseCodeArray
}
func convertMorseCodeToString(morseCodeArray: [String]) -> String {
let morseCodeString = morseCodeArray.reduce("") { $0 + ($1) }
let separatedArray = morseCodeString.componentsSeparatedByString(",")
var convertedArray = [String]()
for aMorseChar in separatedArray {
if let character = morseCodeToStringDict[aMorseChar] {
convertedArray.append(character)
} else {
convertedArray.append("?")
}
}
let convertedString = convertedArray.joinWithSeparator("")
print(convertedString)
return convertedString
}
lazy var vibrationPlayer = VibrationPlayer()
func playMorseCodeVibration(input:AnyObject) {
var morseCodeArray = [String]()
if let string = input as? String {
morseCodeArray = self.convertStringToMorseCode(string)
} else if let stringArray = input as? [String] {
morseCodeArray = stringArray
}
print(morseCodeArray)
for string in morseCodeArray {
switch string {
case ".":
vibrationPlayer.addDit()
case "-":
vibrationPlayer.addDah()
case ",":
vibrationPlayer.addSingleSpace()
case "/":
vibrationPlayer.addThreeSpaces()
default:
print("unknown character in morse code array")
}
}
vibrationPlayer.finalizeSetupAndPlay()
}
private func initConversionTable() {
stringToMorseCodeDict[" "] = "/"
stringToMorseCodeDict["a"] = ".-"
stringToMorseCodeDict["b"] = "-..."
stringToMorseCodeDict["c"] = "-.-."
stringToMorseCodeDict["d"] = "-.."
stringToMorseCodeDict["e"] = "."
stringToMorseCodeDict["f"] = "..-."
stringToMorseCodeDict["g"] = "--."
stringToMorseCodeDict["h"] = "...."
stringToMorseCodeDict["i"] = ".."
stringToMorseCodeDict["j"] = ".---"
stringToMorseCodeDict["k"] = "-.-"
stringToMorseCodeDict["l"] = ".-.."
stringToMorseCodeDict["m"] = "--"
stringToMorseCodeDict["n"] = "-."
stringToMorseCodeDict["o"] = "---"
stringToMorseCodeDict["p"] = ".--."
stringToMorseCodeDict["q"] = "--.-"
stringToMorseCodeDict["r"] = ".-."
stringToMorseCodeDict["s"] = "..."
stringToMorseCodeDict["t"] = "-"
stringToMorseCodeDict["u"] = "..-"
stringToMorseCodeDict["v"] = "...-"
stringToMorseCodeDict["w"] = ".--"
stringToMorseCodeDict["x"] = "-..-"
stringToMorseCodeDict["y"] = "-.--"
stringToMorseCodeDict["z"] = "--.."
stringToMorseCodeDict["1"] = ".----"
stringToMorseCodeDict["2"] = "..---"
stringToMorseCodeDict["3"] = "...--"
stringToMorseCodeDict["4"] = "....-"
stringToMorseCodeDict["5"] = "....."
stringToMorseCodeDict["6"] = "-...."
stringToMorseCodeDict["7"] = "--..."
stringToMorseCodeDict["8"] = "---.."
stringToMorseCodeDict["9"] = "----."
stringToMorseCodeDict["0"] = "-----"
stringToMorseCodeDict["."] = ".-.-.-"
stringToMorseCodeDict[","] = "--..--"
stringToMorseCodeDict[":"] = "---..."
stringToMorseCodeDict[";"] = "-.-.-."
stringToMorseCodeDict["?"] = "..--.."
stringToMorseCodeDict["'"] = ".----."
stringToMorseCodeDict["-"] = "-....-"
stringToMorseCodeDict["/"] = "-..-."
stringToMorseCodeDict["("] = "-.--.-"
stringToMorseCodeDict[")"] = "-.--.-"
stringToMorseCodeDict["\""] = ".-..-."
stringToMorseCodeDict["@"] = ".--.-."
stringToMorseCodeDict["="] = "-...-"
stringToMorseCodeDict["!"] = "---."
stringToMorseCodeDict["["] = "-.--."
stringToMorseCodeDict["]"] = "-.--."
stringToMorseCodeDict["+"] = ".-.-."
}
func createMorseCodeToStringDict() {
for key in stringToMorseCodeDict.keys {
morseCodeToStringDict.updateValue(key, forKey: stringToMorseCodeDict[key]!)
}
}
} |
//
// User.swift
// SampleProject
//
// Created by 近藤浩市郎 on 2017/09/10.
// Copyright © 2017 Koichiro Kondo. All rights reserved.
//
import Foundation
import Unbox
struct UserDto {
let id: String?
let name: String?
}
extension UserDto: Unboxable {
init(unboxer: Unboxer) throws {
self.id = try unboxer.unbox(key: "id")
self.name = try unboxer.unbox(key: "name")
}
}
|
//
// AppDelegate.swift
// Dog Breed Finder
//
// Created by Gabriel Veit on 11/24/19.
// Copyright © 2019 Gabriel Veit. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
}
|
//
// PartyModel.swift
// Teazy
//
// Created by Dev on 05/06/2017.
// Copyright © 2017 Dev. All rights reserved.
//
import UIKit
class Party {
var name: String
var date: String
var hour: String
var place: String
var informations: String
var friends: [String]
var drinks: [String]
init?(name: String, date: String, hour: String, place: String, informations: String, friends: [String], drinks: [String]) {
if name.isEmpty || date.isEmpty || hour.isEmpty || place.isEmpty || friends.isEmpty {
return nil
}
self.name = name
self.date = date
self.hour = hour
self.place = place
self.informations = informations
self.friends = friends
self.drinks = drinks
}
}
|
//
// RecipeAppTests.swift
// RecipeApp
//
// Created by Kishor Pahalwani on 18/02/20.
// Copyright © 2020 Kishor Pahalwani. All rights reserved.
//
import XCTest
@testable import RecipeApp
class RecipeAppTests: XCTestCase {
override func setUp() {
// Put setup code here. This method is called before the invocation of each test method in the class.
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class.
}
func testExample() {
// This is an example of a functional test case.
// Use XCTAssert and related functions to verify your tests produce the correct results.
}
func testModels() {
let modelRecipe = RecipeModel.init(id: nil, recipeName: nil, categoryId: nil, cookingSteps: nil, ingredients: nil, timeDuration: nil)
let category = CategoryModel.init(id: nil, categoryName: "Value")
XCTAssertEqual(modelRecipe.categoryId, category.id)
XCTAssert(modelRecipe.categoryId == nil)
XCTAssert(category.categoryName != modelRecipe.recipeName)
XCTAssert(modelRecipe.timeDuration == nil, "true")
XCTAssertNil(modelRecipe.id)
XCTAssertNil(category.id, "true")
}
func testModelCategories() {
let modelRecipe = RecipeModel.init(id: "11", recipeName: nil, categoryId: "1", cookingSteps: nil, ingredients: nil, timeDuration: nil)
let category = CategoryModel.init(id: "1", categoryName: "Value")
XCTAssertEqual(modelRecipe.categoryId, category.id)
XCTAssert(modelRecipe.categoryId != nil)
XCTAssert(category.categoryName != modelRecipe.recipeName)
XCTAssert(modelRecipe.timeDuration == nil, "true")
XCTAssertTrue(modelRecipe.id != nil)
XCTAssertNotNil(category.id)
XCTAssertNoThrow(modelRecipe)
}
func testPerformanceExample() {
// This is an example of a performance test case.
self.measure {
// Put the code you want to measure the time of here.
}
}
}
|
//
// APIError.swift
// RepoFetcher
//
// Created by Arkadiusz Buraczek on 23/10/2019.
// Copyright © 2019 Arkadiusz Buraczek. All rights reserved.
//
import Foundation
struct APIError: Decodable {
let message: String?
}
|
//
// Shaders.swift
// LUTFilter
//
// Created by 王文杰 on 2019/7/21.
// Copyright © 2019 wangwenjie. All rights reserved.
//
import Foundation
class Shaders {
static let vertex =
"""
attribute vec4 position;
attribute vec2 a_texCoordIn;
varying vec2 v_TexCoordOut;
void main(void) {
v_TexCoordOut = a_texCoordIn;
gl_Position = position;
}
"""
static let fragement =
"""
precision mediump float;
varying vec2 v_TexCoordOut;
uniform sampler2D inputImageTexture;
uniform sampler2D inputImageTexture2; // lookup texture
uniform float volume;
void main()
{
vec4 textureColor = texture2D(inputImageTexture, v_TexCoordOut);
float blueColor = textureColor.b * 63.0;
vec2 quad1;
quad1.y = floor(floor(blueColor) / 8.0);
quad1.x = floor(blueColor) - (quad1.y * 8.0);
vec2 quad2;
quad2.y = floor(ceil(blueColor) / 8.0);
quad2.x = ceil(blueColor) - (quad2.y * 8.0);
vec2 texPos1;
texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
vec2 texPos2;
texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
vec4 newColor1 = texture2D(inputImageTexture2, texPos1);
vec4 newColor2 = texture2D(inputImageTexture2, texPos2);
vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), volume);
}
"""
}
|
//
// Work.swift
// Artistry
//
// Created by Teaocat on 2018/1/11.
// Copyright © 2018年 school. All rights reserved.
//
// Github: https://github.com/teaocat
//
import UIKit
struct Work {
let title: String
let image: UIImage
let info: String
var isExpanded: Bool
}
|
//
// ImageCell.swift
// Devref
//
// Created by Konstantin on 20/12/2018.
// Copyright © 2018 Alexander Shalamov. All rights reserved.
//
import UIKit
class ImageCell: UICollectionViewCell {
lazy var width: NSLayoutConstraint = {
let width = contentView.widthAnchor.constraint(equalToConstant: bounds.size.width)
width.isActive = true
return width
}()
override init(frame: CGRect) {
super.init(frame: frame)
contentView.translatesAutoresizingMaskIntoConstraints = false
setUpViews()
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func systemLayoutSizeFitting(_ targetSize: CGSize, withHorizontalFittingPriority horizontalFittingPriority: UILayoutPriority, verticalFittingPriority: UILayoutPriority) -> CGSize {
width.constant = bounds.size.width
return contentView.systemLayoutSizeFitting(CGSize(width: targetSize.width, height: 1))
}
var imageView: UIImageView = {
let image = UIImageView()
image.image = UIImage(named: "")
image.translatesAutoresizingMaskIntoConstraints = false
image.contentMode = .scaleAspectFit
return image
}()
func setUpViews() {
addSubview(imageView)
contentView.addSubview(imageView)
imageView.topAnchor.constraint(equalTo: contentView.topAnchor).isActive = true
imageView.leftAnchor.constraint(equalTo: contentView.leftAnchor).isActive = true
imageView.widthAnchor.constraint(equalTo: contentView.widthAnchor).isActive = true
backgroundColor = UIColor.white
contentView.bottomAnchor.constraint(equalTo: imageView.bottomAnchor, constant: 10).isActive = true
}
}
|
//
// MercernaryUpgrade.swift
// SailingThroughHistory
//
// Created by henry on 7/4/19.
// Copyright © 2019 Sailing Through History Team. All rights reserved.
//
/// An Auxiliary Upgrade that gives ships immunity to pirates.
import Foundation
class MercernaryUpgrade: AuxiliaryUpgrade {
override var type: UpgradeType {
return .mercernary
}
override var name: String {
return "Mercernary"
}
override var cost: Int {
return 1000
}
}
|
//
// This source file is part of the Apodini open source project
//
// SPDX-FileCopyrightText: 2019-2021 Paul Schmiedmayer and the Apodini project authors (see CONTRIBUTORS.md) <paul.schmiedmayer@tum.de>
//
// SPDX-License-Identifier: MIT
//
// swiftlint:disable missing_docs
import MetadataSystem
@resultBuilder
public enum RestrictedMetadataBlockBuilder<Block: RestrictedMetadataBlock> {}
// MARK: Restricted Content Metadata Block
public extension RestrictedMetadataBlockBuilder where Block: ContentMetadataBlock, Block.RestrictedContent: AnyContentMetadata {
static func buildExpression(_ expression: Block.RestrictedContent) -> AnyContentMetadata {
expression
}
static func buildExpression(_ expression: Block) -> AnyContentMetadata {
expression
}
static func buildOptional(_ component: AnyContentMetadata?) -> AnyContentMetadata {
component ?? EmptyContentMetadata()
}
static func buildEither(first: AnyContentMetadata) -> AnyContentMetadata {
first
}
static func buildEither(second: AnyContentMetadata) -> AnyContentMetadata {
second
}
static func buildArray(_ components: [AnyContentMetadata]) -> AnyContentMetadata {
AnyContentMetadataArray(components)
}
static func buildBlock(_ components: AnyContentMetadata...) -> AnyContentMetadata {
AnyContentMetadataArray(components)
}
}
|
//
// PlaceTableViewCell.swift
// ProjetParking
//
// Created by quentin courvoisier on 11/02/2018.
// Copyright © 2018 com.iut-bm.univ. All rights reserved.
//
import UIKit
class PlaceTableViewCell: UITableViewCell {
@IBOutlet weak var lblAdresse: UILabel!
@IBOutlet weak var lblPrix: UILabel!
func update(adresse: String , prix: Double){
lblAdresse.text = adresse
lblPrix.text = String(prix)
}
override func awakeFromNib() {
super.awakeFromNib()
// Initialization code
}
override func setSelected(_ selected: Bool, animated: Bool) {
super.setSelected(selected, animated: animated)
// Configure the view for the selected state
}
}
|
//
// JobOffer.swift
// HireTalent
//
// Created by Ricardo Luna Guerrero on 17/04/20.
// Copyright © 2020 Dream Team. All rights reserved.
//
import Foundation
struct JobOffer {
var jobOfferId: String = ""
var jobTitle: String = ""
var jobDescription: String = ""
var vacants: Int = 0
var startDate: String = ""
var endDate: String = ""
var salary: Int = 0
var experience: Int = 0
var offerKey: String = ""
var companyName:String = ""
var specialityField: String = ""
var open: Bool = true
var interestedStudents: [String] = []
var userId: String = ""
}
|
// Copyright 2019, Oath Inc.
// Licensed under the terms of the MIT License. See LICENSE.md file in project root for terms.
import XCTest
@testable import VerizonVideoPartnerSDK
@testable import PlayerCore
class FailoverDetectorsTests: XCTestCase {
let adRequestId = UUID()
var detector: Detectors.Failover!
override func setUp() {
super.setUp()
detector = Detectors.Failover()
}
func testResponseAndNonEmptyGroupQueue() {
let result = detector.process(isVRMResponseGroupsEmpty: false,
isCurrentVRMGroupEmpty: false,
isVRMGroupsQueueEmpty: false,
adSessionId: adRequestId)
XCTAssertFalse(result)
}
func testResponseWithEmptyGroupQueue() {
let result = detector.process(isVRMResponseGroupsEmpty: false,
isCurrentVRMGroupEmpty: false,
isVRMGroupsQueueEmpty: true,
adSessionId: adRequestId)
XCTAssertFalse(result)
}
func testFailoverCase() {
let result = detector.process(isVRMResponseGroupsEmpty: false,
isCurrentVRMGroupEmpty: true,
isVRMGroupsQueueEmpty: true,
adSessionId: adRequestId)
XCTAssertTrue(result)
}
func testResponseWithNoAds() {
let result = detector.process(isVRMResponseGroupsEmpty: true,
isCurrentVRMGroupEmpty: true,
isVRMGroupsQueueEmpty: true,
adSessionId: adRequestId)
XCTAssertFalse(result)
}
func testResponseWithMultipleAdSessions() {
var result = detector.process(isVRMResponseGroupsEmpty: false,
isCurrentVRMGroupEmpty: true,
isVRMGroupsQueueEmpty: true,
adSessionId: adRequestId)
XCTAssertTrue(result)
let newRequestId = UUID()
result = detector.process(isVRMResponseGroupsEmpty: false,
isCurrentVRMGroupEmpty: true,
isVRMGroupsQueueEmpty: true,
adSessionId: newRequestId)
XCTAssertTrue(result)
}
}
|
//
// CarTypeCollectionViewCell.swift
// YuQinClient
//
// Created by ksn_cn on 16/3/18.
// Copyright © 2016年 YuQin. All rights reserved.
//
import UIKit
class CarTypeCollectionViewCell: UICollectionViewCell {
@IBOutlet weak var label: UILabel!
@IBOutlet weak var imageView1: UIImageView!
@IBOutlet weak var imageView2: UIImageView!
}
|
//
// UIButton+Extension.swift
// FBMIF50
//
// Created by BeInMedia on 3/26/20.
// Copyright © 2020 MIF50. All rights reserved.
//
import UIKit
extension UIButton {
func leftImage(image: UIImage, renderMode: UIImage.RenderingMode) {
self.setImage(image.withRenderingMode(renderMode), for: .normal)
self.imageEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: image.size.width / 2)
self.contentHorizontalAlignment = .left
self.imageView?.contentMode = .scaleAspectFit
}
func rightImage(image: UIImage, renderMode: UIImage.RenderingMode){
self.setImage(image.withRenderingMode(renderMode), for: .normal)
self.imageEdgeInsets = UIEdgeInsets(top: 0, left:image.size.width / 2, bottom: 0, right: 0)
self.contentHorizontalAlignment = .right
self.imageView?.contentMode = .scaleAspectFit
}
func centerImage(image: UIImage, renderMode: UIImage.RenderingMode){
self.setImage(image.withRenderingMode(renderMode), for: .normal)
self.imageEdgeInsets = UIEdgeInsets(top: 0, left:image.size.width / 2, bottom: 0, right: 0)
self.contentHorizontalAlignment = .right
self.imageView?.contentMode = .scaleAspectFit
}
func alignVertical(spacing: CGFloat = 6.0) {
guard let imageSize = imageView?.image?.size,
let text = titleLabel?.text,
let font = titleLabel?.font
else { return }
titleEdgeInsets = UIEdgeInsets(
top: 0.0,
left: -imageSize.width,
bottom: -(imageSize.height + spacing),
right: 0.0
)
let titleSize = text.size(withAttributes: [.font: font])
imageEdgeInsets = UIEdgeInsets(
top: -(titleSize.height + spacing),
left: 0.0,
bottom: 0.0, right: -titleSize.width
)
let edgeOffset = abs(titleSize.height - imageSize.height) / 2.0
contentEdgeInsets = UIEdgeInsets(
top: edgeOffset,
left: 0.0,
bottom: edgeOffset,
right: 0.0
)
}
func centerVertically(padding: CGFloat = 6.0) {
guard let imageViewSize = self.imageView?.frame.size,
let titleLabelSize = self.titleLabel?.frame.size else {
return
}
let totalHeight = imageViewSize.height + titleLabelSize.height + padding
self.imageEdgeInsets = UIEdgeInsets(
top: -(totalHeight - imageViewSize.height),
left: 0.0,
bottom: 0.0,
right: -titleLabelSize.width
)
self.titleEdgeInsets = UIEdgeInsets(
top: 0.0,
left: -imageViewSize.width,
bottom: -(totalHeight - titleLabelSize.height),
right: 0.0
)
self.contentEdgeInsets = UIEdgeInsets(
top: 0.0,
left: 0.0,
bottom: titleLabelSize.height,
right: 0.0
)
}
func centerImageAndButton(_ gap: CGFloat, imageOnTop: Bool) {
guard let imageView = self.currentImage,
let titleLabel = self.titleLabel?.text else { return }
let sign: CGFloat = imageOnTop ? 1 : -1
self.titleEdgeInsets = UIEdgeInsets(top: (imageView.size.height + gap) * sign, left: -imageView.size.width, bottom: 0, right: 0);
let titleSize = titleLabel.size(withAttributes:[NSAttributedString.Key.font: self.titleLabel!.font!])
self.imageEdgeInsets = UIEdgeInsets(top: -(titleSize.height + gap) * sign, left: 0, bottom: 0, right: -titleSize.width)
}
}
|
//
// MyViewController.swift
// develop_head
//
// Created by zhj on 2019/6/13.
// Copyright © 2019年 zhj. All rights reserved.
//
import UIKit
class MyViewController:UIViewController{
override func viewDidLoad() {
super.viewDidLoad()
let navigationBar = self.navigationController?.navigationBar
navigationBar?.isHidden = false
navigationBar?.barTintColor = UIColor.rgba(45,171,250)
var textAttributes: [NSAttributedString.Key: AnyObject] = [:]
textAttributes[.foregroundColor] = UIColor.white
navigationBar?.titleTextAttributes = textAttributes
view.backgroundColor = UIColor.white
}
@objc func goBack(button:UIButton){
self.navigationController?.navigationBar.isHidden = true
self.navigationController?.popViewController(animated: true)
}
}
|
//
// Copyright © 2017 Rosberry. All rights reserved.
//
import UIKit
/// Delegate for convenience work with adaptors.
protocol PickLDelegate: class {
func pickerView(_ pickerView: UIPickerView, widthForComponent component: Int) -> CGFloat
func pickerView(_ pickerView: UIPickerView, rowHeightForComponent component: Int) -> CGFloat
func pickerView(_ pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int)
func pickerView(_ pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String?
func pickerView(_ pickerView: UIPickerView, attributedTitleForRow row: Int, forComponent component: Int) -> NSAttributedString?
func pickerView(_ pickerView: UIPickerView, viewForRow row: Int, forComponent component: Int, reusing view: UIView?) -> UIView
}
public typealias RowIndex = Int
public typealias ComponentIndex = Int
open class PickL<Adaptor>: NSObject, UIPickerViewDataSource where Adaptor: BaseAdaptor & SpecificAdaptor {
/// The reference to `UIPickerView`.
public unowned let pickerView: UIPickerView
private lazy var adaptor: Adaptor = .init(delegate: self)
/// A Boolean value that determines whether the selection indicator is displayed.
public var showsSelectionIndicator: Bool {
get {
return pickerView.showsSelectionIndicator
}
set {
pickerView.showsSelectionIndicator = newValue
}
}
/// Current selected row indexes.
public private(set) var selectedRows: [RowIndex] = []
internal var selectedRowsHandler: (([RowIndex]) -> Void)?
/// The array of component items with specific row items type.
public var components: [ComponentItem<Adaptor>] = [] {
didSet {
selectedRows = Array(repeating: 0, count: components.count)
for component in components {
component.pickL = self
component.pickerView = pickerView
}
pickerView.reloadAllComponents()
}
}
/// Initializes and returns a newly allocated `PickL` object with the specified pickerView.
public init(pickerView: UIPickerView) {
self.pickerView = pickerView
super.init()
pickerView.dataSource = self
pickerView.delegate = adaptor
}
/// Subscript that returns the row item with specified column and row.
open subscript(component: Int, row: Int) -> Adaptor.RowItemType {
assert(component >= 0, "Component index can not be negative.")
assert(row >= 0, "Row index can not be negative.")
assert(component < components.count, "Component index(\(component)) out of component items count(\(components.count)) range.")
let componentItem = components[component]
assert(row < componentItem.rowItems.count, "Row index(\(row)) out of row items count(\(componentItem.rowItems.count)) range.")
return componentItem.rowItems[row]
}
// MARK: - UIPickerViewDataSource
public func numberOfComponents(in pickerView: UIPickerView) -> Int {
return components.count
}
public func pickerView(_ pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int {
return components[component].rowItems.count
}
}
// MARK: - PickLDelegate
extension PickL: PickLDelegate {
func pickerView(_ pickerView: UIPickerView, widthForComponent component: Int) -> CGFloat {
if case let .value(width) = components[component].width {
return width
}
var numberOfComponentsWithWidth = 0
var widthSum: CGFloat = 0
components.forEach { component in
if case let .value(width) = component.width {
numberOfComponentsWithWidth += 1
widthSum += width
}
}
return (pickerView.bounds.width - widthSum) / CGFloat(components.count - numberOfComponentsWithWidth)
}
func pickerView(_ pickerView: UIPickerView, rowHeightForComponent component: Int) -> CGFloat {
let isIndexOfRange = component >= components.count
if !isIndexOfRange, case let .value(height) = components[component].height {
return height
}
return 44
}
func pickerView(_ pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) {
guard selectedRows.indices.contains(component) else {
return
}
selectedRows[component] = row
selectedRowsHandler?(selectedRows)
let componentItem = components[component]
componentItem.didSelectRowHandler?(componentItem, row, componentItem.rowItems[row])
if let rowItem = componentItem[row] as? RowItemProtocol {
rowItem.pickerView(pickerView, didSelectRow: row, inComponent: component)
}
}
}
// MARK: Strings
public extension PickL {
func pickerView(_ pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String? {
if let rowItem = components[component][row] as? RowStringItemProtocol {
return rowItem.pickerView(pickerView, titleForRow: row, forComponent: component)
}
return nil
}
func pickerView(_ pickerView: UIPickerView, attributedTitleForRow row: Int, forComponent component: Int) -> NSAttributedString? {
if let rowItem = components[component][row] as? RowStringItemProtocol {
return rowItem.pickerView(pickerView, attributedTitleForRow: row, forComponent: component)
}
return nil
}
}
// MARK: Views
public extension PickL {
func pickerView(_ pickerView: UIPickerView, viewForRow row: Int, forComponent component: Int, reusing view: UIView?) -> UIView {
if let rowItem = components[component][row] as? RowViewItemProtocol {
return rowItem.pickerView(pickerView, viewForRow: row, forComponent: component, reusing: view)
}
return UIView()
}
}
|
//
// SBDiffEntityProtocol.swift
// BaseMVVM
//
// Created by ALEXEY ABDULIN on 13/05/2020.
// Copyright © 2020 ALEXEY ABDULIN. All rights reserved.
//
import Foundation
public protocol SBDiffEntity
{
func IsTheSame( entity: SBDiffEntity ) -> Bool
func IsContentChanged( entity: SBDiffEntity ) -> Bool
}
public protocol SBDiffEntitySection
{
@inlinable subscript( index: Int ) -> [SBDiffEntity] { get }
var count: Int { get }
}
enum SBDiffState
{
case nothing, inserted, moved, movedChanged, changed, deleted
}
struct SBDiffItem
{
let oldSec: Int
let oldI: Int
let newSec: Int
let newI: Int
let state: SBDiffState
var description: String
{
return "[OLD: (\(oldSec), \(oldI)), NEW: (\(newSec), \(newI)), STATE: \(state)]"
}
}
struct SBDefaultSection: SBDiffEntitySection
{
let items: [[SBDiffEntity]]
subscript(index: Int) -> [SBDiffEntity]
{
return items[index]
}
var count: Int
{
return items.count
}
}
public class SBDiffCalculator
{
let oldItems: SBDiffEntitySection
let newItems: SBDiffEntitySection
private(set) var changedItems: [SBDiffItem] = []
private(set) var insertedItems: [SBDiffItem] = []
private(set) var movedItems: [SBDiffItem] = []
private(set) var deletedItems: [SBDiffItem] = []
public init( oldItems: SBDiffEntitySection, newItems: SBDiffEntitySection )
{
self.oldItems = oldItems
self.newItems = newItems
}
public convenience init( oldItems: [[SBDiffEntity]], newItems: [[SBDiffEntity]] )
{
self.init( oldItems: SBDefaultSection( items: oldItems ), newItems: SBDefaultSection( items: newItems ) )
}
public convenience init( oldItems: [SBDiffEntity], newItems: [SBDiffEntity] )
{
self.init( oldItems: [oldItems], newItems: [newItems] )
}
public func Calc()
{
var wasItems = [Int: [Int: Bool]]()
for secO in 0..<oldItems.count
{
for o in 0..<oldItems[secO].count
{
let item = CheckItems( oldSec: secO, oldI: o )
switch item.state
{
case .changed:
changedItems.append( item )
case .moved, .movedChanged:
movedItems.append( item )
case .deleted:
deletedItems.append( item )
default:
break
}
if item.state != .deleted
{
var w = wasItems[item.newSec] ?? [:]
w[item.newI] = true
wasItems[item.newSec] = w
}
}
}
for secN in 0..<newItems.count
{
for n in 0..<newItems[secN].count
{
if wasItems[secN]?[n] == nil
{
insertedItems.append( SBDiffItem( oldSec: 0, oldI: 0, newSec: secN, newI: n, state: .inserted ) )
}
}
}
}
public func AsyncCalc( _ completion: @escaping (SBDiffCalculator) -> Void )
{
DispatchQueue.global().async
{
self.Calc()
DispatchQueue.main.async
{
completion( self )
}
}
}
func CheckItems( oldSec: Int, oldI: Int ) -> SBDiffItem
{
for secN in 0..<newItems.count
{
if newItems[secN].count > oldI, let item = CheckItems( oldSec: oldSec, oldI: oldI, newSec: secN, newI: oldI )
{
return item
}
for n in 0..<newItems[secN].count
{
if let item = CheckItems( oldSec: oldSec, oldI: oldI, newSec: secN, newI: n )
{
return item
}
}
}
return SBDiffItem( oldSec: oldSec, oldI: oldI, newSec: 0, newI: 0, state: .deleted )
}
func CheckItems( oldSec: Int, oldI: Int, newSec: Int, newI: Int ) -> SBDiffItem?
{
let olds = oldItems[oldSec]
let news = newItems[newSec]
let old = olds[oldI]
let new = news[newI]
if old.IsTheSame( entity: new )
{
var state = SBDiffState.nothing
if oldSec == newSec && oldI == newI
{
if old.IsContentChanged( entity: new )
{
state = .changed
}
}
else
{
state = old.IsContentChanged( entity: new ) ? .movedChanged : .moved
}
return SBDiffItem( oldSec: oldSec, oldI: oldI, newSec: newSec, newI: newI, state: state )
}
return nil
}
}
|
//
// NIProfileViewController.swift
// NagarajanImgur
//
// Created by Nagarajan S D on 19/04/20.
// Copyright © 2020 Nagarajan. All rights reserved.
//
import UIKit
import UIImageColors
class NIProfileViewController: NIViewController {
//MARK:- Properties
//MARK: Outlets
@IBOutlet private weak var bannerImageView: UIImageView!
@IBOutlet private weak var avatarImageView: UIImageView!
@IBOutlet private weak var userNameLabel: UILabel!
@IBOutlet private weak var reputationCount: UILabel!
@IBOutlet private weak var reputationType: UILabel!
@IBOutlet private weak var activitiesView: UIView!
//MARK: Variables
var accountData: NIAccountData?
//MARK:- Initialization
override func initializeOnViewDidLoad() {
super.initializeOnViewDidLoad()
self.addBottomShadowForNavigationBar()
self.configAccountData()
}
}
//MARK:- View Config
private extension NIProfileViewController {
func configAccountData() {
if let accountData = self.accountData {
self.userNameLabel.text = accountData.url
self.reputationCount.text = "\(accountData.reputation) PTS"
self.reputationType.text = accountData.reputation_name
self.bannerImageView.downloaded(from: accountData.cover, contentMode: .scaleAspectFill) { (success) in
if (success) {
let colors = self.bannerImageView.image?.getColors()
self.userNameLabel.textColor = colors?.primary
self.reputationCount.textColor = colors?.secondary
self.reputationType.textColor = colors?.detail
}
}
self.avatarImageView.downloaded(from: accountData.avatar, contentMode: .scaleAspectFill) { (success) in
if (success) {
}
}
}
}
}
|
//
// GeofenceAreaModel.swift
// GeofenceArrea
//
// Created by Naeem Paracha on 26/12/2019.
// Copyright © 2019 Naeem Paracha. All rights reserved.
//
import Foundation
import CoreLocation
class GeofenceAreaModel: NSObject {
//MARK: Vars and Lets
var coordinate: CLLocationCoordinate2D
var radius: CLLocationDistance
var identifier: String
var wifiName: String
//MARK:Initializer
init(coordinate: CLLocationCoordinate2D, radius: CLLocationDistance, wifiName: String, identifier:String) {
self.coordinate = coordinate
self.radius = radius
self.wifiName = wifiName
self.identifier = identifier
}
}
|
//
// Explosion.swift
// Topdown Shooter
//
// Created by cadet on 29/07/2017.
// Copyright © 2017 Jason Fry. All rights reserved.
//
import SpriteKit
class Explosion: SKNode
{
//Explosion
var explosionAtlas: SKTextureAtlas?
var explosionAction = SKAction()
let explosionSound = SKAction.playSoundFileNamed("Explosion+9", waitForCompletion: false)
var createAndRemoveExplosion = SKAction()
func initaliseExplosionAtlas()
{
////print("initaliseAlas called")
explosionAtlas = SKTextureAtlas(named:"Explosions")
//Grab the frames from the texture atlas in an array
//Note: Check out the syntax explicitly declaring entity frames as an Array
//SKTextures. This is not strictly necessary, but it makes the intent of the
//code more readable
let explosionFrames:[SKTexture] =
[
explosionAtlas!.textureNamed("explosion-0"),
explosionAtlas!.textureNamed("explosion-1"),
explosionAtlas!.textureNamed("explosion-2"),
explosionAtlas!.textureNamed("explosion-3"),
explosionAtlas!.textureNamed("explosion-4"),
explosionAtlas!.textureNamed("explosion-5"),
explosionAtlas!.textureNamed("explosion-6"),
explosionAtlas!.textureNamed("explosion-7"),
explosionAtlas!.textureNamed("explosion-8"),
explosionAtlas!.textureNamed("explosion-9"),
explosionAtlas!.textureNamed("explosion-10"),
explosionAtlas!.textureNamed("explosion-11"),
explosionAtlas!.textureNamed("explosion-12"),
explosionAtlas!.textureNamed("explosion-13"),
explosionAtlas!.textureNamed("explosion-14"),
explosionAtlas!.textureNamed("explosion-15"),
explosionAtlas!.textureNamed("explosion-16"),
explosionAtlas!.textureNamed("explosion-17"),
explosionAtlas!.textureNamed("explosion-18"),
explosionAtlas!.textureNamed("explosion-19"),
explosionAtlas!.textureNamed("explosion-20"),
explosionAtlas!.textureNamed("explosion-21"),
explosionAtlas!.textureNamed("explosion-22"),
explosionAtlas!.textureNamed("explosion-23")
]
//Create a new SKAction to animate between the frames once
let explosionAnimation = SKAction.animate(with: explosionFrames, timePerFrame: 0.14)
//Create the SKACtion to run the sprite animation repeatedly
explosionAction = SKAction.repeat(explosionAnimation, count: 1)
//Remove explosion from scene
let explosionRemoval = SKAction.removeFromParent()
//Group explosion and sound to run sychronously
let createExplosion = SKAction.group([explosionAction, explosionSound])
//Sequence creation and removal
createAndRemoveExplosion = SKAction.sequence([createExplosion, explosionRemoval])
}
func createExplosion(nodeToExplode: SKNode)
{
nodeToExplode.run(createAndRemoveExplosion)
}
}
|
//
// TestDTO.swift
// CompositionalLayout
//
// Created by Mikhail Kuzmin on 14.03.2021.
//
import UIKit
struct TestDTO {
enum Category {
case grid
case courusel
case fullWidth
}
let category: Category
let items: [(id: UUID, color: UIColor)]
}
|
//
// SearchRepositoriesResponse.swift
// Githuber
//
// Created by Meng Li on 2020/9/9.
// Copyright © 2020 Meng Li. All rights reserved.
//
class SearchRepositoriesResponse: Codable {
let totalCount: Int
let incompleteResults: Bool
let items: [RepositoryItem]
private enum CodingKeys: String, CodingKey {
case totalCount = "total_count"
case incompleteResults = "incomplete_results"
case items
}
}
|
//
// JKAttributedString.swift
// JKAttributedString
//
// Created by Junmo KIM on 2017. 7. 30..
//
//
import Foundation
public struct JKAttributedString {
typealias Converter = JKStringRangeConverter
internal var _backing: NSMutableAttributedString
public var string: String {
return _backing.string
}
public var attributedString: NSAttributedString {
return _backing.copy() as! NSAttributedString // swiftlint:disable:this force_cast
}
public var utf8: String.UTF8View {
return string.utf8
}
public var utf16: String.UTF16View {
return string.utf16
}
public var characters: String.CharacterView {
return string.characters
}
public var startIndex: String.Index {
return string.startIndex
}
public var endIndex: String.Index {
return string.endIndex
}
public func index(after i: String.Index) -> String.Index {
return string.index(after: i)
}
public func index(before i: String.Index) -> String.Index {
return string.index(before: i)
}
public func index(_ i: String.Index, offsetBy n: String.IndexDistance) -> String.Index {
return string.index(i, offsetBy: n)
}
public func index(_ i: String.Index, offsetBy n: String.IndexDistance, limitedBy limit: String.Index) -> String.Index? {
return string.index(i, offsetBy: n, limitedBy: limit)
}
}
extension JKAttributedString {
public init() {
_backing = NSMutableAttributedString()
}
public init(string str: String, attributes attrs: [JKAttribute]) {
_backing = NSMutableAttributedString(string: str, attributes: attrs.attributes)
}
public init(string str: String, attributes attrs: [JKAttributeType]) {
_backing = NSMutableAttributedString(string: str, attributes: attrs.attributes)
}
public init(string str: String, attributes attrs: [String : Any]? = nil) {
_backing = NSMutableAttributedString(string: str, attributes: attrs)
}
public init(attributedString attrStr: NSAttributedString) {
_backing = attrStr.mutableCopy() as! NSMutableAttributedString // swiftlint:disable:this force_cast
}
public func attributes(at location: String.Index) -> ([String : Any], effectiveRange: Range<String.Index>?) {
let utf16Location = Converter.utf16Location(of: string, at: location)
var range = NSRange(location: 0, length: _backing.length)
let attributes = _backing.attributes(at: utf16Location, effectiveRange: &range)
return (attributes, Converter.characterRange(of: string, for: range))
}
public func attribute(_ attrName: String, at location: String.Index) -> (Any?, effectiveRange: Range<String.Index>?) {
var range = NSRange(location: 0, length: _backing.length)
let attribute = _backing.attribute(attrName, at: Converter.utf16Location(of: string, at: location), effectiveRange: &range)
return (attribute, Converter.characterRange(of: string, for: range))
}
public func attributedSubstring(from range: Range<String.Index>) -> JKAttributedString {
let attributedString = _backing.attributedSubstring(from: Converter.utf16Range(of: string, for: range))
return JKAttributedString(attributedString: attributedString)
}
public typealias EnumerationOptions = NSAttributedString.EnumerationOptions
public func enumerateAttributes(in enumerationRange: Range<String.Index>? = nil,
options opts: EnumerationOptions = [],
using block: ([String : Any], Range<String.Index>, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {
let range = Converter.utf16Range(of: string, for: enumerationRange)
_backing.enumerateAttributes(in: range, options: opts) { (attributes, utf16Range, stop) in
if let charctersRange = Converter.characterRange(of: string, for: utf16Range) {
block(attributes, charctersRange, stop)
}
}
}
public func enumerateAttribute(_ attrName: String,
in enumerationRange: Range<String.Index>? = nil,
options opts: EnumerationOptions = [],
using block: (Any?, Range<String.Index>, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {
let range = Converter.utf16Range(of: string, for: enumerationRange)
_backing.enumerateAttribute(attrName, in: range, options: opts) { (attribute, utf16Range, stop) in
if let charctersRange = Converter.characterRange(of: string, for: utf16Range) {
block(attribute, charctersRange, stop)
}
}
}
}
extension JKAttributedString {
public func attributed(_ attributes: [JKAttribute]) -> JKAttributedString {
return self.attributed(attributes as [JKAttributeType])
}
public func attributed(_ attributes: [JKAttributeType]) -> JKAttributedString {
var base = self
base.setAttributes(attributes.attributes)
return base
}
public func adding(attributes: [JKAttribute], for range: Range<String.Index>? = nil) -> JKAttributedString {
return self.adding(attributes: (attributes as [JKAttributeType]), for: range)
}
public func adding(attributes: [JKAttributeType], for range: Range<String.Index>? = nil) -> JKAttributedString {
var base = self
base.addAttribute(attributes.attributes, range: range)
return base
}
public static func + (left: JKAttributedString, right: JKAttributedString) -> JKAttributedString {
var base = left
base.append(right)
return base
}
public static func + (left: NSAttributedString, right: JKAttributedString) -> JKAttributedString {
var base = right
base.insert(left, at: base.string.startIndex)
return base
}
public static func + (left: JKAttributedString, right: NSAttributedString) -> JKAttributedString {
var base = left
base.append(right)
return base
}
public static func + (left: String, right: JKAttributedString) -> JKAttributedString {
let attributes: [String: Any]? = {
guard right.characters.count > 0 else { return nil }
let (startAttributes, _) = right.attributes(at: right.string.startIndex)
return startAttributes
}()
var base = JKAttributedString(string: left, attributes: attributes)
base.insert(right, at: base.string.endIndex)
return base
}
public static func + (left: JKAttributedString, right: String) -> JKAttributedString {
var base = left
let attributes: [String: Any]? = {
if let lastCharIndex = base.string.index(base.string.endIndex, offsetBy: -1, limitedBy: base.string.startIndex) {
let (endAttributes, _) = base.attributes(at: lastCharIndex)
return endAttributes
}
return nil
}()
base.insert(JKAttributedString(string: right, attributes: attributes), at: base.string.endIndex)
return base
}
}
extension JKAttributedString: Equatable {
public static func ==(lhs: JKAttributedString, rhs: JKAttributedString) -> Bool {
return lhs._backing.isEqual(to: rhs._backing)
}
}
extension JKAttributedString {
fileprivate mutating func _confirmUniquelyReferenced() {
// Provide mutability to backing `NSMutableAttributedString` class instance
// cf) https://github.com/apple/swift/blob/swift-4.0-branch/stdlib/public/SDK/Foundation/Data.swift
if !isKnownUniquelyReferenced(&_backing) {
_backing = _backing.mutableCopy() as! NSMutableAttributedString // swiftlint:disable:this force_cast
}
}
public mutating func setAttributes(_ attrs: [String : Any]?, range: Range<String.Index>? = nil) {
_confirmUniquelyReferenced()
_backing.setAttributes(attrs, range: Converter.utf16Range(of: string, for: range))
}
public mutating func addAttribute(_ name: String, value: Any, range: Range<String.Index>? = nil) {
addAttribute([name: value], range: range)
}
public mutating func addAttribute(_ attribute: JKAttribute, range: Range<String.Index>? = nil) {
addAttribute([attribute.name: attribute.value], range: range)
}
public mutating func addAttribute(_ attribute: JKAttributeType, range: Range<String.Index>? = nil) {
addAttribute([attribute.name: attribute.value], range: range)
}
public mutating func addAttribute(_ attributes: [JKAttribute], range: Range<String.Index>? = nil) {
addAttribute(attributes.attributes, range: range)
}
public mutating func addAttribute(_ attributes: [JKAttributeType], range: Range<String.Index>? = nil) {
addAttribute(attributes.attributes, range: range)
}
public mutating func addAttribute(_ attributes: [String : Any], range: Range<String.Index>? = nil) {
_confirmUniquelyReferenced()
_backing.addAttributes(attributes, range: Converter.utf16Range(of: string, for: range))
}
public mutating func removeAttribute(_ name: String, range: Range<String.Index>? = nil) {
_confirmUniquelyReferenced()
_backing.removeAttribute(name, range: Converter.utf16Range(of: string, for: range))
}
public mutating func replaceCharacters(in range: Range<String.Index>? = nil, with str: String) {
_confirmUniquelyReferenced()
_backing.replaceCharacters(in: Converter.utf16Range(of: string, for: range), with: str)
}
public mutating func replaceCharacters(in range: Range<String.Index>? = nil, with attrString: NSAttributedString) {
_confirmUniquelyReferenced()
_backing.replaceCharacters(in: Converter.utf16Range(of: string, for: range), with: attrString)
}
public mutating func replaceCharacters(in range: Range<String.Index>? = nil, with attrString: JKAttributedString) {
_confirmUniquelyReferenced()
_backing.replaceCharacters(in: Converter.utf16Range(of: string, for: range), with: attrString._backing)
}
public mutating func insert(_ attrString: NSAttributedString, at loc: String.Index) {
_confirmUniquelyReferenced()
_backing.insert(attrString, at: Converter.utf16Location(of: string, at: loc))
}
public mutating func insert(_ attrString: JKAttributedString, at loc: String.Index) {
_confirmUniquelyReferenced()
_backing.insert(attrString._backing, at: Converter.utf16Location(of: string, at: loc))
}
public mutating func append(_ attrString: NSAttributedString) {
_confirmUniquelyReferenced()
_backing.append(attrString)
}
public mutating func append(_ attrString: JKAttributedString) {
_confirmUniquelyReferenced()
_backing.append(attrString._backing)
}
public mutating func deleteCharacters(in range: Range<String.Index>? = nil) {
_confirmUniquelyReferenced()
_backing.deleteCharacters(in: Converter.utf16Range(of: string, for: range))
}
public mutating func setAttributedString(_ attrString: NSAttributedString) {
_confirmUniquelyReferenced()
_backing.setAttributedString(attrString)
}
public mutating func setAttributedString(_ attrString: JKAttributedString) {
_confirmUniquelyReferenced()
_backing.setAttributedString(attrString._backing)
}
}
|
//
// FavoritesListView.swift
// 100 Percent Calculator
//
// Created by Thomas Andre Johansen on 06/04/2020.
// Copyright © 2020 Appkokeriet. All rights reserved.
//
import SwiftUI
struct FavoritesListView: View {
@EnvironmentObject var userSettings: UserSettings
@ObservedObject var calculator: Calculator = Calculator()
@EnvironmentObject var keyboard: KeyboardController
var body: some View {
ZStack {
List{
ForEach(userSettings.favoriteCalculations){ favorite in
FavoriteCellView(calculator: self.calculator, favorite: favorite)
}
.onMove(perform: moveCell)
}.padding(.bottom, (self.keyboard.height == 0 ? 0 : self.keyboard.height-self.getSafeAreaInsets()))
.listStyle(GroupedListStyle())
VStack(alignment: .trailing){
KeyboardButtonRow(calculator: self.calculator)
}
}
.navigationBarTitle(Text("Favorites"), displayMode: .automatic)
.navigationBarItems(trailing: EditButton())
}
func moveCell(from source: IndexSet, to destination: Int){
userSettings.favoriteCalculations.move(fromOffsets: source, toOffset: destination)
}
}
struct FavoritesListView_Previews: PreviewProvider {
static var previews: some View {
let userSettings = UserSettings(data: calculationsData, favoriteCalculations: calculationsData[0].calculations)
let keyboard = KeyboardController()
return FavoritesListView().environmentObject(userSettings).environmentObject(keyboard)
}
}
|
//
// SignUpViewModel.swift
// logReg
//
// Created by Максим Бойчук on 28.04.2020.
// Copyright © 2020 bmstu. All rights reserved.
//
import Foundation
import UIKit
class SignUpViewModel: SignUpViewModelProtocol {
private let signUpModel: SignUpModel
init() {
signUpModel = SignUpModel()
}
func signUp(email: String, password: String, user: User, completion: ((ErrorViewModel?) -> Void)?) {
signUpModel.checkUsernameAndSignUp(email: email, password: password, user: user, completion: {
[weak self] (error) in
guard let self = self else { return }
if let error = error {
let receivedError = self.handleError(error: error)
completion?(receivedError)
} else {
completion?(nil)
}
})
}
}
extension SignUpViewModel {
private func handleError(error: ErrorModel) -> ErrorViewModel {
switch error {
case .networkError:
return ErrorViewModel.networkError
case .tooManyRequests:
return ErrorViewModel.tooManyRequests
case .invalidAPIKey:
return ErrorViewModel.invalidAPIKey
case .appNotAuthorized:
return ErrorViewModel.appNotAuthorized
case .keychainError:
return ErrorViewModel.keychainError
case .internalError:
return ErrorViewModel.internalError
case .invalidEmail:
return ErrorViewModel.invalidEmail
case .emailAlreadyInUse:
return ErrorViewModel.emailAlreadyInUse
case .operationNotAllowed:
return ErrorViewModel.operationNotAllowed
case .weakPassword:
return ErrorViewModel.weakPassword
default:
return ErrorViewModel.unknownAuthError
}
}
}
|
//
// DemoTableViewController.swift
// Demo
//
// Created by Kyle Van Essen on 3/24/20.
// Copyright © 2020 Kyle Van Essen. All rights reserved.
//
import ListableUI
import BlueprintUILists
import BlueprintUI
import BlueprintUICommonControls
import UIKit
final class SwipeActionsViewController: UIViewController {
private let blueprintView = BlueprintView()
private var allowDeleting: Bool = true
private var items = (0..<20).map { SwipeActionItem(isSaved: Bool.random(), identifier: $0) }
override func loadView() {
self.title = "Swipe Actions"
self.view = self.blueprintView
self.navigationItem.rightBarButtonItems = [
UIBarButtonItem(barButtonSystemItem: .add, target: self, action: #selector(addItem)),
UIBarButtonItem(barButtonSystemItem: .trash, target: self, action: #selector(toggleDelete)),
]
self.reloadData()
}
func reloadData(animated: Bool = false) {
self.blueprintView.element = List { list in
list.animatesChanges = animated
list.layout = .table { [weak self] in
guard let self = self else { return }
if #available(iOS 11, *) {
$0.bounds = .init(
padding: UIEdgeInsets(
top: 0.0,
left: self.view.safeAreaInsets.left,
bottom: 0.0,
right: self.view.safeAreaInsets.right
)
)
}
}
list += Section("items") { section in
section += self.items.map { item in
Item(
SwipeActionsDemoItem(item: item),
swipeActions: self.makeSwipeActions(for: item)
)
}
}
}
}
private func makeSwipeActions(for item: SwipeActionItem) -> SwipeActionsConfiguration {
var actions: [SwipeAction] = []
if allowDeleting {
actions.append(
SwipeAction(
title: "Delete",
backgroundColor: .systemRed,
image: nil,
handler: { [weak self] expandActions in
self?.confirmDelete(item: item, expandActions: expandActions)
})
)
}
actions.append(
SwipeAction(
title: item.isSaved ? "Unsave" : "Save",
backgroundColor: UIColor(displayP3Red: 0, green: 0.741, blue: 0.149, alpha: 1),
image: nil,
handler: { [weak self] expandActions in
self?.toggleSave(item: item)
expandActions(false)
})
)
return SwipeActionsConfiguration(actions: actions, performsFirstActionWithFullSwipe: true)
}
@objc private func addItem() {
let identifier = (items.last?.identifier ?? -1) + 1
items.append(SwipeActionItem(isSaved: false, identifier: identifier))
reloadData(animated: true)
}
@objc private func toggleDelete() {
allowDeleting.toggle()
reloadData()
}
private func confirmDelete(item: SwipeActionItem, expandActions: @escaping (Bool) -> Void) {
let alert = UIAlertController(title: item.title, message: nil, preferredStyle: .actionSheet)
alert.addAction(UIAlertAction(title: "Cancel", style: .cancel) { _ in
expandActions(false)
})
alert.addAction(UIAlertAction(title: "Delete", style: .destructive) { [weak self] _ in
self?.items.removeAll(where: { $0 == item })
self?.reloadData(animated: true)
expandActions(true)
})
present(alert, animated: true, completion: nil)
}
private func toggleSave(item: SwipeActionItem) {
guard let index = items.firstIndex(of: item) else { return }
items[index].isSaved.toggle()
reloadData(animated: true)
}
struct SwipeActionsDemoItem: BlueprintItemContent, Equatable {
var item: SwipeActionItem
var identifierValue: Int {
self.item.identifier
}
func element(with info : ApplyItemContentInfo) -> Element {
return Column { column in
column.horizontalAlignment = .fill
let row = Row { row in
row.minimumHorizontalSpacing = 8
row.horizontalUnderflow = .spaceEvenly
row.verticalAlignment = .center
row.add(child: Label(text: self.item.title))
let bookmark = UIImage(named: "bookmark")!
if item.isSaved {
var image = Image(image: bookmark)
image.contentMode = .center
row.add(child: image)
} else {
let spacer = Spacer(size: bookmark.size)
row.add(child: spacer)
}
}
let inset = Inset(uniformInset: 16, wrapping: row)
column.add(child: inset)
let color = UIColor(displayP3Red: 0.725, green: 0.729, blue: 0.741, alpha: 1)
let separator = Inset(left: 16, wrapping: Rule(orientation: .horizontal, color: color))
column.add(growPriority: 0, shrinkPriority: 0, child: separator)
}
.accessibility(label: "Swipeable item", value: item.title)
}
}
struct SwipeActionItem: Equatable, Hashable {
var isSaved: Bool
var identifier: Int
var title: String { "Item #\(identifier)" }
}
}
|
//
// ChooseItem.swift
// LightPlanPhilips
//
// Created by Mark Aptroot on 01-12-16.
// Copyright © 2016 The App Academy. All rights reserved.
//
import UIKit
class ChooseItem{
var itemName: String
var itemImage: UIImage
init(name: String, image: UIImage) {
self.itemName = name
self.itemImage = image
}
}
|
//
// PreferitiController.swift
// iAm-inquadrami
//
// Created by Antonio Virgone on 04/03/16.
// Copyright © 2016 Antonio Virgone. All rights reserved.
//
import UIKit
class PreferitiController: BaseController, UICollectionViewDataSource, UICollectionViewDelegate
{
private var quadriArray = [QuadroNuovoArtista]()
@IBOutlet weak var collectionView: UICollectionView!
@IBOutlet weak var loadingIndicator: UIActivityIndicatorView!
override func viewDidLoad()
{
super.viewDidLoad()
}
override func viewWillAppear(animated: Bool) {
super.viewWillAppear(animated)
app.loadPreferiti(
{ (data) -> Void in
dispatch_async(dispatch_get_main_queue(), { () -> Void in
NSLog("data: \(data)")
let response = data["data"] as! [AnyObject]
for i in 0 ..< response.count {
let datiQuadro = response[i]["info"] as! [String : AnyObject]
if let quadro = datiQuadro["quadro"] as? [String : AnyObject] {
let foto = quadro["foto"] as! String
let urlBitmap = "http://www.iam-inquadrami.com/uploads/\(foto)"
let quadro = QuadroNuovoArtista(data: quadro, image: UIImage(data: NSData(contentsOfURL: NSURL(string: urlBitmap)!)!)!)
self.quadriArray.append(quadro)
}
}
self.loadingIndicator.stopAnimating()
self.collectionView.reloadData()
})
},
onError: { (error401, errorMessage) -> Void in
}
)
}
override func didReceiveMemoryWarning()
{
super.didReceiveMemoryWarning()
}
func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell
{
let quadro = quadriArray[indexPath.row]
let cell = collectionView.dequeueReusableCellWithReuseIdentifier("preferitiCell", forIndexPath: indexPath) as! PreferitiCell
cell.imageView.image = quadro.getFoto()
return cell
}
func collectionView(collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int
{
return quadriArray.count
}
func numberOfSectionsInCollectionView(collectionView: UICollectionView) -> Int
{
return 1
}
}
class PreferitiCell: UICollectionViewCell
{
@IBOutlet weak var imageView: UIImageView!
}
|
//
// RotatingNavigationController.swift
// adlantis_sample_swift
//
// Created on 05/09/2014.
// Copyright (c) 2014 Atlantis Inc. All rights reserved.
//
import UIKit
class RotatingNavigationController: UINavigationController {
override var shouldAutorotate : Bool {
return true
}
// override internal func supoortedInterfaceOrientations() -> UIInterfaceOrientationMask
// {
// let orientation: UIInterfaceOrientationMask = [UIInterfaceOrientationMask.portrait,UIInterfaceOrientationMask.portraitUpsideDown,UIInterfaceOrientationMask.landscapeRight,UIInterfaceOrientationMask.landscapeLeft]
// return UIInterfaceOrientationMask.all
// }
}
|
//
// NewsVMMock.swift
// CryptocurrencyNews
//
// Created by Kristijan Delivuk on 24/10/2017.
// Copyright © 2017 Kristijan Delivuk. All rights reserved.
//
import RxSwift
import Defines
final class NewsVMMock: NewsVMProtocol {
var titleObservable = Observable<String>.empty()
var priceInFiat: String = "Price in fiat"
var title: String = "Top 100"
let disposeBag: DisposeBag
// MARK: - Coordinator Actions
var onDidTapItem: ((Cryptocurrency) -> ()) = { _ in }
// MARK: - Public Properties
var numberOfRows: Int {
return items.count
}
lazy var stateObservable: Observable<NewsVMState> = self._state.asObservable().throttle(0.5, scheduler: MainScheduler.instance)
// MARK: - Private Properties
private var items: [Cryptocurrency]
private let _state: Variable<NewsVMState>
// MARK: - Class Lifecycle
init() {
_state = Variable(NewsVMState.top([]))
items = CurrencyMock.generateData()
disposeBag = DisposeBag()
}
// MARK: - Public Methods
func item(for indexPath: IndexPath) -> Cryptocurrency {
return items[indexPath.row]
}
func didSelectItem(at indexPath: IndexPath) {
onDidTapItem(items[indexPath.row])
}
func clear() {
items = []
}
func search(word: String) {
// set state to searching which enables spinner
// while quering for result
_state.value = .search(.searching)
// if there are more than 0 characters currently
// present in the searchbar
if word.count > 0 {
// query through all the mock items and find ones that contain search word
items = CurrencyMock.generateData().filter({$0.name.lowercased().contains(word.lowercased())})
// if there are no items that satisfy our search result
// set the empty state for search table view
if items.count == 0 {
items = []
_state.value = NewsVMState.search(SearchResultState.empty)
} else {
// else return those items and show them to user
_state.value = NewsVMState.search(SearchResultState.results(items))
}
} else {
// if the search bar is empty
// show the top 100 results to the user
items = CurrencyMock.generateData()
_state.value = NewsVMState.top(items)
}
}
func top() {
}
}
struct CurrencyMock {
static private var currencies: [Cryptocurrency] = [
// Currency(rank: "1", name: "bitcoin", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "2", name: "ethereum", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "3", name: "ripple", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "4", name: "bitcoin-cash", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "5", name: "litecoin", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "6", name: "dash", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "7", name: "neo", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "8", name: "bitconnect", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "9", name: "monero", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "10", name: "iota", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "11", name: "ethereum-classic", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "12", name: "qtum", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "13", name: "cardano", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "14", name: "stellar", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "15", name: "lisk", priceInFiat: "5738.89", changeIn24h: 3113190000.0),
// Currency(rank: "16", name: "zcash", priceInFiat: "5738.89", changeIn24h: 3113190000.0)
]
static func generateData() -> [Cryptocurrency] {
return currencies
}
}
|
//
// popView.swift
// honyakun
//
// Created by WKC on 2016/09/10.
// Copyright © 2016年 WKC. All rights reserved.
//
import Foundation
protocol popViewProt:class {
func protReturn(_ text:String)
}
class popView:UIView,LangInfoProt{
var delegate:popViewProt?
var buttons = [UIButton]()
let langList:[String] = ["en","es","fr","zh-CHS","ko","de","ru","it"]
let langTitle:[String] = ["英語","スペイン語","フランス語","中国語","韓国語","ドイツ語","ロシア語","イタリア語"]
let colorList:[UInt] = [0xC91380,0xED0E3F,0xF36C20,0xFFCC2F,0x50AE24,0x1AA2C4,0x0A5299,0x021479]
let ulist:[UInt] = [0xDDDDDD]
override init(frame:CGRect){
super.init(frame: frame)
initButtons()
self.backgroundColor = UIColorFromRGB(0xFFFFFF)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
func LangInfoProt(_ text: String) {
delegate?.protReturn(text)
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
self.next
}
}
extension popView{
func initButtons(){
for i in 0 ... 7{
let button = LangInfoButton(frame:CGRect(x: 0,y: CGFloat(i)*40,width: 300,height: 40),lang: langList[i],title: langTitle[i],color: colorList[i])
self.addSubview(button)
button.delegate = self
}
}
}
protocol LangInfoProt:class{
func LangInfoProt(_ text:String)
}
class LangInfoButton:UIButton{
var lang = ""
weak var delegate:LangInfoProt?
init(frame:CGRect,lang:String,title:String,color:UInt){
super.init(frame: frame)
self.lang=lang
self.setTitle(title, for: UIControlState())
self.tintColor = UIColorFromRGB(color)
self.setTitleColor(UIColorFromRGB(color), for: UIControlState())
self.layer.borderWidth = 0.3
self.layer.borderColor = UIColorFromRGB(0xCCCCCC).cgColor
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
delegate?.LangInfoProt(self.lang)
}
}
extension popView {
func UIColorFromRGB(_ rgbValue: UInt) -> UIColor {
return UIColor(
red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
alpha: CGFloat(1.0)
)
}
}
extension LangInfoButton {
func UIColorFromRGB(_ rgbValue: UInt) -> UIColor {
return UIColor(
red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
alpha: CGFloat(1.0)
)
}
}
|
//
// SectionCreator.swift
// RSSReader
//
// Created by Noah Davis on 8/6/16.
// Copyright © 2016 Noah Davis. All rights reserved.
//
import Foundation
class SectionCreator {
var returnSourceTitles = ["Action", "Drama", "Science Fiction", "Kids", "Horror"]
func addSource (_ title: Array<String>) -> Array<String> {
returnSourceTitles += title
return returnSourceTitles
}
}
|
//
// Ant.swift
// AntColonyOptimization
//
// Created by Zackery leman on 4/5/15.
// Copyright (c) 2015 Zleman. All rights reserved.
//
import Foundation
class Ant{
var currentTour: Tour = Tour()
var currentCity:Int!
var remainingCities: [Int]!
init(){
}
}
class Tour: Printable{
var edgesInTour: [String:Edge] = [:]
lazy var length: Double = { [unowned self] in
return self.sumEdgeDistance() }()
init(){}
private func sumEdgeDistance() -> Double{
var sum = 0.0
for (name,edge) in edgesInTour{
sum += edge.euclideanDistance!
}
return sum
}
var description: String {
return "\(length)"
}
} |
//
// FlickrClient.swift
// Virtual Tourist
//
// Created by Che-Chuen Ho on 6/22/15.
// Copyright (c) 2015 Che-Chuen Ho. All rights reserved.
//
import Foundation
import UIKit
class FlickrClient: NSObject {
class func sharedInstance() -> FlickrClient {
struct Singleton {
static var sharedInstance = FlickrClient()
}
return Singleton.sharedInstance
}
func getBBoxString(latitude: Double, longitude: Double, meters: Double) -> String {
let distance = meters * 0.00001
var lowerLeftLat: Double
var upperRightLat: Double
var lowerLeftLong: Double
var upperRightLong: Double
if latitude > 0 {
lowerLeftLat = latitude - distance
upperRightLat = latitude + distance
} else {
lowerLeftLat = latitude + distance
upperRightLat = latitude - distance
}
if longitude > 0 {
lowerLeftLong = longitude + distance
upperRightLong = longitude - distance
} else {
lowerLeftLong = longitude - distance
upperRightLong = longitude + distance
}
return "\(lowerLeftLong), \(lowerLeftLat), \(upperRightLong), \(upperRightLat)"
}
func searchByLatLong(pin: Location, completionHandler: (success: Bool, data: [[String: AnyObject]]?, total: Int?, error: NSError?) -> Void) {
let arguments = [
"method": Methods.Method_Name,
"api_key": Constants.API_Key,
"bbox": getBBoxString(pin.latitude.doubleValue, longitude: pin.longitude.doubleValue, meters: 10),
"extras": Keys.Extras,
"format": Keys.Data_Format,
"nojsoncallback": Keys.No_JSON_Callback,
"content_type": Keys.Photos_Only
]
let urlString = Constants.Base_URL + UtilityMethods.escapedParameters(arguments)
let url = NSURL(string: urlString)!
let request = NSURLRequest(URL: url)
sendRequest(request) {
success, data, total, error in
completionHandler(success: success, data: data, total: total, error: error)
}
}
func getNextPage(pin: Location, downloadedPage: Int, completionHandler: (success: Bool, data: [[String: AnyObject]]?, total: Int?, error: NSError?) -> Void) {
let nextPage = downloadedPage + 1
let arguments = [
"method": Methods.Method_Name,
"api_key": Constants.API_Key,
"bbox": getBBoxString(pin.latitude.doubleValue, longitude: pin.longitude.doubleValue, meters: 10),
"extras": Keys.Extras,
"format": Keys.Data_Format,
"nojsoncallback": Keys.No_JSON_Callback,
"content_type": Keys.Photos_Only,
"page": nextPage
]
let urlString = Constants.Base_URL + UtilityMethods.escapedParameters(arguments as! [String : AnyObject])
let url = NSURL(string: urlString)!
let request = NSURLRequest(URL: url)
sendRequest(request) {
success, data, total, error in
completionHandler(success: success, data: data, total: total, error: error)
}
}
func sendRequest(request: NSURLRequest, completionHandler: (success: Bool, data: [[String: AnyObject]]?, total: Int?, error: NSError?) -> Void) {
let session = NSURLSession.sharedSession()
let task = session.dataTaskWithRequest(request) {
data, response, downloadError in
dispatch_async(dispatch_get_main_queue()) {
UIApplication.sharedApplication().networkActivityIndicatorVisible = false
}
if let error = downloadError {
println("Could not complete ther request: \(error)")
completionHandler(success: false, data: nil, total: nil, error: error)
} else {
var parsingError: NSError? = nil
let parsedResults: AnyObject! = NSJSONSerialization.JSONObjectWithData(data, options: .AllowFragments, error: &parsingError)
if let photosDictionary = parsedResults.valueForKey(JSONKeys.Photo_Dictionary) as? NSDictionary {
let count = photosDictionary.valueForKey(JSONKeys.Photo_Pages) as? Int
if let photoArray = photosDictionary.valueForKey(JSONKeys.Photo_Array) as? [[String: AnyObject]] {
completionHandler(success: true, data: photoArray, total: count, error: nil)
} else {
completionHandler(success: false, data: nil, total: nil, error: NSError(domain: VirtualTouristError.DOMAIN, code: VirtualTouristError.ErrorCodes.FlickrPhotoArrayError, userInfo: [VirtualTouristError.UserInfoKeys.DESCRIPTION: "There was a problem retrieving the photos array from Flickr."]))
}
} else {
completionHandler(success: false, data: nil, total: nil, error: NSError(domain: VirtualTouristError.DOMAIN, code: VirtualTouristError.ErrorCodes.FlickrPhotoDictionaryError, userInfo: [VirtualTouristError.UserInfoKeys.DESCRIPTION: "There was a problem retrieving the photos dictionary from Flickr."]))
}
}
}
dispatch_async(dispatch_get_main_queue()) {
UIApplication.sharedApplication().networkActivityIndicatorVisible = true
}
task.resume()
}
func downloadPhoto(urlString: String) -> UIImage? {
if let url = NSURL(string: urlString) {
if let data = NSData(contentsOfURL: url) {
return UIImage(data: data)
}
}
return nil
}
} |
//
// Post+CoreDataClass.swift
// PersistenceDemo
//
// Created by Mark Randall on 7/30/19.
// Copyright © 2019 Mark Randall. All rights reserved.
//
//
import Foundation
import CoreData
struct PostAttribute {
static let content = "content"
static let created = "created"
static let id = "id"
static let lastEdited = "lastEdited"
static let title = "title"
}
struct PostRelationship {
static let tags = "tags"
}
@objc(Post)
public class Post: NSManagedObject {
}
|
//
// VolleyBallSceneExtension.swift
// VolleyMan
//
// Created by User on 12.07.15.
// Copyright (c) 2015 akkretov. All rights reserved.
//
import Foundation
import SpriteKit
extension VolleyBallScene {
/* initial scene configuration */
func initializeScene() {
physicsWorld.gravity = CGVectorMake(0, -3)
physicsWorld.contactDelegate = self
initializeGeneralNodes()
initializePlayers()
initializeEdges()
}
func initializeGeneralNodes () {
background.size = screenSize
background.position = CGPointMake(0, 0)
background.anchorPoint = CGPointMake(0, 0)
background.name = "background"
self.addChild(background)
scoreLabel.position = CGPointMake(screenSize.width - 50, screenSize.height - 40)
scoreLabel.fontColor = UIColor.whiteColor()
scoreLabel.fontName = "Helvetica-Bold"
scoreLabel.fontSize = 30
self.addChild(scoreLabel)
counterLabel.position = CGPointMake(screenSize.width / 2.0, screenSize.height - 100)
counterLabel.fontColor = UIColor.whiteColor()
counterLabel.fontName = "Helvetica-Bold"
counterLabel.fontSize = 40
net.size = CGSizeMake(10, screenSize.height * 0.55)
net.position = CGPointMake(screenSize.width / 2.0, net.size.height / 2.0)
net.name = "net"
net.physicsBody = SKPhysicsBody(rectangleOfSize: net.size)
net.physicsBody!.dynamic = false
self.addChild(net)
ball.prepareBall("ball")
ball.position = CGPointMake(screenSize.width * 0.75, screenSize.height - ball.size.height)
self.addChild(ball)
}
func initializeEdges () {
var bottomEdge = SKShapeNode(rect: CGRectMake(0, 0, screenSize.width, 1))
bottomEdge.position = CGPointMake(screenSize.width / 2.0, 0)
bottomEdge.name = "bottomEdge"
bottomEdge.physicsBody = SKPhysicsBody(rectangleOfSize: bottomEdge.frame.size)
bottomEdge.physicsBody!.dynamic = false
bottomEdge.physicsBody!.categoryBitMask = PhysicsCategory.All
self.addChild(bottomEdge)
var leftEdge = SKShapeNode(rect: CGRectMake(0, 0, 1, 10000))
leftEdge.position = CGPointZero
leftEdge.name = "leftEdge"
leftEdge.physicsBody = SKPhysicsBody(rectangleOfSize: leftEdge.frame.size)
leftEdge.physicsBody!.dynamic = false
leftEdge.physicsBody!.categoryBitMask = PhysicsCategory.All
self.addChild(leftEdge)
var rightEdge = SKShapeNode(rect: CGRectMake(0, 0, 1, 10000))
rightEdge.position = CGPointMake(screenSize.width, 0)
rightEdge.name = "rightEdge"
rightEdge.physicsBody = SKPhysicsBody(rectangleOfSize: rightEdge.frame.size)
rightEdge.physicsBody!.dynamic = false
rightEdge.physicsBody?.categoryBitMask = PhysicsCategory.All
self.addChild(rightEdge)
}
func initializePlayers () {
systemPlayer.prepareForUsing("systemPlayer")
self.addChild(systemPlayer)
manPlayer.prepareForUsing("manPlayer")
self.addChild(manPlayer)
}
func refreshPlayersState () {
systemPlayer.runAction(SKAction.moveTo(CGPointMake(screenSize.width * 0.25, systemPlayer.size.height / 2.0), duration: 0.0))
manPlayer.runAction(SKAction.moveTo(CGPointMake(screenSize.width * 0.75, manPlayer.size.height / 2.0), duration: 0.0))
systemPlayer.physicsBody!.velocity = CGVectorMake(0, 0)
manPlayer.physicsBody!.velocity = CGVectorMake(0, 0)
}
/* helpers */
func random() -> CGFloat {
return CGFloat(Float(arc4random()) / 0xFFFFFFFF)
}
func random(#min: CGFloat, max: CGFloat) -> CGFloat {
return random() * (max - min) + min
}
}
|
//
// AudioPlayerTest.swift
// AudioControllerTests
//
// Created by Admin on 12/12/17.
// Copyright © 2017 newbeeCorp. All rights reserved.
//
@testable import AudioController
import XCTest
class AudioPlayerTest: XCTestCase {
var audioPlayerServiceMock: AudioPlayerServiceMock!
var fileAdapter: IOFileAdapterMock!
var audioPlayer: AudioPlayer!
override func setUp() {
super.setUp()
audioPlayerServiceMock = AudioPlayerServiceMock()
fileAdapter = IOFileAdapterMock()
audioPlayer = AudioPlayer(audioPlayerService: audioPlayerServiceMock ,
fileAdapter: fileAdapter)
}
func testRecord () {
audioPlayer.record()
XCTAssertTrue(audioPlayerServiceMock.isRecording)
XCTAssertTrue(audioPlayerServiceMock.hasCalled["recordWith"] ?? false)
XCTAssertTrue(fileAdapter.hasCalled["getDocumentDirectoryPath"] ?? false)
}
func testStopRecord() {
audioPlayer.stopRecord()
XCTAssertFalse(audioPlayerServiceMock.isRecording)
XCTAssertTrue(audioPlayerServiceMock.hasCalled["stopRecord"] ?? false)
}
func testPlay() {
audioPlayer.play()
XCTAssertTrue(audioPlayerServiceMock.isPlaying)
XCTAssertTrue(audioPlayerServiceMock.hasCalled["playWith"] ?? false)
XCTAssertTrue(fileAdapter.hasCalled["getDocumentDirectoryPath"] ?? false)
}
func testStopPlay() {
audioPlayer.stopPlay()
XCTAssertFalse(audioPlayerServiceMock.isPlaying)
XCTAssertTrue(audioPlayerServiceMock.hasCalled["stopPlay"] ?? false)
}
}
|
//
// CardsView.swift
// CS193P-3-GraphicalSet
//
// Created by Constantine Shatalov on 5/15/19.
// Copyright © 2019 Hexocat. All rights reserved.
//
import UIKit
extension CardsView {
struct SizeRatio {
static let cardWidthToHeight: CGFloat = 1.0 / 1.618
static let cardCornerRadiusToHeight: CGFloat = 0.035
static let cardsSpacingToGridCellHeight: CGFloat = 0.05
}
}
class CardsView: UIView {
private lazy var grid = Grid(layout: Grid.Layout.aspectRatio(SizeRatio.cardWidthToHeight))
func clearView() {
for subview in subviews {
subview.removeFromSuperview()
}
}
override func layoutSubviews() {
super.layoutSubviews()
grid.frame = bounds
grid.cellCount = subviews.count
let gridFrameInset = grid.cellSize.height * SizeRatio.cardsSpacingToGridCellHeight
let cardCornerRadius = grid.cellSize.height * SizeRatio.cardCornerRadiusToHeight
for (index, cardView) in subviews.enumerated() {
cardView.frame = grid[index]?.insetBy(dx: gridFrameInset, dy: gridFrameInset) ?? CGRect.zero
cardView.layer.cornerRadius = cardCornerRadius
cardView.layer.masksToBounds = true
}
}
}
|
/*
See LICENSE folder for this sample’s licensing information.
Abstract:
An enumeration of Quake fetch and consumption errors.
*/
import Foundation
enum QuakeError: Error {
case urlError
case networkUnavailable
case wrongDataFormat
case missingData
case creationError
}
extension QuakeError: LocalizedError {
public var errorDescription: String? {
switch self {
case .urlError:
return NSLocalizedString("Could not create a URL.", comment: "")
case .networkUnavailable:
return NSLocalizedString("Could not get data from the remote server.", comment: "")
case .wrongDataFormat:
return NSLocalizedString("Could not digest the fetched data.", comment: "")
case .missingData:
return NSLocalizedString("Found and will discard a quake missing a valid code, magnitude, place, or time.", comment: "")
case .creationError:
return NSLocalizedString("Failed to create a new Quake object.", comment: "")
}
}
}
|
//
// MWCityDataModel.swift
// MyWeather
//
// Created by zhang zhiyao on 10/31/15.
// Copyright © 2015 NJIT656. All rights reserved.
//
import Foundation
import UIKit
enum MWCityDataType : Int {
case current = 0b00000001
case five = 0b00000010
case sixteen = 0b00000100
}
protocol MWCityDataModelRequestDelegate {
func dataRequestResponse(dataModel : MWCityDataModel, dataTypes:[MWCityDataType])
}
private class MWCityDataTuple : NSObject {
var delegate : MWCityDataModelRequestDelegate!
var types : [MWCityDataType]!
init(adelegate:MWCityDataModelRequestDelegate,aTypes:[MWCityDataType]) {
super.init()
delegate = adelegate
types = aTypes
}
}
class MWCityDataModel: NSObject,NSCoding {
var cityid : String?
var country : String?
var name : String?
var lon : String?
var lat : String?
var zipcode : String?
var state : String?
var currentData : MWCurrentWeatherDataModel? = nil
var fiveDaysData : MW5DaysDataModel? = nil
var sixteenDaysData : MW16DaysDataModel? = nil
var dataRequests : NSMutableArray = NSMutableArray()
init(cityid:String,name:String,country:String,state:String,zipcode:String,lon:String,lat:String) {
super.init()
self.cityid = cityid
self.name = name
self.country = country
self.lon = lon
self.lat = lat
self.state = state
self.zipcode = zipcode
}
required convenience init?(coder aDecoder: NSCoder) {
guard let cityid = aDecoder.decodeObjectForKey("cityid") as? String,
let country = aDecoder.decodeObjectForKey("country") as? String,
let name = aDecoder.decodeObjectForKey("name") as? String,
let state = aDecoder.decodeObjectForKey("state") as? String,
let zipcode = aDecoder.decodeObjectForKey("zipcode") as? String,
let lon = aDecoder.decodeObjectForKey("lon") as? String,
let lat = aDecoder.decodeObjectForKey("lat") as? String
else {
return nil
}
self.init(cityid:cityid,name:name,country:country,state:state,zipcode:zipcode,lon:lon,lat:lat)
}
func encodeWithCoder(aCoder: NSCoder) {
aCoder.encodeObject(self.cityid, forKey: "cityid")
aCoder.encodeObject(self.country, forKey: "country")
aCoder.encodeObject(self.name, forKey: "name")
aCoder.encodeObject(self.state, forKey: "state")
aCoder.encodeObject(self.zipcode, forKey: "zipcode")
aCoder.encodeObject(self.lon, forKey: "lon")
aCoder.encodeObject(self.lat, forKey: "lat")
}
}
extension MWCityDataModel {
func requestCurrentDataModel() {
if self.currentData == nil {
let request : MWBaseRequest?
if let cityIdStr = self.cityid {
request = MWCurrentWeatherRequest(cityId: cityIdStr)
}
else if let aLat = self.lat, let aLon = self.lon {
request = MWCurrentWeatherRequest(latitude: aLat, longitude: aLon)
}
else if let aCityName = self.name {
request = MWCurrentWeatherRequest(cityName: aCityName)
}
else if let aZipcode = self.zipcode {
request = MWCurrentWeatherRequest(zipCode: aZipcode)
}
else {
request = nil
}
if let aRequest = request {
aRequest.request({ (resultDataModel) -> Void in
self.currentData = resultDataModel as? MWCurrentWeatherDataModel
self.checkAndResponseWaitingRequests()
}) { (err) -> Void in
print(err)
}
}
}
else {
self.checkAndResponseWaitingRequests()
}
}
func request5DaysDataModel() {
if self.fiveDaysData == nil {
let request : MWBaseRequest?
if let cityIdStr = self.cityid {
request = MW5DaysWeatherRequest(cityId: cityIdStr)
}
else if let aLat = self.lat, let aLon = self.lon {
request = MW5DaysWeatherRequest(latitude: aLat, longitude: aLon)
}
else if let aCityName = self.name {
request = MW5DaysWeatherRequest(cityName: aCityName)
}
else if let aZipcode = self.zipcode {
request = MW5DaysWeatherRequest(zipCode: aZipcode)
}
else {
request = nil
}
if let aRequest = request {
aRequest.request({ (resultDataModel) -> Void in
self.fiveDaysData = resultDataModel as? MW5DaysDataModel
self.checkAndResponseWaitingRequests()
}) { (err) -> Void in
print(err)
}
}
}
else {
self.checkAndResponseWaitingRequests()
}
}
func request16DaysDataModel() {
if self.sixteenDaysData == nil {
let request : MWBaseRequest?
if let cityIdStr = self.cityid {
request = MW16DaysWeatherRequest(cityId: cityIdStr)
}
else if let aLat = self.lat, let aLon = self.lon {
request = MW16DaysWeatherRequest(latitude: aLat, longitude: aLon)
}
else if let aCityName = self.name {
request = MW16DaysWeatherRequest(cityName: aCityName)
}
else if let aZipcode = self.zipcode {
request = MW16DaysWeatherRequest(zipCode: aZipcode)
}
else {
request = nil
}
if let aRequest = request {
aRequest.request({ (resultDataModel) -> Void in
self.sixteenDaysData = resultDataModel as? MW16DaysDataModel
self.checkAndResponseWaitingRequests()
}) { (err) -> Void in
print(err)
}
}
}
else {
self.checkAndResponseWaitingRequests()
}
}
private func checkAndResponseWaitingRequests() {
for aRequest in self.dataRequests {
let currentRequest : MWCityDataTuple = aRequest as! MWCityDataTuple
var isDataAllReady = true
if currentRequest.types.contains(.current) && self.currentData == nil {
isDataAllReady = false
}
if currentRequest.types.contains(.five) && self.fiveDaysData == nil {
isDataAllReady = false
}
if currentRequest.types.contains(.sixteen) && self.sixteenDaysData == nil {
isDataAllReady = false
}
if isDataAllReady {
currentRequest.delegate.dataRequestResponse(self, dataTypes:currentRequest.types)
self.removeRequest(currentRequest.delegate)
}
}
}
func checkIfDataReady(types:[MWCityDataType]) -> Bool {
if types.contains(.current) && self.currentData == nil {
return false
}
if types.contains(.five) && self.fiveDaysData == nil {
return false
}
if types.contains(.sixteen) && self.sixteenDaysData == nil {
return false
}
return true
}
func addRequest(delegate:MWCityDataModelRequestDelegate,types:[MWCityDataType]) {
let aRequest : MWCityDataTuple = MWCityDataTuple(adelegate: delegate,aTypes: types)
self.removeRequest(delegate)
self.dataRequests.addObject(aRequest)
if types.contains(.current) {
self.requestCurrentDataModel()
}
if types.contains(.five) {
self.request5DaysDataModel()
}
if types.contains(.sixteen) {
self.request16DaysDataModel()
}
}
func removeRequest(delegate:MWCityDataModelRequestDelegate) {
for aRequest in self.dataRequests {
let currentRequest : MWCityDataTuple = aRequest as! MWCityDataTuple
if currentRequest.delegate as! NSObject == delegate as! NSObject {
self.dataRequests.removeObject(currentRequest)
}
}
}
}
|
//
// findFriendsViewController.swift
// sleden2
//
// Created by Daniel Alvestad on 12/12/15.
// Copyright © 2015 Daniel Alvestad. All rights reserved.
//
import UIKit
import Parse
class findFriendsViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
var actInd: UIActivityIndicatorView = UIActivityIndicatorView(frame: CGRectMake(0,0,150,150)) as UIActivityIndicatorView
@IBOutlet weak var searchField: UITextField!
@IBOutlet weak var findFriendsTable: UITableView!
var users: FindFriends = FindFriends()
var searchResult: NSMutableArray! = NSMutableArray()
override func viewDidLoad() {
super.viewDidLoad()
// Oppretter Activity Indicator (Den som spinne i midten)
self.actInd.center = self.view.center
self.actInd.hidesWhenStopped = true
self.actInd.activityIndicatorViewStyle = UIActivityIndicatorViewStyle.Gray
view.addSubview(self.actInd)
let barViewController = self.tabBarController?.viewControllers
let myFriendsView = barViewController![0] as! myFrindsViewController
self.users.myFriends = myFriendsView.getFriends.myFriends
// Henter alle som er venner og plasserer de i getFriends objectet
users.allUsernames(self.findFriendsTable, acnInt: self.actInd)
self.findFriendsTable.reloadData()
}
// MARK - table view
func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return self.users.usersTable.count
}
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = self.findFriendsTable.dequeueReusableCellWithIdentifier("cell", forIndexPath: indexPath) as! tableViewCell
cell.titleLabel.text = "\((self.users.usersTable.objectAtIndex(indexPath.row) as? String)!) (\(self.users.usersIsFriendsTable.objectAtIndex(indexPath.row)))"
cell.addButton.tag = indexPath.row
return cell
}
@IBAction func searchButton(sender: AnyObject) {
if (searchField == nil) {
print("Error søkefeltet er tome!")
return
}
print(searchField.text!)
let queryUsers = PFQuery(className: "User")
queryUsers.whereKey("username", equalTo: searchField.text!)
queryUsers.findObjectsInBackgroundWithBlock({(objects: [PFObject]?, error: NSError?) -> Void in
if error == nil {
print("Fikk kontakt med databasen!!! :D :D :D")
print(objects)
for object in objects! {
print("Kom in i løkken")
let username = object["username"] as! String
print(username)
}
} else {
print(error)
}
})
// Loop trough all the objects inn class!!
}
}
|
import Foundation
//Write a function that returns true if a Tic-Tac-Toe board has a winner
public func checkBoardGame(board : [[String]]) -> Bool {
var diag1: [String] = []
var diag2: [String] = []
for row in board {
if (Set(row).count == 1) {
return true
}
}
for x in 0..<3 {
var vertical: [String] = []
for y in 0..<3 {
if (x == y) {
diag1.append(board[x][y])
diag2.append(board[x][2-y])
}
vertical.append(board[y][x])
}
if (Set(vertical).count == 1) {
return true
}
}
if (Set(diag1).count == 1 || Set(diag2).count == 1) {
return true
}
return false
}
|
//
// UICollectionView.swift
// XTAnimations
//
// Created by summerxx on 2023/3/18.
// Copyright © 2023 夏天然后. All rights reserved.
//
import Foundation
import UIKit
extension UICollectionView {
/// 注册 cell 类，identifier 为类名字符串
public func registerCell<T: UICollectionViewCell>(_ type: T.Type) {
let identifier = NSStringFromClass(type.self)
register(type, forCellWithReuseIdentifier: identifier)
}
/// 通过类名获取注册的 cell
public func dequeueReusableCell<T: UICollectionViewCell>(_ type: T.Type, for indexPath: IndexPath) -> T {
let identifier = NSStringFromClass(type.self)
guard let cell = dequeueReusableCell(withReuseIdentifier: identifier, for: indexPath) as? T else {
fatalError("\(type.self) was not registered")
}
return cell
}
}
extension UICollectionView {
/// 注册 header 类，identifier 为类名字符串
public func registerHeader<T: UICollectionReusableView>(_ type: T.Type) {
let identifier = NSStringFromClass(type.self)
register(type,
forSupplementaryViewOfKind: UICollectionView.elementKindSectionHeader,
withReuseIdentifier: identifier)
}
/// 通过类名获取注册的 header
public func dequeueReusableHeader<T: UICollectionReusableView>(_ type: T.Type, for indexPath: IndexPath) -> T {
let identifier = NSStringFromClass(type.self)
guard let header = dequeueReusableSupplementaryView(ofKind: UICollectionView.elementKindSectionHeader,
withReuseIdentifier: identifier,
for: indexPath) as? T
else {
fatalError("\(type.self) was not registered")
}
return header
}
}
extension UICollectionView {
/// 注册 footer 类，identifier 为类名字符串
public func registerFooter<T: UICollectionReusableView>(_ type: T.Type) {
let identifier = NSStringFromClass(type.self)
register(type,
forSupplementaryViewOfKind: UICollectionView.elementKindSectionFooter,
withReuseIdentifier: identifier)
}
/// 通过类名获取注册的 footer
public func dequeueReusableFooter<T: UICollectionReusableView>(_ type: T.Type, for indexPath: IndexPath) -> T {
let identifier = NSStringFromClass(type.self)
guard let footer = dequeueReusableSupplementaryView(ofKind: UICollectionView.elementKindSectionFooter,
withReuseIdentifier: identifier,
for: indexPath) as? T
else {
fatalError("\(type.self) was not registered")
}
return footer
}
}
|
//
// Tool+CoreDataClass.swift
// GriDot
//
// Created by 박찬울 on 2021/12/28.
//
//
import Foundation
import CoreData
@objc(Tool)
public class Tool: NSManagedObject {
}
|
//
// OnboardPartFive.swift
// Tipper
//
// Created by Ryan Romanchuk on 9/27/15.
// Copyright © 2015 Ryan Romanchuk. All rights reserved.
//
import UIKit
class OnboardPartFive: GAITrackedViewController, StandardViewController {
var provider: AWSCognitoCredentialsProvider!
var currentUser: CurrentUser!
var className = "OnboardPartFive"
var managedObjectContext: NSManagedObjectContext?
var market: Market!
weak var containerController: OnboardingViewController?
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
func didTapButton(sender: UIButton) {
log.verbose("")
API.sharedInstance.autotip({ (json, error) -> Void in
//
})
(parentViewController as! OnboardingPageControllerViewController).autoAdvance()
}
}
|
//
// ExchangeForexRates.swift
// Cryptohopper-iOS-SDK
//
// Created by Kaan Baris Bayrak on 04/11/2020.
//
import Foundation
public class ExchangeForexRates : Codable {
public private(set) var quoteCurrency : String?
public private(set) var currency : String?
public private(set) var exchangeRate : String?
private enum CodingKeys: String, CodingKey {
case quoteCurrency = "quoteCurrency"
case currency = "currency"
case exchangeRate = "exchange_rate"
}
}
|
//
// CustomAudioUnit.swift
// AudioEngine
//
// Created by cjfire on 2018/4/9.
// Copyright © 2018年 cjfire. All rights reserved.
//
import UIKit
import AVFoundation
class CustomAudioUnit: AVAudioUnitEffect {
}
|
//
// ConfigerUser-UI.swift
// MessageMyFriends
//
// Created by Anita Shen on 3/12/19.
// Copyright © 2019 Tyler Reinecke. All rights reserved.
//
import UIKit
extension ConfigUserVC {
/// Add signup screen elements
func uiSetup(){
profileImageSetup()
userNameSetup()
emailDisplay()
addTapDismiss()
}
func profileImageSetup(){
profileImage = UIButton(frame: CGRect(x: 0, y: view.frame.height / 10, width: view.frame.width, height: view.frame.height / 3))
profileImage.setImage(UIImage(named: "profile2"), for: .normal)
profileImage.contentMode = .scaleAspectFit
profileImage.imageView?.contentMode = .scaleAspectFill
profileImage.addTarget(self, action: #selector(imageTaking), for: .touchUpInside)
//view.insertSubview(eventImageButton, at: 0)
view.addSubview(profileImage)
}
@objc func imageTaking() {
let actionSheet = UIAlertController(title: "Select Photo From", message: nil, preferredStyle: .actionSheet)
actionSheet.addAction(UIAlertAction(title: "Camera", style: .default, handler: { (action) -> Void in
self.createImagePicker(preferredType: .camera)
}))
actionSheet.addAction(UIAlertAction(title: "Photo Gallery", style: .default, handler: { (action) -> Void in
self.createImagePicker(preferredType: .photoLibrary)
}))
actionSheet.addAction(UIAlertAction(title: "Cancel", style: .cancel, handler: nil))
self.present(actionSheet, animated: true)
}
@objc func createImagePicker(preferredType: UIImagePickerController.SourceType) {
let picker = UIImagePickerController()
picker.delegate = self
if(UIImagePickerController .isSourceTypeAvailable(UIImagePickerController.SourceType.camera)) {
picker.sourceType = preferredType
picker.mediaTypes = UIImagePickerController.availableMediaTypes(for: .photoLibrary)!
self.present(picker, animated: true, completion: nil)
}
else {
picker.sourceType = .photoLibrary
self.present(picker, animated: true, completion: nil)
}
}
@objc func imagePickerController(_ picker: UIImagePickerController,
didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]){
let chosenImage = info[UIImagePickerController.InfoKey.originalImage] as! UIImage
profileImage.setImage(chosenImage, for: .normal)
dismiss(animated:true, completion: nil)
FirebaseAPI().putUser(User(), chosenImage)
}
func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
dismiss(animated: true, completion: nil)
}
func userNameSetup(){
firstName = UITextField(frame: CGRect(x: view.frame.width / 12 , y: profileImage.frame.maxY + 50, width: view.frame.width - 80, height: 50))
firstName.text = "First Name"
firstName.font = UIFont(name: "Avenir", size: 28)
firstName.layer.cornerRadius = 7
firstName.textColor = UIColor(red:0.57, green:0.70, blue:0.95, alpha:1.0)
view.addSubview(firstName)
lastName = UITextField(frame: CGRect(x: view.frame.width / 12 , y: firstName.frame.maxY + 50, width: view.frame.width - 80, height: 50))
lastName.text = "Last Name"
lastName.font = UIFont(name: "Avenir", size: 28)
lastName.layer.cornerRadius = 7
lastName.textColor = UIColor(red:0.57, green:0.70, blue:0.95, alpha:1.0)
view.addSubview(lastName)
}
func emailDisplay(){
email = UILabel(frame: CGRect(x: view.frame.width / 12 , y: lastName.frame.maxY + 50, width: view.frame.width - 80, height: 50))
email.text = "Email: "
email.font = UIFont(name: "Avenir", size: 28)
email.textColor = UIColor(red:0.57, green:0.70, blue:0.95, alpha:1.0)
view.addSubview(email)
}
func addTapDismiss() {
view.addGestureRecognizer(UITapGestureRecognizer(target: firstName, action: #selector(resignFirstResponder)))
//view.addGestureRecognizer(UITapGestureRecognizer(target: lastName, action: #selector(resignFirstResponder)))
}
func addTapDismiss2() {
//view.addGestureRecognizer(UITapGestureRecognizer(target: firstName, action: #selector(resignFirstResponder)))
view.addGestureRecognizer(UITapGestureRecognizer(target: lastName, action: #selector(resignFirstResponder)))
}
func textFieldShouldReturn(_ textField: UITextField) -> Bool {
firstName.resignFirstResponder()
lastName.resignFirstResponder()
return true
}
}
|
//
// JSONDecoder.swift
// LocalizeWiz
//
// Created by John Warmann on 2020-01-22.
// Copyright © 2020 LocalizeWiz. All rights reserved.
//
import Foundation
extension JSONDecoder {
static let wizDecoder: JSONDecoder = {
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .formatted(DateFormatter.wizFormatter)
return decoder
}()
}
|
//
// UIButton+Animate.swift
// NutrAI
//
// Created by Thalys Viana on 04/07/19.
// Copyright © 2019 Vinicius Mangueira. All rights reserved.
//
import UIKit
extension UIButton {
func clickAnimation() {
UIView.animateKeyframes(withDuration: 0.3, delay: 0, options: .beginFromCurrentState, animations: {
UIView.addKeyframe(withRelativeStartTime: 0.15, relativeDuration: 0.15, animations: {
self.transform = CGAffineTransform(scaleX: 0.8, y: 0.8)
})
UIView.addKeyframe(withRelativeStartTime: 0.3, relativeDuration: 0.3, animations: {
self.transform = CGAffineTransform(scaleX: 1.0, y: 1.0)
})
})
}
func pulsate() {
let pulse = CASpringAnimation(keyPath: "transform.scale")
pulse.duration = 0.8
pulse.fromValue = 0.95
pulse.toValue = 1.0
pulse.autoreverses = false
pulse.initialVelocity = 0.2
pulse.damping = 1.0
layer.add(pulse, forKey: nil)
}
}
|
//
// DetailViewController.swift
// RxPlaygrounds
//
// Created by 杨弘宇 on 2016/9/17.
// Copyright © 2016年 杨弘宇. All rights reserved.
//
import UIKit
class DetailViewController: UIViewController {
@IBOutlet weak var playBarButtonItem: UIBarButtonItem!
@IBOutlet weak var majorTimeline: TimelineView!
@IBOutlet weak var parameterTimeline: TimelineView!
@IBOutlet weak var outputTimeline: TimelineView!
@IBOutlet weak var summaryLabel: UILabel!
@IBOutlet weak var formulaLabel: UILabel!
@IBOutlet weak var detailLabel: UILabel!
@IBOutlet weak var jumpToDocButton: UIButton!
@IBOutlet weak var parameterTimelineHeightConstraint: NSLayoutConstraint!
var performer = Performer()
var currentOperator: Operator? {
get {
return performer.currentOperator
}
set(value) {
performer.currentOperator = value
self.playBarButtonItem.isEnabled = true
}
}
override func viewDidLoad() {
super.viewDidLoad()
self.automaticallyAdjustsScrollViewInsets = false
self.playBarButtonItem.isEnabled = self.currentOperator != nil
self.jumpToDocButton.setBackgroundImage(UIImage.imageWithRoundRect(filled: UIColor(red:0.98, green:0.10, blue:0.59, alpha:1.00), radius: 6), for: .normal)
self.jumpToDocButton.setBackgroundImage(UIImage.imageWithRoundRect(filled: UIColor(red:0.95, green:0.10, blue:0.56, alpha:1.00), radius: 6), for: .normal)
self.jumpToDocButton.setTitleColor(UIColor(white: 1.0, alpha: 0.72), for: .highlighted)
self.performer.delegate = self
self.majorTimeline.delegate = self
self.parameterTimeline.delegate = self
self.outputTimeline.editable = false
self.summaryLabel.text = self.currentOperator?.summary
self.formulaLabel.text = self.currentOperator?.formula
self.detailLabel.text = self.currentOperator?.detailDocument
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
self.resetStage(resetAll: true)
}
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
}
// MARK: -
@IBAction func playButtonDidTap(_ sender: AnyObject) {
if self.performer.isPlaying {
self.performer.stop()
} else {
self.resetStage(resetAll: false)
self.performer.start()
}
(sender as! UIButton).isSelected = self.performer.isPlaying
}
func resetStage(resetAll: Bool) {
self.outputTimeline.clearMarbles()
self.majorTimeline.cursorPosition = 0
self.parameterTimeline.cursorPosition = 0
self.outputTimeline.cursorPosition = 0
if resetAll {
self.parameterTimeline.isHidden = self.currentOperator?.parameterInput == nil
self.parameterTimelineHeightConstraint.isActive = !self.parameterTimeline.isHidden
self.majorTimeline.clearMarbles()
self.parameterTimeline.clearMarbles()
self.currentOperator?.input.forEach { input in
let marble = MarbleView(frame: CGRect.zero)
marble.position = input.timeOffset
marble.textLabel.text = input.value.displayString
marble.backgroundColor = input.value.color
self.majorTimeline.addMarble(marble)
}
self.currentOperator?.parameterInput?.forEach { input in
let marble = MarbleView(frame: CGRect.zero)
marble.position = input.timeOffset
marble.textLabel.text = input.value.displayString
marble.backgroundColor = input.value.color
self.parameterTimeline.addMarble(marble)
}
}
}
}
extension DetailViewController: PerformerDelegate {
func performer(_ performer: Performer, didEmitOutputValue value: (Int8, SampleValue)) {
let marble = MarbleView(frame: CGRect.zero)
marble.position = value.0
marble.textLabel.text = value.1.displayString
marble.backgroundColor = value.1.color
self.outputTimeline.addMarble(marble)
}
func performer(didComplete performer: Performer) {
(self.playBarButtonItem.customView as! UIButton).isSelected = false
}
func performer(_ performer: Performer, didChangeProgress progress: Int8) {
self.majorTimeline.cursorPosition = progress
self.parameterTimeline.cursorPosition = progress
self.outputTimeline.cursorPosition = progress
}
}
extension DetailViewController: TimelineViewDelegate {
func timelineView(marblesDidChange view: TimelineView) {
if view == self.majorTimeline {
self.currentOperator?.input = view.marbles.enumerated().map { i, view -> SampleInput in
return SampleInput(value: self.currentOperator!.input[i].value, timeOffset: view.position)
}
} else {
self.currentOperator?.parameterInput = view.marbles.enumerated().map { i, view -> SampleInput in
return SampleInput(value: self.currentOperator!.parameterInput![i].value, timeOffset: view.position)
}
}
}
}
|
import Foundation
class TreeNode<T: Comparable> {
var value: T
var count: Int
var leftNode: TreeNode<T>?
var rightNode: TreeNode<T>?
init(value: T) {
self.value = value
self.count = 1
}
func insert(_ value: T) {
self.count += 1
if value < self.value {
if let leftNode = self.leftNode {
leftNode.insert(value)
} else {
self.leftNode = TreeNode(value: value)
}
} else {
if let rightNode = self.rightNode {
rightNode.insert(value)
} else {
self.rightNode = TreeNode(value: value)
}
}
}
func find(_ value: T) -> TreeNode? {
if value == self.value {
return self
} else if value < self.value {
if let leftNode = self.leftNode {
return leftNode.find(value)
} else {
return nil
}
} else {
if let rightNode = self.rightNode {
return rightNode.find(value)
} else {
return nil
}
}
}
func deleteAndReplace(_ value: T) -> (success: Bool, replacement: TreeNode?) {
if value < self.value {
// Smaller value
guard let result = self.leftNode?.deleteAndReplace(value) else {
return (false, self)
}
if result.success {
self.count -= 1
}
self.leftNode = result.replacement
return (result.success, self)
} else if value > self.value{
// Greater value
guard let result = self.rightNode?.deleteAndReplace(value) else {
return (false, self)
}
if result.success {
self.count -= 1
}
self.rightNode = result.replacement
return (result.success, self)
}
// The value is found
return (true, self.deleteAndReplace())
}
}
private extension TreeNode {
func findSmallest() -> TreeNode {
if let leftNode = self.leftNode {
return leftNode.findSmallest()
}
return self
}
func deleteAndReplace() -> TreeNode? {
guard let _ = self.leftNode else {
// Will be replaced by right node
let rightNode = self.rightNode
self.rightNode = nil
self.count = 1
return rightNode
}
guard let rightNode = self.rightNode else {
// Will be replaced by left node
self.count = 1
return self.leftNode
}
// Need to find a kid replacement
let replacement = rightNode.findSmallest()
self.rightNode = self.deleteAndReplace(replacement.value).replacement
self.count -= 1
self.value = replacement.value
return self
}
}
class Tree<T: Comparable> {
private(set) var root: TreeNode<T>?
func insert(_ value: T) {
if let root = self.root {
root.insert(value)
} else {
self.root = TreeNode(value: value)
}
}
func find(_ value: T) -> Bool {
if let root = self.root {
return root.find(value) != nil
} else {
return false
}
}
func delete(_ value: T) -> Bool {
if let root = self.root {
let result = root.deleteAndReplace(value)
self.root = result.replacement
return result.success
} else {
return false
}
}
}
let tree = Tree<Int>()
tree.insert(1)
tree.insert(2)
tree.insert(3)
tree.insert(4)
tree.insert(5)
tree.insert(6)
tree.insert(7)
tree.insert(8)
let result = tree.delete(5)
print("Deleted \(result)")
print(tree.find(5)) |
//
// Controller.swift
// CSVAssignment
//
// Created by Rukmani on 18/08/17.
// Copyright © 2017 rukmani. All rights reserved.
//
import Foundation
import Alamofire
import SwiftSoup
class Controller {
var delegate: CompletionHandler?
private var maxTempTextLinks = [String]()
private var minTempTextLinks = [String]()
private var meanTempTextLinks = [String]()
private var sunshineTextLinks = [String]()
private var rainfallTextLinks = [String]()
private var links = [[String]]()
private var dictData = [DataModel]()
public func getListOfTextFiles() {
let url = StaticURL.url
Alamofire.request(url).response { response in
let string = NSString(data: response.data!, encoding: String.Encoding.utf8.rawValue)
do {
let doc = try SwiftSoup.parse(string! as String)
do {
let textLinks = try doc.select("a").array()
for link in textLinks {
do {
let text = try link.attr("href")
if text.contains("/date/") && (text.contains("/UK.txt") || text.contains("/England.txt") || text.contains("/Wales.txt") || text.contains("/Scotland.txt")) {
if text.contains("/Tmax/") {
self.maxTempTextLinks.append(text)
}
if text.contains("/Tmin/") {
self.minTempTextLinks.append(text)
}
if text.contains("/Tmean/") {
self.meanTempTextLinks.append(text)
}
if text.contains("/Sunshine/") {
self.sunshineTextLinks.append(text)
}
if text.contains("/Rainfall/") {
self.rainfallTextLinks.append(text)
}
}
} catch {
print("error: ", error.localizedDescription)
}
}
} catch {
print("error: ", error.localizedDescription)
}
} catch {
print("error: ", error.localizedDescription)
}
self.links = [self.maxTempTextLinks, self.minTempTextLinks, self.meanTempTextLinks, self.sunshineTextLinks, self.rainfallTextLinks]
self.delegate?.onGettingTextFileLinks(links: self.links)
}
}
public func getDataOfTextFile(url: String, weatherParam: String, completed: @escaping GetDataCompletion) {
do {
let textFileData = try NSString(contentsOf: URL(string: url)!, encoding: String.Encoding.utf8.rawValue)
let lines = textFileData.components(separatedBy: "\n")
let regionCode = (lines[0].components(separatedBy: " ")).first
var keys = [String]()
var values = [String]()
for index in 7..<lines.count-1 {
let line = lines[index]
var word = ""
var spaceCount = 0
for ch in 0..<line.characters.count {
if line[ch] != " " {
word.append(line[ch])
spaceCount = 0
} else {
spaceCount += 1
let emptyvalues = spaceCount/7 //Assuming gap between two consecutive values
if emptyvalues > 0 {
spaceCount = 0
for _ in 1...emptyvalues {
if index == 7 {
keys.append("N/A")
} else {
values.append("N/A")
}
}
}
if index == 7 && word != "" {
keys.append(word)
} else if word != "" {
values.append(word)
}
word = ""
}
}
if index == 7 {
keys.append(word)
} else {
values.append(word)
}
if index>7 {
let diff = keys.count - values.count
if diff > 0 {
for _ in 1...diff {
values.append("N/A")
}
}
for i in 1..<keys.count {
if values[i] == "---" {
values[i] = "N/A"
}
let dictClassElement = DataModel(_regionCode: regionCode!, _weatherParam: weatherParam, _year: values[0], _key: keys[i], _value: values[i])
self.dictData.append(dictClassElement)
}
values.removeAll()
}
}
} catch {
print("error: ", error.localizedDescription)
}
completed(self.dictData)
}
}
|
import RealmSwift
import Foundation
class RealmManager {
let realm = try! Realm()
static let shared = RealmManager()
func beginWrite(){
realm.beginWrite()
}
func saveChanges(){
try! realm.commitWrite()
}
func discardChanges(){
if self.realm.isInWriteTransaction {
realm.cancelWrite()
}
}
}
|
//
// RealmRepository.swift
// OSOM_app
//
// Created by Miłosz Bugla on 09.12.2017.
//
import Foundation
import RealmSwift
import SwiftyBeaver
protocol RealmRepository: class {
associatedtype RealmEntityType
func addObject(object: RealmEntityType)
func removeObject(with id: String)
}
class RealmRepositoryImpl<T>: RealmRepository where T:Object {
typealias RealmEntityType = T
private let log = SwiftyBeaver.self
var realm: Realm {
get {
do {
let realm = try Realm()
return realm
}
catch {
assertionFailure("Could not access database: \(error)")
log.error("Could not access database: \(error)")
}
return self.realm
}
}
func addObject(object: RealmEntityType) {
do {
try realm.write {
realm.create(RealmEntityType.self, value: object)
}
} catch {
log.error("Could not add or update object")
}
}
func getObject(forPrimaryKey id: String) -> RealmEntityType? {
let object = realm.object(ofType: RealmEntityType.self, forPrimaryKey: id)
return object
}
func getObject() -> RealmEntityType? {
let object = realm.objects(RealmEntityType.self).first
return object
}
func getObjects(withPredicate predicate: String) -> Results<RealmEntityType> {
let objects = realm.objects(RealmEntityType.self).filter(predicate)
return objects
}
func getObjects() -> Results<RealmEntityType> {
let objects = realm.objects(RealmEntityType.self)
return objects
}
func removeObject(with id: String) {
guard let object = realm.object(ofType: RealmEntityType.self, forPrimaryKey: id) else {
return
}
realm.beginWrite()
realm.delete(object)
commitWrite()
}
func remove(list: Results<RealmEntityType>) {
realm.beginWrite()
realm.delete(list)
commitWrite()
}
func commitWrite() {
do {
try realm.commitWrite()
} catch {
log.error("Could not add or update object")
}
}
}
|
//
// GameViewController.swift
// WWDC
//
// Created by Marcelo Martimiano Junior on 20/03/2018.
// Copyright © 2018 Marcelove. All rights reserved.
//
import UIKit
import QuartzCore
import SceneKit
public class NavSystemViewController: UIViewController {
public var systemInterface: NaveInterface!
private var sceneName: String!
var sceneController: SceneController!
public override func viewDidLoad() {
super.viewDidLoad()
//================================================================================
// let frame = CGRect(origin: CGPoint.zero, size: CGSize(width: 600, height: 800))
// self.view = SCNView(frame: frame)
//==================================================================================
let scnView = self.view as! SCNView
self.sceneController = SceneController(scnView: scnView)
scnView.showsStatistics = true
// scnView.allowsCameraControl = true
scnView.debugOptions = SCNDebugOptions.showPhysicsShapes
self.systemInterface = self.sceneController
self.playground()
}
public override var shouldAutorotate: Bool {
return true
}
public override var prefersStatusBarHidden: Bool {
return true
}
public override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
if UIDevice.current.userInterfaceIdiom == .phone {
return .allButUpsideDown
} else {
return .all
}
}
public override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Release any cached data, images, etc that aren't in use.
}
public func page1() {
self.systemInterface.changeCamera(type: .upper)
self.systemInterface.setSpeed(goalSpeed: 70)
self.systemInterface.setupFrontalRadars(limitDistance: 10)
// self.systemInterface.showRadars()
func obstacleDetectedHandler() {
self.systemInterface.brakeTheCar()
}
self.systemInterface.obstacleDetected(handler: obstacleDetectedHandler)
}
public func playground() {
page1()
}
}
|
//
// Crypto.swift
// NGTools
//
// Created by Lambert, Romain (Ordinateur) on 2022-11-01.
// Copyright © 2022 Nuglif. All rights reserved.
//
import Foundation
public struct Crypto {
public enum CryptoError: Error {
case rsaKeyCreationError
case rsaEncryptionError
case rsaAlgorithmNotSupported
case aesKeyCreationError
case aesRandomBytesError
case aesEncryptionError
case aesDecryptionError
}
public static func encryptForAuthenticationServer(_ text: String, rsaPublicKey: String) throws -> String {
let serverEncryptor = CryptoBuilder.build()
return try serverEncryptor.encryptForAuthenticationServer(text, rsaPublicKey: rsaPublicKey)
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.