Datasets:

ammarnasr

/

the-stack-swift-clean

like 2

564be8d8c7b10b64c79f1338294e098df9a49354

// RUN: %empty-directory(%t) // RUN: %target-swift-frontend -emit-module -o %t/Foo.swiftmodule -emit-abi-descriptor-path %t/abi.json %S/Inputs/ConstExtraction/SimpleReferences.swift // RUN: %api-digester -deserialize-sdk -input-paths %t/abi.json -o %t.result // RUN: %FileCheck %s < %t/abi.json // CHECK: "offset": 249, // CHECK-NEXT: "length": 10, // CHECK-NEXT: "value": "\"abc\"", // CHECK-NEXT: "decl": "global_str" // CHECK: "kind": "IntegerLiteral", // CHECK-NEXT: "offset": 266, // CHECK-NEXT: "length": 10, // CHECK-NEXT: "value": "3", // CHECK-NEXT: "decl": "global_int" // CHECK: "kind": "FloatLiteral", // CHECK-NEXT: "offset": 283, // CHECK-NEXT: "length": 12, // CHECK-NEXT: "value": "3.2", // CHECK-NEXT: "decl": "global_float" // CHECK: "kind": "BooleanLiteral", // CHECK-NEXT: "offset": 302, // CHECK-NEXT: "length": 12, // CHECK-NEXT: "value": "false", // CHECK-NEXT: "decl": "class_bool" // CHECK: "kind": "Array", // CHECK-NEXT: "offset": 321, // CHECK-NEXT: "length": 11, // CHECK-NEXT: "value": "[2, 2, 3]", // CHECK-NEXT: "decl": "class_arr" // CHECK: "kind": "Dictionary", // CHECK-NEXT: "offset": 339, // CHECK-NEXT: "length": 12, // CHECK-NEXT: "value": "[(2, 1), (2, 1), (3, 1)]", // CHECK-NEXT: "decl": "class_dict"

1e44ed1f08032fcc9a207b5597f55228366356ef

// // ResponseDeserializer.swift // DRNet // // Created by Dariusz Rybicki on 02/11/14. // Copyright (c) 2014 Darrarski. All rights reserved. // import Foundation public protocol ResponseDeserializer { func deserializeResponseData(response: Response) -> (deserializedData: AnyObject?, errors: [NSError]?) }

0eb09d10aec343501b504470d48a2411b930a271

// // Enums.swift // Pirate Fleet // // Created by Jarrod Parkes on 8/26/15. // Copyright © 2015 Udacity. All rights reserved. // // MARK: - PlayerType enum PlayerType { case human, computer } // MARK: - ShipPieceOrientation enum ShipPieceOrientation { case endUp, endDown, endLeft, endRight, bodyVert, bodyHorz } // MARK: - Difficulty enum Difficulty: Int { case basic = 0, advanced } // MARK: - ShipSize enum ShipSize: Int { case small = 2, medium = 3, large = 4, xLarge = 5 }

08a075cd303c8723095919e6624fed5e143b1400

//Copyright (c) 2017 pikachu987 <[email protected]> // //Permission is hereby granted, free of charge, to any person obtaining a copy //of this software and associated documentation files (the "Software"), to deal //in the Software without restriction, including without limitation the rights //to use, copy, modify, merge, publish, distribute, sublicense, and/or sell //copies of the Software, and to permit persons to whom the Software is //furnished to do so, subject to the following conditions: // //The above copyright notice and this permission notice shall be included in //all copies or substantial portions of the Software. // //THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE //AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN //THE SOFTWARE. import UIKit public class PKCCrop: NSObject { public func cropViewController(_ image: UIImage, tag: Int = 0) -> PKCCropViewController{ let pkcCropVC = PKCCropViewController(image, tag: tag) return pkcCropVC } }

0339115c8a6df9c1ff7b70b625a1d646b86a357f

// // OfferEditTableViewController.swift // nextStudents // // Copyright © 2020 Tim Kohlstadt, Benedict Zendel. All rights reserved. // import UIKit import Firebase import FirebaseFirestore import ImagePicker class OfferEditTableViewController: UITableViewController, UIPickerViewDelegate, UIPickerViewDataSource, UITextFieldDelegate { // MARK: - Variables var pickerData = [["5", "10", "15", "30", "60"], ["1", "2", "3", "4", "5", "10", "15", "20", "24"], ["Min.", "Std."]] var pickerDataShown = [String]() var currentOffer: Offer? var imageViews = [UIImageView]() var deletedImages = [String]() var addedImages = [UIImageView]() // MARK: - IBOutlets @IBOutlet weak var offerNeedControl: UISegmentedControl! @IBOutlet weak var titleTextField: UITextField! @IBOutlet weak var descriptionTextField: UITextField! @IBOutlet weak var timePickerView: UIPickerView! @IBOutlet weak var createBarButtonItem: UIBarButtonItem! @IBOutlet weak var cancelBarButtonItem: UIBarButtonItem! @IBOutlet weak var deleteOfferCell: UITableViewCell! @IBOutlet weak var newOfferImageView: UIImageView! @IBOutlet weak var imageScrollView: UIScrollView! // MARK: - UIViewController events override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) // Must be set for func textFieldShouldReturn() titleTextField.delegate = self descriptionTextField.delegate = self if currentOffer != nil { titleTextField.text = currentOffer!.title createBarButtonItem.title = "Speichern" navigationItem.title = currentOffer!.title offerNeedControl.selectedSegmentIndex = currentOffer!.type == "Biete" ? 0 : 1 descriptionTextField.text = currentOffer!.description timePickerView.selectRow(pickerData[2].firstIndex(of: currentOffer!.timeFormat)!, inComponent: 1, animated: true) self.pickerView(self.timePickerView, didSelectRow: pickerData[2].firstIndex(of: currentOffer!.timeFormat)!, inComponent: 1) timePickerView.selectRow(pickerDataShown.firstIndex(of: currentOffer!.duration)!, inComponent: 0, animated: true) deleteOfferCell.isHidden = false MainController.dataService.getOfferPicturesReferences(for: currentOffer!.uid, completion: { references in for reference in references { MainController.dataService.getOfferPicture(from: reference, completion: { image in let newView = UIImageView(image: image) newView.accessibilityIdentifier = reference.name newView.frame.size.width = 115 newView.frame.size.height = 106 newView.contentMode = .scaleAspectFit let tapGesture = UITapGestureRecognizer(target: self, action: #selector(OfferEditTableViewController.imageTappedDelete(gesture:))) newView.addGestureRecognizer(tapGesture) newView.isUserInteractionEnabled = true self.imageViews.insert(newView, at: 0) self.imageScrollView.insertSubview(newView, at: 0) self.imageScrollView.contentSize.width = self.imageScrollView.frame.size.width + CGFloat(self.imageViews.count - 1) * self.newOfferImageView.frame.size.width + CGFloat(self.imageViews.count - 1) * 5.0 self.layoutImages(animated: false) }) } }) } } override func viewDidLoad() { super.viewDidLoad() timePickerView.delegate = self timePickerView.dataSource = self let tapGesture = UITapGestureRecognizer(target: self, action: #selector(OfferEditTableViewController.imageTapped(gesture:))) // Add it to the image view newOfferImageView.addGestureRecognizer(tapGesture) // Make sure imageView can be interacted with by user newOfferImageView.isUserInteractionEnabled = true } func numberOfComponents(in pickerView: UIPickerView) -> Int { return 2 } func pickerView(_ pickerView: UIPickerView, numberOfRowsInComponent component: Int) -> Int { if component == 0 { return pickerDataShown.count } else { return pickerData[2].count } } func pickerView(_ pickerView: UIPickerView, titleForRow row: Int, forComponent component: Int) -> String? { if component == 0 { return pickerDataShown[row] } else { return pickerData[2][row] } } func pickerView(_ pickerView: UIPickerView, didSelectRow row: Int, inComponent component: Int) { if component == 1 { pickerDataShown = pickerData[pickerView.selectedRow(inComponent: component)] pickerView.reloadComponent(0) } } override func prepare(for segue: UIStoryboardSegue, sender: Any?) { if let identifier = segue.identifier { switch identifier { case "backToOffers": let vc = segue.destination as! OffersTableViewController if vc.allOffers.count > OffersTableViewController.offersArray.count { vc.allOffers = OffersTableViewController.offersArray } default: break } } } // MARK: - Table view data source override func numberOfSections(in tableView: UITableView) -> Int { return 6 } override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return 1 } @IBAction func touchCancel(_ sender: UIBarButtonItem) { performSegue(withIdentifier: "backToOffers", sender: nil) } @IBAction func touchDelete(_ sender: UIButton) { let alert = UIAlertController( title: "Wollen Sie das Angebot wirklich löschen?", message: nil, preferredStyle: .alert) alert.addAction(UIAlertAction( title: "Ja", style: .default, handler: { (UIAlertAction) in MainController.dataService.deleteOffer(for: self.currentOffer!.uid) // Remove Offer object from array if let existingOffer = OffersTableViewController.offersArray.firstIndex(where: { $0.uid == self.currentOffer!.uid }) { OffersTableViewController.offersArray.remove(at: existingOffer) } self.performSegue(withIdentifier: "backToOffers", sender: nil) })) alert.addAction(UIAlertAction( title: "Abbrechen", style: .default, handler: nil)) self.present(alert, animated: true) } // MARK: - Methods @objc func imageTapped(gesture: UIGestureRecognizer) { // If the tapped view is a UIImageView then set it to imageview if (gesture.view as? UIImageView) != nil { let pickerController = ImagePickerController() pickerController.delegate = self present(pickerController, animated: true, completion: nil) } } @objc func imageTappedDelete(gesture: UIGestureRecognizer) { // If the tapped view is a UIImageView then set it to imageview if let gestureView = gesture.view as? UIImageView { if let index = imageViews.firstIndex(of: gestureView) { let deletedView = imageViews.remove(at: index) deletedView.removeFromSuperview() layoutImages(animated: true) if let identifier = deletedView.accessibilityIdentifier { deletedImages.append(identifier) } } if let index = addedImages.firstIndex(of: gestureView) { addedImages.remove(at: index) } } } private func layoutImages(animated: Bool) { var latestView = newOfferImageView for view in imageViews { let newX = latestView!.frame.origin.x + latestView!.frame.size.width + 5.0 let newY: CGFloat = imageScrollView.frame.origin.y + (imageScrollView.frame.size.height - view.frame.size.height) / 2 if animated { UIView.animate(withDuration: 0.5) { view.frame.origin = CGPoint(x: newX, y: newY) } } else { view.frame.origin = CGPoint(x: newX, y: newY) } latestView = view } } @IBAction func touchCreate(_ sender: UIBarButtonItem) { if titleTextField.text != nil && titleTextField.text != "" && descriptionTextField.text != nil && descriptionTextField.text != "" { // Show an animated waiting circle let indicatorView = self.activityIndicator(style: .medium, center: self.view.center) self.view.addSubview(indicatorView) indicatorView.startAnimating() if currentOffer != nil { saveOffer() } else { createOffer() } self.performSegue(withIdentifier: "backToOffers", sender: nil) } else { let alert = Utility.displayAlert(withTitle: "Fehler", withMessage: "Titel und Beschreibung müssen ausgefüllt sein.", withSignOut: false) self.present(alert, animated: true, completion: nil) } } private func createOffer() { let dict: [String: Any] = [ "date": Timestamp(), "title": titleTextField.text!, "type": offerNeedControl.titleForSegment(at: offerNeedControl.selectedSegmentIndex)!, "description": descriptionTextField.text!, "duration": pickerDataShown[timePickerView.selectedRow(inComponent: 0)], "timeFormat" : pickerData[2][timePickerView.selectedRow(inComponent: 1)] ] MainController.dataService.createOffer(with: dict, completion: { newOfferId in if let newOfferId = newOfferId { self.uploadImages(images: self.addedImages, for: newOfferId) } }) } private func saveOffer() { let dict: [String: Any] = [ "title": titleTextField.text ?? "", "type": offerNeedControl.titleForSegment(at: offerNeedControl.selectedSegmentIndex)!, "description": descriptionTextField.text ?? "", "duration": pickerDataShown[timePickerView.selectedRow(inComponent: 0)], "timeFormat" : pickerData[2][timePickerView.selectedRow(inComponent: 1)] ] MainController.dataService.updateOffer(with: dict, offerID: currentOffer!.uid) if !deletedImages.isEmpty { for imageID in deletedImages { MainController.dataService.deleteOfferPicture(for: currentOffer!.uid, imageID: imageID) } } self.uploadImages(images: self.addedImages, for: currentOffer!.uid) } private func uploadImages(currentOfferUID: String) { uploadImages(images: imageViews, for: currentOfferUID) } private func uploadImages(images: [UIImageView], for offerID: String) { if images.count > 0 { for view in images { if let image = view.image { MainController.dataService.uploadOfferPicture(image: image, offerID: offerID, completion: { // Don't go back to the offers TableView until the new image has been completely uploaded self.performSegue(withIdentifier: "backToOffers", sender: nil) }) } } } else { // Perform segue without having to wait for an image to be uploaded self.performSegue(withIdentifier: "backToOffers", sender: nil) } } private func activityIndicator(style: UIActivityIndicatorView.Style = .medium, frame: CGRect? = nil, center: CGPoint? = nil) -> UIActivityIndicatorView { let activityIndicatorView = UIActivityIndicatorView(style: style) if let frame = frame { activityIndicatorView.frame = frame } if let center = center { activityIndicatorView.center = center } return activityIndicatorView } // This function is called when you click return key in the text field. func textFieldShouldReturn(_ textField: UITextField) -> Bool { // Resign the first responder from textField to close the keyboard. textField.resignFirstResponder() return true } } // MARK: - Extensions extension OfferEditTableViewController: ImagePickerDelegate { func wrapperDidPress(_ imagePicker: ImagePickerController, images: [UIImage]) {} func doneButtonDidPress(_ imagePicker: ImagePickerController, images: [UIImage]) { var latestView = newOfferImageView for image in images { let newView = UIImageView(image: image) newView.frame.size.width = 115 newView.frame.size.height = 106 newView.contentMode = .scaleAspectFit imageScrollView.insertSubview(newView, at: 0) latestView = newView let tapGesture = UITapGestureRecognizer(target: self, action: #selector(OfferEditTableViewController.imageTappedDelete(gesture:))) latestView!.addGestureRecognizer(tapGesture) latestView!.isUserInteractionEnabled = true imageViews.insert(latestView!, at: 0) addedImages.append(latestView!) } imageScrollView.contentSize.width = imageScrollView.frame.size.width + CGFloat(imageViews.count - 1) * newOfferImageView.frame.size.width + CGFloat(imageViews.count - 1) * 5.0 layoutImages(animated: true) presentedViewController?.dismiss(animated: true, completion: nil) } func cancelButtonDidPress(_ imagePicker: ImagePickerController) { presentedViewController?.dismiss(animated: true, completion: nil) } }

f82e5c14a98a4277b827da9572798be713f79643

// // CoursePlayer.swift // PPPlayer_Example // // Created by 王小涛 on 2019/2/20. // Copyright © 2019 CocoaPods. All rights reserved. // import RxSwift struct PBCourse {} class CoursePlayer { // // var course = PublishSubject<PBCourse>() // // private let items: [Pla] // // init() { // course.subscribe(onNext: { // // }) // } }

e449fd0130c688011b7814418040a23188002962

// // AppDelegate.swift // Gemini // // Created by Vitaliy Malakhovskiy on 7/10/16. // Copyright © 2016 Vitalii Malakhovskyi. All rights reserved. // import Cocoa @NSApplicationMain class AppDelegate: NSObject, NSApplicationDelegate { @IBOutlet weak var window: NSWindow! let viewController = ViewControllerFactory.defaultViewController() func applicationDidFinishLaunching(aNotification: NSNotification) { window.contentView?.addSubview(viewController.view) } }

f55dd5f466ca477d73808f3fb2d3a3e2b21cd3ce

//////////////////////////////////////////////////////////////////////////// // // Copyright 2017 Realm Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // //////////////////////////////////////////////////////////////////////////// import UIKit import RxSwift import RxCocoa import Then import RxFeedback import RxGesture import EventBlankKit class SessionDetailsCell: UITableViewCell, ClassIdentifier { @IBOutlet weak var userImage: UIImageView! @IBOutlet weak var nameLabel: UILabel! @IBOutlet weak var twitterLabel: UILabel! @IBOutlet weak var websiteLabel: UILabel! @IBOutlet weak var btnToggleIsFavorite: UIButton! @IBOutlet weak var descriptionTextView: UITextView! @IBOutlet weak var sessionTitleLabel: UITextView! @IBOutlet weak var trackTitleLabel: UILabel! private var reuseBag = DisposeBag() private var viewModel: SessionDetailsCellViewModel! { didSet { populateFromViewModel() } } enum Event { case openPhoto, openTwitter, openWebsite, refresh case setIsFavorite(Bool) } static func createWith(_ dataSource: SectionedViewDataSourceType, tableView: UITableView, index: IndexPath, session: Session) -> SessionDetailsCell { return tableView.dequeueReusableCell(SessionDetailsCell.self).then { cell in cell.reuseBag = DisposeBag() cell.viewModel = SessionDetailsCellViewModel(session: session) cell.willAppear() } } override func awakeFromNib() { super.awakeFromNib() btnToggleIsFavorite.setImage(UIImage(named: "like-full")?.withRenderingMode(.alwaysTemplate), for: .selected) descriptionTextView.delegate = self } private func willAppear() { Observable<Any>.system( initialState: viewModel, reduce: updateState, scheduler: MainScheduler.instance, scheduledFeedback: bindUI) .subscribe() .disposed(by: reuseBag) //activate model viewModel.activate() } private func updateState(state: SessionDetailsCellViewModel, event: Event) -> SessionDetailsCellViewModel { switch event { case .openPhoto: showPhoto?() case .openTwitter: openTwitter() case .openWebsite: if let website = viewModel.session.speaker?.url, let websiteURL = URL(string: website) { openWebsite?(websiteURL) } case .refresh: populateFromViewModel() case .setIsFavorite(let isFavorite): viewModel.updateIsFavorite(isFavorite: isFavorite) btnToggleIsFavorite.animateSelect(scale: 0.8, completion: nil) _ = Notifications.toggleNotification(for: viewModel.session, on: isFavorite) .subscribe(onError: { print($0) }) } return state } private var bindUI: ((RxFeedback.ObservableSchedulerContext<SessionDetailsCellViewModel>) -> Observable<Event>) { return RxFeedback.bind(self) { this, state in let subscriptions = [ // favorite button this.viewModel.isFavorite .bind(to: this.btnToggleIsFavorite.rx.isSelected) ] let events = [ // tap image this.userImage.rx.tapGesture() .when(.recognized) .map { _ in Event.openPhoto }, // tap twitter button this.twitterLabel.rx.tapGesture() .when(.recognized) .map { _ in Event.openTwitter }, // tap website button this.websiteLabel.rx.tapGesture() .when(.recognized) .map { _ in Event.openWebsite }, // refresh cell data Observable.from(object: this.viewModel.session) .map { _ in Event.refresh }, //bind UI this.viewModel.isFavorite .sample(this.btnToggleIsFavorite.rx.tap) .map { isFavorite in Event.setIsFavorite(!isFavorite) } ] return RxFeedback.Bindings(subscriptions: subscriptions, events: events) } } func populateFromViewModel() { let session = viewModel.session nameLabel.text = session.speaker?.name let time = shortStyleDateFormatter.string(from: session.date) var textAttributes = [NSAttributedStringKey: Any]() textAttributes[NSAttributedStringKey.font] = UIFont.systemFont(ofSize: 22) sessionTitleLabel.attributedText = NSAttributedString( string: "\(time) \(session.title)\n", attributes: textAttributes) trackTitleLabel.text = (session.track?.track ?? "") + "\n" if let twitter = session.speaker?.twitter, !twitter.isEmpty { twitterLabel.text = twitter.hasPrefix("@") ? twitter : "@"+twitter } else { twitterLabel.text = nil } websiteLabel.text = session.speaker?.url //only way to force textview autosizing I found descriptionTextView.text = session.sessionDescription + "\n\n" if let photoUrl = session.speaker?.photoUrl, let url = URL(string: photoUrl) { let size = userImage.bounds.size userImage.kf.indicatorType = .activity userImage.kf.setImage(with: url, placeholder: nil, options: [.transition(.fade(0.1))], completionHandler: { [weak self] (image, error, cacheType, imageUrl) in guard let image = image else { return } self?.showPhoto = { PhotoPopupView.showImage(image, inView: UIApplication.shared.windows.first!) } image.asyncToSize(.fillSize(size), cornerRadius: size.width/2, completion: { result in self?.userImage.image = result }) }) } //theme let event = EventData.default(in: RealmProvider.event) sessionTitleLabel.textColor = event.mainColor trackTitleLabel.textColor = event.mainColor.lighter(amount: 0.1).desaturated() //check if in the past if Date().compare(.isLater(than: session.date)) { sessionTitleLabel.textColor = sessionTitleLabel.textColor?.desaturated(amount: 0.5).lighter() trackTitleLabel.textColor = sessionTitleLabel.textColor } } private var showPhoto: (()->Void)? var openWebsite: ((URL)->Void)? func openTwitter() { if let twitter = viewModel.session.speaker?.twitter { openWebsite?(twitterUrl(twitter)) } } } extension SessionDetailsCell { func textView(_ textView: UITextView, shouldInteractWithURL URL: Foundation.URL, inRange characterRange: NSRange) -> Bool { openWebsite?(URL) return false } }

ffbbb2dc67098cdeefb84cf2ee79ded61e03011c

// Generated by Lona Compiler 0.6.0 import AppKit import Foundation // MARK: - ImageWithBackgroundColor private class ImageWithBackgroundColor: LNAImageView { var fillColor = NSColor.clear override func draw(_ dirtyRect: NSRect) { fillColor.set() bounds.fill() super.draw(dirtyRect) } } // MARK: - PrimaryAxisFillSiblings public class PrimaryAxisFillSiblings: NSBox { // MARK: Lifecycle public init(_ parameters: Parameters) { self.parameters = parameters super.init(frame: .zero) setUpViews() setUpConstraints() update() } public convenience init() { self.init(Parameters()) } public required init?(coder aDecoder: NSCoder) { self.parameters = Parameters() super.init(coder: aDecoder) setUpViews() setUpConstraints() update() } // MARK: Public public var parameters: Parameters { didSet { if parameters != oldValue { update() } } } // MARK: Private private var horizontalView = NSBox() private var leftCardView = NSBox() private var imageView = ImageWithBackgroundColor() private var titleView = LNATextField(labelWithString: "") private var subtitleView = LNATextField(labelWithString: "") private var spacerView = NSBox() private var rightCardView = NSBox() private var image1View = ImageWithBackgroundColor() private var title1View = LNATextField(labelWithString: "") private var subtitle1View = LNATextField(labelWithString: "") private var titleViewTextStyle = TextStyles.body2 private var subtitleViewTextStyle = TextStyles.body1 private var title1ViewTextStyle = TextStyles.body2 private var subtitle1ViewTextStyle = TextStyles.body1 private func setUpViews() { boxType = .custom borderType = .noBorder contentViewMargins = .zero horizontalView.boxType = .custom horizontalView.borderType = .noBorder horizontalView.contentViewMargins = .zero leftCardView.boxType = .custom leftCardView.borderType = .noBorder leftCardView.contentViewMargins = .zero spacerView.boxType = .custom spacerView.borderType = .noBorder spacerView.contentViewMargins = .zero rightCardView.boxType = .custom rightCardView.borderType = .noBorder rightCardView.contentViewMargins = .zero titleView.lineBreakMode = .byWordWrapping subtitleView.lineBreakMode = .byWordWrapping title1View.lineBreakMode = .byWordWrapping subtitle1View.lineBreakMode = .byWordWrapping addSubview(horizontalView) horizontalView.addSubview(leftCardView) horizontalView.addSubview(spacerView) horizontalView.addSubview(rightCardView) leftCardView.addSubview(imageView) leftCardView.addSubview(titleView) leftCardView.addSubview(subtitleView) rightCardView.addSubview(image1View) rightCardView.addSubview(title1View) rightCardView.addSubview(subtitle1View) fillColor = Colors.teal50 horizontalView.fillColor = Colors.teal100 imageView.image = #imageLiteral(resourceName: "icon_128x128") imageView.fillColor = Colors.teal200 titleView.attributedStringValue = titleViewTextStyle.apply(to: "Title") titleViewTextStyle = TextStyles.body2 titleView.attributedStringValue = titleViewTextStyle.apply(to: titleView.attributedStringValue) subtitleView.attributedStringValue = subtitleViewTextStyle.apply(to: "Subtitle") subtitleViewTextStyle = TextStyles.body1 subtitleView.attributedStringValue = subtitleViewTextStyle.apply(to: subtitleView.attributedStringValue) spacerView.fillColor = #colorLiteral(red: 0.847058823529, green: 0.847058823529, blue: 0.847058823529, alpha: 1) image1View.image = #imageLiteral(resourceName: "icon_128x128") image1View.fillColor = Colors.teal200 title1View.attributedStringValue = title1ViewTextStyle.apply(to: "Title") title1ViewTextStyle = TextStyles.body2 title1View.attributedStringValue = title1ViewTextStyle.apply(to: title1View.attributedStringValue) subtitle1View.attributedStringValue = subtitle1ViewTextStyle.apply(to: "Subtitle") subtitle1ViewTextStyle = TextStyles.body1 subtitle1View.attributedStringValue = subtitle1ViewTextStyle.apply(to: subtitle1View.attributedStringValue) } private func setUpConstraints() { translatesAutoresizingMaskIntoConstraints = false horizontalView.translatesAutoresizingMaskIntoConstraints = false leftCardView.translatesAutoresizingMaskIntoConstraints = false spacerView.translatesAutoresizingMaskIntoConstraints = false rightCardView.translatesAutoresizingMaskIntoConstraints = false imageView.translatesAutoresizingMaskIntoConstraints = false titleView.translatesAutoresizingMaskIntoConstraints = false subtitleView.translatesAutoresizingMaskIntoConstraints = false image1View.translatesAutoresizingMaskIntoConstraints = false title1View.translatesAutoresizingMaskIntoConstraints = false subtitle1View.translatesAutoresizingMaskIntoConstraints = false let horizontalViewTopAnchorConstraint = horizontalView.topAnchor.constraint(equalTo: topAnchor, constant: 10) let horizontalViewBottomAnchorConstraint = horizontalView .bottomAnchor .constraint(equalTo: bottomAnchor, constant: -10) let horizontalViewLeadingAnchorConstraint = horizontalView .leadingAnchor .constraint(equalTo: leadingAnchor, constant: 10) let horizontalViewTrailingAnchorConstraint = horizontalView .trailingAnchor .constraint(equalTo: trailingAnchor, constant: -10) let leftCardViewRightCardViewWidthAnchorSiblingConstraint = leftCardView .widthAnchor .constraint(equalTo: rightCardView.widthAnchor) let leftCardViewHeightAnchorParentConstraint = leftCardView .heightAnchor .constraint(lessThanOrEqualTo: horizontalView.heightAnchor) let spacerViewHeightAnchorParentConstraint = spacerView .heightAnchor .constraint(lessThanOrEqualTo: horizontalView.heightAnchor) let rightCardViewHeightAnchorParentConstraint = rightCardView .heightAnchor .constraint(lessThanOrEqualTo: horizontalView.heightAnchor) let leftCardViewLeadingAnchorConstraint = leftCardView .leadingAnchor .constraint(equalTo: horizontalView.leadingAnchor) let leftCardViewTopAnchorConstraint = leftCardView.topAnchor.constraint(equalTo: horizontalView.topAnchor) let leftCardViewBottomAnchorConstraint = leftCardView.bottomAnchor.constraint(equalTo: horizontalView.bottomAnchor) let spacerViewLeadingAnchorConstraint = spacerView.leadingAnchor.constraint(equalTo: leftCardView.trailingAnchor) let spacerViewTopAnchorConstraint = spacerView.topAnchor.constraint(equalTo: horizontalView.topAnchor) let rightCardViewTrailingAnchorConstraint = rightCardView .trailingAnchor .constraint(equalTo: horizontalView.trailingAnchor) let rightCardViewLeadingAnchorConstraint = rightCardView .leadingAnchor .constraint(equalTo: spacerView.trailingAnchor) let rightCardViewTopAnchorConstraint = rightCardView.topAnchor.constraint(equalTo: horizontalView.topAnchor) let rightCardViewBottomAnchorConstraint = rightCardView .bottomAnchor .constraint(equalTo: horizontalView.bottomAnchor) let imageViewTopAnchorConstraint = imageView.topAnchor.constraint(equalTo: leftCardView.topAnchor) let imageViewLeadingAnchorConstraint = imageView.leadingAnchor.constraint(equalTo: leftCardView.leadingAnchor) let imageViewTrailingAnchorConstraint = imageView.trailingAnchor.constraint(equalTo: leftCardView.trailingAnchor) let titleViewTopAnchorConstraint = titleView.topAnchor.constraint(equalTo: imageView.bottomAnchor) let titleViewLeadingAnchorConstraint = titleView.leadingAnchor.constraint(equalTo: leftCardView.leadingAnchor) let titleViewTrailingAnchorConstraint = titleView.trailingAnchor.constraint(equalTo: leftCardView.trailingAnchor) let subtitleViewBottomAnchorConstraint = subtitleView.bottomAnchor.constraint(equalTo: leftCardView.bottomAnchor) let subtitleViewTopAnchorConstraint = subtitleView.topAnchor.constraint(equalTo: titleView.bottomAnchor) let subtitleViewLeadingAnchorConstraint = subtitleView.leadingAnchor.constraint(equalTo: leftCardView.leadingAnchor) let subtitleViewTrailingAnchorConstraint = subtitleView .trailingAnchor .constraint(equalTo: leftCardView.trailingAnchor) let spacerViewHeightAnchorConstraint = spacerView.heightAnchor.constraint(equalToConstant: 0) let spacerViewWidthAnchorConstraint = spacerView.widthAnchor.constraint(equalToConstant: 8) let image1ViewTopAnchorConstraint = image1View.topAnchor.constraint(equalTo: rightCardView.topAnchor) let image1ViewLeadingAnchorConstraint = image1View.leadingAnchor.constraint(equalTo: rightCardView.leadingAnchor) let image1ViewTrailingAnchorConstraint = image1View.trailingAnchor.constraint(equalTo: rightCardView.trailingAnchor) let title1ViewTopAnchorConstraint = title1View.topAnchor.constraint(equalTo: image1View.bottomAnchor) let title1ViewLeadingAnchorConstraint = title1View.leadingAnchor.constraint(equalTo: rightCardView.leadingAnchor) let title1ViewTrailingAnchorConstraint = title1View.trailingAnchor.constraint(equalTo: rightCardView.trailingAnchor) let subtitle1ViewBottomAnchorConstraint = subtitle1View.bottomAnchor.constraint(equalTo: rightCardView.bottomAnchor) let subtitle1ViewTopAnchorConstraint = subtitle1View.topAnchor.constraint(equalTo: title1View.bottomAnchor) let subtitle1ViewLeadingAnchorConstraint = subtitle1View .leadingAnchor .constraint(equalTo: rightCardView.leadingAnchor) let subtitle1ViewTrailingAnchorConstraint = subtitle1View .trailingAnchor .constraint(equalTo: rightCardView.trailingAnchor) let imageViewHeightAnchorConstraint = imageView.heightAnchor.constraint(equalToConstant: 100) let image1ViewHeightAnchorConstraint = image1View.heightAnchor.constraint(equalToConstant: 100) leftCardViewHeightAnchorParentConstraint.priority = NSLayoutConstraint.Priority.defaultLow spacerViewHeightAnchorParentConstraint.priority = NSLayoutConstraint.Priority.defaultLow rightCardViewHeightAnchorParentConstraint.priority = NSLayoutConstraint.Priority.defaultLow NSLayoutConstraint.activate([ horizontalViewTopAnchorConstraint, horizontalViewBottomAnchorConstraint, horizontalViewLeadingAnchorConstraint, horizontalViewTrailingAnchorConstraint, leftCardViewRightCardViewWidthAnchorSiblingConstraint, leftCardViewHeightAnchorParentConstraint, spacerViewHeightAnchorParentConstraint, rightCardViewHeightAnchorParentConstraint, leftCardViewLeadingAnchorConstraint, leftCardViewTopAnchorConstraint, leftCardViewBottomAnchorConstraint, spacerViewLeadingAnchorConstraint, spacerViewTopAnchorConstraint, rightCardViewTrailingAnchorConstraint, rightCardViewLeadingAnchorConstraint, rightCardViewTopAnchorConstraint, rightCardViewBottomAnchorConstraint, imageViewTopAnchorConstraint, imageViewLeadingAnchorConstraint, imageViewTrailingAnchorConstraint, titleViewTopAnchorConstraint, titleViewLeadingAnchorConstraint, titleViewTrailingAnchorConstraint, subtitleViewBottomAnchorConstraint, subtitleViewTopAnchorConstraint, subtitleViewLeadingAnchorConstraint, subtitleViewTrailingAnchorConstraint, spacerViewHeightAnchorConstraint, spacerViewWidthAnchorConstraint, image1ViewTopAnchorConstraint, image1ViewLeadingAnchorConstraint, image1ViewTrailingAnchorConstraint, title1ViewTopAnchorConstraint, title1ViewLeadingAnchorConstraint, title1ViewTrailingAnchorConstraint, subtitle1ViewBottomAnchorConstraint, subtitle1ViewTopAnchorConstraint, subtitle1ViewLeadingAnchorConstraint, subtitle1ViewTrailingAnchorConstraint, imageViewHeightAnchorConstraint, image1ViewHeightAnchorConstraint ]) } private func update() {} } // MARK: - Parameters extension PrimaryAxisFillSiblings { public struct Parameters: Equatable { public init() {} } } // MARK: - Model extension PrimaryAxisFillSiblings { public struct Model: LonaViewModel, Equatable { public var id: String? public var parameters: Parameters public var type: String { return "PrimaryAxisFillSiblings" } public init(id: String? = nil, parameters: Parameters) { self.id = id self.parameters = parameters } public init(_ parameters: Parameters) { self.parameters = parameters } public init() { self.init(Parameters()) } } }

28282311372eae3b09bda84d4e02205f31ebbe65

// // DetailVC.swift // AdvancedTableView // // Created by cemal tüysüz on 19.12.2021. // import UIKit class DetailVC: UIViewController { @IBOutlet weak var productDetailTitle: UILabel! @IBOutlet weak var productDetailımage: UIImageView! @IBOutlet weak var productDetailPrice: UILabel! var product:Product? override func viewDidLoad() { super.viewDidLoad() if let p = product { productDetailTitle.text = p.productName! productDetailımage.image = UIImage(named: p.productImage!) productDetailPrice.text = "\(p.productPrice!)₺" } } @IBAction func addToChart(_ sender: Any) { } }

90b0f4cd4ccf1cc1ac230258c65a350d49987142

// // SwiftUIView.swift // PasscodeLock // // Created by Devonly on 3/23/21. // Copyright © 2021 Yanko Dimitrov. All rights reserved. // import SwiftUI public struct PasscodeLockView: View, UIViewControllerRepresentable { public typealias LockState = PasscodeLockViewController.LockState @Environment(\.presentationMode) var present @Binding var isSucceed: Bool let type: LockState let configuration: PasscodeLockConfigurationType public init(isSucceed: Binding<Bool>, type: LockState, configuration: PasscodeLockConfigurationType) { self._isSucceed = isSucceed self.type = type self.configuration = configuration } public func makeUIViewController(context: Context) -> PasscodeLockViewController { let uiViewController = PasscodeLockViewController(state: type, configuration: configuration) uiViewController.successCallback = { lock in isSucceed = true } uiViewController.dismissCompletionCallback = { present.wrappedValue.dismiss() } return uiViewController } public func updateUIViewController(_ uiViewController: PasscodeLockViewController, context: Context) { } }

46bb15119ef352253146d851630d2c78023e113e

print("result: \(promise.result)")

76341714466d4b3e51e8bca7a5f5cb8450bcf5b7

// This source file is part of the Swift.org open source project // Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors // Licensed under Apache License v2.0 with Runtime Library Exception // // See http://swift.org/LICENSE.txt for license information // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors // RUN: not %target-swift-frontend %s -parse protocol A { func f: a(x: C = B struct q: Collection where B : b<T== "[B, x in x in 0) ->(g: B, AnyObject, U) protocol a { func d<B : b func n<Int) -> String { } import Foundatio: Any, self.f { } protocol b { typealias e: d(m

f5a5c191c4010b4f93696539d8be448fc7684856

// // Tool.swift // Drafter // // Created by Alex Veledzimovich on 11/11/19. // Copyright © 2019 Alex Veledzimovich. All rights reserved. // import Cocoa let tools: [Tool] = [ Drag(), Line(), Triangle(), Rectangle(), Pentagon(), Hexagon(), Star(), Arc(), Oval(), Stylus(), Vector(), Text() ] let toolsKeys: [String: Tool] = [ "m": tools[0], "l": tools[1], "t": tools[2], "r": tools[3], "p": tools[4], "h": tools[5], "s": tools[6], "a": tools[7], "o": tools[8], "d": tools[9], "v": tools[10], "f": tools[11]] protocol Drawable { var tag: Int { get } var name: String { get } func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent?) func move(shift: Bool, fn: Bool) func drag(shift: Bool, fn: Bool) func down(ctrl: Bool) func up(editDone: Bool) } class Tool: Drawable { var tag: Int {-1} var cursor: NSCursor {NSCursor.arrow} static var view: SketchPad? func useTool(_ action: @autoclosure () -> Void) { Tool.view!.editedPath = NSBezierPath() action() if Tool.view!.filledCurve { Tool.view!.editedPath.close() } Tool.view!.editDone = true } func flipSize(topLeft: CGPoint, bottomRight: CGPoint) -> (wid: CGFloat, hei: CGFloat) { return (bottomRight.x - topLeft.x, bottomRight.y - topLeft.y) } func appendStraightCurves(points: [CGPoint]) { Tool.view!.controlPoints = [] Tool.view!.editedPath.move(to: points[0]) for i in 0..<points.count { let pnt = points[i] Tool.view!.controlPoints.append( ControlPoint(Tool.view!, cp1: pnt, cp2: pnt, mp: pnt)) if i == points.count-1 { Tool.view!.editedPath.curve(to: points[0], controlPoint1: points[0], controlPoint2: points[0]) } else { Tool.view!.editedPath.curve(to: points[i+1], controlPoint1: points[i+1], controlPoint2: points[i+1]) } } } var mpPoints: [CGPoint] { return [Tool.view!.startPos] } // MARK: Protocol var name: String {"shape"} func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { } func move(shift: Bool, fn: Bool) { var mpPoints: [CGPoint] = [] if let mp = Tool.view!.movePoint { mpPoints.append(mp.position) } for cp in Tool.view!.controlPoints { mpPoints.append(cp.mp.position) } var mPos = Tool.view!.startPos var snap = CGPoint() if let pos = mpPoints.first, shift { Tool.view!.locationX.isHidden = true Tool.view!.locationY.isHidden = true Tool.view!.startPos = Tool.view!.shiftAngle( topLeft: pos, bottomRight: Tool.view!.startPos) mPos = pos Tool.view!.setLabel(key: "x", pos: mPos, dist: Tool.view!.startPos.magnitude( origin: mPos)) Tool.view!.rulers.appendCustomRule(move: mPos, line: Tool.view!.startPos) } else { snap = Tool.view!.snapToRulers(points: [Tool.view!.startPos], curves: Tool.view!.curves, curvePoints: mpPoints, fn: fn) } Tool.view!.startPos.x -= snap.x Tool.view!.startPos.y -= snap.y Tool.view!.snapMouseToRulers(snap: snap, pos: Tool.view!.startPos) if let mp = Tool.view!.movePoint, let cp1 = Tool.view!.controlPoint1 { Tool.view!.moveCurvedPath(move: mp.position, to: Tool.view!.startPos, cp1: mp.position, cp2: cp1.position) } } func drag(shift: Bool, fn: Bool) { let snap = Tool.view!.snapToRulers( points: [Tool.view!.finPos], curves: Tool.view!.curves, curvePoints: mpPoints, fn: fn) Tool.view!.finPos.x -= snap.x Tool.view!.finPos.y -= snap.y Tool.view!.snapMouseToRulers(snap: snap, pos: Tool.view!.finPos) } func down(ctrl: Bool) { Tool.view!.controlPoints = [] Tool.view!.editedPath.removeAllPoints() } func up(editDone: Bool) { if let curve = Tool.view!.selectedCurve { Tool.view!.clearControls(curve: curve) } else { if Tool.view!.groups.count>1 { Tool.view!.selectedCurve = Tool.view!.groups[0] } } if editDone { Tool.view!.newCurve() } if let curve = Tool.view!.selectedCurve, !curve.canvas.isHidden { curve.reset() Tool.view!.createControls(curve: curve) } } } class Drag: Tool { override var tag: Int {0} override var name: String {"drag"} func action(topLeft: CGPoint, bottomRight: CGPoint) { let size = self.flipSize(topLeft: topLeft, bottomRight: bottomRight) Tool.view!.curvedPath.appendRect(NSRect( x: topLeft.x, y: topLeft.y, width: size.wid, height: size.hei)) if let curve = Tool.view!.selectedCurve, curve.edit { for point in curve.points { if Tool.view!.curvedPath.bounds.contains(point.mp.position) { point.showControlDots( dotMag: Tool.view!.dotMag, lineWidth: Tool.view!.lineWidth) if !curve.controlDots.contains(point) { curve.controlDots.append(point) } } } } else { Tool.view!.groups.removeAll() for cur in Tool.view!.curves where ( !cur.lock && !cur.canvas.isHidden) { let curves = cur.groupRect(curves: cur.groups) if Tool.view!.curvedPath.bounds.contains(curves) && !Tool.view!.groups.contains(cur) { Tool.view!.groups.append(contentsOf: cur.groups) } } for cur in Tool.view!.groups { Tool.view!.curvedPath.append(cur.path) } } } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { Tool.view!.clearPathLayer(layer: Tool.view!.curveLayer, path: Tool.view!.curvedPath) if let curve = Tool.view!.selectedCurve, !curve.edit, !curve.lock { Tool.view!.dragCurve(deltaX: event?.deltaX ?? 0, deltaY: event?.deltaY ?? 0, shift: shift, fn: fn) } else { self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos) } } override func drag(shift: Bool, fn: Bool) { Tool.view!.clearRulers() } override func move(shift: Bool, fn: Bool) { Tool.view!.clearRulers() } override func down(ctrl: Bool) { Tool.view!.clearPathLayer(layer: Tool.view!.curveLayer, path: Tool.view!.curvedPath) Tool.view!.selectCurve(pos: Tool.view!.startPos, ctrl: ctrl) } } class Line: Tool { override var cursor: NSCursor {NSCursor.crosshair} override var tag: Int {1} override var name: String {"line"} func action(topLeft: CGPoint, bottomRight: CGPoint) { Tool.view!.editedPath.move(to: topLeft) Tool.view!.editedPath.curve(to: bottomRight, controlPoint1: bottomRight, controlPoint2: bottomRight) Tool.view!.editedPath.move(to: bottomRight) Tool.view!.controlPoints = [ ControlPoint(Tool.view!, cp1: topLeft, cp2: topLeft, mp: topLeft), ControlPoint(Tool.view!, cp1: bottomRight, cp2: bottomRight, mp: bottomRight)] } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action( topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos)) Tool.view!.filledCurve = false } override func drag(shift: Bool, fn: Bool) { let par = Tool.view! if shift { par.locationX.isHidden = true par.locationY.isHidden = true par.finPos = par.shiftAngle(topLeft: par.startPos, bottomRight: par.finPos) par.setLabel(key: "x", pos: par.startPos, dist: par.finPos.magnitude(origin: par.startPos)) par.rulers.appendCustomRule(move: par.startPos, line: par.finPos) } else { super.drag(shift: shift, fn: fn) } } } class Triangle: Tool { override var cursor: NSCursor {NSCursor.crosshair} override var tag: Int {2} func action(topLeft: CGPoint, bottomRight: CGPoint, sides: Int, shift: Bool) { let size = self.flipSize(topLeft: topLeft, bottomRight: bottomRight) let signWid: CGFloat = size.wid > 0 ? 1 : -1 let signHei: CGFloat = size.hei > 0 ? 1 : -1 var wid = abs(size.wid) var hei = abs(size.hei) if shift { let maxSize = wid > hei ? wid : hei wid = maxSize hei = maxSize } let cx: CGFloat = signWid > 0 ? topLeft.x + wid/2 : topLeft.x - wid/2 let cy: CGFloat = signHei > 0 ? topLeft.y + hei/2 : topLeft.y - hei/2 var points: [CGPoint] = [CGPoint(x: cx, y: topLeft.y)] let midWid = signWid * wid/2 let midHei = signHei * hei/2 if sides == 3 { points.append(contentsOf: [CGPoint(x: cx + midWid, y: cy+midHei), CGPoint(x: cx - midWid, y: cy+midHei) ]) } else if sides == 5 { let pentWid = signWid * wid * (0.381966011727603 * 0.5) let pentHei = signHei * hei * 0.381966011727603 points.append(contentsOf: [CGPoint(x: cx + midWid, y: cy - midHei + pentHei), CGPoint(x: cx + midWid - pentWid, y: cy+midHei), CGPoint(x: cx - midWid + pentWid, y: cy+midHei), CGPoint(x: cx - midWid, y: cy - midHei + pentHei) ]) } else if sides == 6 { let hexHei = signHei * hei * 0.25 points.append(contentsOf: [CGPoint(x: cx + midWid, y: cy - midHei + hexHei), CGPoint(x: cx + midWid, y: cy + midHei - hexHei), CGPoint(x: cx, y: cy + midHei), CGPoint(x: cx - midWid, y: cy + midHei - hexHei), CGPoint(x: cx - midWid, y: cy - midHei + hexHei) ]) } else if sides == 10 { let pentWid = signWid * wid * (0.381966011727603 * 0.5) let pentHei = signHei * hei * 0.381966011727603 let starMinWid = signWid * wid * 0.116788321167883 let starMaxWid = signWid * wid * 0.187956204379562 let starMinHei = signHei * hei * 0.62043795620438 let starMaxHei = signHei * hei * 0.755474452554745 points.append(contentsOf: [CGPoint(x: cx + starMinWid, y: cy - midHei + pentHei), CGPoint(x: cx + midWid, y: cy - midHei + pentHei), CGPoint(x: cx + starMaxWid, y: cy - midHei + starMinHei), CGPoint(x: cx + midWid - pentWid, y: cy+midHei), CGPoint(x: cx, y: cy-midHei+starMaxHei), CGPoint(x: cx - midWid + pentWid, y: cy+midHei), CGPoint(x: cx - starMaxWid, y: cy - midHei + starMinHei), CGPoint(x: cx - midWid, y: cy - midHei + pentHei), CGPoint(x: cx - starMinWid, y: cy - midHei + pentHei) ]) } if points.count>0 { self.appendStraightCurves(points: points) } } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos, sides: 3, shift: shift)) } } class Rectangle: Tool { override var cursor: NSCursor {NSCursor.crosshair} override var tag: Int {3} func action(topLeft: CGPoint, bottomRight: CGPoint, shift: Bool = false) { var botLeft: CGPoint var topRight: CGPoint if topLeft.x < bottomRight.x && topLeft.y > bottomRight.y { botLeft = CGPoint(x: topLeft.x, y: bottomRight.y) topRight = CGPoint(x: bottomRight.x, y: topLeft.y) } else if topLeft.x < bottomRight.x && topLeft.y < bottomRight.y { botLeft = CGPoint(x: topLeft.x, y: topLeft.y) topRight = CGPoint(x: bottomRight.x, y: bottomRight.y) } else if topLeft.x > bottomRight.x && topLeft.y > bottomRight.y { botLeft = CGPoint(x: bottomRight.x, y: bottomRight.y) topRight = CGPoint(x: topLeft.x, y: topLeft.y) } else { botLeft = CGPoint(x: bottomRight.x, y: topLeft.y) topRight = CGPoint(x: topLeft.x, y: bottomRight.y) } let size = self.flipSize(topLeft: botLeft, bottomRight: topRight) var wid = size.wid var hei = size.hei if shift { let maxSize = abs(size.wid) > abs(size.hei) ? abs(size.wid) : abs(size.hei) wid = maxSize hei = maxSize } if shift && (topLeft.x < bottomRight.x) && (topLeft.y > bottomRight.y) { botLeft.y = topRight.y - hei } else if shift && (topLeft.x > bottomRight.x) && (topLeft.y < bottomRight.y) { botLeft.x = topRight.x - wid } else if shift && (topLeft.x > bottomRight.x) && (topLeft.y > bottomRight.y) { botLeft.x = topRight.x - wid botLeft.y = topRight.y - hei } let points: [CGPoint] = [ CGPoint(x: botLeft.x, y: botLeft.y + hei), CGPoint(x: botLeft.x, y: botLeft.y), CGPoint(x: botLeft.x + wid, y: botLeft.y), CGPoint(x: botLeft.x + wid, y: botLeft.y + hei)] Tool.view!.controlPoints = [] Tool.view!.editedPath.move(to: points[0]) for i in 0..<points.count { let pnt = points[i] Tool.view!.controlPoints.append( ControlPoint(Tool.view!, cp1: pnt, cp2: pnt, mp: pnt)) Tool.view!.controlPoints.append( ControlPoint(Tool.view!, cp1: pnt, cp2: pnt, mp: pnt)) Tool.view!.editedPath.curve(to: pnt, controlPoint1: pnt, controlPoint2: pnt) if i == points.count-1 { Tool.view!.editedPath.curve(to: points[0], controlPoint1: points[0], controlPoint2: points[0]) } else { Tool.view!.editedPath.curve(to: points[i+1], controlPoint1: points[i+1], controlPoint2: points[i+1]) } } Tool.view!.roundedCurve = CGPoint(x: 0, y: 0) } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos, shift: shift)) } } class Pentagon: Triangle { override var tag: Int {4} override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos, sides: 5, shift: shift)) } } class Hexagon: Triangle { override var tag: Int {5} override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos, sides: 6, shift: shift)) } } class Star: Triangle { override var tag: Int {6} override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos, sides: 10, shift: shift)) } } class Arc: Tool { override var cursor: NSCursor {NSCursor.crosshair} override var tag: Int {7} func action(topLeft: CGPoint, bottomRight: CGPoint) { let size = self.flipSize(topLeft: topLeft, bottomRight: bottomRight) let delta = remainder(abs(size.hei/2), 360) let startAngle = -delta let endAngle = delta Tool.view!.editedPath.move(to: topLeft) Tool.view!.editedPath.appendArc(withCenter: topLeft, radius: size.wid, startAngle: startAngle, endAngle: endAngle, clockwise: false) let mPnt = Tool.view!.editedPath.findPoint(0) let lPnt = Tool.view!.editedPath.findPoint(1) Tool.view!.editedPath = Tool.view!.editedPath.placeCurve( at: 1, with: [lPnt[0], lPnt[0], lPnt[0]], replace: false) let fPnt = Tool.view!.editedPath.findPoint( Tool.view!.editedPath.elementCount-1) Tool.view!.editedPath = Tool.view!.editedPath.placeCurve( at: Tool.view!.editedPath.elementCount, with: [fPnt[2], fPnt[2], mPnt[0]]) let points = Tool.view!.editedPath.findPoints(.curveTo) let lst = points.count-1 if lst > 0 { Tool.view!.controlPoints = [ ControlPoint(Tool.view!, cp1: points[lst][2], cp2: points[lst][2], mp: points[lst][2]), ControlPoint(Tool.view!, cp1: points[1][0], cp2: points[0][2], mp: points[0][2])] } if lst > 1 { for i in 1..<lst-1 { Tool.view!.controlPoints.append( ControlPoint(Tool.view!, cp1: points[i+1][0], cp2: points[i][1], mp: points[i][2])) } Tool.view!.controlPoints.append( ControlPoint(Tool.view!, cp1: points[lst-1][2], cp2: points[lst-1][1], mp: points[lst-1][2])) } } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos)) } } class Oval: Tool { override var cursor: NSCursor {NSCursor.crosshair} override var tag: Int {8} func action(topLeft: CGPoint, bottomRight: CGPoint, shift: Bool = false) { let size = self.flipSize(topLeft: topLeft, bottomRight: bottomRight) var wid = size.wid var hei = size.hei if shift { let maxSize = abs(size.wid) > abs(size.hei) ? abs(size.wid) : abs(size.hei) let signWid: CGFloat = wid>0 ? 1 : -1 let signHei: CGFloat = hei>0 ? 1 : -1 wid = maxSize * signWid hei = maxSize * signHei } Tool.view!.editedPath.appendOval( in: NSRect(x: topLeft.x, y: topLeft.y, width: wid, height: hei)) let points = Tool.view!.editedPath.findPoints(.curveTo) if points.count == 4 { Tool.view!.controlPoints = [ ControlPoint(Tool.view!, cp1: points[0][0], cp2: points[3][1], mp: points[3][2]), ControlPoint(Tool.view!, cp1: points[1][0], cp2: points[0][1], mp: points[0][2]), ControlPoint(Tool.view!, cp1: points[2][0], cp2: points[1][1], mp: points[1][2]), ControlPoint(Tool.view!, cp1: points[3][0], cp2: points[2][1], mp: points[2][2])] } } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.useTool(self.action(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos, shift: shift)) } } class Stylus: Line { override var cursor: NSCursor {setCursor.stylus} override var tag: Int {9} override var name: String {"line"} override func action(topLeft: CGPoint, bottomRight: CGPoint) { Tool.view!.editedPath.curve(to: bottomRight, controlPoint1: bottomRight, controlPoint2: bottomRight) Tool.view!.controlPoints.append( ControlPoint(Tool.view!, cp1: bottomRight, cp2: bottomRight, mp: bottomRight)) } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { let par = Tool.view! if abs(par.startPos.x - par.finPos.x) > setEditor.dotSize || abs(par.startPos.y - par.finPos.y) > setEditor.dotSize { self.action(topLeft: par.startPos, bottomRight: par.finPos) par.startPos = par.finPos par.editDone = true } par.filledCurve = false } override var mpPoints: [CGPoint] { return [] } override func down(ctrl: Bool) { Tool.view!.controlPoints = [] Tool.view!.editedPath.removeAllPoints() Tool.view!.editedPath.move(to: Tool.view!.startPos) Tool.view!.controlPoints.append( ControlPoint(Tool.view!, cp1: Tool.view!.startPos, cp2: Tool.view!.startPos, mp: Tool.view!.startPos)) } override func up(editDone: Bool) { if Tool.view!.editDone { Tool.view!.editedPath.move(to: Tool.view!.startPos) } else { Tool.view!.controlPoints = [] Tool.view!.editedPath.removeAllPoints() } super.up(editDone: editDone) } } class Vector: Line { override var cursor: NSCursor {setCursor.vector} override var tag: Int {10} override var name: String {"shape"} func action(topLeft: CGPoint) { let par = Tool.view! if let mp = par.movePoint, let cp1 = par.controlPoint1, let cp2 = par.controlPoint2 { par.moveCurvedPath(move: mp.position, to: topLeft, cp1: cp1.position, cp2: topLeft) par.addSegment(mp: mp, cp1: cp1, cp2: cp2) } par.movePoint = Dot(par, pos: topLeft) par.layer?.addSublayer(par.movePoint!) par.controlPoint1 = Dot(par, pos: topLeft, strokeColor: setEditor.fillColor, fillColor: setEditor.strokeColor) par.layer?.addSublayer(par.controlPoint1!) par.controlPoint2 = Dot(par, pos: topLeft, strokeColor: setEditor.fillColor, fillColor: setEditor.strokeColor) par.layer?.addSublayer(Tool.view!.controlPoint2!) par.clearPathLayer(layer: par.controlLayer, path: par.controlPath) if let mp = par.movePoint { let options: NSTrackingArea.Options = [ .mouseEnteredAndExited, .activeInActiveApp] let area = NSTrackingArea(rect: NSRect(x: mp.frame.minX, y: mp.frame.minY, width: mp.frame.width, height: mp.frame.height), options: options, owner: par) par.addTrackingArea(area) } if par.editedPath.elementCount==0 { par.editedPath.move(to: topLeft) } } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { if Tool.view!.editDone { return } Tool.view!.dragCurvedPath(topLeft: Tool.view!.startPos, bottomRight: Tool.view!.finPos, opt: opt) } override var mpPoints: [CGPoint] { let par = Tool.view! var points: [CGPoint] = [par.startPos] if let mp = par.movePoint { points.append(mp.position) } for cp in par.controlPoints { points.append(cp.mp.position) } return points } override func down(ctrl: Bool) { self.action(topLeft: Tool.view!.startPos) } override func up(editDone: Bool) { if let curve = Tool.view!.selectedCurve, curve.edit || editDone { Tool.view!.clearControls(curve: curve) } if editDone { Tool.view!.newCurve() } if let curve = Tool.view!.selectedCurve, curve.edit || editDone { curve.reset() Tool.view!.createControls(curve: curve) } } } class Text: Tool { override var cursor: NSCursor {NSCursor.crosshair} override var tag: Int {11} override var name: String {"text"} func action(pos: CGPoint? = nil) { let topLeft = pos ?? Tool.view!.startPos let deltaX = topLeft.x-Tool.view!.bounds.minX let deltaY = topLeft.y-Tool.view!.bounds.minY Tool.view!.fontUI.inputField.setFrameOrigin(CGPoint( x: deltaX * Tool.view!.zoomed, y: deltaY * Tool.view!.zoomed)) Tool.view!.fontUI.inputField.show() } override func create(fn: Bool, shift: Bool, opt: Bool, event: NSEvent? = nil) { self.action(pos: Tool.view!.finPos) } override var mpPoints: [CGPoint] { return [] } override func down(ctrl: Bool) { self.action(pos: Tool.view!.startPos) } }

f46e3b25a88fdf9433a31752bfba0b8bc855489c

// The MIT License (MIT) // // Copyright (c) 2016 Joakim Gyllström // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. import Foundation import UIKit protocol BinaryRepresentable { func layoutFor(state: Bool?, style: UIUserInterfaceStyle) }

e53fd679e229dcaa5b1c67bafd117e889b35a792

// // ProfileHighlight.swift // CompositionalDiffablePlayground // // Created by Filip Němeček on 16/01/2021. // import UIKit struct ProfileHighlight: Hashable { let id = UUID() let image: UIImage } extension ProfileHighlight { func hash(into hasher: inout Hasher) { hasher.combine(id) } } extension ProfileHighlight { static var demoHighlights: [ProfileHighlight] { let imageNames = (1...7).map({ "flower\($0)" }) return imageNames.map({ ProfileHighlight(image: UIImage(named: $0)!) }) } }

f519570793c9bc8c1ecbe073cc5d46ccb50c5b35

// This source file is part of the Swift.org open source project // // Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors // Licensed under Apache License v2.0 with Runtime Library Exception // // See http://swift.org/LICENSE.txt for license information // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors // #if os(OSX) || os(iOS) import Darwin #elseif os(Linux) import Glibc #endif import CoreFoundation private func disposeTLS(_ ctx: UnsafeMutablePointer<Void>?) -> Void { Unmanaged<AnyObject>.fromOpaque(ctx!).release() } internal class NSThreadSpecific<T: AnyObject> { private var NSThreadSpecificKeySet = false private var NSThreadSpecificKeyLock = NSLock() private var NSThreadSpecificKey = pthread_key_t() private var key: pthread_key_t { NSThreadSpecificKeyLock.lock() if !NSThreadSpecificKeySet { withUnsafeMutablePointer(&NSThreadSpecificKey) { key in NSThreadSpecificKeySet = pthread_key_create(key, disposeTLS) == 0 } } NSThreadSpecificKeyLock.unlock() return NSThreadSpecificKey } internal func get(_ generator: (Void) -> T) -> T { let specific = pthread_getspecific(self.key) if specific != nil { return Unmanaged<T>.fromOpaque(specific!).takeUnretainedValue() } else { let value = generator() pthread_setspecific(self.key, Unmanaged<AnyObject>.passRetained(value).toOpaque()) return value } } internal func set(_ value: T) { let specific = pthread_getspecific(self.key) var previous: Unmanaged<T>? if specific != nil { previous = Unmanaged<T>.fromOpaque(specific!) } if let prev = previous { if prev.takeUnretainedValue() === value { return } } pthread_setspecific(self.key, Unmanaged<AnyObject>.passRetained(value).toOpaque()) if let prev = previous { prev.release() } } } internal enum _NSThreadStatus { case Initialized case Starting case Executing case Finished } private func NSThreadStart(_ context: UnsafeMutablePointer<Void>?) -> UnsafeMutablePointer<Void>? { let unmanaged: Unmanaged<NSThread> = Unmanaged.fromOpaque(context!) let thread = unmanaged.takeUnretainedValue() NSThread._currentThread.set(thread) thread._status = _NSThreadStatus.Executing thread.main() thread._status = _NSThreadStatus.Finished unmanaged.release() return nil } public class NSThread : NSObject { static internal var _currentThread = NSThreadSpecific<NSThread>() public static func currentThread() -> NSThread { return NSThread._currentThread.get() { return NSThread(thread: pthread_self()) } } /// Alternative API for detached thread creation /// - Experiment: This is a draft API currently under consideration for official import into Foundation as a suitable alternative to creation via selector /// - Note: Since this API is under consideration it may be either removed or revised in the near future public class func detachNewThread(_ main: (Void) -> Void) { let t = NSThread(main) t.start() } public class func isMultiThreaded() -> Bool { return true } public class func sleepUntilDate(_ date: NSDate) { let start_ut = CFGetSystemUptime() let start_at = CFAbsoluteTimeGetCurrent() let end_at = date.timeIntervalSinceReferenceDate var ti = end_at - start_at let end_ut = start_ut + ti while (0.0 < ti) { var __ts__ = timespec(tv_sec: LONG_MAX, tv_nsec: 0) if ti < Double(LONG_MAX) { var integ = 0.0 let frac: Double = withUnsafeMutablePointer(&integ) { integp in return modf(ti, integp) } __ts__.tv_sec = Int(integ) __ts__.tv_nsec = Int(frac * 1000000000.0) } let _ = withUnsafePointer(&__ts__) { ts in nanosleep(ts, nil) } ti = end_ut - CFGetSystemUptime() } } public class func sleepForTimeInterval(_ interval: NSTimeInterval) { var ti = interval let start_ut = CFGetSystemUptime() let end_ut = start_ut + ti while 0.0 < ti { var __ts__ = timespec(tv_sec: LONG_MAX, tv_nsec: 0) if ti < Double(LONG_MAX) { var integ = 0.0 let frac: Double = withUnsafeMutablePointer(&integ) { integp in return modf(ti, integp) } __ts__.tv_sec = Int(integ) __ts__.tv_nsec = Int(frac * 1000000000.0) } let _ = withUnsafePointer(&__ts__) { ts in nanosleep(ts, nil) } ti = end_ut - CFGetSystemUptime() } } public class func exit() { pthread_exit(nil) } internal var _main: (Void) -> Void = {} #if os(OSX) || os(iOS) private var _thread: pthread_t? = nil #elseif os(Linux) private var _thread = pthread_t() #endif internal var _attr = pthread_attr_t() internal var _status = _NSThreadStatus.Initialized internal var _cancelled = false /// - Note: this differs from the Darwin implementation in that the keys must be Strings public var threadDictionary = [String:AnyObject]() internal init(thread: pthread_t) { // Note: even on Darwin this is a non-optional pthread_t; this is only used for valid threads, which are never null pointers. _thread = thread } public init(_ main: (Void) -> Void) { _main = main let _ = withUnsafeMutablePointer(&_attr) { attr in pthread_attr_init(attr) } } public func start() { precondition(_status == .Initialized, "attempting to start a thread that has already been started") _status = .Starting if _cancelled { _status = .Finished return } withUnsafeMutablePointers(&_thread, &_attr) { thread, attr in let ptr = Unmanaged.passRetained(self) pthread_create(thread, attr, NSThreadStart, ptr.toOpaque()) } } public func main() { _main() } public var stackSize: Int { get { var size: Int = 0 return withUnsafeMutablePointers(&_attr, &size) { attr, sz in pthread_attr_getstacksize(attr, sz) return sz.pointee } } set { // just don't allow a stack size more than 1GB on any platform var s = newValue if (1 << 30) < s { s = 1 << 30 } let _ = withUnsafeMutablePointer(&_attr) { attr in pthread_attr_setstacksize(attr, s) } } } public var executing: Bool { return _status == .Executing } public var finished: Bool { return _status == .Finished } public var cancelled: Bool { return _cancelled } public func cancel() { _cancelled = true } public class func callStackReturnAddresses() -> [NSNumber] { NSUnimplemented() } public class func callStackSymbols() -> [String] { NSUnimplemented() } }

4aeb6ca402b75e3a67d320aa63081a35ece660a8

// // ButtonStyle.swift // twitterclone // // Created by Stephen Wall on 5/18/21. // import SwiftUI struct EditButtonStyle: ButtonStyle { func makeBody(configuration: Configuration) -> some View { configuration.label .frame(width: 360, height: 40) .background(Color.blue) .foregroundColor(.white) .cornerRadius(20) } } struct FollowButtonStyle: ButtonStyle { func makeBody(configuration: Configuration) -> some View { configuration.label .frame(width: 180, height: 40) .background(Color.blue) .foregroundColor(.white) .cornerRadius(20) } } struct MessageButtonStyle: ButtonStyle { func makeBody(configuration: Configuration) -> some View { configuration.label .frame(width: 180, height: 40) .background(Color.purple) .foregroundColor(.white) .cornerRadius(20) } } struct SignInButtonStyle: ButtonStyle { func makeBody(configuration: Configuration) -> some View { configuration.label .font(.headline) .foregroundColor(.blue) .frame(width: 325, height: 50) .background(Color.white) .clipShape(Capsule()) .padding() } } struct TweetButtonStyle: ButtonStyle { func makeBody(configuration: Configuration) -> some View { configuration.label .padding(.horizontal) .padding(.vertical, 8) .background(Color.blue) .foregroundColor(.white) .clipShape(Capsule()) } } struct ButtonStyle_Previews: PreviewProvider { static var previews: some View { VStack(spacing: 40) { // Edit Button("Edit", action: {}) .buttonStyle(EditButtonStyle()) // Follow/ Message HStack { Button("Follow", action: {}) .buttonStyle(FollowButtonStyle()) Button("Message", action: {}) .buttonStyle(MessageButtonStyle()) } // Log In VStack { Button("Log In", action: {}) .buttonStyle(SignInButtonStyle()) } .background(Color(#colorLiteral(red: 0.1131996438, green: 0.631419003, blue: 0.9528219104, alpha: 1))) } } }

717a896db90fbf297e692905e3d70f9523d2aace

// // UIHelper.swift // GHFollowers // // Created by Mr Kes on 11/18/21. // Copyright © 2021 Sean Allen. All rights reserved. // import UIKit // struct UIHelper - we don't want empty UIHelper initialization, ex: let helper = UIHelper() so we made it enum enum UIHelper { static func createThreeColumnFlowLayout(in view: UIView) -> UICollectionViewFlowLayout { let width = view.bounds.width let padding: CGFloat = 12 let minimumItemSpacing: CGFloat = 10 let availableWidth = width - (padding * 2) - (minimumItemSpacing * 2) let itemWidth = availableWidth / 3 let flowLayout = UICollectionViewFlowLayout() flowLayout.sectionInset = UIEdgeInsets(top: padding, left: padding, bottom: padding, right: padding) flowLayout.itemSize = CGSize(width: itemWidth, height: itemWidth + 40) return flowLayout } }

394abbcd28fcd234eb45d45bbb89e7479cfec533

//===--- OpenLocationCode.swift - Open Location Code encoding/decoding-----===// // // Copyright 2017 Google Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // //===----------------------------------------------------------------------===// // // Convert between decimal degree coordinates and Open Location Codes. Shorten // and recover Open Location Codes for a given reference location. // // Exposes the Swift objects in OpenLocationCode.swift as NSObject visible in // Objective-C. The reason that OpenLocationCode and OpenLocationCodeArea don't // descend from NSObject directly is that such classes can't be used in Swift // for Linux and this time. It also allows for more "pure" swift paradigms to // be employed for those objects, such as the declaring OpenLocationCodeArea // as a struct, and more customization for the Objective-C representation // such as with default parameters. // // Authored by William Denniss. // //===----------------------------------------------------------------------===// import Foundation #if !os(Linux) /// Convert between decimal degree coordinates and plus codes. Shorten and /// recover plus codes for a given reference location. /// /// Open Location Codes are short, 10-11 character codes that can be used /// instead of street addresses. The codes can be generated and decoded offline, /// and use a reduced character set that minimises the chance of codes including /// words. /// /// Codes are able to be shortened relative to a nearby location. This means /// that in many cases, only four to seven characters of the code are needed. /// To recover the original code, the same location is not required, as long as /// a nearby location is provided. /// /// Codes represent rectangular areas rather than points, and the longer the /// code, the smaller the area. A 10 character code represents a 13.5x13.5 /// meter area (at the equator. An 11 character code represents approximately /// a 2.8x3.5 meter area. /// /// Two encoding algorithms are used. The first 10 characters are pairs of /// characters, one for latitude and one for latitude, using base 20. Each pair /// reduces the area of the code by a factor of 400. Only even code lengths are /// sensible, since an odd-numbered length would have sides in a ratio of 20:1. /// /// At position 11, the algorithm changes so that each character selects one /// position from a 4x5 grid. This allows single-character refinements. /// /// # Swift Example /// ``` /// import OpenLocationCode /// /// // ... /// /// // Encode a location with default code length. /// if let code = OpenLocationCode.encode(latitude: 37.421908, /// longitude: -122.084681) { /// print("Open Location Code: \(code)") /// } /// /// // Encode a location with specific code length. /// if let code10Digit = OpenLocationCode.encode(latitude: 37.421908, /// longitude: -122.084681, /// codeLength: 10) { /// print("Open Location Code: \(code10Digit)") /// } /// /// // Decode a full code: /// if let coord = OpenLocationCode.decode("849VCWC8+Q48") { /// print("Center is \(coord.latitudeCenter), \(coord.longitudeCenter)") /// } /// /// // Attempt to trim the first characters from a code: /// if let shortCode = OpenLocationCode.shorten(code: "849VCWC8+Q48", /// latitude: 37.4, /// longitude: -122.0) { /// print("Short code: \(shortCode)") /// } /// /// // Recover the full code from a short code: /// if let fullCode = OpenLocationCode.recoverNearest(shortcode: "CWC8+Q48", /// referenceLatitude: 37.4, /// referenceLongitude: -122.0) { /// print("Recovered full code: \(fullCode)") /// } /// ``` /// # Objective-C Examples /// ``` /// @import OpenLocationCode; /// /// // ... /// /// // Encode a location with default code length. /// NSString *code = [OLCConverter encodeLatitude:37.421908 /// longitude:-122.084681]; /// NSLog(@"Open Location Code: %@", code); /// /// // Encode a location with specific code length. /// NSString *code10Digit = [OLCConverter encodeLatitude:37.421908 /// longitude:-122.084681 /// codeLength:10]; /// NSLog(@"Open Location Code: %@", code10Digit); /// /// // Decode a full code: /// OLCArea *coord = [OLCConverter decode:@"849VCWC8+Q48"]; /// NSLog(@"Center is %.6f, %.6f", coord.latitudeCenter, coord.longitudeCenter); /// /// // Attempt to trim the first characters from a code: /// NSString *shortCode = [OLCConverter shortenCode:@"849VCWC8+Q48" /// latitude:37.4 /// longitude:-122.0]; /// NSLog(@"Short Code: %@", shortCode); /// /// // Recover the full code from a short code: /// NSString *recoveredCode = [OLCConverter recoverNearestWithShortcode:@"CWC8+Q48" /// referenceLatitude:37.4 /// referenceLongitude:-122.1]; /// NSLog(@"Recovered Full Code: %@", recoveredCode); /// ``` /// @objc public class OLCConverter: NSObject { /// Determines if a code is valid. /// To be valid, all characters must be from the Open Location Code character /// set with at most one separator. The separator can be in any even-numbered /// position up to the eighth digit. /// /// - Parameter code: The Open Location Code to test. /// - Returns: true if the code is a valid Open Location Code. @objc(isValidCode:) public static func isValid(code: String) -> Bool { return OpenLocationCode.isValid(code: code) } /// Determines if a code is a valid short code. /// A short Open Location Code is a sequence created by removing four or more /// digits from an Open Location Code. It must include a separator /// character. /// /// - Parameter code: The Open Location Code to test. /// - Returns: true if the code is a short Open Location Code. @objc(isShortCode:) public static func isShort(code: String) -> Bool { return OpenLocationCode.isShort(code: code) } // Determines if a code is a valid full Open Location Code. // Not all possible combinations of Open Location Code characters decode to // valid latitude and longitude values. This checks that a code is valid // and also that the latitude and longitude values are legal. If the prefix // character is present, it must be the first character. If the separator // character is present, it must be after four characters. /// /// - Parameter code: The Open Location Code to test. /// - Returns: true if the code is a full Open Location Code. @objc(isFullCode:) public static func isFull(code: String) -> Bool { return OpenLocationCode.isFull(code: code) } /// Encode a location using the grid refinement method into an OLC string. /// The grid refinement method divides the area into a grid of 4x5, and uses a /// single character to refine the area. This allows default accuracy OLC /// codes to be refined with just a single character. /// /// - Parameter latitude: A latitude in signed decimal degrees. /// - Parameter longitude: A longitude in signed decimal degrees. /// - Parameter codeLength: The number of characters required. /// - Returns: Open Location Code representing the given grid. @objc(encodeGridForLatitude:longitude:codeLength:) public static func encodeGrid(latitude: Double, longitude: Double, codeLength: Int) -> String { return OpenLocationCode.encodeGrid(latitude:latitude, longitude:longitude, codeLength:codeLength) } /// Encode a location into an Open Location Code. /// Produces a code of the specified length, or the default length if no /// length is provided. /// The length determines the accuracy of the code. The default length is /// 10 characters, returning a code of approximately 13.5x13.5 meters. Longer /// codes represent smaller areas, but lengths > 14 are sub-centimetre and so /// 11 or 12 are probably the limit of useful codes. /// /// - Parameter latitude: A latitude in signed decimal degrees. Will be /// clipped to the range -90 to 90. /// - Parameter longitude: A longitude in signed decimal degrees. Will be /// normalised to the range -180 to 180. /// - Parameter codeLength: The number of significant digits in the output /// code, not including any separator characters. Possible values are; /// `2`, `4`, `6`, `8`, `10`, `11`, `12`, `13` and above. Lower values /// indicate a larger area, higher values a more precise area. /// You can also shorten a code after encoding for codes used with a /// reference point (e.g. your current location, a city, etc). /// /// - Returns: Open Location Code for the given coordinate. @objc(encodeLatitude:longitude:codeLength:) public static func encode(latitude: Double, longitude: Double, codeLength: Int) -> String? { return OpenLocationCode.encode(latitude:latitude, longitude:longitude, codeLength:codeLength) } /// Encode a location into an Open Location Code. /// Produces a code of the specified length, or the default length if no /// length is provided. /// The length determines the accuracy of the code. The default length is /// 10 characters, returning a code of approximately 13.5x13.5 meters. Longer /// codes represent smaller areas, but lengths > 14 are sub-centimetre and so /// 11 or 12 are probably the limit of useful codes. /// /// - Parameter latitude: A latitude in signed decimal degrees. Will be /// clipped to the range -90 to 90. /// - Parameter longitude: A longitude in signed decimal degrees. Will be /// normalised to the range -180 to 180. /// /// - Returns: Open Location Code for the given coordinate. @objc(encodeLatitude:longitude:) public static func encode(latitude: Double, longitude: Double) -> String? { return OpenLocationCode.encode(latitude:latitude, longitude:longitude) } /// Decodes an Open Location Code into the location coordinates. /// Returns a OpenLocationCodeArea object that includes the coordinates of the /// bounding box - the lower left, center and upper right. /// /// - Parameter code: The Open Location Code to decode. /// - Returns: A CodeArea object that provides the latitude and longitude of /// two of the corners of the area, the center, and the length of the /// original code. @objc public static func decode(_ code: String) -> OLCArea? { guard let area = OpenLocationCode.decode(code) else { return nil } return OLCArea.init(area) } /// Recover the nearest matching code to a specified location. /// Given a short Open Location Code of between four and seven characters, /// this recovers the nearest matching full code to the specified location. /// The number of characters that will be prepended to the short code, depends /// on the length of the short code and whether it starts with the separator. /// If it starts with the separator, four characters will be prepended. If it /// does not, the characters that will be prepended to the short code, where S /// is the supplied short code and R are the computed characters, are as /// follows: /// ``` /// SSSS -> RRRR.RRSSSS /// SSSSS -> RRRR.RRSSSSS /// SSSSSS -> RRRR.SSSSSS /// SSSSSSS -> RRRR.SSSSSSS /// ``` /// /// Note that short codes with an odd number of characters will have their /// last character decoded using the grid refinement algorithm. /// /// - Parameter shortcode: A valid short OLC character sequence. /// - Parameter referenceLatitude: The latitude (in signed decimal degrees) to /// use to find the nearest matching full code. /// - Parameter referenceLongitude: The longitude (in signed decimal degrees) /// to use to find the nearest matching full code. /// - Returns: The nearest full Open Location Code to the reference location /// that matches the short code. If the passed code was not a valid short /// code, but was a valid full code, it is returned unchanged. @objc public static func recoverNearest(shortcode: String, referenceLatitude: Double, referenceLongitude: Double) -> String? { return OpenLocationCode.recoverNearest(shortcode:shortcode, referenceLatitude:referenceLatitude, referenceLongitude:referenceLongitude) } /// Remove characters from the start of an OLC code. /// This uses a reference location to determine how many initial characters /// can be removed from the OLC code. The number of characters that can be /// removed depends on the distance between the code center and the reference /// location. /// The minimum number of characters that will be removed is four. If more /// than four characters can be removed, the additional characters will be /// replaced with the padding character. At most eight characters will be /// removed. The reference location must be within 50% of the maximum range. /// This ensures that the shortened code will be able to be recovered using /// slightly different locations. /// /// - Parameter code: A full, valid code to shorten. /// - Parameter latitude: A latitude, in signed decimal degrees, to use as the /// reference point. /// - Parameter longitude: A longitude, in signed decimal degrees, to use as /// the reference point. /// - Parameter maximumTruncation: The maximum number of characters to remove. /// - Returns: Either the original code, if the reference location was not /// close enough, or the original. @objc(shortenCode:latitude:longitude:maximumTruncation:) public static func shorten(code: String, latitude: Double, longitude: Double, maximumTruncation: Int) -> String? { return OpenLocationCode.shorten(code:code, latitude:latitude, longitude:longitude, maximumTruncation:maximumTruncation) } /// Remove characters from the start of an OLC code. /// This uses a reference location to determine how many initial characters /// can be removed from the OLC code. The number of characters that can be /// removed depends on the distance between the code center and the reference /// location. /// The minimum number of characters that will be removed is four. If more /// than four characters can be removed, the additional characters will be /// replaced with the padding character. At most eight characters will be /// removed. The reference location must be within 50% of the maximum range. /// This ensures that the shortened code will be able to be recovered using /// slightly different locations. /// /// - Parameter code: A full, valid code to shorten. /// - Parameter latitude: A latitude, in signed decimal degrees, to use as the /// reference point. /// - Parameter longitude: A longitude, in signed decimal degrees, to use as /// the reference point. /// - Returns: Either the original code, if the reference location was not /// close enough, or the original. @objc(shortenCode:latitude:longitude:) public static func shorten(code: String, latitude: Double, longitude: Double) -> String? { return OpenLocationCode.shorten(code:code, latitude:latitude, longitude:longitude) } } /// Coordinates of a decoded Open Location Code. /// The coordinates include the latitude and longitude of the lower left and /// upper right corners and the center of the bounding box for the area the /// code represents. @objc public class OLCArea: NSObject { /// The latitude of the SW corner in degrees. @objc public var latitudeLo: Double = 0 /// The longitude of the SW corner in degrees. @objc public var longitudeLo: Double = 0 /// The latitude of the NE corner in degrees. @objc public var latitudeHi: Double = 0 /// The longitude of the NE corner in degrees. @objc public var longitudeHi: Double = 0 /// The number of significant characters that were in the code. /// This excludes the separator. @objc public var codeLength: Int = 0 /// The latitude of the center in degrees. @objc public var latitudeCenter: Double = 0 /// latitude_center: The latitude of the center in degrees. @objc public var longitudeCenter: Double = 0 /// - Parameter latitudeLo: The latitude of the SW corner in degrees. /// - Parameter longitudeLo: The longitude of the SW corner in degrees. /// - Parameter latitudeHi: The latitude of the NE corner in degrees. /// - Parameter longitudeHi: The longitude of the NE corner in degrees. /// - Parameter codeLength: The number of significant characters that were in /// the code. @objc init(latitudeLo: Double, longitudeLo: Double, latitudeHi: Double, longitudeHi: Double, codeLength: Int) { self.latitudeLo = latitudeLo self.longitudeLo = longitudeLo self.latitudeHi = latitudeHi self.longitudeHi = longitudeHi self.codeLength = codeLength self.latitudeCenter = min(latitudeLo + (latitudeHi - latitudeLo) / 2, kLatitudeMax) self.longitudeCenter = min(longitudeLo + (longitudeHi - longitudeLo) / 2, kLongitudeMax) } init(_ area: OpenLocationCodeArea) { self.latitudeLo = area.latitudeLo self.longitudeLo = area.longitudeLo self.latitudeHi = area.latitudeHi self.longitudeHi = area.longitudeHi self.codeLength = area.codeLength self.latitudeCenter = area.latitudeCenter self.longitudeCenter = area.longitudeCenter } // Returns lat/lng coordinate array representing the area's center point. @objc func latlng() -> Array<Double>{ return [self.latitudeCenter, self.longitudeCenter] } } #endif

2f00eb05a53f167f836307cffa21de6e0d2d9194

// // VTextDemoView.swift // VComponentsDemo // // Created by Vakhtang Kontridze on 1/12/21. // import SwiftUI import VComponents // MARK: - V Text Demo View struct VTextDemoView: View { // MARK: Properties static var navBarTitle: String { "Text" } @State private var vTextDemoType: VTextDemoType = .center private let baseTextTitle: String = "Lorem ipsum dolor sit amet" private let baseTextText: String = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla dapibus volutpat enim, vitae blandit justo iaculis sit amet. Aenean vitae leo tincidunt, sollicitudin mauris a, mollis massa. Sed posuere, nibh non fermentum ultrices, ipsum nunc luctus arcu, a auctor velit nisl ac nibh. Donec vel arcu condimentum, iaculis quam sed, commodo orci." private let titleColor: Color = ColorBook.primary private let titleFont: Font = .system(size: 16, weight: .semibold) private let textFont: Font = .system(size: 14) // MARK: Body var body: some View { VBaseView(title: Self.navBarTitle, content: { DemoView(component: component, settings: settings) }) } @ViewBuilder private func component() -> some View { switch vTextDemoType { case .center: VText(type: .oneLine, font: titleFont, color: titleColor, title: baseTextTitle) .frame(maxWidth: .infinity, alignment: .center) case .leading: VText(type: .oneLine, font: titleFont, color: titleColor, title: baseTextTitle) .frame(maxWidth: .infinity, alignment: .leading) case .trailing: VText(type: .oneLine, font: titleFont, color: titleColor, title: baseTextTitle) .frame(maxWidth: .infinity, alignment: .trailing) case .multiLineCenter: VText(type: .multiLine(limit: nil, alignment: .center), font: titleFont, color: titleColor, title: baseTextText) case .multiLineLeading: VText(type: .multiLine(limit: nil, alignment: .leading), font: titleFont, color: titleColor, title: baseTextText) case .multiLineTrailing: VText(type: .multiLine(limit: nil, alignment: .trailing), font: titleFont, color: titleColor, title: baseTextText) } } @ViewBuilder private func settings() -> some View { VWheelPicker( selection: $vTextDemoType, headerTitle: "Type", footerTitle: "Not an actual type of the component. Just different configurations listed for demo purposes." ) } } // MARK: - Helpers private enum VTextDemoType: Int, VPickableTitledItem { case center case leading case trailing case multiLineCenter case multiLineLeading case multiLineTrailing var pickerTitle: String { switch self { case .center: return "Center" case .leading: return "Leading" case .trailing: return "Trailing" case .multiLineCenter: return "Multi-Line Center" case .multiLineLeading: return "Multi-Line Leading" case .multiLineTrailing: return "Multi-Line Trailing" } } } // MARK: - Preview struct VTextDemoView_Previews: PreviewProvider { static var previews: some View { VTextDemoView() } }

1df6a0b1eb97f2efc55df2700c22ed0fb1bef972

// // Copyright (c) 2020 Touch Instinct // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the Software), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. // import UIKit import TIUIKitCore import TISwiftUtils /// Base full OTP View for entering the verification code open class OTPSwiftView<View: OTPView>: BaseInitializableControl { private var emptyOTPView: View? { textFieldsCollection.first { $0.codeTextField.text.orEmpty.isEmpty } ?? textFieldsCollection.last } public private(set) var codeStackView = UIStackView() public private(set) var textFieldsCollection: [View] = [] public var onTextEnter: ParameterClosure<String>? public var code: String { get { textFieldsCollection.compactMap { $0.codeTextField.text }.joined() } set { textFieldsCollection.first?.codeTextField.set(inputText: newValue) } } public override var isFirstResponder: Bool { !textFieldsCollection.allSatisfy { !$0.codeTextField.isFirstResponder } } open override func addViews() { super.addViews() addSubview(codeStackView) } open override func configureAppearance() { super.configureAppearance() codeStackView.contentMode = .center codeStackView.distribution = .fillEqually } open func configure(with config: OTPCodeConfig) { textFieldsCollection = createTextFields(numberOfFields: config.codeSymbolsCount) codeStackView.addArrangedSubviews(textFieldsCollection) codeStackView.spacing = config.spacing configure(customSpacing: config.customSpacing, for: codeStackView) bindTextFields(with: config) } @discardableResult open override func becomeFirstResponder() -> Bool { guard let emptyOTPView = emptyOTPView, !emptyOTPView.isFirstResponder else { return false } return emptyOTPView.codeTextField.becomeFirstResponder() } @discardableResult open override func resignFirstResponder() -> Bool { guard let emptyOTPView = emptyOTPView, emptyOTPView.isFirstResponder else { return false } return emptyOTPView.codeTextField.resignFirstResponder() } } // MARK: - Configure textfields private extension OTPSwiftView { func configure(customSpacing: OTPCodeConfig.Spacing?, for stackView: UIStackView) { guard let customSpacing = customSpacing else { return } customSpacing.forEach { viewIndex, spacing in guard viewIndex < stackView.arrangedSubviews.count, viewIndex >= .zero else { return } self.set(spacing: spacing, after: stackView.arrangedSubviews[viewIndex], for: stackView) } } func set(spacing: CGFloat, after view: UIView, for stackView: UIStackView) { stackView.setCustomSpacing(spacing, after: view) } func createTextFields(numberOfFields: Int) -> [View] { var textFieldsCollection: [View] = [] (.zero..<numberOfFields).forEach { _ in let textField = View() textField.codeTextField.previousTextField = textFieldsCollection.last?.codeTextField textFieldsCollection.last?.codeTextField.nextTextField = textField.codeTextField textFieldsCollection.append(textField) } return textFieldsCollection } func bindTextFields(with config: OTPCodeConfig) { let onTextChangedSignal: VoidClosure = { [weak self] in guard let code = self?.code else { return } let correctedCode = code.prefix(config.codeSymbolsCount).string self?.onTextEnter?(correctedCode) } let onTap: VoidClosure = { [weak self] in self?.becomeFirstResponder() } textFieldsCollection.forEach { $0.codeTextField.onTextChangedSignal = onTextChangedSignal $0.onTap = onTap } } }

8f7615a8ba55cd888ff6c3d535f802b73c4018c0

/** * Copyright IBM Corporation 2018 * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. **/ import Foundation /** The user input. */ public struct InputData: Codable { /** The text of the user input. This string cannot contain carriage return, newline, or tab characters, and it must be no longer than 2048 characters. */ public var text: String // Map each property name to the key that shall be used for encoding/decoding. private enum CodingKeys: String, CodingKey { case text = "text" } /** Initialize a `InputData` with member variables. - parameter text: The text of the user input. This string cannot contain carriage return, newline, or tab characters, and it must be no longer than 2048 characters. - returns: An initialized `InputData`. */ public init( text: String ) { self.text = text } }

898e9326227a4383f8e68f2aaa8acf94bc5014ca

import Flutter import UIKit import MLKitTranslate import MLKitLanguageID public class SwiftMlkitTranslatePlugin: NSObject, FlutterPlugin { let locale = Locale.current lazy var allLanguages = TranslateLanguage.allLanguages().sorted { return locale.localizedString(forLanguageCode: $0.rawValue)! < locale.localizedString(forLanguageCode: $1.rawValue)! } public static func register(with registrar: FlutterPluginRegistrar) { let channel = FlutterMethodChannel(name: "mlkit_translate", binaryMessenger: registrar.messenger()) let instance = SwiftMlkitTranslatePlugin() registrar.addMethodCallDelegate(instance, channel: channel) } public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) { switch call.method { case "translate": let args = call.arguments as? [String: Any] let source = args?["source"] as? String let target = args?["target"] as? String ?? "en" let text = args?["text"] as? String ?? "" if (source == nil) { LanguageIdentification.languageIdentification(options: LanguageIdentificationOptions(confidenceThreshold: 0.0)).identifyLanguage(for: text) { (languageCode, error) in if (error != nil) { self.translateText(result: result, source: "en", target: target, text: text) } else { self.translateText(result: result, source: languageCode ?? "en", target: target, text: text) } } } else { translateText(result: result, source: source!, target: target, text: text) } break; case "downloadModel": if let args = call.arguments as? [String: Any], let model = args["model"] as? String { ModelManager.modelManager().download( TranslateRemoteModel.translateRemoteModel( language: TranslateLanguage.allLanguages().first(where: {$0.rawValue == model}) ?? .english ), conditions: ModelDownloadConditions( allowsCellularAccess: true, allowsBackgroundDownloading: true ) ) } else { result(FlutterError(code: "-1", message: "iOS could not extract " + "flutter arguments in method: (downloadModel)", details: nil)) } result("Success") break; default: result(FlutterMethodNotImplemented); } } private func translateText(result: @escaping FlutterResult, source: String, target: String, text: String) { let translator = Translator.translator(options: TranslatorOptions( sourceLanguage: TranslateLanguage.allLanguages().first(where: {$0.rawValue == source}) ?? .english, targetLanguage: TranslateLanguage.allLanguages().first(where: {$0.rawValue == target}) ?? .english )) translator.downloadModelIfNeeded(with: ModelDownloadConditions( allowsCellularAccess: true, allowsBackgroundDownloading: true )) { error in if (error != nil) { result(text) } else { translator.translate(text) { translatedText, error in guard error == nil, let translatedText = translatedText else { return } result(translatedText) } } } } }

f7c1871e8df125296893e80adc70db39a5f1f8db

// Copyright 2018-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"). // You may not use this file except in compliance with the License. // A copy of the License is located at // // http://www.apache.org/licenses/LICENSE-2.0 // // or in the "license" file accompanying this file. This file is distributed // on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either // express or implied. See the License for the specific language governing // permissions and limitations under the License. // // InternalSingleValueDecodingContainer.swift // SmokeDynamoDB // import Foundation import DynamoDBModel internal struct InternalSingleValueDecodingContainer { internal let codingPath: [CodingKey] internal let userInfo: [CodingUserInfoKey: Any] internal let attributeValue: DynamoDBModel.AttributeValue internal let attributeNameTransform: ((String) -> String)? init(attributeValue: DynamoDBModel.AttributeValue, codingPath: [CodingKey], userInfo: [CodingUserInfoKey: Any], attributeNameTransform: ((String) -> String)?) { self.attributeValue = attributeValue self.codingPath = codingPath self.userInfo = userInfo self.attributeNameTransform = attributeNameTransform } } extension InternalSingleValueDecodingContainer: SingleValueDecodingContainer { func decodeNil() -> Bool { return attributeValue.NULL ?? false } func decode(_ type: Bool.Type) throws -> Bool { guard let value = attributeValue.BOOL else { throw getTypeMismatchError(expectation: Bool.self) } return value } func decode(_ type: Int.Type) throws -> Int { guard let valueAsString = attributeValue.N, let value = Int(valueAsString) else { throw getTypeMismatchError(expectation: Int.self) } return value } func decode(_ type: Int8.Type) throws -> Int8 { guard let valueAsString = attributeValue.N, let value = Int8(valueAsString) else { throw getTypeMismatchError(expectation: Int8.self) } return value } func decode(_ type: Int16.Type) throws -> Int16 { guard let valueAsString = attributeValue.N, let value = Int16(valueAsString) else { throw getTypeMismatchError(expectation: Int16.self) } return value } func decode(_ type: Int32.Type) throws -> Int32 { guard let valueAsString = attributeValue.N, let value = Int32(valueAsString) else { throw getTypeMismatchError(expectation: Int32.self) } return value } func decode(_ type: Int64.Type) throws -> Int64 { guard let valueAsString = attributeValue.N, let value = Int64(valueAsString) else { throw getTypeMismatchError(expectation: Int64.self) } return value } func decode(_ type: UInt.Type) throws -> UInt { guard let valueAsString = attributeValue.N, let value = UInt(valueAsString) else { throw getTypeMismatchError(expectation: UInt.self) } return value } func decode(_ type: UInt8.Type) throws -> UInt8 { guard let valueAsString = attributeValue.N, let value = UInt8(valueAsString) else { throw getTypeMismatchError(expectation: UInt8.self) } return value } func decode(_ type: UInt16.Type) throws -> UInt16 { guard let valueAsString = attributeValue.N, let value = UInt16(valueAsString) else { throw getTypeMismatchError(expectation: UInt16.self) } return value } func decode(_ type: UInt32.Type) throws -> UInt32 { guard let valueAsString = attributeValue.N, let value = UInt32(valueAsString) else { throw getTypeMismatchError(expectation: UInt32.self) } return value } func decode(_ type: UInt64.Type) throws -> UInt64 { guard let valueAsString = attributeValue.N, let value = UInt64(valueAsString) else { throw getTypeMismatchError(expectation: UInt64.self) } return value } func decode(_ type: Float.Type) throws -> Float { guard let valueAsString = attributeValue.N, let value = Float(valueAsString) else { throw getTypeMismatchError(expectation: Float.self) } return value } func decode(_ type: Double.Type) throws -> Double { guard let valueAsString = attributeValue.N, let value = Double(valueAsString) else { throw getTypeMismatchError(expectation: Double.self) } return value } func decode(_ type: String.Type) throws -> String { guard let value = attributeValue.S else { throw getTypeMismatchError(expectation: String.self) } return value } func decode<T>(_ type: T.Type) throws -> T where T: Decodable { if type == Date.self { let dateAsString = try String(from: self) guard let date = dateAsString.dateFromISO8601 as? T else { throw getTypeMismatchError(expectation: Date.self) } return date } return try T(from: self) } private func getTypeMismatchError(expectation: Any.Type) -> DecodingError { let description = "Expected to decode \(expectation)." let context = DecodingError.Context(codingPath: codingPath, debugDescription: description) return DecodingError.typeMismatch(expectation, context) } } extension InternalSingleValueDecodingContainer: Swift.Decoder { func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key: CodingKey { let container = InternalKeyedDecodingContainer<Key>(decodingContainer: self) return KeyedDecodingContainer<Key>(container) } func unkeyedContainer() throws -> UnkeyedDecodingContainer { let container = InternalUnkeyedDecodingContainer(decodingContainer: self) return container } func singleValueContainer() throws -> SingleValueDecodingContainer { return self } }

8a57e127294c888777ba71afc78542ac782a4f8b

// // AppDelegate.swift // Hahabbit // // Created by TSAI TSUNG-HAN on 2021/5/12. // import UIKit import Firebase import IQKeyboardManagerSwift import UserNotifications import SwiftTheme @main class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { // setup theme color ThemeManager.setTheme(index: UserManager.shared.themeColorNumber) UITabBar.appearance().theme_tintColor = ThemeColor.color // setup NavigationBar back button let image = UIImage(named: "arrowCircleLeft") UINavigationBar.appearance().backIndicatorImage = image UINavigationBar.appearance().backIndicatorTransitionMaskImage = image UINavigationBar.appearance().theme_tintColor = ThemeColor.color // setup IQKeyboard IQKeyboardManager.shared.enable = true IQKeyboardManager.shared.disabledDistanceHandlingClasses.append(ChatPageViewController.self) // setup Firebase FirebaseApp.configure() // request Notification Authorization UNUserNotificationCenter.current() .requestAuthorization(options: [.alert, .sound, .badge, .carPlay]) { _, error in if let err = error { print(err) } } return true } // MARK: UISceneSession Lifecycle func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration { // Called when a new scene session is being created. // Use this method to select a configuration to create the new scene with. return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role) } func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) { // Called when the user discards a scene session. // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions. // Use this method to release any resources that were specific to the discarded scenes, as they will not return. } }

183a194cda6db152c7e52dbe4ff5f7e51ad122d4

// // CloudKitManager.swift // CloudKitSyncPOC // // Created by Nick Harris on 12/16/15. // Copyright © 2015 Nick Harris. All rights reserved. // import Foundation import UIKit import CoreData import CloudKit class CloudKitManager { // MARK: Class Properties fileprivate let privateDB: CKDatabase fileprivate let coreDataManager: CoreDataManager fileprivate let operationQueue: OperationQueue // MARK: init init(coreDataManager: CoreDataManager) { self.coreDataManager = coreDataManager self.operationQueue = OperationQueue() self.operationQueue.maxConcurrentOperationCount = 1 privateDB = CKContainer.default().privateCloudDatabase CKContainer.default().accountStatus { [unowned self] (accountStatus, error) in switch accountStatus { case .available: self.initializeCloudKit() default: self.handleCloudKitUnavailable(accountStatus, error: error! as NSError) } } } // MARK: Public Functions func saveChangesToCloudKit(_ insertedObjects: [NSManagedObjectID], modifiedManagedObjectIDs: [NSManagedObjectID], deletedRecordIDs: [CKRecordID]) { // create the operations let createRecordsForNewObjectsOperation = CreateRecordsForNewObjectsOperation(insertedManagedObjectIDs: insertedObjects, coreDataManager: coreDataManager) let fetchModifiedRecordsOperation = FetchRecordsForModifiedObjectsOperation(coreDataManager: coreDataManager, modifiedManagedObjectIDs: modifiedManagedObjectIDs) let modifyRecordsOperation = ModifyRecordsFromManagedObjectsOperation(coreDataManager: coreDataManager, cloudKitManager: self, modifiedManagedObjectIDs: modifiedManagedObjectIDs, deletedRecordIDs: deletedRecordIDs) let clearDeletedCloudKitObjectsOperation = ClearDeletedCloudKitObjectsOperation(coreDataManager: coreDataManager) let transferCreatedRecordsOperation = BlockOperation() { [unowned modifyRecordsOperation, unowned createRecordsForNewObjectsOperation] in modifyRecordsOperation.recordsToSave = createRecordsForNewObjectsOperation.createdRecords } let transferFetchedRecordsOperation = BlockOperation() { [unowned modifyRecordsOperation, unowned fetchModifiedRecordsOperation] in modifyRecordsOperation.fetchedRecordsToModify = fetchModifiedRecordsOperation.fetchedRecords } // setup dependencies transferCreatedRecordsOperation.addDependency(createRecordsForNewObjectsOperation) transferFetchedRecordsOperation.addDependency(fetchModifiedRecordsOperation) modifyRecordsOperation.addDependency(transferCreatedRecordsOperation) modifyRecordsOperation.addDependency(transferFetchedRecordsOperation) clearDeletedCloudKitObjectsOperation.addDependency(modifyRecordsOperation) // add the operations to the queue operationQueue.addOperation(createRecordsForNewObjectsOperation) operationQueue.addOperation(transferCreatedRecordsOperation) operationQueue.addOperation(fetchModifiedRecordsOperation) operationQueue.addOperation(transferFetchedRecordsOperation) operationQueue.addOperation(modifyRecordsOperation) operationQueue.addOperation(clearDeletedCloudKitObjectsOperation) } func performFullSync() { queueFullSyncOperations() } func syncZone(_ zoneName: String, completionBlockOperation: BlockOperation) { if let cloudKitZone = CloudKitZone(rawValue: zoneName) { // suspend the queue so nothing finishes before all our dependencies are setup operationQueue.isSuspended = true // queue up the change operations for a zone let saveChangedRecordsToCoreDataOperation = queueChangeOperationsForZone(cloudKitZone, modifyRecordZonesOperation: nil) // add our completion block to the queue as well to handle background fetches completionBlockOperation.addDependency(saveChangedRecordsToCoreDataOperation) operationQueue.addOperation(completionBlockOperation) // let the queue begin firing again operationQueue.isSuspended = false } } // MARK: CloudKit Unavailable Functions fileprivate func handleCloudKitUnavailable(_ accountStatus: CKAccountStatus, error:NSError?) { cloudKitEnabled = false var errorText = "Synchronization is disabled\n" if let error = error { print("handleCloudKitUnavailable ERROR: \(error)") print("An error occured: \(error.localizedDescription)") errorText += error.localizedDescription } switch accountStatus { case .restricted: errorText += "iCloud is not available due to restrictions" case .noAccount: errorText += "There is no CloudKit account setup.\nYou can setup iCloud in the Settings app." default: break } displayCloudKitNotAvailableError(errorText) } fileprivate func displayCloudKitNotAvailableError(_ errorText: String) { if !suppressCloudKitEnabledError { DispatchQueue.main.async(execute: { let alertController = UIAlertController(title: "iCloud Synchronization Error", message: errorText, preferredStyle: UIAlertControllerStyle.alert) let firstButton = CloudKitPromptButtonType.OK let firstButtonAction = UIAlertAction(title: firstButton.rawValue, style: firstButton.actionStyle(), handler: { (action: UIAlertAction) -> Void in firstButton.performAction() }); alertController.addAction(firstButtonAction) let secondButton = CloudKitPromptButtonType.DontShowAgain let secondButtonAction = UIAlertAction(title: secondButton.rawValue, style: secondButton.actionStyle(), handler: { (action: UIAlertAction) -> Void in secondButton.performAction() }); alertController.addAction(secondButtonAction) if let appDelegate = UIApplication.shared.delegate, let appWindow = appDelegate.window!, // yes the UIWindow really is window?? - http://stackoverflow.com/questions/28901893/why-is-main-window-of-type-double-optional let rootViewController = appWindow.rootViewController { rootViewController.present(alertController, animated: true, completion: nil) } }) } } // MARK: CloudKit Init Functions fileprivate func initializeCloudKit() { print("CloudKit IS available") cloudKitEnabled = true // suspend the operation queue until all operations are created and enqueued operationQueue.isSuspended = true // self.deleteRecordZone() let modifyRecordZonesOperation = queueZoneInitilizationOperations() let modifySubscriptionsOperation = queueSubscriptionInitilizationOperations() // set the dependencies between zones and subscriptions (we need the zones to exist before any subscriptions can be created) modifySubscriptionsOperation.addDependency(modifyRecordZonesOperation) let syncAllZonesOperation = BlockOperation { [unowned self] in self.queueFullSyncOperations() } syncAllZonesOperation.addDependency(modifyRecordZonesOperation) operationQueue.addOperation(syncAllZonesOperation) // all init operations are ready, start the queue operationQueue.isSuspended = false } fileprivate func queueFullSyncOperations() { // 1. Fetch all the changes both locally and from each zone let fetchOfflineChangesFromCoreDataOperation = FetchOfflineChangesFromCoreDataOperation(coreDataManager: coreDataManager, cloudKitManager: self, entityNames: ModelObjectType.allCloudKitModelObjectTypes) let fetchCarZoneChangesOperation = FetchRecordChangesForCloudKitZoneOperation(cloudKitZone: CloudKitZone.CarZone) let fetchTruckZoneChangesOperation = FetchRecordChangesForCloudKitZoneOperation(cloudKitZone: CloudKitZone.TruckZone) let fetchBusZoneChangesOperation = FetchRecordChangesForCloudKitZoneOperation(cloudKitZone: CloudKitZone.BusZone) // 2. Process the changes after transfering let processSyncChangesOperation = ProcessSyncChangesOperation(coreDataManager: coreDataManager) let transferDataToProcessSyncChangesOperation = BlockOperation { [unowned processSyncChangesOperation, unowned fetchOfflineChangesFromCoreDataOperation, unowned fetchCarZoneChangesOperation, unowned fetchTruckZoneChangesOperation, unowned fetchBusZoneChangesOperation] in processSyncChangesOperation.preProcessLocalChangedObjectIDs.append(contentsOf: fetchOfflineChangesFromCoreDataOperation.updatedManagedObjects) processSyncChangesOperation.preProcessLocalDeletedRecordIDs.append(contentsOf: fetchOfflineChangesFromCoreDataOperation.deletedRecordIDs) processSyncChangesOperation.preProcessServerChangedRecords.append(contentsOf: fetchCarZoneChangesOperation.changedRecords) processSyncChangesOperation.preProcessServerChangedRecords.append(contentsOf: fetchTruckZoneChangesOperation.changedRecords) processSyncChangesOperation.preProcessServerChangedRecords.append(contentsOf: fetchBusZoneChangesOperation.changedRecords) processSyncChangesOperation.preProcessServerDeletedRecordIDs.append(contentsOf: fetchCarZoneChangesOperation.deletedRecordIDs) processSyncChangesOperation.preProcessServerDeletedRecordIDs.append(contentsOf: fetchTruckZoneChangesOperation.deletedRecordIDs) processSyncChangesOperation.preProcessServerDeletedRecordIDs.append(contentsOf: fetchBusZoneChangesOperation.deletedRecordIDs) } // 3. Fetch records from the server that we need to change let fetchRecordsForModifiedObjectsOperation = FetchRecordsForModifiedObjectsOperation(coreDataManager: coreDataManager) let transferDataToFetchRecordsOperation = BlockOperation { [unowned fetchRecordsForModifiedObjectsOperation, unowned processSyncChangesOperation] in fetchRecordsForModifiedObjectsOperation.preFetchModifiedRecords = processSyncChangesOperation.postProcessChangesToServer } // 4. Modify records in the cloud let modifyRecordsFromManagedObjectsOperation = ModifyRecordsFromManagedObjectsOperation(coreDataManager: coreDataManager, cloudKitManager: self) let transferDataToModifyRecordsOperation = BlockOperation { [unowned fetchRecordsForModifiedObjectsOperation, unowned modifyRecordsFromManagedObjectsOperation, unowned processSyncChangesOperation] in if let fetchedRecordsDictionary = fetchRecordsForModifiedObjectsOperation.fetchedRecords { modifyRecordsFromManagedObjectsOperation.fetchedRecordsToModify = fetchedRecordsDictionary } modifyRecordsFromManagedObjectsOperation.preModifiedRecords = processSyncChangesOperation.postProcessChangesToServer // also set the recordIDsToDelete from what we processed modifyRecordsFromManagedObjectsOperation.recordIDsToDelete = processSyncChangesOperation.postProcessDeletesToServer } // 5. Modify records locally let saveChangedRecordsToCoreDataOperation = SaveChangedRecordsToCoreDataOperation(coreDataManager: coreDataManager) let transferDataToSaveChangesToCoreDataOperation = BlockOperation { [unowned saveChangedRecordsToCoreDataOperation, unowned processSyncChangesOperation] in saveChangedRecordsToCoreDataOperation.changedRecords = processSyncChangesOperation.postProcessChangesToCoreData saveChangedRecordsToCoreDataOperation.deletedRecordIDs = processSyncChangesOperation.postProcessDeletesToCoreData } // 6. Delete all of the DeletedCloudKitObjects let clearDeletedCloudKitObjectsOperation = ClearDeletedCloudKitObjectsOperation(coreDataManager: coreDataManager) // set dependencies // 1. transfering all the fetched data to process for conflicts transferDataToProcessSyncChangesOperation.addDependency(fetchOfflineChangesFromCoreDataOperation) transferDataToProcessSyncChangesOperation.addDependency(fetchCarZoneChangesOperation) transferDataToProcessSyncChangesOperation.addDependency(fetchTruckZoneChangesOperation) transferDataToProcessSyncChangesOperation.addDependency(fetchBusZoneChangesOperation) // 2. processing the data onces its transferred processSyncChangesOperation.addDependency(transferDataToProcessSyncChangesOperation) // 3. fetching records changed local transferDataToFetchRecordsOperation.addDependency(processSyncChangesOperation) fetchRecordsForModifiedObjectsOperation.addDependency(transferDataToFetchRecordsOperation) // 4. modifying records in CloudKit transferDataToModifyRecordsOperation.addDependency(fetchRecordsForModifiedObjectsOperation) modifyRecordsFromManagedObjectsOperation.addDependency(transferDataToModifyRecordsOperation) // 5. modifying records in CoreData transferDataToSaveChangesToCoreDataOperation.addDependency(processSyncChangesOperation) saveChangedRecordsToCoreDataOperation.addDependency(transferDataToModifyRecordsOperation) // 6. clear the deleteCloudKitObjects clearDeletedCloudKitObjectsOperation.addDependency(saveChangedRecordsToCoreDataOperation) // add operations to the queue operationQueue.addOperation(fetchOfflineChangesFromCoreDataOperation) operationQueue.addOperation(fetchCarZoneChangesOperation) operationQueue.addOperation(fetchTruckZoneChangesOperation) operationQueue.addOperation(fetchBusZoneChangesOperation) operationQueue.addOperation(transferDataToProcessSyncChangesOperation) operationQueue.addOperation(processSyncChangesOperation) operationQueue.addOperation(transferDataToFetchRecordsOperation) operationQueue.addOperation(fetchRecordsForModifiedObjectsOperation) operationQueue.addOperation(transferDataToModifyRecordsOperation) operationQueue.addOperation(modifyRecordsFromManagedObjectsOperation) operationQueue.addOperation(transferDataToSaveChangesToCoreDataOperation) operationQueue.addOperation(saveChangedRecordsToCoreDataOperation) operationQueue.addOperation(clearDeletedCloudKitObjectsOperation) } // MARK: RecordZone Functions fileprivate func queueZoneInitilizationOperations() -> CKModifyRecordZonesOperation { // 1. Fetch all the zones // 2. Process the returned zones and create arrays for zones that need creating and those that need deleting // 3. Modify the zones in cloudkit let fetchAllRecordZonesOperation = FetchAllRecordZonesOperation.fetchAllRecordZonesOperation() let processServerRecordZonesOperation = ProcessServerRecordZonesOperation() let modifyRecordZonesOperation = createModifyRecordZoneOperation(nil, recordZoneIDsToDelete: nil) let transferFetchedZonesOperation = BlockOperation() { [unowned fetchAllRecordZonesOperation, unowned processServerRecordZonesOperation] in if let fetchedRecordZones = fetchAllRecordZonesOperation.fetchedRecordZones { processServerRecordZonesOperation.preProcessRecordZoneIDs = Array(fetchedRecordZones.keys) } } let transferProcessedZonesOperation = BlockOperation() { [unowned modifyRecordZonesOperation, unowned processServerRecordZonesOperation] in modifyRecordZonesOperation.recordZonesToSave = processServerRecordZonesOperation.postProcessRecordZonesToCreate modifyRecordZonesOperation.recordZoneIDsToDelete = processServerRecordZonesOperation.postProcessRecordZoneIDsToDelete } transferFetchedZonesOperation.addDependency(fetchAllRecordZonesOperation) processServerRecordZonesOperation.addDependency(transferFetchedZonesOperation) transferProcessedZonesOperation.addDependency(processServerRecordZonesOperation) modifyRecordZonesOperation.addDependency(transferProcessedZonesOperation) operationQueue.addOperation(fetchAllRecordZonesOperation) operationQueue.addOperation(transferFetchedZonesOperation) operationQueue.addOperation(processServerRecordZonesOperation) operationQueue.addOperation(transferProcessedZonesOperation) operationQueue.addOperation(modifyRecordZonesOperation) return modifyRecordZonesOperation } fileprivate func deleteRecordZone() { let fetchAllRecordZonesOperation = FetchAllRecordZonesOperation.fetchAllRecordZonesOperation() let modifyRecordZonesOperation = createModifyRecordZoneOperation(nil, recordZoneIDsToDelete: nil) let dataTransferOperation = BlockOperation() { [unowned modifyRecordZonesOperation, unowned fetchAllRecordZonesOperation] in if let fetchedRecordZones = fetchAllRecordZonesOperation.fetchedRecordZones { modifyRecordZonesOperation.recordZoneIDsToDelete = Array(fetchedRecordZones.keys) } } dataTransferOperation.addDependency(fetchAllRecordZonesOperation) modifyRecordZonesOperation.addDependency(dataTransferOperation) operationQueue.addOperation(fetchAllRecordZonesOperation) operationQueue.addOperation(dataTransferOperation) operationQueue.addOperation(modifyRecordZonesOperation) } // MARK: Subscription Functions fileprivate func queueSubscriptionInitilizationOperations() -> CKModifySubscriptionsOperation { // 1. Fetch all subscriptions // 2. Process which need to be created and which need to be deleted // 3. Make the adjustments in iCloud let fetchAllSubscriptionsOperation = FetchAllSubscriptionsOperation.fetchAllSubscriptionsOperation() let processServerSubscriptionsOperation = ProcessServerSubscriptionsOperation() let modifySubscriptionsOperation = createModifySubscriptionOperation() let transferFetchedSubscriptionsOperation = BlockOperation() { [unowned processServerSubscriptionsOperation, unowned fetchAllSubscriptionsOperation] in processServerSubscriptionsOperation.preProcessFetchedSubscriptions = fetchAllSubscriptionsOperation.fetchedSubscriptions } let transferProcessedSubscriptionsOperation = BlockOperation() { [unowned modifySubscriptionsOperation, unowned processServerSubscriptionsOperation] in modifySubscriptionsOperation.subscriptionsToSave = processServerSubscriptionsOperation.postProcessSubscriptionsToCreate modifySubscriptionsOperation.subscriptionIDsToDelete = processServerSubscriptionsOperation.postProcessSubscriptionIDsToDelete } transferFetchedSubscriptionsOperation.addDependency(fetchAllSubscriptionsOperation) processServerSubscriptionsOperation.addDependency(transferFetchedSubscriptionsOperation) transferProcessedSubscriptionsOperation.addDependency(processServerSubscriptionsOperation) modifySubscriptionsOperation.addDependency(transferProcessedSubscriptionsOperation) operationQueue.addOperation(fetchAllSubscriptionsOperation) operationQueue.addOperation(transferFetchedSubscriptionsOperation) operationQueue.addOperation(processServerSubscriptionsOperation) operationQueue.addOperation(transferProcessedSubscriptionsOperation) operationQueue.addOperation(modifySubscriptionsOperation) return modifySubscriptionsOperation } // MARK: Sync Records fileprivate func queueChangeOperationsForZone(_ cloudKitZone: CloudKitZone, modifyRecordZonesOperation: CKModifyRecordZonesOperation?) -> SaveChangedRecordsToCoreDataOperation { // there are two operations that need to be chained together for each zone // the first is to fetch record changes // the second is to save those changes to CoreData // we'll also need a block operation to transfer data between them let fetchRecordChangesOperation = FetchRecordChangesForCloudKitZoneOperation(cloudKitZone: cloudKitZone) let saveChangedRecordsToCoreDataOperation = SaveChangedRecordsToCoreDataOperation(coreDataManager: coreDataManager) let dataTransferOperation = BlockOperation() { [unowned saveChangedRecordsToCoreDataOperation, unowned fetchRecordChangesOperation] in print("addChangeOperationsForZone.dataTransferOperation") saveChangedRecordsToCoreDataOperation.changedRecords = fetchRecordChangesOperation.changedRecords saveChangedRecordsToCoreDataOperation.deletedRecordIDs = fetchRecordChangesOperation.deletedRecordIDs } // set the dependencies if let modifyRecordZonesOperation = modifyRecordZonesOperation { fetchRecordChangesOperation.addDependency(modifyRecordZonesOperation) } dataTransferOperation.addDependency(fetchRecordChangesOperation) saveChangedRecordsToCoreDataOperation.addDependency(dataTransferOperation) // add the operations to the queue operationQueue.addOperation(fetchRecordChangesOperation) operationQueue.addOperation(dataTransferOperation) operationQueue.addOperation(saveChangedRecordsToCoreDataOperation) return saveChangedRecordsToCoreDataOperation } // MARK: Create Operation Helper Functions fileprivate func createModifyRecordZoneOperation(_ recordZonesToSave: [CKRecordZone]?, recordZoneIDsToDelete: [CKRecordZoneID]?) -> CKModifyRecordZonesOperation { let modifyRecordZonesOperation = CKModifyRecordZonesOperation(recordZonesToSave: recordZonesToSave, recordZoneIDsToDelete: recordZoneIDsToDelete) modifyRecordZonesOperation.modifyRecordZonesCompletionBlock = { (modifiedRecordZones: [CKRecordZone]?, deletedRecordZoneIDs: [CKRecordZoneID]?, error: NSError?) -> Void in print("--- CKModifyRecordZonesOperation.modifyRecordZonesOperation") if let error = error { print("createModifyRecordZoneOperation ERROR: \(error)") return } if let modifiedRecordZones = modifiedRecordZones { for recordZone in modifiedRecordZones { print("Modified recordZone: \(recordZone)") } } if let deletedRecordZoneIDs = deletedRecordZoneIDs { for zoneID in deletedRecordZoneIDs { print("Deleted zoneID: \(zoneID)") } } } as? ([CKRecordZone]?, [CKRecordZoneID]?, Error?) -> Void return modifyRecordZonesOperation } fileprivate func createModifySubscriptionOperation() -> CKModifySubscriptionsOperation { let modifySubscriptionsOperation = CKModifySubscriptionsOperation() modifySubscriptionsOperation.modifySubscriptionsCompletionBlock = { (modifiedSubscriptions: [CKSubscription]?, deletedSubscriptionIDs: [String]?, error: NSError?) -> Void in print("--- CKModifySubscriptionsOperation.modifySubscriptionsCompletionBlock") if let error = error { print("createModifySubscriptionOperation ERROR: \(error)") return } if let modifiedSubscriptions = modifiedSubscriptions { for subscription in modifiedSubscriptions { print("Modified subscription: \(subscription)") } } if let deletedSubscriptionIDs = deletedSubscriptionIDs { for subscriptionID in deletedSubscriptionIDs { print("Deleted subscriptionID: \(subscriptionID)") } } } as? ([CKSubscription]?, [String]?, Error?) -> Void return modifySubscriptionsOperation } // MARK: NSUserDefault Properties var lastCloudKitSyncTimestamp: Date { get { if let lastCloudKitSyncTimestamp = UserDefaults.standard.object(forKey: CloudKitUserDefaultKeys.LastCloudKitSyncTimestamp.rawValue) as? Date { return lastCloudKitSyncTimestamp } else { return Date.distantPast } } set { UserDefaults.standard.set(newValue, forKey: CloudKitUserDefaultKeys.LastCloudKitSyncTimestamp.rawValue) } } fileprivate var cloudKitEnabled: Bool { get { return UserDefaults.standard.bool(forKey: CloudKitUserDefaultKeys.CloudKitEnabledKey.rawValue) } set { UserDefaults.standard.set(newValue, forKey: CloudKitUserDefaultKeys.CloudKitEnabledKey.rawValue) } } fileprivate var suppressCloudKitEnabledError: Bool { get { return UserDefaults.standard.bool(forKey: CloudKitUserDefaultKeys.SuppressCloudKitErrorKey.rawValue) } } }

fcbc2421f3764d7f3538c37a3bd46799588657af

// // FileTests.swift // EP DiagramTests // // Created by David Mann on 6/28/20. // Copyright © 2020 EP Studios. All rights reserved. // import XCTest @testable import EP_Diagram class FileTests: XCTestCase { func testCleanupFilename() { var filename = DiagramIO.cleanupFilename("x:x/y:z") XCTAssertEqual("x_x_y_z", filename) filename = DiagramIO.cleanupFilename("abcde.tmp") XCTAssertEqual("abcde.tmp", filename) filename = DiagramIO.cleanupFilename("abcde\ntmp") XCTAssertEqual("abcde_tmp", filename) } }

33aad226bb55970d401cb28af84cee41128c3bea

/** * Definition for a binary tree node. * public class TreeNode { * public var val: Int * public var left: TreeNode? * public var right: TreeNode? * public init() { self.val = 0; self.left = nil; self.right = nil; } * public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; } * public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) { * self.val = val * self.left = left * self.right = right * } * } */ class Solution { func constructMaximumBinaryTree(_ nums: [Int]) -> TreeNode? { if nums.count == 0 { return nil } if nums.count == 1 { return TreeNode(nums[0]) } let node = TreeNode(nums.max()!) let indexOfMax = nums.firstIndex(of: nums.max()!)! node.left = constructMaximumBinaryTree(Array(nums[..<indexOfMax])) node.right = constructMaximumBinaryTree(Array(nums[(indexOfMax+1)...])) return node } }

1a5ba6bf60ac591bd0116474213a96b526aa655b

// // MessengerUITests.swift // MessengerUITests // // Created by Ayham Al Chouhuf on 4/19/21. // import XCTest class MessengerUITests: XCTestCase { override func setUpWithError() throws { // Put setup code here. This method is called before the invocation of each test method in the class. // In UI tests it is usually best to stop immediately when a failure occurs. continueAfterFailure = false // In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this. } override func tearDownWithError() throws { // Put teardown code here. This method is called after the invocation of each test method in the class. } func testExample() throws { // UI tests must launch the application that they test. let app = XCUIApplication() app.launch() // Use recording to get started writing UI tests. // Use XCTAssert and related functions to verify your tests produce the correct results. } func testLaunchPerformance() throws { if #available(macOS 10.15, iOS 13.0, tvOS 13.0, *) { // This measures how long it takes to launch your application. measure(metrics: [XCTApplicationLaunchMetric()]) { XCUIApplication().launch() } } } }

8f1cc5552ee779c3c1c473df69908e189642c3c4

// // CalendarKit_SwiftTests.swift // CalendarKit-SwiftTests // // Created by Maurice Arikoglu on 29.11.17. // Copyright © 2017 Maurice Arikoglu. All rights reserved. // import XCTest @testable import CalendarKit_Swift class CalendarKit_SwiftTests: XCTestCase { override func setUp() { super.setUp() // Put setup code here. This method is called before the invocation of each test method in the class. } override func tearDown() { // Put teardown code here. This method is called after the invocation of each test method in the class. super.tearDown() } func testExample() { // This is an example of a functional test case. // Use XCTAssert and related functions to verify your tests produce the correct results. } func testPerformanceExample() { // This is an example of a performance test case. self.measure { // Put the code you want to measure the time of here. } } }

ff87d1e473a6321fd25edaf97def7a30a0c373e7

// // Talk.swift // PyConJP // // Created by Yutaro Muta on 7/11/16. // Copyright © 2016 PyCon JP. All rights reserved. // import Foundation struct Talk { let id: Int let title: String let description: String let speakers: [String] let startDate: Date let endDate: Date let day: String let startTime: String let endTime: String let category: String let room: Room let language: Language } extension Talk { init?(dictionary: [String: Any]) { guard let id = dictionary["id"] as? Int, let title = dictionary["title"] as? String, let description = dictionary["description"] as? String, let speakers = dictionary["speakers"] as? [String], let day = dictionary["day"] as? String, let startTime = dictionary["start"] as? String, let startDate = Date.date(from: day + " " + startTime), let endTime = dictionary["end"] as? String, let endDate = Date.date(from: day + " " + endTime), let category = dictionary["category"] as? String, let room = Room(dictionary["rooms"] as? String ?? ""), let language = Language(dictionary["language"] as? String ?? "") else { return nil } self.init(id: id, title: title, description: description, speakers: speakers, startDate: startDate, endDate: endDate, day: day, startTime: startTime, endTime: endTime, category: category, room: room, language: language) } init?(_ talkObject: TalkObject) { guard let room = talkObject.room, let language = talkObject.language else { return nil } self.init(id: talkObject.id, title: talkObject.title, description: talkObject.descriptionText, speakers: talkObject.speakers.components(separatedBy: ", "), startDate: talkObject.startDate, endDate: talkObject.endDate, day: talkObject.day, startTime: talkObject.startTime, endTime: talkObject.endTime, category: talkObject.category, room: room, language: language) } }

2fe30c8e4e7a6a87495cdaec50d9538b3dcd6d26

import Foundation import os.log #if DEBUG && true fileprivate var log = Logger( subsystem: Bundle.main.bundleIdentifier!, category: "SyncTxManager_PendingSettings" ) #else fileprivate var log = Logger(OSLog.disabled) #endif class SyncTxManager_PendingSettings: Equatable, CustomStringConvertible { enum EnableDisable{ case willEnable case willDisable } private weak var parent: SyncTxManager? let paymentSyncing: EnableDisable let delay: TimeInterval let startDate: Date let fireDate: Date init(_ parent: SyncTxManager, enableSyncing delay: TimeInterval) { let now = Date() self.parent = parent self.paymentSyncing = .willEnable self.delay = delay self.startDate = now self.fireDate = now + delay log.trace("init()") startTimer() } init(_ parent: SyncTxManager, disableSyncing delay: TimeInterval) { let now = Date() self.parent = parent self.paymentSyncing = .willDisable self.delay = delay self.startDate = now self.fireDate = now + delay log.trace("init()") startTimer() } deinit { log.trace("deinit()") } private func startTimer() { log.trace("startTimer()") let deadline: DispatchTime = DispatchTime.now() + fireDate.timeIntervalSinceNow DispatchQueue.global(qos: .utility).asyncAfter(deadline: deadline) {[weak self] in self?.approve() } } /// Automatically invoked after the timer expires. /// Can also be called manually to approve before the delay. /// func approve() { log.trace("approve()") if let parent = parent { parent.updateState(pending: self, approved: true) } } func cancel() { log.trace("cancel()") if let parent = parent { parent.updateState(pending: self, approved: false) } } var description: String { let dateStr = fireDate.description(with: Locale.current) switch paymentSyncing { case .willEnable: return "<SyncTxManager_PendingSettings: willEnable @ \(dateStr)>" case .willDisable: return "<SyncTxManager_PendingSettings: willDisable @ \(dateStr)>" } } static func == (lhs: SyncTxManager_PendingSettings, rhs: SyncTxManager_PendingSettings) -> Bool { return (lhs.paymentSyncing == rhs.paymentSyncing) && (lhs.fireDate == rhs.fireDate) } }

0ae9bd7ce179492bbe353a646d6dbe6d6055e43c

// // AppDelegate.swift // Habits // // Created by Mario Hahn on 13.03.20. // Copyright © 2020 Mario Hahn. All rights reserved. // import UIKit import CoreData @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { UITableView.appearance().tableFooterView = UIView() // Override point for customization after application launch. return true } // MARK: UISceneSession Lifecycle func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration { // Called when a new scene session is being created. // Use this method to select a configuration to create the new scene with. return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role) } func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) { // Called when the user discards a scene session. // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions. // Use this method to release any resources that were specific to the discarded scenes, as they will not return. } // MARK: - Core Data stack lazy var persistentContainer: NSPersistentContainer = { /* The persistent container for the application. This implementation creates and returns a container, having loaded the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail. */ let container = NSPersistentContainer(name: "Habits") container.loadPersistentStores(completionHandler: { (storeDescription, error) in if let error = error as NSError? { // Replace this implementation with code to handle the error appropriately. // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development. /* Typical reasons for an error here include: * The parent directory does not exist, cannot be created, or disallows writing. * The persistent store is not accessible, due to permissions or data protection when the device is locked. * The device is out of space. * The store could not be migrated to the current model version. Check the error message to determine what the actual problem was. */ fatalError("Unresolved error \(error), \(error.userInfo)") } }) return container }() // MARK: - Core Data Saving support func saveContext () { let context = persistentContainer.viewContext if context.hasChanges { do { try context.save() } catch { // Replace this implementation with code to handle the error appropriately. // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development. let nserror = error as NSError fatalError("Unresolved error \(nserror), \(nserror.userInfo)") } } } }

bf5ac53fa18c6cbfe8926b7984ac936bc48f6a5c

class Solution { func addDigits(num: Int) -> Int { return num - 9 * ((num - 1) / 9 ) } }

5b77cff83fcf8acd7feb7cb169d2c2bfd35b7581

// // Project5App.swift // Project5 WatchKit Extension // // Created by Paul Hudson on 07/10/2020. // import SwiftUI @main struct Project5App: App { var body: some Scene { WindowGroup { NavigationView { ContentView() } } } }

d79f4a14bcc6d93524e3ac93cc33a3ef1076d7ba

// // CurvedTabBar.swift // CustomTabBar // // Created by Zhi Zhou on 2020/7/14. // Copyright © 2020 Zhi Zhou. All rights reserved. // import UIKit open class CurvedTabBar: UITabBar { private enum ShapeLayerStyle { case mask, fill } private var maskShapeLayer: CALayer? private var fillShapeLayer: CALayer? private let effectView = UIVisualEffectView(effect: UIBlurEffect(style: .systemThickMaterial)) private let centerButton = UIButton(type: .system) private var centerButtonWidthLayoutConstraint: NSLayoutConstraint? private var centerButtonHeightLayoutConstraint: NSLayoutConstraint? open var centerButtonBottomOffset: CGFloat = 5.0 public typealias ActionHandler = (UIButton) -> Void? public var centerActionHandler: ActionHandler? open override func draw(_ rect: CGRect) { setupShapeLayer() } open override func point(inside point: CGPoint, with event: UIEvent?) -> Bool { let buttonRadius: CGFloat = bounds.height / 2 return point.y > 0 || (point.y >= -buttonRadius && (point.x >= center.x - buttonRadius) && (point.x <= center.x + buttonRadius)) } public override init(frame: CGRect) { super.init(frame: frame) setupInterface() } required public init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") } open override func layoutSubviews() { super.layoutSubviews() layoutCenterButton() } } extension CurvedTabBar { private func setupInterface() { setupEffectView() setupCenterButton() } private func setupEffectView() { effectView.contentView.layer.masksToBounds = false insertSubview(effectView, at: 0) effectView.translatesAutoresizingMaskIntoConstraints = false NSLayoutConstraint.activate([ effectView.leftAnchor.constraint(equalTo: self.leftAnchor), effectView.rightAnchor.constraint(equalTo: self.rightAnchor), effectView.topAnchor.constraint(equalTo: self.topAnchor), effectView.bottomAnchor.constraint(equalTo: self.bottomAnchor) ]) } private func setupCenterButton() { centerButton.backgroundColor = .systemBlue centerButton.isPointerInteractionEnabled = true centerButton.pointerStyleProvider = { button, proposedEffect, proposedShape -> UIPointerStyle? in var rect = button.bounds.insetBy(dx: 0, dy: 0) rect = button.convert(rect, to: proposedEffect.preview.target.container) return UIPointerStyle(effect: .lift(proposedEffect.preview), shape: .roundedRect(rect, radius: button.bounds.width / 2)) } centerButton.addTarget(self, action: #selector(action(_:)), for: .touchUpInside) addSubview(centerButton) centerButton.translatesAutoresizingMaskIntoConstraints = false centerButtonWidthLayoutConstraint = centerButton.widthAnchor.constraint(equalToConstant: 0) centerButtonHeightLayoutConstraint = centerButton.heightAnchor.constraint(equalToConstant: 0) NSLayoutConstraint.activate([ centerButton.centerXAnchor.constraint(equalTo: self.centerXAnchor, constant: 0), centerButton.centerYAnchor.constraint(equalTo: self.topAnchor, constant: -centerButtonBottomOffset), centerButtonWidthLayoutConstraint!, centerButtonHeightLayoutConstraint! ]) } private func layoutCenterButton() { let centerImage = UIImage(systemName: "plus", withConfiguration: UIImage.SymbolConfiguration(pointSize: (bounds.height - safeAreaInsets.bottom) / 2 - centerButtonBottomOffset, weight: .medium))?.withRenderingMode(.alwaysOriginal).withTintColor(.systemBackground) centerButton.setImage(centerImage, for: .normal) // bounds.height - safeAreaInsets.bottom: 减去底部安全区域，防止按钮显示过大不协调。 let sizeConstant = bounds.height - safeAreaInsets.bottom - centerButtonBottomOffset centerButtonWidthLayoutConstraint?.constant = sizeConstant centerButtonHeightLayoutConstraint?.constant = sizeConstant centerButton.layer.cornerRadius = centerButton.bounds.height / 2 } } extension CurvedTabBar { private func setupShapeLayer() { let maskShapeLayer = CAShapeLayer() maskShapeLayer.path = createPath(style: .mask) if let oldShapeLayer = self.maskShapeLayer { effectView.layer.replaceSublayer(oldShapeLayer, with: maskShapeLayer) } else { effectView.layer.mask = maskShapeLayer } let fillShapeLayer = CAShapeLayer() fillShapeLayer.path = createPath(style: .fill) fillShapeLayer.strokeColor = UIColor.shadowColor.cgColor if let oldShapeLayer = self.fillShapeLayer { effectView.contentView.layer.replaceSublayer(oldShapeLayer, with: fillShapeLayer) } else { effectView.contentView.layer.addSublayer(fillShapeLayer) } self.maskShapeLayer = maskShapeLayer self.fillShapeLayer = fillShapeLayer } private func createPath(style: ShapeLayerStyle) -> CGPath { // bounds.height - safeAreaInsets.bottom: 减去底部安全区域，防止弧度显示过大不协调。 let height: CGFloat = (bounds.height - safeAreaInsets.bottom) / 2 let path = UIBezierPath() let centerWidth = frame.width / 2 let shadowHeight = 1 / UIScreen.main.scale path.move(to: CGPoint(x: 0, y: -shadowHeight)) path.addLine(to: CGPoint(x: centerWidth - height * 2, y: -shadowHeight)) path.addCurve(to: CGPoint(x: centerWidth, y: height), controlPoint1: CGPoint(x: centerWidth - height / 2, y: 0), controlPoint2: CGPoint(x: centerWidth - height, y: height)) path.addCurve(to: CGPoint(x: centerWidth + height * 2, y: -shadowHeight), controlPoint1: CGPoint(x: centerWidth + height, y: height), controlPoint2: CGPoint(x: centerWidth + height / 2, y: 0)) path.addLine(to: CGPoint(x: frame.width, y: -shadowHeight)) switch style { case .mask: path.addLine(to: CGPoint(x: frame.width, y: frame.height)) path.addLine(to: CGPoint(x: 0, y: frame.height)) default: break } path.close() return path.cgPath } } extension CurvedTabBar { @objc private func action(_ button: UIButton) { centerActionHandler?(button) } } fileprivate extension UIImage { /// 根据新的尺寸重绘图片 func resizeImage(withSize newSize: CGSize) -> UIImage? { let format = UIGraphicsImageRendererFormat() format.opaque = false format.scale = 0 let renderer = UIGraphicsImageRenderer(size: newSize, format: format) let newImage = renderer.image { (context) in let rect = CGRect(origin: .zero, size: newSize) draw(in: rect) } return newImage } } fileprivate extension UIColor { /// 分割线颜色 static var shadowColor: UIColor { return UIColor { (traitCollection) -> UIColor in if traitCollection.userInterfaceStyle == .dark { return UIColor(white: 1, alpha: 0.15) } else { return UIColor(white: 0, alpha: 0.3) } } } }

76ec7d20ca24ce862264eaa2977bd51966fab83e

// // viewHorizontal.swift // xo // // Created by Sajjad Hashemian on 9/25/15. // Copyright © 2015 Sajjad Hashemian. All rights reserved. // import Cocoa class viewHorizontal: NSView { override func drawRect(dirtyRect: NSRect) { let path = NSBezierPath(); let start = NSPoint(x: 0, y: self.frame.height / 2) let end = NSPoint(x:self.frame.width,y: self.frame.height / 2) path.moveToPoint(start) path.lineToPoint(end) NSColor.blackColor().set() path.stroke() } }

2f039384f2684977907327236b0064ee8b89ff9d

// // ColorPickerMapView.swift // Alderis // // Created by Adam Demasi on 14/3/20. // Copyright © 2020 HASHBANG Productions. All rights reserved. // import UIKit internal protocol ColorPickerWheelViewDelegate: AnyObject { func colorPickerWheelView(didSelectColor color: Color) } internal class ColorPickerWheelView: UIView { weak var delegate: ColorPickerWheelViewDelegate? var color: Color { didSet { updateColor() } } private var containerView: UIView! private var wheelView: ColorPickerWheelInnerView! private var selectionView: ColorWell! private var selectionViewXConstraint: NSLayoutConstraint! private var selectionViewYConstraint: NSLayoutConstraint! private var selectionViewFingerDownConstraint: NSLayoutConstraint! private var isFingerDown = false private let touchDownFeedbackGenerator = UIImpactFeedbackGenerator(style: .medium) private let touchUpFeedbackGenerator = UIImpactFeedbackGenerator(style: .light) init(color: Color) { self.color = color super.init(frame: .zero) containerView = UIView() containerView.translatesAutoresizingMaskIntoConstraints = false containerView.clipsToBounds = true addSubview(containerView) containerView.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(gestureRecognizerFired(_:)))) containerView.addGestureRecognizer(UILongPressGestureRecognizer(target: self, action: #selector(gestureRecognizerFired(_:)))) let panGestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(gestureRecognizerFired(_:))) panGestureRecognizer.maximumNumberOfTouches = 1 containerView.addGestureRecognizer(panGestureRecognizer) wheelView = ColorPickerWheelInnerView() wheelView.translatesAutoresizingMaskIntoConstraints = false wheelView.handleLayout = { [weak self] in self?.setNeedsLayout() } containerView.addSubview(wheelView) selectionView = ColorWell() selectionView.translatesAutoresizingMaskIntoConstraints = false selectionView.isDragInteractionEnabled = false selectionView.isDropInteractionEnabled = false #if swift(>=5.3) if #available(iOS 14, *) { selectionView.isContextMenuInteractionEnabled = false } #endif containerView.addSubview(selectionView) selectionViewXConstraint = selectionView.leftAnchor.constraint(equalTo: containerView.leftAnchor) selectionViewYConstraint = selectionView.topAnchor.constraint(equalTo: containerView.topAnchor) // https://www.youtube.com/watch?v=Qs8kDiOwPBA selectionViewFingerDownConstraint = selectionView.widthAnchor.constraint(equalToConstant: 56) let selectionViewNormalConstraint = selectionView.widthAnchor.constraint(equalToConstant: UIFloat(24)) selectionViewNormalConstraint.priority = .defaultHigh // Remove minimum width constraint configured by ColorWell internally let selectionWidthConstraint = selectionView.constraints.first { $0.firstAnchor == selectionView.widthAnchor } selectionWidthConstraint?.isActive = false NSLayoutConstraint.activate([ containerView.centerXAnchor.constraint(equalTo: self.centerXAnchor), containerView.topAnchor.constraint(equalTo: self.topAnchor), containerView.bottomAnchor.constraint(equalTo: self.bottomAnchor), containerView.widthAnchor.constraint(equalTo: containerView.heightAnchor, constant: UIFloat(30)), wheelView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor, constant: UIFloat(30)), wheelView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor, constant: UIFloat(-30)), wheelView.topAnchor.constraint(equalTo: containerView.topAnchor, constant: UIFloat(15)), wheelView.bottomAnchor.constraint(equalTo: containerView.bottomAnchor, constant: UIFloat(-15)), selectionViewXConstraint, selectionViewYConstraint, selectionViewNormalConstraint, selectionView.heightAnchor.constraint(equalTo: selectionView.widthAnchor) ]) } required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") } override func layoutSubviews() { super.layoutSubviews() updateSelectionPoint() } private func updateColor() { wheelView.brightness = color.brightness selectionView.backgroundColor = color.uiColor updateSelectionPoint() } private func updateSelectionPoint() { let colorPoint = pointForColor(color, in: wheelView.frame.size) let point = CGPoint(x: wheelView.frame.origin.x + colorPoint.x - (selectionView.frame.size.width / 2), y: min( frame.size.height - selectionView.frame.size.height - 1, max(1, wheelView.frame.origin.y + colorPoint.y - (selectionView.frame.size.height / 2)) )) selectionViewXConstraint.constant = point.x selectionViewYConstraint.constant = point.y } private func colorAt(position: CGPoint, in size: CGSize) -> Color { let point = CGPoint(x: (size.width / 2) - position.x, y: (size.height / 2) - position.y) let h = 180 + round(atan2(point.y, point.x) * (180 / .pi)) let handleRange = size.width / 2 let handleDistance = min(sqrt(point.x * point.x + point.y * point.y), handleRange) let s = round(100 / handleRange * handleDistance) return Color(hue: h / 360, saturation: s / 100, brightness: color.brightness, alpha: 1) } private func pointForColor(_ color: Color, in size: CGSize) -> CGPoint { let handleRange = size.width / 2 let handleAngle = (color.hue * 360) * (.pi / 180) let handleDistance = color.saturation * handleRange return CGPoint(x: (size.width / 2) + handleDistance * cos(handleAngle), y: (size.height / 2) + handleDistance * sin(handleAngle)) } @objc private func gestureRecognizerFired(_ sender: UIGestureRecognizer) { switch sender.state { case .began, .changed, .ended: var location = sender.location(in: containerView) location.x -= wheelView.frame.origin.x location.y -= wheelView.frame.origin.y color = colorAt(position: location, in: wheelView.frame.size) delegate?.colorPickerWheelView(didSelectColor: color) case .possible, .cancelled, .failed: break @unknown default: break } if sender is UITapGestureRecognizer { return } switch sender.state { case .began, .ended, .cancelled: isFingerDown = sender.state == .began selectionViewFingerDownConstraint.isActive = isFingerDown && !isCatalyst updateSelectionPoint() UIView.animate(withDuration: 0.2, animations: { self.containerView.layoutIfNeeded() self.updateSelectionPoint() }, completion: { _ in self.updateSelectionPoint() }) if sender.state == .began { touchDownFeedbackGenerator.impactOccurred() } else { touchUpFeedbackGenerator.impactOccurred() } case .possible, .changed, .failed: break @unknown default: break } } } private class ColorPickerWheelInnerView: UIView { private var brightnessView: UIView! var brightness: CGFloat { get { 1 - brightnessView.alpha } set { brightnessView.alpha = 1 - newValue } } var handleLayout: (() -> Void)! private var saturationMask: GradientView! override init(frame: CGRect) { super.init(frame: frame) clipsToBounds = true let hueView = GradientView() hueView.translatesAutoresizingMaskIntoConstraints = false hueView.autoresizingMask = [.flexibleWidth, .flexibleHeight] hueView.gradientLayer.type = .conic hueView.gradientLayer.colors = Color.Component.hue.sliderTintColor(for: Color(red: 1, green: 0, blue: 0, alpha: 1)).map(\.uiColor.cgColor) hueView.gradientLayer.startPoint = CGPoint(x: 0.5, y: 0.5) hueView.gradientLayer.endPoint = CGPoint(x: 0.5, y: 0) hueView.gradientLayer.transform = CATransform3DMakeRotation(0.5 * .pi, 0, 0, 1) addSubview(hueView) let saturationView = UIView() saturationView.translatesAutoresizingMaskIntoConstraints = false saturationView.autoresizingMask = [.flexibleWidth, .flexibleHeight] saturationView.backgroundColor = .white addSubview(saturationView) saturationMask = GradientView() saturationMask.gradientLayer.type = .radial saturationMask.gradientLayer.colors = [UIColor.white.cgColor, UIColor.clear.cgColor] saturationMask.gradientLayer.startPoint = CGPoint(x: 0.5, y: 0.5) saturationMask.gradientLayer.endPoint = CGPoint(x: 1, y: 1) saturationView.mask = saturationMask brightnessView = UIView() brightnessView.translatesAutoresizingMaskIntoConstraints = false brightnessView.autoresizingMask = [.flexibleWidth, .flexibleHeight] brightnessView.backgroundColor = .black addSubview(brightnessView) } convenience init() { self.init(frame: .zero) } required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") } override func layoutSubviews() { super.layoutSubviews() layer.cornerRadius = frame.size.height / 2 saturationMask.frame = bounds handleLayout() } }

79f48786946ed0e1953fe3f757d888e92ad3c1c5

// // NSObject+JY.swift // JYFoundation // // Created by Scott Rong on 2017/3/25. // Copyright © 2018年 jayasme All rights reserved. // import Foundation import ObjectiveC extension NSObject { public func jy_getAssociatedObject(key: String) -> Any? { let key: UnsafeRawPointer! = UnsafeRawPointer.init(bitPattern: key.hashValue) return objc_getAssociatedObject(self, key) } public func jy_setAssociatedObject(key: String, object: Any?) { guard let object = object else { jy_removeAssociationObject(key: key) return } // determin the type of association storage policy var policy: objc_AssociationPolicy = .OBJC_ASSOCIATION_COPY_NONATOMIC if object is NSString || object is NSNumber { policy = .OBJC_ASSOCIATION_COPY_NONATOMIC } else if object is NSObject { policy = .OBJC_ASSOCIATION_RETAIN_NONATOMIC } else { policy = .OBJC_ASSOCIATION_ASSIGN } jy_setAssociatedObject(key: key, object: object, policy: policy) } public func jy_setAssociatedObject(key: String, object: Any, policy: objc_AssociationPolicy) { let key: UnsafeRawPointer! = UnsafeRawPointer.init(bitPattern: key.hashValue) objc_setAssociatedObject(self, key, object, policy) } public func jy_removeAssociationObject(key: String) { let key: UnsafeRawPointer! = UnsafeRawPointer.init(bitPattern: key.hashValue) objc_removeAssociatedObjects(key ?? "") } }

ebc993c2151fdcdfbd3886e919aecafbb20a1fdc

//: [Previous](@previous) import Foundation var queue = CircularQueue(capacity: 3, defaultValue: -1) //queue.dequeue() queue.enqueue(elem: 4) queue.enqueue(elem: 2) queue.enqueue(elem: 2) queue.enqueue(elem: 2) queue.enqueue(elem: 2) queue.dequeue() queue.dequeue() //queue.dequeue() print("\(queue)")

76bc590ebf9c3637d951647a27fbd7c38dcd8334

// The local grid computing cluster. public class SporificaVirus { // Function type used as status change callback by the infection burst // process. public typealias Callback = (Grid.Point) -> () var grid: Grid var virus: Virus var listeners: [Grid.Status: Callback] = [:] // Create a computing cluster given a string description of the grid and its // virus generation. Returns nil if parsing the grid failed. public convenience init?(grid s: String, generation: Virus.Generation) { let xs = s.split(separator: "\n").map(String.init) self.init(grid: xs, generation: generation) } // Create a computing cluster given a string description of the grid and its // virus generation. Returns nil if parsing the grid failed. public init?(grid xs: [String], generation: Virus.Generation) { guard let grid = Grid(xs) else { return nil } self.grid = grid self.virus = Virus(heading: .up, position: .origin, generation: generation) } // Register the given callback function to be called when the provided status // change arise. Returns the callback previously setup for the event if any. @discardableResult public func on(_ event: Grid.Status, callback: @escaping Callback) -> Callback? { let old = listeners[event] listeners[event] = callback return old } // Make the virus burst a given number of time in this computing cluster. public func burst(times: Int = 1) { for _ in 0..<times { let current = virus.position // the current node let status = virus.burst(in: grid) // Notify listener if any. if let callback = listeners[status] { callback(current) } } } // Returns a description of the grid with the virus frop the top-left (tl) // point to the bottom-right (br) point included. public func draw(_ tl: Grid.Point, _ br: Grid.Point) -> String { // Helper giving the prefix to display just before the given position. func separator(_ p: Grid.Point) -> String { switch p { case _ where p.x == tl.x: return "" case virus.position: return "[" case virus.position[.right]: return "]" default: return " " } } var description = "" for y in tl.y...br.y { for x in tl.x...br.x { let position = Grid.Point(x: x, y: y) description.append(separator(position)) description.append(grid[position].rawValue) } if y != br.y { // don't finish with a newline. description.append("\n") } } return description } }

4b10b09b17e1919135a417147ba733ca67b90e43

// // WGColors.swift // TheWordGame // // Created by Daniel McCrystal on 6/13/17. // Copyright © 2017 Lampshade Software. All rights reserved. // import UIKit class WordGameUI { static let yellow = UIColor(red: 255 / 256, green: 208 / 256, blue: 60 / 256, alpha: 1.0) static let red = UIColor(red: 255 / 256, green: 137 / 256, blue: 119 / 256, alpha: 1.0) static let blue = UIColor(red: 181 / 256, green: 213 / 256, blue: 255 / 256, alpha: 1.0) static let green = UIColor(red: 134 / 256, green: 255 / 256, blue: 134 / 256, alpha: 1.0) static let dark = UIColor(red: 34 / 256, green: 40 / 256, blue: 47 / 256, alpha: 1.0) static let lightDark = UIColor(red: 34 * 1.5 / 256, green: 40 * 1.5 / 256, blue: 47 * 1.5 / 256, alpha: 1.0) static func font(size: Int) -> UIFont { return UIFont(name: "GillSans-Light", size: CGFloat(size))! } static func getBanner(view: UIView) -> UIView { let width = view.bounds.width let height = view.bounds.height let bannerView = UIView(frame: CGRect(x: 0, y: 0, width: width, height: height * 0.1)) bannerView.backgroundColor = WordGameUI.yellow return bannerView } }

3882ac3c4c5f914790fea3a1697139af57b51c06

/* file: unary_boolean_expression.swift generated: Mon Jan 3 16:32:52 2022 */ /* This file was generated by the EXPRESS to Swift translator "exp2swift", derived from STEPcode (formerly NIST's SCL). exp2swift version: v.1.0.1, derived from stepcode v0.8 as of 2019/11/23 WARNING: You probably don't want to edit it since your modifications will be lost if exp2swift is used to regenerate it. */ import SwiftSDAIcore extension AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF { //MARK: -ENTITY DEFINITION in EXPRESS /* ENTITY unary_boolean_expression ABSTRACT SUPERTYPE OF ( ONEOF ( not_expression, odd_function ) ) SUBTYPE OF ( boolean_expression, unary_generic_expression ); END_ENTITY; -- unary_boolean_expression (line:33182 file:ap242ed2_mim_lf_v1.101.TY.exp) */ //MARK: - ALL DEFINED ATTRIBUTES /* SUPER- ENTITY(1) generic_expression (no local attributes) SUPER- ENTITY(2) expression (no local attributes) SUPER- ENTITY(3) boolean_expression (no local attributes) SUPER- ENTITY(4) unary_generic_expression ATTR: operand, TYPE: generic_expression -- EXPLICIT -- possibly overriden by ENTITY: linearized_table_function, TYPE: maths_function ENTITY: restriction_function, TYPE: maths_space ENTITY: repackaging_function, TYPE: maths_function ENTITY: not_expression, TYPE: boolean_expression ENTITY: value_function, TYPE: string_expression ENTITY: reindexed_array_function, TYPE: maths_function ENTITY: homogeneous_linear_function, TYPE: maths_function ENTITY: b_spline_function, TYPE: maths_function ENTITY: length_function, TYPE: string_expression ENTITY: partial_derivative_function, TYPE: maths_function ENTITY: odd_function, TYPE: numeric_expression ENTITY: rationalize_function, TYPE: maths_function ENTITY: general_linear_function, TYPE: maths_function ENTITY: unary_numeric_expression, TYPE: numeric_expression ENTITY: definite_integral_function, TYPE: maths_function ENTITY(SELF) unary_boolean_expression (no local attributes) SUB- ENTITY(6) not_expression REDCR: operand, TYPE: boolean_expression -- EXPLICIT -- OVERRIDING ENTITY: unary_generic_expression SUB- ENTITY(7) odd_function REDCR: operand, TYPE: numeric_expression -- EXPLICIT -- OVERRIDING ENTITY: unary_generic_expression */ //MARK: - Partial Entity public final class _unary_boolean_expression : SDAI.PartialEntity { public override class var entityReferenceType: SDAI.EntityReference.Type { eUNARY_BOOLEAN_EXPRESSION.self } //ATTRIBUTES // (no local attributes) public override var typeMembers: Set<SDAI.STRING> { var members = Set<SDAI.STRING>() members.insert(SDAI.STRING(Self.typeName)) return members } //VALUE COMPARISON SUPPORT public override func hashAsValue(into hasher: inout Hasher, visited complexEntities: inout Set<SDAI.ComplexEntity>) { super.hashAsValue(into: &hasher, visited: &complexEntities) } public override func isValueEqual(to rhs: SDAI.PartialEntity, visited comppairs: inout Set<SDAI.ComplexPair>) -> Bool { guard let rhs = rhs as? Self else { return false } if !super.isValueEqual(to: rhs, visited: &comppairs) { return false } return true } public override func isValueEqualOptionally(to rhs: SDAI.PartialEntity, visited comppairs: inout Set<SDAI.ComplexPair>) -> Bool? { guard let rhs = rhs as? Self else { return false } var result: Bool? = true if let comp = super.isValueEqualOptionally(to: rhs, visited: &comppairs) { if !comp { return false } } else { result = nil } return result } //EXPRESS IMPLICIT PARTIAL ENTITY CONSTRUCTOR public init() { super.init(asAbstructSuperclass:()) } //p21 PARTIAL ENTITY CONSTRUCTOR public required convenience init?(parameters: [P21Decode.ExchangeStructure.Parameter], exchangeStructure: P21Decode.ExchangeStructure) { let numParams = 0 guard parameters.count == numParams else { exchangeStructure.error = "number of p21 parameters(\(parameters.count)) are different from expected(\(numParams)) for entity(\(Self.entityName)) constructor"; return nil } self.init( ) } } //MARK: - Entity Reference /** ENTITY reference - EXPRESS: ```express ENTITY unary_boolean_expression ABSTRACT SUPERTYPE OF ( ONEOF ( not_expression, odd_function ) ) SUBTYPE OF ( boolean_expression, unary_generic_expression ); END_ENTITY; -- unary_boolean_expression (line:33182 file:ap242ed2_mim_lf_v1.101.TY.exp) ``` */ public final class eUNARY_BOOLEAN_EXPRESSION : SDAI.EntityReference { //MARK: PARTIAL ENTITY public override class var partialEntityType: SDAI.PartialEntity.Type { _unary_boolean_expression.self } public let partialEntity: _unary_boolean_expression //MARK: SUPERTYPES public let super_eGENERIC_EXPRESSION: eGENERIC_EXPRESSION // [1] public let super_eEXPRESSION: eEXPRESSION // [2] public let super_eBOOLEAN_EXPRESSION: eBOOLEAN_EXPRESSION // [3] public let super_eUNARY_GENERIC_EXPRESSION: eUNARY_GENERIC_EXPRESSION // [4] public var super_eUNARY_BOOLEAN_EXPRESSION: eUNARY_BOOLEAN_EXPRESSION { return self } // [5] //MARK: SUBTYPES public var sub_eNOT_EXPRESSION: eNOT_EXPRESSION? { // [6] return self.complexEntity.entityReference(eNOT_EXPRESSION.self) } public var sub_eODD_FUNCTION: eODD_FUNCTION? { // [7] return self.complexEntity.entityReference(eODD_FUNCTION.self) } //MARK: ATTRIBUTES /// __EXPLICIT__ attribute /// - origin: SUPER( ``eUNARY_GENERIC_EXPRESSION`` ) public var OPERAND: eGENERIC_EXPRESSION { get { return SDAI.UNWRAP( super_eUNARY_GENERIC_EXPRESSION.partialEntity._operand ) } set(newValue) { let partial = super_eUNARY_GENERIC_EXPRESSION.partialEntity partial._operand = SDAI.UNWRAP(newValue) } } //MARK: INITIALIZERS public convenience init?(_ entityRef: SDAI.EntityReference?) { let complex = entityRef?.complexEntity self.init(complex: complex) } public required init?(complex complexEntity: SDAI.ComplexEntity?) { guard let partial = complexEntity?.partialEntityInstance(_unary_boolean_expression.self) else { return nil } self.partialEntity = partial guard let super1 = complexEntity?.entityReference(eGENERIC_EXPRESSION.self) else { return nil } self.super_eGENERIC_EXPRESSION = super1 guard let super2 = complexEntity?.entityReference(eEXPRESSION.self) else { return nil } self.super_eEXPRESSION = super2 guard let super3 = complexEntity?.entityReference(eBOOLEAN_EXPRESSION.self) else { return nil } self.super_eBOOLEAN_EXPRESSION = super3 guard let super4 = complexEntity?.entityReference(eUNARY_GENERIC_EXPRESSION.self) else { return nil } self.super_eUNARY_GENERIC_EXPRESSION = super4 super.init(complex: complexEntity) } public required convenience init?<G: SDAIGenericType>(fromGeneric generic: G?) { guard let entityRef = generic?.entityReference else { return nil } self.init(complex: entityRef.complexEntity) } public convenience init?<S: SDAISelectType>(_ select: S?) { self.init(possiblyFrom: select) } public convenience init?(_ complex: SDAI.ComplexEntity?) { self.init(complex: complex) } //MARK: DICTIONARY DEFINITION public class override var entityDefinition: SDAIDictionarySchema.EntityDefinition { _entityDefinition } private static let _entityDefinition: SDAIDictionarySchema.EntityDefinition = createEntityDefinition() private static func createEntityDefinition() -> SDAIDictionarySchema.EntityDefinition { let entityDef = SDAIDictionarySchema.EntityDefinition(name: "UNARY_BOOLEAN_EXPRESSION", type: self, explicitAttributeCount: 0) //MARK: SUPERTYPE REGISTRATIONS entityDef.add(supertype: eGENERIC_EXPRESSION.self) entityDef.add(supertype: eEXPRESSION.self) entityDef.add(supertype: eBOOLEAN_EXPRESSION.self) entityDef.add(supertype: eUNARY_GENERIC_EXPRESSION.self) entityDef.add(supertype: eUNARY_BOOLEAN_EXPRESSION.self) //MARK: ATTRIBUTE REGISTRATIONS entityDef.addAttribute(name: "OPERAND", keyPath: \eUNARY_BOOLEAN_EXPRESSION.OPERAND, kind: .explicit, source: .superEntity, mayYieldEntityReference: true) return entityDef } } }

aca0fac3d8e27d4ea8578c68fe532b83be39c1f0

// // Copyright © 2021 Jesús Alfredo Hernández Alarcón. All rights reserved. // import Foundation enum Endpoint { case newStories case topStories case bestStories case item(Int) static let baseUrl = URL(string: "https://hacker-news.firebaseio.com")! func url(_ baseURL: URL) -> URL { switch self { case .newStories: return baseURL.appendingPathComponent("/v0/newstories.json") case .topStories: return baseURL.appendingPathComponent("/v0/topstories.json") case .bestStories: return baseURL.appendingPathComponent("/v0/beststories.json") case let .item(id): return baseURL.appendingPathComponent("/v0/item/\(id).json") } } }

50920df171499df9f8a382f561d673ea84cfd01b

// // ViewController.swift // TDBadgedCell // // Created by Tim Davies on 07/09/2016. // Copyright © 2016 Tim Davies. All rights reserved. // import UIKit class ViewController: UITableViewController { /// List of example table view cells let demoItems : [[String:String]] = [ ["title" : "This is an example badge", "badge": "1"], ["title" : "This is a second example badge", "badge": "123"], ["title" : "A text badge", "badge": "Warning!"], ["title" : "Another text badge with a really long title!", "badge": "Danger!"], ] override func viewDidLoad() { super.viewDidLoad() navigationItem.rightBarButtonItem = editButtonItem } override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return demoItems.count } override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { var cell = tableView.dequeueReusableCell(withIdentifier:"BadgedCell") as? TDBadgedCell; if(cell == nil) { cell = TDBadgedCell(style: .default, reuseIdentifier: "BadgedCell"); } cell?.textLabel!.text = demoItems[indexPath.row]["title"] cell?.detailTextLabel?.text = demoItems[indexPath.row]["title"] cell?.badgeString = demoItems[indexPath.row]["badge"]! // Set accessory views for two badges if(indexPath.row == 0) { cell?.accessoryType = .disclosureIndicator } if(indexPath.row == 1) { cell?.badgeColor = .lightGray cell?.badgeTextColor = .black cell?.accessoryType = .checkmark } // Set background colours for two badges if(indexPath.row == 2) { cell?.badgeColor = .orange } else if(indexPath.row == 3) { cell?.badgeColor = .red } // Uncomment this to test with dynamic type. // cell?.badgeTextStyle = .caption1 return cell! } override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) { DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { tableView.deselectRow(at: indexPath, animated: true) } } }

e217561e245ac44892e0736d908db75342c819f5

// // FileManager.swift // MenoumeSpiti-MovementSMS // // Created by Orestis Papadopoulos on 26/03/2020. // Copyright © 2020 opapadopoulos. All rights reserved. // import Foundation func saveUserDetailsModel(_ model: UserDetailsModel) { guard let documentsDirectoryUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else { return } try? FileManager().createDirectory(at: documentsDirectoryUrl, withIntermediateDirectories: true) let filePath = documentsDirectoryUrl.appendingPathComponent("userDetails.json") let json = try? JSONEncoder().encode(model) do { try json!.write(to: filePath) } catch { print("Failed to write JSON data: \(error.localizedDescription)") } } func loadUserDetailsModel() -> UserDetailsModel? { guard let documentsDirectoryUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else { return nil } let filePath = documentsDirectoryUrl.appendingPathComponent("userDetails.json") do { let data = try Data(contentsOf: filePath, options: .mappedIfSafe) let jsonResult = try JSONDecoder().decode(UserDetailsModel.self, from: data) return jsonResult } catch { print(error) return nil } }

48461ee172e6f44059bbd013213a0ae60cebfcb0

// // NewsItemCell.swift // facile // // Created by Renaud Pradenc on 28/08/2019. // import UIKit class NewsItemCell: UITableViewCell { private static var dateFormatter: DateFormatter = { let formatter = DateFormatter() formatter.timeStyle = .short formatter.dateStyle = .medium return formatter }() @objc var date: Date? = nil { didSet { if let date = date { dateLabel.text = NewsItemCell.dateFormatter.string(from: date) } else { dateLabel.text = "" } } } @objc var title: String? = nil { didSet { titleLabel.text = title } } // TODO: the title should be bold when not read @objc var isRead: Bool = false { didSet { titleLabel.textColor = titleColor(isRead: isRead) titleLabel.font = UIFont.systemFont(ofSize: 15.0, weight: isRead ? .regular : .semibold) } } private func titleColor(isRead: Bool) -> UIColor { if #available(iOS 11, *) { if isRead { return UIColor(named: "news.title.read")! } else { return UIColor(named: "news.title.unread")! } } else { // < iOS 11 if isRead { return UIColor(white: 0.3, alpha: 1.0) } else { return .black } } } @IBOutlet private weak var dateLabel: UILabel! @IBOutlet private weak var titleLabel: UILabel! }

7137cef2cb73b9dea807edc1c594bbc5632ec714

// // LinuxMain.swift // ThreadlyTests // // The MIT License (MIT) // // Copyright (c) 2017 Nikolai Vazquez // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. // import XCTest @testable import ThreadlyTests XCTMain([ testCase(ThreadlyTests.allTests), ])

aca8b122f6ab75b6a82f4bdef748b2ac3e397c88

/* * Copyright (c) Meta Platforms, Inc. and affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ import Foundation import SwiftyJSON class StringUnpacker: Unpacker { func unpack(ivalue: IValue, modelSpec: JSON, result: inout [String: Any], packerContext: PackerContext) throws { let unpack = modelSpec["unpack"] guard let key = unpack["key"].string else { throw BaseIValuePackerError.missingKeyParam } guard let answer = ivalue.toString() else { throw BaseIValuePackerError.decodeStringError } result[key] = answer } }

b9ad2dcfcf7efb3e874aac65391e21f61098be6c

// RUN: %target-swift-frontend -Xllvm -tf-dump-intermediates -Xllvm -tf-dump-graph -O -emit-sil -verify %s | %FileCheck %s import TensorFlow public func testDatasetWithFakeData() { TensorFlow.enableTPU(infeed: true) let x: TensorHandle<Float> = #tfop( "tfc.makeIteratorGetNextWithDatasets", dataSource: "fake", filePath: "dummy_path", batchSize: 1, outputShapes: [TensorShape()]) let y = Tensor<Float>(handle: x) + 1 _hostOp(y.array.scalars[0]) } // CHECK-LABEL: --- TFPartition Accelerator Result: {{.*}}testDatasetWithFakeData{{.*}} // CHECK: bb0: // CHECK: [[GETNEXT:%[0-9]+]] = graph_op "tfc.makeIteratorGetNextWithDatasets{{.*}} : $TensorHandle<Float> // CHECK: [[RESULT:%[0-9]+]] = graph_op "Add"([[GETNEXT]] : $TensorHandle<Float>, {{.*}} : $TensorHandle<Float> // CHECK-NEXT: return [[RESULT]] : $TensorHandle<Float> public func testDatasetWithMNIST() { TensorFlow.enableTPU(infeed: true) let (images1, labels1): (TensorHandle<Float>, TensorHandle<Int32>) = #tfop( "tfc.makeIteratorGetNextWithDatasets", dataSource: "mnist", filePath: "some_path", batchSize: 64, output_shapes: [TensorShape(64,224,224,3), TensorShape(64)]) let images : TensorHandle<Float> = #tfop("Identity", images1) let labels : TensorHandle<Int32> = #tfop("Identity", labels1) // Confirm we can add more nodes to the graph. let imagesMod = Tensor<Float>(handle: images) + 1 let labelsMod = Tensor<Int32>(handle: labels) + 2 _hostOp(imagesMod.array.scalars[0]) _hostOp(labelsMod.array.scalars[0]) } // CHECK-LABEL: --- TFPartition Accelerator Result: {{.*}}testDatasetWithMNIST{{.*}} // CHECK: bb0: // CHECK: (%0, %1) = graph_op "tfc.makeIteratorGetNextWithDatasets{{.*}} : $TensorHandle<Float>, $TensorHandle<Int32> // CHECK: graph_op "Add"( // CHECK: graph_op "Add"( // The operands can appear in arbitrary order here. // CHECK: [[RESULT:%.*]] = tuple ({{.*}} : $TensorHandle<{{.*}}>, {{.*}} : $TensorHandle<{{.*}}>) // CHECK-NEXT: return [[RESULT]] : $(TensorHandle<{{.*}}>, TensorHandle<{{.*}}>)

abc9ab01f58572e7dcf0b77832c48176e752523d

// // ContainerTableViewCell.swift // LoadMoreDemo // // Created by Alessandro Marzoli on 03/04/2020. // Copyright © 2020 Alessandro Marzoli. All rights reserved. // import UIKit public final class ContainerTableViewCell<V: UIView>: UITableViewCell { public lazy var view: V = { return V() }() public required init?(coder aDecoder: NSCoder) { fatalError() } public override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) { super.init(style: style, reuseIdentifier: reuseIdentifier) setup() } private func setup() { view.translatesAutoresizingMaskIntoConstraints = false contentView.addSubview(view) NSLayoutConstraint.activate([ view.leadingAnchor.constraint(equalTo: contentView.leadingAnchor), view.trailingAnchor.constraint(equalTo: contentView.trailingAnchor), view.topAnchor.constraint(equalTo: contentView.topAnchor), view.bottomAnchor.constraint(equalTo: contentView.bottomAnchor) ]) } }

ed0c2f2a09dd0f93d28e6a61af2dcaac6bb002a0

// // StereoViewController.swift // MetalScope // // Created by Jun Tanaka on 2017/01/23. // Copyright © 2017 eje Inc. All rights reserved. // import UIKit import SceneKit open class StereoViewController: UIViewController, SceneLoadable { #if (arch(arm) || arch(arm64)) && os(iOS) public let device: MTLDevice #endif open var scene: SCNScene? { didSet { _stereoView?.scene = scene } } open var stereoParameters: StereoParametersProtocol = StereoParameters() { didSet { _stereoView?.stereoParameters = stereoParameters } } open var stereoView: StereoView { if !isViewLoaded { loadView() } guard let view = _stereoView else { fatalError("Unexpected context to load stereoView") } return view } open var showsCloseButton: Bool = true { didSet { _closeButton?.isHidden = !showsCloseButton } } open var closeButton: UIButton { if _closeButton == nil { loadCloseButton() } guard let button = _closeButton else { fatalError("Unexpected context to load closeButton") } return button } open var closeButtonHandler: ((_ sender: UIButton) -> Void)? open var showsHelpButton: Bool = false { didSet { _helpButton?.isHidden = !showsHelpButton } } open var helpButton: UIButton { if _helpButton == nil { loadHelpButton() } guard let button = _helpButton else { fatalError("Unexpected context to load helpButton") } return button } open var helpButtonHandler: ((_ sender: UIButton) -> Void)? open var introductionView: UIView? { willSet { introductionView?.removeFromSuperview() } didSet { guard isViewLoaded else { return } if let _ = introductionView { showIntroductionView() } else { hideIntroductionView() } } } private weak var _stereoView: StereoView? private weak var _closeButton: UIButton? private weak var _helpButton: UIButton? private weak var introdutionContainerView: UIView? private var introductionViewUpdateTimer: DispatchSourceTimer? #if (arch(arm) || arch(arm64)) && os(iOS) public init(device: MTLDevice) { self.device = device super.init(nibName: nil, bundle: nil) } #else public init() { super.init(nibName: nil, bundle: nil) } #endif public required init?(coder aDecoder: NSCoder) { fatalError("init(coder:) has not been implemented") } open override func loadView() { #if (arch(arm) || arch(arm64)) && os(iOS) let stereoView = StereoView(device: device) #else let stereoView = StereoView() #endif stereoView.backgroundColor = .black stereoView.scene = scene stereoView.stereoParameters = stereoParameters stereoView.translatesAutoresizingMaskIntoConstraints = false stereoView.isPlaying = false _stereoView = stereoView let introductionContainerView = UIView(frame: stereoView.bounds) introductionContainerView.isHidden = true self.introdutionContainerView = introductionContainerView let view = UIView(frame: stereoView.bounds) view.backgroundColor = .black view.addSubview(stereoView) view.addSubview(introductionContainerView) self.view = view NSLayoutConstraint.activate([ stereoView.topAnchor.constraint(equalTo: view.topAnchor), stereoView.bottomAnchor.constraint(equalTo: view.bottomAnchor), stereoView.leadingAnchor.constraint(equalTo: view.leadingAnchor), stereoView.trailingAnchor.constraint(equalTo: view.trailingAnchor) ]) if showsCloseButton { loadCloseButton() } if showsHelpButton { loadHelpButton() } } open override func viewDidLayoutSubviews() { super.viewDidLayoutSubviews() introdutionContainerView!.bounds = view!.bounds introdutionContainerView!.center = CGPoint(x: view!.bounds.midX, y: view!.bounds.midY) introductionView?.frame = introdutionContainerView!.bounds } open override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) if animated { _stereoView?.alpha = 0 } } open override func viewDidAppear(_ animated: Bool) { super.viewDidAppear(animated) _stereoView?.isPlaying = true if animated { UIView.animate(withDuration: 0.2) { self._stereoView?.alpha = 1 } } if UIDevice.current.orientation != .unknown { showIntroductionView(animated: animated) startIntroductionViewVisibilityUpdates() } } open override func viewWillDisappear(_ animated: Bool) { super.viewWillDisappear(animated) _stereoView?.isPlaying = false stopIntroductionViewVisibilityUpdates() } open override var prefersStatusBarHidden: Bool { return true } open override var supportedInterfaceOrientations: UIInterfaceOrientationMask { return .landscapeRight } private func loadCloseButton() { if !isViewLoaded { loadView() } let icon = UIImage(named: "icon-close", in: Bundle(for: StereoViewController.self), compatibleWith: nil) let closeButton = UIButton(type: .system) closeButton.setImage(icon, for: .normal) closeButton.isHidden = !showsCloseButton closeButton.contentVerticalAlignment = .top closeButton.contentHorizontalAlignment = .left closeButton.contentEdgeInsets = UIEdgeInsets(top: 11, left: 11, bottom: 0, right: 0) closeButton.translatesAutoresizingMaskIntoConstraints = false _closeButton = closeButton view.addSubview(closeButton) NSLayoutConstraint.activate([ closeButton.widthAnchor.constraint(equalToConstant: 88), closeButton.heightAnchor.constraint(equalToConstant: 88), closeButton.topAnchor.constraint(equalTo: view.topAnchor), closeButton.leadingAnchor.constraint(equalTo: view.leadingAnchor) ]) closeButton.addTarget(self, action: #selector(handleTapOnCloseButton(_:)), for: .touchUpInside) } @objc private func handleTapOnCloseButton(_ sender: UIButton) { if let handler = closeButtonHandler { handler(sender) } else if sender.allTargets.count == 1 { presentingViewController?.dismiss(animated: true, completion: nil) } } private func loadHelpButton() { if !isViewLoaded { loadView() } let icon = UIImage(named: "icon-help", in: Bundle(for: StereoViewController.self), compatibleWith: nil) let helpButton = UIButton(type: .system) helpButton.setImage(icon, for: .normal) helpButton.isHidden = !showsHelpButton helpButton.contentVerticalAlignment = .top helpButton.contentHorizontalAlignment = .right helpButton.contentEdgeInsets = UIEdgeInsets(top: 11, left: 0, bottom: 0, right: 11) helpButton.translatesAutoresizingMaskIntoConstraints = false _helpButton = helpButton view.addSubview(helpButton) NSLayoutConstraint.activate([ helpButton.widthAnchor.constraint(equalToConstant: 88), helpButton.heightAnchor.constraint(equalToConstant: 88), helpButton.topAnchor.constraint(equalTo: view.topAnchor), helpButton.trailingAnchor.constraint(equalTo: view.trailingAnchor) ]) helpButton.addTarget(self, action: #selector(handleTapOnHelpButton(_:)), for: .touchUpInside) } @objc private func handleTapOnHelpButton(_ sender: UIButton) { if let handler = helpButtonHandler { handler(sender) } else if sender.allTargets.count == 1 { let url = URL(string: "https://support.google.com/cardboard/answer/6383058")! UIApplication.shared.openURL(url) } } private func showIntroductionView(animated: Bool = false) { precondition(isViewLoaded) guard let introductionView = introductionView, let containerView = introdutionContainerView, let stereoView = _stereoView else { return } if introductionView.superview != containerView { introductionView.frame = containerView.bounds introductionView.autoresizingMask = [] containerView.addSubview(introductionView) } if animated { if containerView.isHidden { containerView.isHidden = false containerView.transform = CGAffineTransform(translationX: 0, y: containerView.bounds.height) } UIView.animate( withDuration: 0.5, delay: 0, usingSpringWithDamping: 1, initialSpringVelocity: 0, options: [.beginFromCurrentState], animations: { containerView.transform = .identity stereoView.alpha = 0 }, completion: nil) } else { containerView.isHidden = false containerView.transform = .identity stereoView.alpha = 0 } } private func hideIntroductionView(animated: Bool = false) { precondition(isViewLoaded) guard let containerView = introdutionContainerView, let stereoView = _stereoView else { return } if animated { UIView.animate( withDuration: 0.5, delay: 0, usingSpringWithDamping: 1, initialSpringVelocity: 0, options: [.beginFromCurrentState], animations: { containerView.transform = CGAffineTransform(translationX: 0, y: containerView.bounds.height) stereoView.alpha = 1 }, completion: { isFinished in guard isFinished else { return } containerView.isHidden = true containerView.transform = .identity }) } else { containerView.isHidden = true containerView.transform = .identity stereoView.alpha = 1 } } private func startIntroductionViewVisibilityUpdates(withInterval interval: TimeInterval = 3, afterDelay delay: TimeInterval = 3) { precondition(introductionViewUpdateTimer == nil) let timer = DispatchSource.makeTimerSource(queue: .main) timer.scheduleRepeating(deadline: .now() + delay, interval: interval) timer.setEventHandler { [weak self] in guard self?.isViewLoaded == true, let _ = self?.introductionView else { return } switch UIDevice.current.orientation { case .landscapeLeft where self?.introdutionContainerView?.isHidden == false: self?.hideIntroductionView(animated: true) case .landscapeRight where self?.introdutionContainerView?.isHidden == true: self?.showIntroductionView(animated: true) default: break } } timer.resume() introductionViewUpdateTimer = timer } private func stopIntroductionViewVisibilityUpdates() { introductionViewUpdateTimer?.cancel() introductionViewUpdateTimer = nil } } extension StereoViewController: ImageLoadable {} #if (arch(arm) || arch(arm64)) && os(iOS) extension StereoViewController: VideoLoadable {} #endif

3982f28699aa85a63d15718ad469ced6a053a4d4

// // MovieCollectionViewCell.swift // MoviesApp // // Created by ÜNAL ÖZTÜRK on 5.04.2020. // Copyright © 2020 ÜNAL ÖZTÜRK. All rights reserved. // import UIKit class MovieCollectionViewCell: UICollectionViewCell { static var identifier: String = "movieCell" var posterImage: PosterImageLoader = { var imageView = PosterImageLoader() imageView.translatesAutoresizingMaskIntoConstraints = false imageView.contentMode = .scaleToFill return imageView }() var titleLabel: UILabel = { var label = UILabel() label.translatesAutoresizingMaskIntoConstraints = false label.textAlignment = .center label.numberOfLines = 0 label.textColor = .white label.backgroundColor = UIColor.init(red: 0, green: 0, blue: 0, alpha: 0.5) return label }() var starImage: UIImageView = { var imageView = UIImageView() imageView.translatesAutoresizingMaskIntoConstraints = false imageView.contentMode = .scaleAspectFit imageView.image = FavoriteBarButton.favorited.image return imageView }() override init(frame: CGRect) { super.init(frame: frame) configureUI() } required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") } override func prepareForReuse() { super.prepareForReuse() resetCell() } private func resetCell() { self.titleLabel.text = "" self.starImage.isHidden = true self.posterImage.image = nil } private func configureUI() { backgroundColor = .gray layer.cornerRadius = 5 layer.masksToBounds = true addSubview(posterImage) NSLayoutConstraint.activate([ posterImage.topAnchor.constraint(equalTo: topAnchor), posterImage.bottomAnchor.constraint(equalTo: bottomAnchor), posterImage.trailingAnchor.constraint(equalTo: trailingAnchor), posterImage.leadingAnchor.constraint(equalTo: leadingAnchor) ]) addSubview(titleLabel) NSLayoutConstraint.activate([ titleLabel.bottomAnchor.constraint(equalTo: bottomAnchor), titleLabel.trailingAnchor.constraint(equalTo: trailingAnchor), titleLabel.leadingAnchor.constraint(equalTo: leadingAnchor), ]) addSubview(starImage) NSLayoutConstraint.activate([ starImage.topAnchor.constraint(equalTo: topAnchor, constant: 5), starImage.trailingAnchor.constraint(equalTo: trailingAnchor,constant: -5), starImage.heightAnchor.constraint(equalTo: heightAnchor, multiplier: 1/5), starImage.widthAnchor.constraint(equalTo: heightAnchor, multiplier: 1/5) ]) } func configureWithMovie(movie: Movie) { titleLabel.text = movie.title movie.favorite ? (starImage.isHidden = false) : (starImage.isHidden = true) //To get poster image guard let posterPath = movie.posterPath, let url = posterImage.tmdbImageUrl(width: frame.size.width, path: posterPath) else { return } posterImage.loadImageWithUrl(url) } }

39583bf88c37cc265d037e7cf997504bcf64c44d

// // AppDelegate.swift // iShowcaseExample // // Created by Rahul Iyer on 14/10/15. // Copyright © 2015 rahuliyer. All rights reserved. // import UIKit @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool { // Override point for customization after application launch. return true } func applicationWillResignActive(_ application: UIApplication) { // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game. } func applicationDidEnterBackground(_ application: UIApplication) { // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. } func applicationWillEnterForeground(_ application: UIApplication) { // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background. } func applicationDidBecomeActive(_ application: UIApplication) { // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. } func applicationWillTerminate(_ application: UIApplication) { // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. } }

fe8136df753d7363babeff0e9504c4dbf65b9348

// // BusinessesViewController.swift // Yelp // // Created by Timothy Lee on 4/23/15. // Copyright (c) 2015 Timothy Lee. All rights reserved. // import UIKit import MBProgressHUD class ResultsViewController: UIViewController, UITableViewDelegate, UITableViewDataSource { var businesses: [Business]! @IBOutlet weak var resultsTableView: UITableView! var filterSearchSettings = FilterSettings() //views var searchBar: UISearchBar! var spinner: UIActivityIndicatorView! //infinite scrolling var isMoreDataLoading = false override func viewDidLoad() { super.viewDidLoad() resultsTableView.delegate = self resultsTableView.dataSource = self resultsTableView.estimatedRowHeight = 100 resultsTableView.rowHeight = UITableViewAutomaticDimension //add a search bar searchBar = UISearchBar() searchBar.sizeToFit() searchBar.delegate = self navigationItem.titleView = searchBar //add inifite scroll indicator spinner = UIActivityIndicatorView(activityIndicatorStyle: .gray) spinner.frame = CGRect(x:0, y: 0, width: self.resultsTableView.frame.width, height: 40) self.resultsTableView.tableFooterView = spinner //perform search at first loaded businesses = [Business]() doSearch() /* Example of Yelp search with more search options specified Business.searchWithTerm("Restaurants", sort: .distance, categories: ["asianfusion", "burgers"], deals: true) { (businesses: [Business]!, error: Error!) -> Void in self.businesses = businesses for business in businesses { print(business.name!) print(business.address!) } } */ } override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() // Dispose of any resources that can be recreated. } func numberOfSections(in tableView: UITableView) -> Int { return businesses?.count ?? 0 } func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return 1 } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCell(withIdentifier: "ResultCell") as! ResultCell cell.business = businesses[indexPath.section] cell.resultNameLabelView.text = "\(indexPath.section + 1). " + cell.business.name! return cell } func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) { //when it reaches bottom of tableview if(indexPath.section == self.businesses.count - 1 && resultsTableView.isDragging) { isMoreDataLoading = true spinner.startAnimating() doSearch() } } // MARK: - Perform Search fileprivate func doSearch() { if !isMoreDataLoading {MBProgressHUD.showAdded(to: self.view, animated: true)} let term = filterSearchSettings.searchString ?? "Everything" let sortby = YelpSortMode(rawValue: filterSearchSettings.sortbySelectedIndex) var categories: [String]? let selectedCategories = filterSearchSettings.selectedCategories if selectedCategories.count > 0 { categories = [String] () for (_, value) in selectedCategories { categories?.append(value) } } let deals = filterSearchSettings.isOfferingDeal let distance = filterSearchSettings.radius[filterSearchSettings.distanceSelectedIndex] let offset = isMoreDataLoading ? businesses.count : nil //number of results business returned per API call is default to be 20. It can be changed by passing the limit parameter Business.searchWithTerm(term: term, sort: sortby, categories: categories, deals: deals, distance: distance, offset: offset, completion: { (businesses: [Business]?, error: Error?) -> Void in //update load more data flag if self.isMoreDataLoading { if let businesses = businesses { self.businesses.append(contentsOf: businesses) } self.spinner.stopAnimating() self.resultsTableView.reloadData() } else { MBProgressHUD.hide(for: self.view, animated: true) self.businesses = businesses //self.resultsTableView.setContentOffset(.zero, animated: false) let indexPath = IndexPath(row: 0, section: 0) self.resultsTableView.reloadData() self.resultsTableView.scrollToRow(at: indexPath, at: .top, animated: false) } self.isMoreDataLoading = false } ) } /* // MARK: - Navigation // In a storyboard-based application, you will often want to do a little preparation before navigation override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) { // Get the new view controller using segue.destinationViewController. // Pass the selected object to the new view controller. } */ override func prepare(for segue: UIStoryboardSegue, sender: Any?) { if segue.identifier == "ShowFilterSettings" { guard let filterNav = segue.destination as? UINavigationController, let filterVC = filterNav.viewControllers.first as? FiltersViewController else { return } filterVC.prepare(filterSetting: filterSearchSettings, filterSettingsHandler: { (filters) in self.filterSearchSettings = filters self.doSearch() }) } else if segue.identifier == "ShowMapView" { guard let mapViewVC = segue.destination as? ResultsMapViewController else { return } mapViewVC.businesses = businesses } } } //search bar extension extension ResultsViewController: UISearchBarDelegate { //on search button clicked func searchBarSearchButtonClicked(_ searchBar: UISearchBar) { filterSearchSettings.searchString = searchBar.text searchBar.setShowsCancelButton(false, animated: true) searchBar.resignFirstResponder() doSearch() } //on search bar text changed // func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) { // filterSearchSettings.searchString = searchText // doSearch() // } //show cancel button func searchBarShouldBeginEditing(_ searchBar: UISearchBar) -> Bool { searchBar.setShowsCancelButton(true, animated: true) return true } //dismiss cancel button func searchBarShouldEndEditing(_ searchBar: UISearchBar) -> Bool { searchBar.setShowsCancelButton(false, animated: true) return true } //dismiss input keyboard func searchBarCancelButtonClicked(_ searchBar: UISearchBar) { self.searchBar.showsCancelButton = false searchBar.text = "" searchBar.resignFirstResponder() } }

e489651b170a9b2cf2005b781ae9dcaa561ddc46

// // Prefix.swift // PrefixPackageDescription // // Created by Borinschi Ivan on 4/23/18. // import Foundation import Files public class PrefixFiles { public init() { } /// Get all swift files in directory /// /// - Parameter folder: Folder /// - Returns: Optional array of Files public func getAllSwiftFiles(folder: Folder) -> [File]? { return getFilesFrom(folder: folder, contain: ".swift") } /// Get files from /// /// - Parameters: /// - folder: Folder /// - name: name to check if file name contain this contain /// - Returns: Optional array of Files public func getFilesFrom(folder: Folder, contain name: String) -> [File]? { return getFilesFrom(folder: folder, contain: PrefixParser.containWord(name)) } /// Get all files from current directory if files names contain pattern /// /// - Parameter pattern: PrefixParserPattern /// - Returns: Optional array of Files public func getFilesFromCurrentFolder(contain pattern: PrefixParserPattern? = nil) -> [File]? { return getFilesFrom(folder: Folder.current, contain: pattern) } /// Get all files from Folder if file names contain pattern /// /// - Parameters: /// - folder: Folder /// - pattern: PrefixParserPattern /// - Returns: Optional array of Files public func getFilesFrom(folder: Folder, contain pattern: PrefixParserPattern? = nil) -> [File]? { var files = [File]() for file in folder.files { if let pattern = pattern { if file.name.contains(pattern) { files.append(file) } } else { files.append(file) } } return files } }

62675ee240d41c3ec8546239b8aa7920005ab8c0

// swift-tools-version:5.1 import PackageDescription let package = Package( name: "combine-schedulers", platforms: [ .iOS(.v10), .macOS(.v10_12), .tvOS(.v10), .watchOS(.v3), ], products: [ .library( name: "CombineSchedulers", targets: ["CombineSchedulers"] ) ], targets: [ .target(name: "CombineSchedulers"), .testTarget( name: "CombineSchedulersTests", dependencies: ["CombineSchedulers"] ), ] )

fbe4c91b25779f417e482c33820e830e31b99226

// // Tests_macOS.swift // Tests macOS // // Created by Vladislav Fitc on 10/04/2021. // import XCTest class Tests_macOS: XCTestCase { override func setUpWithError() throws { // Put setup code here. This method is called before the invocation of each test method in the class. // In UI tests it is usually best to stop immediately when a failure occurs. continueAfterFailure = false // In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this. } override func tearDownWithError() throws { // Put teardown code here. This method is called after the invocation of each test method in the class. } func testExample() throws { // UI tests must launch the application that they test. let app = XCUIApplication() app.launch() // Use recording to get started writing UI tests. // Use XCTAssert and related functions to verify your tests produce the correct results. } func testLaunchPerformance() throws { if #available(macOS 10.15, iOS 13.0, tvOS 13.0, *) { // This measures how long it takes to launch your application. measure(metrics: [XCTApplicationLaunchMetric()]) { XCUIApplication().launch() } } } }

48041dfdc79f542be393ebacd6e5c8728e31c892

// // YPFiltersView.swift // photoTaking // // Created by Sacha Durand Saint Omer on 21/10/16. // Copyright © 2016 octopepper. All rights reserved. // import Stevia class YPFiltersView: UIView { let imageView = UIImageView() var collectionView: UICollectionView! var filtersLoader: UIActivityIndicatorView! fileprivate let collectionViewContainer: UIView = UIView() convenience init() { self.init(frame: CGRect.zero) collectionView = UICollectionView(frame: CGRect.zero, collectionViewLayout: layout()) filtersLoader = UIActivityIndicatorView(activityIndicatorStyle: .gray) filtersLoader.hidesWhenStopped = true filtersLoader.startAnimating() filtersLoader.color = YPConfig.colors.tintColor sv( imageView, collectionViewContainer.sv( filtersLoader, collectionView ) ) let isIphone4 = UIScreen.main.bounds.height == 480 let sideMargin: CGFloat = isIphone4 ? 20 : 0 |-sideMargin-imageView.top(0)-sideMargin-| |-sideMargin-collectionViewContainer-sideMargin-| collectionViewContainer.bottom(0) imageView.Bottom == collectionViewContainer.Top |collectionView.centerVertically().height(160)| filtersLoader.centerInContainer() imageView.heightEqualsWidth() backgroundColor = UIColor(r: 66, g: 66, b: 66) imageView.contentMode = .scaleAspectFit imageView.clipsToBounds = true collectionView.backgroundColor = .clear collectionView.showsHorizontalScrollIndicator = false } func layout() -> UICollectionViewFlowLayout { let layout = UICollectionViewFlowLayout() layout.scrollDirection = .horizontal layout.minimumLineSpacing = 4 layout.sectionInset = UIEdgeInsets(top: 0, left: 18, bottom: 0, right: 18) layout.itemSize = CGSize(width: 100, height: 120) return layout } }

2000655c948abb46753da93b13ecc40c75d13074

// // KeyTextField.swift // ⌘英かな // // MIT License // Copyright (c) 2016 iMasanari // import Cocoa var activeKeyTextField: KeyTextField? class KeyTextField: NSComboBox { /// Custom delegate with other methods than NSTextFieldDelegate. var shortcut: KeyboardShortcut? = nil var saveAddress: (row: Int, id: String)? = nil var isAllowModifierOnly = true override func becomeFirstResponder() -> Bool { let became = super.becomeFirstResponder(); if (became) { activeKeyTextField = self } return became; } // override func resignFirstResponder() -> Bool { // let resigned = super.resignFirstResponder(); // if (resigned) { // } // return resigned; // } override func textDidEndEditing(_ obj: Notification) { super.textDidEndEditing(obj) switch self.stringValue { case "English": shortcut = KeyboardShortcut(keyCode: 102) break case "Kana": shortcut = KeyboardShortcut(keyCode: 104) break case "⇧Kana": shortcut = KeyboardShortcut(keyCode: 104, flags: CGEventFlags.maskShift) break case "前の入力ソースを選択", "select the previous input source": let symbolichotkeys = UserDefaults.init(suiteName: "com.apple.symbolichotkeys.plist")?.object(forKey: "AppleSymbolicHotKeys") as! NSDictionary let parameters = symbolichotkeys.value(forKeyPath: "60.value.parameters") as! [Int] shortcut = KeyboardShortcut(keyCode: CGKeyCode(parameters[1]), flags: CGEventFlags(rawValue: UInt64(parameters[2]))) break case "入力メニューの次のソースを選択", "select next source in input menu": let symbolichotkeys = UserDefaults.init(suiteName: "com.apple.symbolichotkeys.plist")?.object(forKey: "AppleSymbolicHotKeys") as! NSDictionary let parameters = symbolichotkeys.value(forKeyPath: "61.value.parameters") as! [Int] shortcut = KeyboardShortcut(keyCode: CGKeyCode(parameters[1]), flags: CGEventFlags(rawValue: UInt64(parameters[2]))) break case "Disable": shortcut = KeyboardShortcut(keyCode: CGKeyCode(999)) break default: break } if let shortcut = shortcut { self.stringValue = shortcut.toString() if let saveAddress = saveAddress { if saveAddress.id == "input" { keyMappingList[saveAddress.row].input = shortcut } else { keyMappingList[saveAddress.row].output = shortcut } keyMappingListToShortcutList() } } else { self.stringValue = "" } saveKeyMappings() if activeKeyTextField == self { activeKeyTextField = nil } } func blur() { self.window?.makeFirstResponder(nil) activeKeyTextField = nil } }

01af148f287b99ec0f679c81cacb4ee9da6dcf10

// // Tab2Cell.swift // HLMiscExample // // Created by 钟浩良 on 2018/7/20. // Copyright © 2018年 钟浩良. All rights reserved. // import UIKit class Tab2Cell: UICollectionViewCell { @IBOutlet weak var label: UILabel! @IBOutlet weak var badgeView: UIView! }

1ee74c7156218c1842d24bcf02d383b4d759b691

// // KeychainItemStorage.swift // TVToday // // Created by Jeans Ruiz on 6/21/20. // Copyright © 2020 Jeans. All rights reserved. // import Foundation import KeychainSwift @propertyWrapper struct KeychainItemStorage { private let key: String private lazy var keychain = KeychainSwift() init(key: String) { self.key = key } var wrappedValue: String? { mutating get { return keychain.get(key) } set { if let newValue = newValue { keychain.set(newValue, forKey: key) } else { keychain.delete(key) } } } }

c11781a92d481d0c11c6da130ee3a20d5ce3d53f

// // PickerView.swift // Pods // // Created by Viktor Rutberg on 2016-12-21. // // import Foundation import UIKit protocol PickerViewDelegate: class { func picker(_ sender: PickerView, didSelectIndex index: Int) func picker(_ sender: PickerView, didSlideTo: CGPoint) } final class PickerView: UIView, UIScrollViewDelegate { private let items: [String] private let itemWidth: Int private let itemFont: UIFont private let itemFontColor: UIColor private let sliderVelocityCoefficient: Double private let defaultSelectedIndex: Int private var didSetDefault = false private var silenceIndexUpdates = false var delegate: PickerViewDelegate? private(set) var selectedIndex: Int = 0 init(items: [String], itemWidth: Int, itemFont: UIFont, itemFontColor: UIColor, sliderVelocityCoefficient: Double, defaultSelectedIndex: Int) { self.items = items self.itemWidth = itemWidth self.itemFont = itemFont self.itemFontColor = itemFontColor self.sliderVelocityCoefficient = sliderVelocityCoefficient self.defaultSelectedIndex = defaultSelectedIndex super.init(frame: .zero) addSubview(scrollView) setupScrollView() setupScrollViewContent() } required init?(coder aDecoder: NSCoder) { fatalError("init(coder:) has not been implemented") } private var xContentInset: CGFloat { return (frame.width - CGFloat(itemWidth)) / 2.0 } lazy var scrollView: UIScrollView = { let scrollView = UIScrollView() scrollView.contentInset = UIEdgeInsets(top: 0, left: self.xContentInset, bottom: 0, right: self.xContentInset) scrollView.translatesAutoresizingMaskIntoConstraints = false scrollView.isScrollEnabled = true scrollView.showsHorizontalScrollIndicator = false scrollView.delegate = self return scrollView }() private lazy var stackView: UIStackView = { let stackView = UIStackView() stackView.translatesAutoresizingMaskIntoConstraints = false stackView.axis = .horizontal stackView.alignment = .center stackView.distribution = .equalCentering return stackView }() private lazy var singleTapGestureRecognizer: UITapGestureRecognizer = { let gestureRecognizer = UITapGestureRecognizer() gestureRecognizer.numberOfTapsRequired = 1 gestureRecognizer.isEnabled = true gestureRecognizer.cancelsTouchesInView = false return gestureRecognizer }() private func scroll(toIndex index: Int, animated: Bool = true) { let point = convert(indexToPoint: index) scrollView.setContentOffset(point, animated: animated) } public func set(selectedIndex index: Int, animated: Bool = true, silently: Bool = false) { if silently { silenceIndexUpdates = true } scroll(toIndex: index, animated: animated) silenceIndexUpdates = false } private func markItemAsSelected(at index: Int) { guard selectedIndex != index else { return } selectedIndex = index if !silenceIndexUpdates { delegate?.picker(self, didSelectIndex: selectedIndex) } } private func convert(contentOffsetToIndex contentOffset: CGFloat) -> Int { let offsetX = contentOffset + xContentInset var itemIndex = Int(round(offsetX / CGFloat(itemWidth))) if itemIndex > items.count - 1 { itemIndex = items.count - 1 } else if itemIndex < 0 { itemIndex = 0 } return itemIndex } private func convert(indexToPoint index: Int) -> CGPoint { let itemX = CGFloat(itemWidth * index) return CGPoint(x: itemX - xContentInset, y: 0) } override func layoutSubviews() { super.layoutSubviews() scrollView.contentInset = UIEdgeInsets(top: 0, left: self.xContentInset, bottom: 0, right: self.xContentInset) if !didSetDefault { set(selectedIndex: defaultSelectedIndex, animated: false, silently: true) didSetDefault = true } else { set(selectedIndex: selectedIndex, animated: false) } } @objc private func scrollViewWasTapped(_ sender: UITapGestureRecognizer) { let point = sender.location(in: scrollView) // TODO(vrutberg): // * This should probably be merged with convert(contentOffsetToIndex) var itemIndex = Int(floor(point.x / CGFloat(itemWidth))) if itemIndex > items.count - 1 { itemIndex = items.count - 1 } else if itemIndex < 0 { itemIndex = 0 } set(selectedIndex: itemIndex) } private func setupScrollView() { addSubview(scrollView) scrollView.addGestureRecognizer(singleTapGestureRecognizer) singleTapGestureRecognizer.addTarget(self, action: #selector(scrollViewWasTapped(_:))) matchSizeWithConstraints(view1: scrollView, view2: self) } private func setupScrollViewContent() { scrollView.addSubview(stackView) for value in items { let valueLabel = UILabel() valueLabel.translatesAutoresizingMaskIntoConstraints = false valueLabel.text = "\(value)" valueLabel.font = itemFont valueLabel.textColor = itemFontColor valueLabel.textAlignment = .center stackView.addArrangedSubview(valueLabel) NSLayoutConstraint(item: valueLabel, attribute: .height, relatedBy: .equal, toItem: scrollView, attribute: .height, multiplier: 1, constant: 0).isActive = true NSLayoutConstraint(item: valueLabel, attribute: .width, relatedBy: .equal, toItem: valueLabel, attribute: .height, multiplier: 1, constant: 0).isActive = true } matchSizeWithConstraints(view1: stackView, view2: scrollView) } internal func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) { let targetOffset = scrollView.contentOffset.x + velocity.x * CGFloat(sliderVelocityCoefficient) let index = convert(contentOffsetToIndex: targetOffset) targetContentOffset.pointee = convert(indexToPoint: index) } internal func scrollViewDidScroll(_ scrollView: UIScrollView) { let index = convert(contentOffsetToIndex: scrollView.contentOffset.x) delegate?.picker(self, didSlideTo: scrollView.contentOffset) markItemAsSelected(at: index) } }

1646e11533a32c7b5fd16c0a2d99bd742544aaac

// // UINavigationController.swift // Pods // // Created by away4m on 12/30/16. // // import Foundation public extension UINavigationController { /// SwifterSwift: Pop ViewController with completion handler. /// /// - Parameter completion: optional completion handler (default is nil). public func popViewController(completion: (() -> Void)? = nil) { // https://github.com/cotkjaer/UserInterface/blob/master/UserInterface/UIViewController.swift CATransaction.begin() CATransaction.setCompletionBlock(completion) popViewController(animated: true) CATransaction.commit() } // Push ViewController with completion handler. /// /// - Parameters: /// - viewController: viewController to push. /// - Parameter completion: optional completion handler (default is nil). public func pushViewController(viewController: UIViewController, completion: (() -> Void)? = nil) { // https://github.com/cotkjaer/UserInterface/blob/master/UserInterface/UIViewController.swift CATransaction.begin() CATransaction.setCompletionBlock(completion) pushViewController(viewController, animated: true) CATransaction.commit() } // Make navigation controller's navigation bar transparent. /// /// - Parameter withTint: tint color (default is .white). public func makeTransparent(withTint: UIColor = .white) { navigationBar.setBackgroundImage(UIImage(), for: .default) navigationBar.shadowImage = UIImage() navigationBar.isTranslucent = true navigationBar.tintColor = withTint navigationBar.titleTextAttributes = [NSForegroundColorAttributeName: withTint] } public func completelyTransparentBar() { navigationBar.setBackgroundImage(UIImage(), for: .default) navigationBar.shadowImage = UIImage() navigationBar.isTranslucent = true view.backgroundColor = UIColor.clear navigationBar.backgroundColor = UIColor.clear } public func previousViewController() -> UIViewController? { return viewController(at: viewControllers.count - 2) } public func viewController(at index: Int) -> UIViewController? { guard index >= 0 else { return nil } return viewControllers[index] } public func removeViewController(at index: Int) { var _viewControllers = viewControllers _viewControllers.remove(at: index) viewControllers = _viewControllers } public func removeViewController(atTail index: Int) { var _viewControllers = viewControllers _viewControllers.remove(at: _viewControllers.count - index - 1) viewControllers = _viewControllers } public func removeViewControllers(previous number: Int) { var _viewControllers = viewControllers if number < _viewControllers.count { _viewControllers.removeSubrange(_viewControllers.count - number - 1..._viewControllers.count - 2) viewControllers = _viewControllers } } public func removePreviousViewController() { removeViewController(atTail: 1) } }

f7f30d4dee7d5ab11ce9279687ca0f9eb3a89ef0

// RUN: not --crash %target-swift-frontend %s -parse // Distributed under the terms of the MIT license // Test case submitted to project by https://github.com/practicalswift (practicalswift) // Test case found by fuzzing class B{deinit{class d<a{struct B}}class S<T{func a<h{func b<T where h.g=a{

d55c5151bc5a8052e4bdf6f79c998d2ca9513902

import XCTest @testable import Aspen class LogLevelTests: XCTestCase { override func setUp() { super.setUp() } override func tearDown() { super.tearDown() } func testInitNewLevel() { let level = DefaultLogLevel.verbose let name = "Test Level" let label = "TESTLABEL" let newLevel = LogLevel(level: level, name: name, label: label) XCTAssertEqual(newLevel.level, level) XCTAssertEqual(newLevel.name, name) XCTAssertEqual(newLevel.label, label) } func testStaticLogLevels() { let verbose = LogLevel.VERBOSE_LEVEL XCTAssertEqual(verbose.level, DefaultLogLevel.verbose) let info = LogLevel.INFO_LEVEL XCTAssertEqual(info.level, DefaultLogLevel.info) let warning = LogLevel.WARNING_LEVEL XCTAssertEqual(warning.level, DefaultLogLevel.warning) let error = LogLevel.ERROR_LEVEL XCTAssertEqual(error.level, DefaultLogLevel.error) } func testFetchingDefaultLevels() { let verbose = LogLevel.getLevel(.verbose) XCTAssertEqual(verbose, LogLevel.VERBOSE_LEVEL) let info = LogLevel.getLevel(.info) XCTAssertEqual(info, LogLevel.INFO_LEVEL) let warning = LogLevel.getLevel(.warning) XCTAssertEqual(warning, LogLevel.WARNING_LEVEL) let error = LogLevel.getLevel(.error) XCTAssertEqual(error, LogLevel.ERROR_LEVEL) } func testGettingEmojiIdentifiers() { let verbose = LogLevel.VERBOSE_LEVEL XCTAssertEqual(verbose.emojiIdentifier(), "🚧") let info = LogLevel.INFO_LEVEL XCTAssertEqual(info.emojiIdentifier(), "☝️") let warning = LogLevel.WARNING_LEVEL XCTAssertEqual(warning.emojiIdentifier(), "⚠️") let error = LogLevel.ERROR_LEVEL XCTAssertEqual(error.emojiIdentifier(), "🚨") } }

ef86e01c6de7cb59ba0d2e780e7bd45f41d34e74

// // ChallengeTableViewCell.swift // JourneyPRO // // Copyright © 2017 Sage Bionetworks. All rights reserved. // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, this // list of conditions and the following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation and/or // other materials provided with the distribution. // // 3. Neither the name of the copyright holder(s) nor the names of any contributors // may be used to endorse or promote products derived from this software without // specific prior written permission. No license is granted to the trademarks of // the copyright holders even if such marks are included in this software. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // import BridgeAppSDK class ChallengeTableViewCell: UITableViewCell { @IBOutlet open var titleLabel: UILabel! @IBOutlet weak var iconImageView: UIImageView! @IBOutlet open var subtitleLabel: UILabel? @IBOutlet weak var checkmarkImageView: UIImageView? @IBOutlet weak var shadowBorderView: UIView! @IBOutlet weak var whiteBorderView: UIView! override func awakeFromNib() { super.awakeFromNib() checkmarkImageView?.isHidden = true titleLabel?.textColor = UIColor(named: "darkGrayText") subtitleLabel?.textColor = UIColor(named: "black54") contentView.backgroundColor = UIColor.appWhiteTwo shadowBorderView?.backgroundColor = UIColor.appWhiteThree whiteBorderView?.backgroundColor = UIColor.white } }

c1976655f8d2a13f8559fc104fcfdb76b142ca8f

public func escapeString(s: String) -> String { var z = "" debugPrint(s, terminator: "", toStream: &z) return z } public func inspect(o: Any) -> String { var z = "" debugPrint(o, terminator: "", toStream: &z) return z } public func p(a: Any...) { for e in a { debugPrint(e) } } // printList is like the "puts" command in Ruby. // printList will check whether the line ends with a new line, and if it does // not, it will append a new line to it. // // Since importing Glibc already imports the "puts" command found in C which // would conflict with this command, we've given it a unique name instead. public func printList(string: String) { // 10 - new line if string.isEmpty || string.utf16.codeUnitAt(string.utf16.count - 1) != 10 { print(string) } else { Stdout.write(string) } }

4627ec01d1765661c37b6bafdebdf1ec25f0452e

import Vapor /// Register your application's routes here. public func routes(_ router: Router) throws { // Basic "It works" router.get { req in return "Session service up and running" } // Example of configuring a controller let sessionController = SessionController.shared router.get("api", "session", use: sessionController.all) router.get("api", "session", String.parameter, use: sessionController.trigger) router.post("api", "session", use: sessionController.create) router.delete("api", "session", Session.parameter, use: sessionController.delete) }

e553b05907d494f6fdfab5638d699d84266a707b

// // JDSubFindFactory.swift // MyFFM // // Created by BaoLuniOS-3 on 2017/2/18. // Copyright © 2017年 BaoLuniOS-3. All rights reserved. // import UIKit enum JDSubFindTyep { case JDSubFindTypeRecommend // 推荐 case JDSubFindTypeCategory // 分类 case JDSubFindTypeRadio // 广播 case JDSubFindTypeRand // 榜单 case JDSubFindTypeAnchor // 主播 case JDSubFindTypeUnkown // 未知 } class JDSubFindFactory { /// 快速构建子控制器 class func subFindVC(identifier : String) -> JDFindBaseController { var con : JDFindBaseController! let type = typeFromTitle(identifier) switch type { case .JDSubFindTypeRecommend: con = JDFindRecommendController() case .JDSubFindTypeCategory: con = JDFindCategoryController() case .JDSubFindTypeRadio: con = JDFindRadioController() case .JDSubFindTypeRand: con = JDFindRandController() case .JDSubFindTypeAnchor: con = JDFindAnchorController() default: con = JDFindBaseController() } return con } /// 获取子控制器的类型 private class func typeFromTitle(_ title : String) -> JDSubFindTyep { switch title { case "推荐": return .JDSubFindTypeRecommend case "分类": return .JDSubFindTypeCategory case "广播": return .JDSubFindTypeRadio case "榜单": return .JDSubFindTypeRand case "主播": return .JDSubFindTypeAnchor default: return .JDSubFindTypeUnkown } } }

eb809e04f5edb644f53e29403ad2b7cd919be50e

// // ViewController.swift // LocalSearch // // Created by Patrick DeSantis on 9/10/16. // Copyright © 2016 Patrick DeSantis. All rights reserved. // import CoreLocation import MapKit import UIKit class ViewController: UIViewController { @IBOutlet weak var textField: UITextField! @IBOutlet weak var tableView: UITableView! @IBOutlet weak var segmentedControl: UISegmentedControl! fileprivate let locationManager = CLLocationManager() fileprivate let searchCompleter = MKLocalSearchCompleter() fileprivate var localSearch: MKLocalSearch? fileprivate var mapItems = [MKMapItem]() fileprivate var searchCompletions = [MKLocalSearchCompletion]() override func viewDidLoad() { super.viewDidLoad() tableView.estimatedRowHeight = 60 tableView.rowHeight = UITableViewAutomaticDimension locationManager.delegate = self searchCompleter.delegate = self searchCompleter.filterType = .locationsOnly } override func viewDidAppear(_ animated: Bool) { super.viewDidAppear(animated) locationManager.requestWhenInUseAuthorization() } @IBAction func toggleResults(_ sender: AnyObject) { tableView.reloadData() } func search(query: String) { guard let location = locationManager.location else { return } let span = MKCoordinateSpan(latitudeDelta: 0.1, longitudeDelta: 0.1) let region = MKCoordinateRegion(center: location.coordinate, span: span) if searchCompleter.isSearching { searchCompleter.cancel() } searchCompleter.region = region searchCompleter.queryFragment = query let request = MKLocalSearchRequest() request.naturalLanguageQuery = query request.region = region localSearch = MKLocalSearch(request: request) localSearch?.start(completionHandler: localSearchCompletionHandler) } func search(searchCompletion: MKLocalSearchCompletion) { let request = MKLocalSearchRequest(completion: searchCompletion) localSearch = MKLocalSearch(request: request) localSearch?.start(completionHandler: localSearchCompletionHandler) segmentedControl.selectedSegmentIndex = 1 textField.text = request.naturalLanguageQuery } func localSearchCompletionHandler(response: MKLocalSearchResponse?, error: Error?) { guard let response = response, error == nil else { self.mapItems = [] print(error) return } self.mapItems = response.mapItems self.tableView.reloadData() } } extension ViewController: CLLocationManagerDelegate { func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) { switch status { case .authorizedAlways, .authorizedWhenInUse: manager.requestLocation() default: break } } func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) { } func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) { print(error) } } extension ViewController: MKLocalSearchCompleterDelegate { func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) { searchCompletions = completer.results tableView.reloadData() } func completer(_ completer: MKLocalSearchCompleter, didFailWithError error: Error) { print(error) } } extension ViewController: UITableViewDataSource { func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { switch segmentedControl.selectedSegmentIndex { case 0: return searchCompletions.count default: return mapItems.count } } func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCell(withIdentifier: "MapItemCell", for: indexPath) as! MapItemTableViewCell switch segmentedControl.selectedSegmentIndex { case 0: let searchCompletion = searchCompletions[indexPath.row] cell.update(searchCompletion: searchCompletion) default: let mapItem = mapItems[indexPath.row] cell.update(mapItem: mapItem) } return cell } } extension ViewController: UITableViewDelegate { func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) { switch segmentedControl.selectedSegmentIndex { case 0: let searchCompletion = searchCompletions[indexPath.row] search(searchCompletion: searchCompletion) default: tableView.deselectRow(at: indexPath, animated: true) } } } extension ViewController: UITextFieldDelegate { func textFieldShouldReturn(_ textField: UITextField) -> Bool { textField.resignFirstResponder() return false } func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool { localSearch?.cancel() let previousText = textField.text as NSString? let text = previousText?.replacingCharacters(in: range, with: string) as String? if let text = text, !text.isEmpty { search(query: text) } else { mapItems = [] searchCompletions = [] } return true } }

0101400bcfa0507fb16e28b6e09c4dbe5c9921e8

// // Copyright (c) Bytedance Inc. and its affiliates. // // This source code is licensed under the MIT license found in the // LICENSE file in the root directory of this source tree. // import UIKit public protocol DCRefreshExecuteProtocol: NSObjectProtocol { func refresh() func loadMore() } public protocol DCRefreshControlProtocol: NSObjectProtocol { var isRefreshing: Bool { get } var isLoading: Bool { get } var hasMoreData: Bool { get } func setRefresh(_ isOpen: Bool) func setLoadMore(_ isOpen: Bool) func beginRefreshing() func endRefresh() func endLoadMore() func endWithNoMoreData() } open class DCRefreshContainerModel: DCContainerModel, DCRefreshExecuteProtocol { public weak var refreshHandler: DCRefreshControlProtocol? override public func addSubmodel(_ model: Any) { if let containerModel = model as? DCRefreshContainerModel { containerModel.refreshHandler = self.refreshHandler } super.addSubmodel(model) } public func refreshSubmodelHandler() { for item in modelArray { if let containerModel = item as? DCRefreshContainerModel { containerModel.refreshHandler = self.refreshHandler containerModel.refreshSubmodelHandler() } } } open func refresh() { for item in modelArray { guard let containerModel = item as? DCRefreshContainerModel else { continue } containerModel.refreshHandler = self.refreshHandler containerModel.refresh() } // override } open func loadMore() { for item in modelArray { guard let containerModel = item as? DCRefreshContainerModel else { continue } containerModel.loadMore() } // override } }

50695b0b7ad670ae4c64597fa3278911d29eb531

// // Tip_CalculatorUITests.swift // Tip CalculatorUITests // // Created by RAUL RIVERO RUBIO on 2/13/20. // Copyright © 2020 RAUL RIVERO RUBIO. All rights reserved. // import XCTest class Tip_CalculatorUITests: XCTestCase { override func setUp() { // Put setup code here. This method is called before the invocation of each test method in the class. // In UI tests it is usually best to stop immediately when a failure occurs. continueAfterFailure = false // UI tests must launch the application that they test. Doing this in setup will make sure it happens for each test method. XCUIApplication().launch() // In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this. } override func tearDown() { // Put teardown code here. This method is called after the invocation of each test method in the class. } func testExample() { // Use recording to get started writing UI tests. // Use XCTAssert and related functions to verify your tests produce the correct results. } }

e80409d4be5286592bce2bd670838e1f93da3fc3

// // SKTileLayer.swift // SKTiled // // Created by Michael Fessenden. // // Web: https://github.com/mfessenden // Email: [email protected] // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. import Foundation import SpriteKit import GameplayKit #if os(iOS) || os(tvOS) import UIKit #else import Cocoa #endif /** ## Overview Subclass of `SKTiledLayerObject`, the tile layer is a container for an array of tiles (sprites). Tiles maintain a link to the map's tileset via their `SKTilesetData` property. ### Properties | Property | Description | |---------------------------|--------------------------------------------------------| | tileCount | Returns a count of valid tiles. | ### Instance Methods ### | Method | Description | |---------------------------|--------------------------------------------------------| | getTiles() | Returns an array of current tiles. | | getTiles(ofType:) | Returns tiles of the given type. | | getTiles(globalID:) | Returns all tiles matching a global id. | | getTilesWithProperty(_:_) | Returns tiles matching the given property & value. | | animatedTiles() | Returns all animated tiles. | | getTileData(globalID:) | Returns all tiles matching a global id. | | tileAt(coord:) | Returns a tile at the given coordinate, if one exists. | ### Usage Accessing a tile at a given coordinate: ```swift let tile = tileLayer.tileAt(2, 6)! ``` Query tiles of a certain type: ```swift let floorTiles = tileLayer.getTiles(ofType: "Floor") ``` */ public class SKTileLayer: SKTiledLayerObject { fileprivate typealias TilesArray = Array2D<SKTile> /// Container for the tile sprites. fileprivate var tiles: TilesArray /// Returns a count of valid tiles. public var tileCount: Int { return self.getTiles().count } /// Tuple of layer render statistics. override internal var renderInfo: RenderInfo { var current = super.renderInfo current.tc = tileCount if let graph = graph { current.gn = graph.nodes?.count ?? nil } return current } override var layerRenderStatistics: LayerRenderStatistics { var current = super.layerRenderStatistics var tc: Int switch updateMode { case .full: tc = self.tileCount case .dynamic: tc = 0 default: tc = 0 } current.tiles = tc return current } /// Debug visualization options. override public var debugDrawOptions: DebugDrawOptions { didSet { guard oldValue != debugDrawOptions else { return } debugNode.draw() let doShowTileBounds = debugDrawOptions.contains(.drawTileBounds) tiles.forEach { $0?.showBounds = doShowTileBounds } } } /// Tile highlight duration override public var highlightDuration: TimeInterval { didSet { tiles.compactMap { $0 }.forEach { $0.highlightDuration = highlightDuration } } } override public var speed: CGFloat { didSet { guard oldValue != speed else { return } self.getTiles().forEach { $0.speed = speed } } } // MARK: - Init /** Initialize with layer name and parent `SKTilemap`. - parameter layerName: `String` layer name. - parameter tilemap: `SKTilemap` parent map. */ override public init(layerName: String, tilemap: SKTilemap) { self.tiles = TilesArray(columns: Int(tilemap.size.width), rows: Int(tilemap.size.height)) super.init(layerName: layerName, tilemap: tilemap) self.layerType = .tile } /** Initialize with parent `SKTilemap` and layer attributes. **Do not use this intializer directly** - parameter tilemap: `SKTilemap` parent map. - parameter attributes: `[String: String]` layer attributes. */ public init?(tilemap: SKTilemap, attributes: [String: String]) { // name, width and height are required guard let layerName = attributes["name"] else { return nil } self.tiles = TilesArray(columns: Int(tilemap.size.width), rows: Int(tilemap.size.height)) super.init(layerName: layerName, tilemap: tilemap, attributes: attributes) self.layerType = .tile } required public init?(coder aDecoder: NSCoder) { fatalError("init(coder:) has not been implemented") } // MARK: - Tiles /** Returns a tile at the given coordinate, if one exists. - parameter x: `Int` y-coordinate. - parameter y: `Int` x-coordinate. - returns: `SKTile?` tile object, if it exists. */ public func tileAt(_ x: Int, _ y: Int) -> SKTile? { if isValid(x, y) == false { return nil } return tiles[x,y] } /** Returns a tile at the given coordinate, if one exists. - parameter coord: `CGPoint` tile coordinate. - returns: `SKTile?` tile object, if it exists. */ public func tileAt(coord: CGPoint) -> SKTile? { return tileAt(Int(coord.x), Int(coord.y)) } /** Returns a tile at the given screen position, if one exists. - parameter point: `CGPoint` screen point. - parameter offset: `CGPoint` pixel offset. - returns: `SKTile?` tile object, if it exists. */ public func tileAt(point: CGPoint, offset: CGPoint = CGPoint.zero) -> SKTile? { let coord = coordinateForPoint(point) return tileAt(coord: coord) } /** Returns an array of current tiles. - returns: `[SKTile]` array of tiles. */ public func getTiles() -> [SKTile] { return tiles.compactMap { $0 } } /** Returns tiles with a property of the given type. - parameter ofType: `String` type. - returns: `[SKTile]` array of tiles. */ public func getTiles(ofType: String) -> [SKTile] { return tiles.compactMap { $0 }.filter { $0.tileData.type == ofType } } /** Returns tiles matching the given global id. - parameter globalID: `Int` tile global id. - returns: `[SKTile]` array of tiles. */ public func getTiles(globalID: Int) -> [SKTile] { return tiles.compactMap { $0 }.filter { $0.tileData.globalID == globalID } } /** Returns tiles with a property of the given type. - parameter type: `String` type. - returns: `[SKTile]` array of tiles. */ public func getTilesWithProperty(_ named: String, _ value: Any) -> [SKTile] { var result: [SKTile] = [] for tile in tiles where tile != nil { if let pairValue = tile!.tileData.keyValuePair(key: named) { if pairValue.value == String(describing: value) { result.append(tile!) } } } return result } /** Returns all tiles with animation. - returns: `[SKTile]` array of animated tiles. */ public func animatedTiles() -> [SKTile] { return getTiles().filter { $0.tileData.isAnimated == true } } /** Return tile data from a global id. - parameter globalID: `Int` global tile id. - returns: `SKTilesetData?` tile data (for valid id). */ public func getTileData(globalID gid: Int) -> SKTilesetData? { return tilemap.getTileData(globalID: gid) } /** Returns tiles with a property of the given type. - parameter type: `String` type. - returns: `[SKTile]` array of tiles. */ public func getTileData(withProperty named: String) -> [SKTilesetData] { var result: [SKTilesetData] = [] for tile in tiles where tile != nil { if tile!.tileData.hasKey(named) && !result.contains(tile!.tileData) { result.append(tile!.tileData) } } return result } // MARK: - Layer Data /** Add tile data array to the layer and render it. - parameter data: `[UInt32]` tile data. - parameter debug: `Bool` debug mode. - returns: `Bool` data was successfully added. */ @discardableResult public func setLayerData(_ data: [UInt32], debug: Bool = false) -> Bool { if !(data.count == size.pointCount) { log("invalid data size for layer \"\(self.layerName)\": \(data.count), expected: \(size.pointCount)", level: .error) return false } var errorCount: Int = 0 for index in data.indices { let gid = data[index] // skip empty tiles if (gid == 0) { continue } let x: Int = index % Int(self.size.width) let y: Int = index / Int(self.size.width) let coord = CGPoint(x: CGFloat(x), y: CGFloat(y)) // build the tile let tile = self.buildTileAt(coord: coord, id: gid) if (tile == nil) { errorCount += 1 } } if (errorCount != 0) { log("layer \"\(self.layerName)\": \(errorCount) \(errorCount > 1 ? "errors" : "error") loading data.", level: .warning) } return errorCount == 0 } /** Clear the layer of tiles. */ public func clearLayer() { self.tiles.forEach { tile in tile?.removeFromParent() } self.tiles = TilesArray(columns: Int(tilemap.size.width), rows: Int(tilemap.size.height)) } /** Build an empty tile at the given coordinates. Returns an existing tile if one already exists, or nil if the coordinate is invalid. - parameter coord: `CGPoint` tile coordinate - parameter gid: `Int?` tile id. - parameter tileType: `String` optional tile class name. - returns: `SKTile?` tile. */ public func addTileAt(coord: CGPoint, gid: Int? = nil, tileType: String? = nil) -> SKTile? { guard isValid(coord: coord) else { return nil } // remove the current tile _ = removeTileAt(coord: coord) let tileData: SKTilesetData? = (gid != nil) ? getTileData(globalID: gid!) : nil let Tile = (tilemap.delegate != nil) ? tilemap.delegate!.objectForTileType(named: tileType) : SKTile.self let tile = Tile.init() tile.tileSize = tileSize if let tileData = tileData { tile.tileData = tileData tile.texture = tileData.texture tile.tileSize = (tileData.tileset != nil) ? tileData.tileset!.tileSize : self.tileSize } // set the tile overlap amount tile.setTileOverlap(tilemap.tileOverlap) tile.highlightColor = highlightColor // set the layer property tile.layer = self self.tiles[Int(coord.x), Int(coord.y)] = tile // get the position in the layer (plus tileset offset) let tilePosition = pointForCoordinate(coord: coord, offsetX: offset.x, offsetY: offset.y) tile.position = tilePosition addChild(tile) // add to tile cache NotificationCenter.default.post( name: Notification.Name.Layer.TileAdded, object: tile, userInfo: ["layer": self] ) return tile } /** Build an empty tile at the given coordinates with a custom texture. Returns nil is the coordinate is invalid. - parameter coord: `CGPoint` tile coordinate. - parameter texture: `SKTexture?` optional tile texture. - returns: `SKTile?` tile. */ public func addTileAt(coord: CGPoint, texture: SKTexture? = nil, tileType: String? = nil) -> SKTile? { guard isValid(coord: coord) else { return nil } let Tile = (tilemap.delegate != nil) ? tilemap.delegate!.objectForTileType(named: tileType) : SKTile.self let tile = Tile.init() tile.tileSize = tileSize tile.texture = texture // set the tile overlap amount tile.setTileOverlap(tilemap.tileOverlap) tile.highlightColor = highlightColor // set the layer property tile.layer = self self.tiles[Int(coord.x), Int(coord.y)] = tile // get the position in the layer (plus tileset offset) let tilePosition = pointForCoordinate(coord: coord, offsetX: offset.x, offsetY: offset.y) tile.position = tilePosition addChild(tile) return tile } /** Build an empty tile at the given coordinates. Returns an existing tile if one already exists, or nil if the coordinate is invalid. - parameter x: `Int` x-coordinate - parameter y: `Int` y-coordinate - parameter gid: `Int?` tile id. - returns: `SKTile?` tile. */ public func addTileAt(_ x: Int, _ y: Int, gid: Int? = nil) -> SKTile? { let coord = CGPoint(x: CGFloat(x), y: CGFloat(y)) return addTileAt(coord: coord, gid: gid) } /** Build an empty tile at the given coordinates with a custom texture. Returns nil is the coordinate is invalid. - parameter x: `Int` x-coordinate - parameter y: `Int` y-coordinate - parameter texture: `SKTexture?` optional tile texture. - returns: `SKTile?` tile. */ public func addTileAt(_ x: Int, _ y: Int, texture: SKTexture? = nil) -> SKTile? { let coord = CGPoint(x: CGFloat(x), y: CGFloat(y)) return addTileAt(coord: coord, texture: texture) } /** Remove the tile at a given x/y coordinates. - parameter x: `Int` x-coordinate - parameter y: `Int` y-coordinate - returns: `SKTile?` removed tile. */ public func removeTileAt(_ x: Int, _ y: Int) -> SKTile? { let coord = CGPoint(x: CGFloat(x), y: CGFloat(y)) return removeTileAt(coord: coord) } /** Clear all tiles. */ public func clearTiles() { self.tiles.forEach { tile in tile?.removeAnimation() tile?.removeFromParent() } self.tiles = TilesArray(columns: Int(tilemap.size.width), rows: Int(tilemap.size.height)) } /** Remove the tile at a given coordinate. - parameter coord: `CGPoint` tile coordinate. - returns: `SKTile?` removed tile. */ public func removeTileAt(coord: CGPoint) -> SKTile? { let current = tileAt(coord: coord) if let current = current { current.removeFromParent() self.tiles[Int(coord.x), Int(coord.y)] = nil } return current } /** Build a tile at the given coordinate with the given id. Returns nil if the id cannot be resolved. - parameter coord: `CGPoint` x&y coordinate. - parameter id: `UInt32` tile id. - returns: `SKTile?` tile object. */ fileprivate func buildTileAt(coord: CGPoint, id: UInt32) -> SKTile? { // get tile attributes from the current id let tileAttrs = flippedTileFlags(id: id) let globalId = Int(tileAttrs.gid) if let tileData = tilemap.getTileData(globalID: globalId) { // set the tile data flip flags tileData.flipHoriz = tileAttrs.hflip tileData.flipVert = tileAttrs.vflip tileData.flipDiag = tileAttrs.dflip // get tile object from delegate let Tile = (tilemap.delegate != nil) ? tilemap.delegate!.objectForTileType(named: tileData.type) : SKTile.self if let tile = Tile.init(data: tileData) { // set the tile overlap amount tile.setTileOverlap(tilemap.tileOverlap) tile.highlightColor = highlightColor // set the layer property tile.layer = self tile.highlightDuration = highlightDuration // get the position in the layer (plus tileset offset) let tilePosition = pointForCoordinate(coord: coord, offsetX: tileData.tileset.tileOffset.x, offsetY: tileData.tileset.tileOffset.y) // add to the layer //tile.tileSize = CGSize(width: 10, height: 10) addChild(tile) //tile.tileSize = CGSize(width: 130, height: 230) // set orientation & position tile.orientTile() tile.position = tilePosition // add to the tiles array self.tiles[Int(coord.x), Int(coord.y)] = tile // set the tile zPosition to the current y-coordinate //tile.zPosition = coord.y if tile.texture == nil { Logger.default.log("cannot find a texture for id: \(tileAttrs.gid)", level: .warning, symbol: self.logSymbol) } // add to tile cache NotificationCenter.default.post( name: Notification.Name.Layer.TileAdded, object: tile, userInfo: ["layer": self] ) return tile } else { Logger.default.log("invalid tileset data (id: \(id))", level: .warning, symbol: self.logSymbol) } } else { // check for bad gid calls if !gidErrors.contains(tileAttrs.gid) { gidErrors.append(tileAttrs.gid) } } return nil } /** Set a tile at the given coordinate. - parameter x: `Int` x-coordinate - parameter y: `Int` y-coordinate - returns: `SKTile?` tile. */ public func setTile(_ x: Int, _ y: Int, tile: SKTile? = nil) -> SKTile? { self.tiles[x, y] = tile return tile } /** Set a tile at the given coordinate. - parameter coord: `CGPoint` tile coordinate. - returns: `SKTile?` tile. */ public func setTile(at coord: CGPoint, tile: SKTile? = nil) -> SKTile? { self.tiles[Int(coord.x), Int(coord.y)] = tile return tile } // MARK: - Overlap /** Set the tile overlap. Only accepts a value between 0 - 1.0 - parameter overlap: `CGFloat` tile overlap value. */ public func setTileOverlap(_ overlap: CGFloat) { for tile in tiles where tile != nil { tile!.setTileOverlap(overlap) } } // MARK: - Callbacks /** Called when the layer is finished rendering. - parameter duration: `TimeInterval` fade-in duration. */ override public func didFinishRendering(duration: TimeInterval = 0) { super.didFinishRendering(duration: duration) } // MARK: - Shaders /** Set a shader for tiles in this layer. - parameter for: `[SKTile]` tiles to apply shader to. - parameter named: `String` shader file name. - parameter uniforms: `[SKUniform]` array of shader uniforms. */ public func setShader(for sktiles: [SKTile], named: String, uniforms: [SKUniform] = []) { let shader = SKShader(fileNamed: named) shader.uniforms = uniforms for tile in sktiles { tile.shader = shader } } // MARK: - Debugging /** Visualize the layer's boundary shape. */ override public func drawBounds() { tiles.compactMap{ $0 }.forEach { $0.drawBounds() } super.drawBounds() } override public func debugLayer() { super.debugLayer() for tile in getTiles() { log(tile.debugDescription, level: .debug) } } // MARK: - Updating: Tile Layer /** Run animation actions on all tiles layer. */ override public func runAnimationAsActions() { super.runAnimationAsActions() let animatedTiles = getTiles().filter { tile in tile.tileData.isAnimated == true } animatedTiles.forEach { $0.runAnimationAsActions() } } /** Remove tile animations. - parameter restore: `Bool` restore tile/obejct texture. */ override public func removeAnimationActions(restore: Bool = false) { super.removeAnimationActions(restore: restore) let animatedTiles = getTiles().filter { tile in tile.tileData.isAnimated == true } animatedTiles.forEach { $0.removeAnimationActions(restore: restore) } } /** Update the tile layer before each frame is rendered. - parameter currentTime: `TimeInterval` update interval. */ override public func update(_ currentTime: TimeInterval) { super.update(currentTime) guard (self.updateMode != TileUpdateMode.actions) else { return } } } // MARK: - Extensions extension SKTiledLayerObject { // convenience properties public var width: CGFloat { return tilemap.width } public var height: CGFloat { return tilemap.height } public var tileWidth: CGFloat { return tilemap.tileWidth } public var tileHeight: CGFloat { return tilemap.tileHeight } public var sizeHalved: CGSize { return tilemap.sizeHalved } public var tileWidthHalf: CGFloat { return tilemap.tileWidthHalf } public var tileHeightHalf: CGFloat { return tilemap.tileHeightHalf } public var sizeInPoints: CGSize { return tilemap.sizeInPoints } /// Layer transparency. public var opacity: CGFloat { get { return self.alpha } set { self.alpha = newValue } } /// Layer visibility. public var visible: Bool { get { return !self.isHidden } set { self.isHidden = !newValue } } /** Add a node at the given coordinates. By default, the zPositon will be higher than all of the other nodes in the layer. - parameter node: `SKNode` object. - parameter x: `Int` x-coordinate. - parameter y: `Int` y-coordinate. - parameter dx: `CGFloat` offset x-amount. - parameter dy: `CGFloat` offset y-amount. - parameter zpos: `CGFloat?` optional z-position. */ public func addChild(_ node: SKNode, _ x: Int, _ y: Int, dx: CGFloat = 0, dy: CGFloat = 0, zpos: CGFloat? = nil) { let coord = CGPoint(x: CGFloat(x), y: CGFloat(y)) let offset = CGPoint(x: dx, y: dy) addChild(node, coord: coord, offset: offset, zpos: zpos) } /** Returns a point for a given coordinate in the layer, with optional offset values for x/y. - parameter x: `Int` x-coordinate. - parameter y: `Int` y-coordinate. - parameter offsetX: `CGFloat` x-offset value. - parameter offsetY: `CGFloat` y-offset value. - returns: `CGPoint` position in layer. */ public func pointForCoordinate(_ x: Int, _ y: Int, offsetX: CGFloat = 0, offsetY: CGFloat = 0) -> CGPoint { return self.pointForCoordinate(coord: CGPoint(x: CGFloat(x), y: CGFloat(y)), offsetX: offsetX, offsetY: offsetY) } /** Returns a point for a given coordinate in the layer, with optional offset. - parameter coord: `CGPoint` tile coordinate. - parameter offset: `CGPoint` tile offset. - returns: `CGPoint` point in layer. */ public func pointForCoordinate(coord: CGPoint, offset: CGPoint) -> CGPoint { return self.pointForCoordinate(coord: coord, offsetX: offset.x, offsetY: offset.y) } /** Returns a point for a given coordinate in the layer, with optional offset. - parameter coord: `CGPoint` tile coordinate. - parameter offset: `TileOffset` tile offset hint. - returns: `CGPoint` point in layer. */ public func pointForCoordinate(coord: CGPoint, tileOffset: SKTiledLayerObject.TileOffset = .center) -> CGPoint { var offset = CGPoint(x: 0, y: 0) switch tileOffset { case .top: offset = CGPoint(x: 0, y: -tileHeightHalf) case .topLeft: offset = CGPoint(x: -tileWidthHalf, y: -tileHeightHalf) case .topRight: offset = CGPoint(x: tileWidthHalf, y: -tileHeightHalf) case .bottom: offset = CGPoint(x: 0, y: tileHeightHalf) case .bottomLeft: offset = CGPoint(x: -tileWidthHalf, y: tileHeightHalf) case .bottomRight: offset = CGPoint(x: tileWidthHalf, y: tileHeightHalf) case .left: offset = CGPoint(x: -tileWidthHalf, y: 0) case .right: offset = CGPoint(x: tileWidthHalf, y: 0) default: break } return self.pointForCoordinate(coord: coord, offsetX: offset.x, offsetY: offset.y) } /** Returns a tile coordinate for a given vector_int2 coordinate. - parameter vec2: `int2` vector int2 coordinate. - parameter offsetX: `CGFloat` x-offset value. - parameter offsetY: `CGFloat` y-offset value. - returns: `CGPoint` position in layer. */ public func pointForCoordinate(vec2: int2, offsetX: CGFloat = 0, offsetY: CGFloat = 0) -> CGPoint { return self.pointForCoordinate(coord: vec2.cgPoint, offsetX: offsetX, offsetY: offsetY) } /** Returns a tile coordinate for a given point in the layer. - parameter x: `Int` x-position. - parameter y: `Int` y-position. - returns: `CGPoint` position in layer. */ public func coordinateForPoint(_ x: Int, _ y: Int) -> CGPoint { return self.coordinateForPoint(CGPoint(x: CGFloat(x), y: CGFloat(y))) } /** Returns the center point of a layer. */ public var center: CGPoint { return CGPoint(x: (size.width / 2) - (size.width * anchorPoint.x), y: (size.height / 2) - (size.height * anchorPoint.y)) } /** Calculate the distance from the layer's origin */ public func distanceFromOrigin(_ pos: CGPoint) -> CGVector { let dx = (pos.x - center.x) let dy = (pos.y - center.y) return CGVector(dx: dx, dy: dy) } override public var description: String { let isTopLevel = self.parents.count == 1 let indexString = (isTopLevel == true) ? ", index: \(index)" : "" let layerTypeString = (layerType != TiledLayerType.none) ? layerType.stringValue.capitalized : "Background" return "\(layerTypeString) Layer: \"\(self.path)\"\(indexString), zpos: \(Int(self.zPosition))" } override public var debugDescription: String { return "<\(description)>" } /// Returns a value for use in a dropdown menu. public var menuDescription: String { let parentCount = parents.count let isGrouped: Bool = (parentCount > 1) var layerSymbol: String = layerType.symbol let isGroupNode = (layerType == TiledLayerType.group) let hasChildren: Bool = (childLayers.isEmpty == false) if (isGroupNode == true) { layerSymbol = (hasChildren == true) ? "▿" : "▹" } let filler = (isGrouped == true) ? String(repeating: " ", count: parentCount - 1) : "" return "\(filler)\(layerSymbol) \(layerName)" } } extension SKTiledLayerObject { /// String representing the layer name (null if not set). public var layerName: String { return self.name ?? "null" } /// Returns an array of parent layers, beginning with the current. public var parents: [SKNode] { var current = self as SKNode var result: [SKNode] = [current] while current.parent != nil { if (current.parent! as? SKTiledLayerObject != nil) { result.append(current.parent!) } current = current.parent! } return result } /// Returns an array of child layers. public var childLayers: [SKNode] { return self.enumerate() } /** Returns an array of tiles/objects that conform to the `SKTiledGeometry` protocol. - returns: `[SKNode]` array of child objects. */ public func renderableObjects() -> [SKNode] { var result: [SKNode] = [] enumerateChildNodes(withName: "*") { node, _ in if (node as? SKTiledGeometry != nil) { result.append(node) } } return result } /// Indicates the layer is a top-level layer. public var isTopLevel: Bool { return self.parents.count <= 1 } /// Translate the parent hierarchy to a path string public var path: String { let allParents: [SKNode] = self.parents.reversed() if (allParents.count == 1) { return self.layerName } return allParents.reduce("") { result, node in let comma = allParents.firstIndex(of: node)! < allParents.count - 1 ? "/" : "" return result + "\(node.name ?? "nil")" + comma } } /// Returns the actual zPosition as rendered by the scene. internal var actualZPosition: CGFloat { return (isTopLevel == true) ? zPosition : parents.reduce(zPosition, { result, parent in return result + parent.zPosition }) } /// Returns a string array representing the current layer name & index. public var layerStatsDescription: [String] { let digitCount: Int = self.tilemap.lastIndex.digitCount + 1 let parentNodes = self.parents let isGrouped: Bool = (parentNodes.count > 1) let isGroupNode: Bool = (self as? SKGroupLayer != nil) let indexString = (isGrouped == true) ? String(repeating: " ", count: digitCount) : "\(index).".zfill(length: digitCount, pattern: " ") let typeString = self.layerType.stringValue.capitalized.zfill(length: 6, pattern: " ", padLeft: false) let hasChildren: Bool = (childLayers.isEmpty == false) var layerSymbol: String = " " if (isGroupNode == true) { layerSymbol = (hasChildren == true) ? "▿" : "▹" } let filler = (isGrouped == true) ? String(repeating: " ", count: parentNodes.count - 1) : "" let layerPathString = "\(filler)\(layerSymbol) \"\(layerName)\"" let layerVisibilityString: String = (self.isolated == true) ? "(i)" : (self.visible == true) ? "[x]" : "[ ]" // layer position string, filters out child layers with no offset var positionString = self.position.shortDescription if (self.position.x == 0) && (self.position.y == 0) { positionString = "" } let graphStat = (renderInfo.gn != nil) ? "\(renderInfo.gn!)" : "" return [indexString, typeString, layerVisibilityString, layerPathString, positionString, self.sizeInPoints.shortDescription, self.offset.shortDescription, self.anchorPoint.shortDescription, "\(Int(self.zPosition))", self.opacity.roundTo(2), graphStat] } /** Recursively enumerate child nodes. - returns: `[SKNode]` child elements. */ internal func enumerate() -> [SKNode] { var result: [SKNode] = [self] for child in children { if let node = child as? SKTiledLayerObject { result += node.enumerate() } } return result } } extension SKTiledLayerObject.TiledLayerType { /// Returns a string representation of the layer type. internal var stringValue: String { return "\(self)".lowercased() } internal var symbol: String { switch self { case .tile: return "⊞" case .object: return "⧉" default: return "" } } } extension SKTiledLayerObject.TiledLayerType: CustomStringConvertible, CustomDebugStringConvertible { var description: String { switch self { case .none: return "none" case .tile: return "tile" case .object: return "object" case .image: return "image" case .group: return "group" } } var debugDescription: String { return description } } /** Initialize a color with RGB Integer values (0-255). - parameter r: `Int` red component. - parameter g: `Int` green component. - parameter b: `Int` blue component. - returns: `SKColor` color with given values. */ internal func SKColorWithRGB(_ r: Int, g: Int, b: Int) -> SKColor { return SKColor(red: CGFloat(r)/255.0, green: CGFloat(g)/255.0, blue: CGFloat(b)/255.0, alpha: 1.0) } /** Initialize a color with RGBA Integer values (0-255). - parameter r: `Int` red component. - parameter g: `Int` green component. - parameter b: `Int` blue component. - parameter a: `Int` alpha component. - returns: `SKColor` color with given values. */ internal func SKColorWithRGBA(_ r: Int, g: Int, b: Int, a: Int) -> SKColor { return SKColor(red: CGFloat(r)/255.0, green: CGFloat(g)/255.0, blue: CGFloat(b)/255.0, alpha: CGFloat(a)/255.0) } // MARK: - Deprecated extension SKTiledLayerObject { @available(*, deprecated, renamed: "runAnimationAsActions") /** Initialize SpriteKit animation actions for the layer. */ public func runAnimationAsAction() { self.runAnimationAsActions() } } extension SKTileLayer { /** Returns an array of valid tiles. - returns: `[SKTile]` array of current tiles. */ @available(*, deprecated, message: "use `getTiles()` instead") public func validTiles() -> [SKTile] { return self.getTiles() } }

1824b240f0cc76539732889dede2b1f773176202

// // AppDelegate.swift // RSScrollMenuView // // Created by WhatsXie on 2017/7/17. // Copyright © 2017年 StevenXie. All rights reserved. // import UIKit @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool { // Override point for customization after application launch. return true } func applicationWillResignActive(_ application: UIApplication) { // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. // Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game. } func applicationDidEnterBackground(_ application: UIApplication) { // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. } func applicationWillEnterForeground(_ application: UIApplication) { // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background. } func applicationDidBecomeActive(_ application: UIApplication) { // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. } func applicationWillTerminate(_ application: UIApplication) { // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. } }

f4d969589c1132ed7f93de39ee4a977311e31e5d

import Foundation import XCTest @testable import Relayer final class DispatcherTests: XCTestCase { var sut: Dispatcher! var webSocketSession: WebSocketSessionMock! var networkMonitor: NetworkMonitoringMock! var socketConnectionObserver: SocketConnectionObserverMock! override func setUp() { webSocketSession = WebSocketSessionMock() networkMonitor = NetworkMonitoringMock() socketConnectionObserver = SocketConnectionObserverMock() let url = URL(string: "ws://staging.walletconnect.org")! sut = Dispatcher(url: url, networkMonitor: networkMonitor, socket: webSocketSession, socketConnectionObserver: socketConnectionObserver) } func testDisconnectOnConnectionLoss() { XCTAssertTrue(sut.socket.isConnected) networkMonitor.onUnsatisfied?() XCTAssertFalse(sut.socket.isConnected) } func testConnectsOnConnectionSatisfied() { sut.disconnect(closeCode: .normalClosure) XCTAssertFalse(sut.socket.isConnected) networkMonitor.onSatisfied?() XCTAssertTrue(sut.socket.isConnected) } func testSendWhileConnected() { sut.connect() sut.send("1"){_ in} XCTAssertEqual(webSocketSession.sendCallCount, 1) } func testTextFramesSentAfterReconnectingSocket() { sut.disconnect(closeCode: .normalClosure) sut.send("1"){_ in} sut.send("2"){_ in} XCTAssertEqual(webSocketSession.sendCallCount, 0) sut.connect() socketConnectionObserver.onConnect?() XCTAssertEqual(webSocketSession.sendCallCount, 2) } func testOnMessage() { let expectation = expectation(description: "on message") sut.onMessage = { message in XCTAssertNotNil(message) expectation.fulfill() } webSocketSession.onMessageReceived?("message") waitForExpectations(timeout: 0.001) } func testOnConnect() { let expectation = expectation(description: "on connect") sut.onConnect = { expectation.fulfill() } socketConnectionObserver.onConnect?() waitForExpectations(timeout: 0.001) } func testOnDisconnect() { let expectation = expectation(description: "on disconnect") sut.onDisconnect = { expectation.fulfill() } socketConnectionObserver.onDisconnect?() waitForExpectations(timeout: 0.001) } } class SocketConnectionObserverMock: SocketConnectionObserving { var onConnect: (() -> ())? var onDisconnect: (() -> ())? }

e21770480f0e86ef4485e151cbb1fd7ebabbbaec

// // PersonQuery.swift // ChikaCore // // Created by Mounir Ybanez on 1/7/18. // Copyright © 2018 Nir. All rights reserved. // public protocol PersonQuery { func getPersons(for personIDs: [ID], completion: @escaping (Result<[Person]>) -> Void) -> Bool } public protocol PersonQueryOperator { func withPersonIDs(_ personIDs: [ID]) -> PersonQueryOperator func withCompletion(_ completion: @escaping (Result<[Person]>) -> Void) ->PersonQueryOperator func getPersons(using query: PersonQuery) -> Bool } public class PersonQueryOperation: PersonQueryOperator { var personIDs: [ID]? var completion: ((Result<[Person]>) -> Void)? public init() { } public func withPersonIDs(_ aPersonIDs: [ID]) -> PersonQueryOperator { personIDs = aPersonIDs return self } public func withCompletion(_ aCompletion: @escaping (Result<[Person]>) -> Void) -> PersonQueryOperator { completion = aCompletion return self } public func getPersons(using query: PersonQuery) -> Bool { defer { personIDs?.removeAll() personIDs = nil completion = nil } guard personIDs != nil else { return false } let callback = completion let ok = query.getPersons(for: personIDs!) { result in callback?(result) } return ok } }

210531953c9243e759a00c03ebc2007dd0f9235d

// // Created by Ryan Ackermann on 7/10/15. // Copyright (c) 2015 Ryan Ackermann. All rights reserved. // import UIKit @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { // Override point for customization after application launch. return true } }

4b44ce6bd8d13d5a258d175b7b1d834175dcd17d

import Foundation import SWXMLHash extension XMLIndexer { func userInfo() throws -> [String: String] { let keysAndValues: [(String, String)] = try self["userInfo"][0].children.map { try ($0.value(ofAttribute: "key"), $0.value(ofAttribute: "value")) } return Dictionary(keysAndValues) { $1 } } }

7a6e962ac66a2cebd36715b863e6604d5fca9d41

// // YPLibraryView.swift // YPImgePicker // // Created by Sacha Durand Saint Omer on 2015/11/14. // Copyright © 2015 Yummypets. All rights reserved. // import UIKit import Stevia import Photos final class YPLibraryView: UIView { let assetZoomableViewMinimalVisibleHeight: CGFloat = 50 @IBOutlet weak var collectionView: UICollectionView! @IBOutlet weak var assetZoomableView: YPAssetZoomableView! @IBOutlet weak var assetViewContainer: YPAssetViewContainer! @IBOutlet weak var assetViewContainerConstraintTop: NSLayoutConstraint! let maxNumberWarningView = UIView() let maxNumberWarningLabel = UILabel() let progressView = UIProgressView() let line = UIView() override func awakeFromNib() { super.awakeFromNib() sv( line ) layout( assetViewContainer!, |line| ~ 1 ) line.backgroundColor = .clear setupMaxNumberOfItemsView() setupProgressBarView() } /// At the bottom there is a view that is visible when selected a limit of items with multiple selection func setupMaxNumberOfItemsView() { // View Hierarchy sv( maxNumberWarningView.sv( maxNumberWarningLabel ) ) // Layout |maxNumberWarningView|.bottom(0) if #available(iOS 11.0, *) { maxNumberWarningView.Top == safeAreaLayoutGuide.Bottom - 40 maxNumberWarningLabel.centerHorizontally().top(11) } else { maxNumberWarningView.height(40) maxNumberWarningLabel.centerInContainer() } // Style maxNumberWarningView.backgroundColor = UIColor(r: 246, g: 248, b: 248) maxNumberWarningLabel.font = UIFont(name: "Helvetica Neue", size: 14) maxNumberWarningView.isHidden = true } /// When video is processing this bar appears func setupProgressBarView() { sv( progressView ) progressView.height(5) progressView.Top == line.Top progressView.Width == line.Width progressView.progressViewStyle = .bar progressView.trackTintColor = YPConfig.colors.progressBarTrackColor progressView.progressTintColor = YPConfig.colors.progressBarCompletedColor ?? YPConfig.colors.tintColor progressView.isHidden = true progressView.isUserInteractionEnabled = false } } // MARK: - UI Helpers extension YPLibraryView { class func xibView() -> YPLibraryView? { let bundle = Bundle(for: YPPickerVC.self) let nib = UINib(nibName: "YPLibraryView", bundle: bundle) let xibView = nib.instantiate(withOwner: self, options: nil)[0] as? YPLibraryView return xibView } // MARK: - Grid func hideGrid() { assetViewContainer.grid.alpha = 0 } // MARK: - Loader and progress func fadeInLoader() { UIView.animate(withDuration: 0.2) { self.assetViewContainer.spinnerView.alpha = 1 } } func hideLoader() { assetViewContainer.spinnerView.alpha = 0 } func updateProgress(_ progress: Float) { progressView.isHidden = progress > 0.99 || progress == 0 progressView.progress = progress UIView.animate(withDuration: 0.1, animations: progressView.layoutIfNeeded) } // MARK: - Crop Rect func currentCropRect() -> CGRect { guard let cropView = assetZoomableView else { return CGRect.zero } let normalizedX = min(1, cropView.contentOffset.x &/ cropView.contentSize.width) let normalizedY = min(1, cropView.contentOffset.y &/ cropView.contentSize.height) let normalizedWidth = min(1, cropView.frame.width / cropView.contentSize.width) let normalizedHeight = min(1, cropView.frame.height / cropView.contentSize.height) return CGRect(x: normalizedX, y: normalizedY, width: normalizedWidth, height: normalizedHeight) } // MARK: - Curtain func refreshImageCurtainAlpha() { let imageCurtainAlpha = abs(assetViewContainerConstraintTop.constant) / (assetViewContainer.frame.height - assetZoomableViewMinimalVisibleHeight) assetViewContainer.curtain.alpha = imageCurtainAlpha } func cellSize() -> CGSize { let size = UIScreen.main.bounds.width/4 * UIScreen.main.scale return CGSize(width: size, height: size) } }

183d62c54ba5ad0db213e4cbc48a64be6ac82ff7

/// Copyright (c) 2020 Razeware LLC /// /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell /// copies of the Software, and to permit persons to whom the Software is /// furnished to do so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in /// all copies or substantial portions of the Software. /// /// Notwithstanding the foregoing, you may not use, copy, modify, merge, publish, /// distribute, sublicense, create a derivative work, and/or sell copies of the /// Software in any work that is designed, intended, or marketed for pedagogical or /// instructional purposes related to programming, coding, application development, /// or information technology. Permission for such use, copying, modification, /// merger, publication, distribution, sublicensing, creation of derivative works, /// or sale is expressly withheld. /// /// This project and source code may use libraries or frameworks that are /// released under various Open-Source licenses. Use of those libraries and /// frameworks are governed by their own individual licenses. /// /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// THE SOFTWARE. import UIKit class KeyboardFollower: ObservableObject { @Published var keyboardHeight: CGFloat = 0 @Published var isVisible = false init() { NotificationCenter.default.addObserver( self, selector: #selector(keyboardVisibilityChanged), name: UIResponder.keyboardWillChangeFrameNotification, object: nil) } // deinit { // NotificationCenter.default.removeObserver( // self, // name: UIResponder.keyboardWillChangeFrameNotification, // object: nil) // } @objc private func keyboardVisibilityChanged(_ notification: Notification) { guard let userInfo = notification.userInfo else { return } guard let keyboardEndFrame = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return } isVisible = keyboardEndFrame.minY < UIScreen.main.bounds.height keyboardHeight = isVisible ? keyboardEndFrame.height : 0 } }

de7a7419a5503953a7f5a27b0593bc9e20003c79

//// //// Created by Mike on 8/15/21. //// final class NavigationLinkDestination { let view: SomeView init<V: View>(_ destination: V) { view = destination } } public struct NavigationLink<Label, Destination>: View where Label: View, Destination: View { // @State var destination: NavigationLinkDestination // let label: Label // // @EnvironmentObject var navigationContext: NavigationContext public init( @ViewBuilder destination: () -> Destination, @ViewBuilder label: () -> Label ) { self.init(destination: destination(), label: label) } public init( isActive: Binding<Swift.Bool>, @ViewBuilder destination: () -> Destination, @ViewBuilder label: () -> Label ) { self.init(destination: destination(), isActive: isActive, label: label) } public init<V>( tag: V, selection: Binding<V?>, @ViewBuilder destination: () -> Destination, @ViewBuilder label: () -> Label ) where V: Hashable { self.init( destination: destination(), tag: tag, selection: selection, label: label) } internal init(destination: Destination, @ViewBuilder label: () -> Label) { // self.label = label() // self.destination = .init(destination) // _destination = State(wrappedValue: NavigationLinkDestination(destination)) // self.label = label() } internal init( destination: Destination, isActive: Binding<Bool>, @ViewBuilder label: () -> Label ) {} internal init<V>( destination: Destination, tag: V, selection: Binding<V?>, @ViewBuilder label: () -> Label ) where V: Hashable {} } extension NavigationLink where Label == Text { @_disfavoredOverload public init<S>(_ title: S, @ViewBuilder destination: () -> Destination) where S : Swift.StringProtocol { self.init(title, destination: destination()) } @_disfavoredOverload public init<S>(_ title: S, isActive: Binding<Swift.Bool>, @ViewBuilder destination: () -> Destination) where S : Swift.StringProtocol { self.init(title, destination: destination(), isActive: isActive) } @_disfavoredOverload public init<S, V>(_ title: S, tag: V, selection: Binding<V?>, @ViewBuilder destination: () -> Destination) where S : Swift.StringProtocol, V : Swift.Hashable { self.init( title, destination: destination(), tag: tag, selection: selection) } internal init<S>(_ title: S, destination: Destination) where S : Swift.StringProtocol {} internal init<S>(_ title: S, destination: Destination, isActive: Binding<Swift.Bool>) where S : Swift.StringProtocol {} internal init<S, V>(_ title: S, destination: Destination, tag: V, selection: Binding<V?>) where S : Swift.StringProtocol, V : Swift.Hashable {} }

03ac23b24d0ff6b934dcd66032d996c2b3ec08a1

// // CustomTimePickerTests.swift // CustomTimePickerTests // // Created by recherst on 2021/8/18. // import XCTest @testable import CustomTimePicker class CustomTimePickerTests: XCTestCase { override func setUpWithError() throws { // Put setup code here. This method is called before the invocation of each test method in the class. } override func tearDownWithError() throws { // Put teardown code here. This method is called after the invocation of each test method in the class. } func testExample() throws { // This is an example of a functional test case. // Use XCTAssert and related functions to verify your tests produce the correct results. } func testPerformanceExample() throws { // This is an example of a performance test case. self.measure { // Put the code you want to measure the time of here. } } }

48eeb77af0d7338d3ed9fa5c33d25715df01b107

// // UITableView+Styles.swift // SurfPlaybook // // Created by Александр Чаусов on 19.04.2021. // Copyright © 2021 Surf. All rights reserved. // import UIKit extension UITableView { func apply(style: TableViewStyleType) { style.apply(for: self) } } enum TableViewStyleType { case `default` func apply(for view: UITableView) { switch self { case .default: view.backgroundColor = Colors.Main.background view.contentInsetAdjustmentBehavior = .never view.keyboardDismissMode = .onDrag view.separatorStyle = .none // дефолтный отступ снизу до контента, как завещал Гомес view.contentInset = .init(top: 0, left: 0, bottom: 30, right: 0) } } }

8fa0054475d9aefe1cc931d89739e57f5ffda32e

import UIKit import XCTest import SwiftyBootpay class Tests: XCTestCase { override func setUp() { super.setUp() // Put setup code here. This method is called before the invocation of each test method in the class. } override func tearDown() { // Put teardown code here. This method is called after the invocation of each test method in the class. super.tearDown() } func testExample() { // This is an example of a functional test case. XCTAssert(true, "Pass") } func testPerformanceExample() { // This is an example of a performance test case. self.measure() { // Put the code you want to measure the time of here. } } }

c1debf58f8826ca53304d9f8780e45a550102c3e

// // WeatherForecastTests.swift // OpenWeather // // Created by Dario Banno on 29/05/2017. // Copyright © 2017 AppTown. All rights reserved. // import XCTest @testable import OpenWeather class WeatherForecastTests: XCTestCase { func test_invalid_json_population() { // GIVEN I have an invalid json let jsonObject = ["ciao": "bella"] // WHEN I populate a forecast object from json let forecast = WeatherForecast(json: jsonObject) // THEN I can see object is nil XCTAssertNil(forecast) } func test_valid_json_population() { // GIVEN I have a json object for weather let jsonObject = json(forFile: "forecast.json")! // WHEN I populate a weather object from json let forecast = WeatherForecast(json: jsonObject) // THEN I can see object is not nil XCTAssertNotNil(forecast) // AND I can see all fields are properly populated XCTAssertEqual(forecast?.station.id, 2643743) XCTAssertEqual(forecast?.station.name, "London") XCTAssertEqual(forecast?.station.country, "GB") XCTAssertEqual(forecast?.weatherList.count, 2) XCTAssertEqual(forecast?.weatherList[0].code, 802) XCTAssertEqual(forecast?.weatherList[0].condition, "Clouds") XCTAssertEqual(forecast?.weatherList[0].humidity, 62) XCTAssertEqual(forecast?.weatherList[0].temperature, 293.81) XCTAssertEqual(forecast?.weatherList[0].temperatureMin, 293.81) XCTAssertEqual(forecast?.weatherList[0].temperatureMax, 295.409) XCTAssertEqual(forecast?.weatherList[0].timestamp, 1496070000) XCTAssertEqual(forecast?.weatherList[0].wind.speed, 5.47) XCTAssertEqual(forecast?.weatherList[0].wind.degrees, 241.503) XCTAssertEqual(forecast?.weatherList[1].code, 800) XCTAssertEqual(forecast?.weatherList[1].condition, "Clear") XCTAssertEqual(forecast?.weatherList[1].humidity, 75) XCTAssertEqual(forecast?.weatherList[1].temperature, 286.917) XCTAssertEqual(forecast?.weatherList[1].temperatureMin, 286.917) XCTAssertEqual(forecast?.weatherList[1].temperatureMax, 286.917) XCTAssertEqual(forecast?.weatherList[1].timestamp, 1496124000) XCTAssertEqual(forecast?.weatherList[1].wind.speed, 3.46) XCTAssertEqual(forecast?.weatherList[1].wind.degrees, 257.501) } }

fbd75321cb70a477657ecc3dd20bb3d9527e327d

// // QueuedDownloadsCell.swift // appdb // // Created by ned on 22/04/2019. // Copyright © 2019 ned. All rights reserved. // import UIKit import Cartography import AlamofireImage class QueuedDownloadsCell: UICollectionViewCell { private var iconSize: CGFloat = (75 ~~ 65) private var margin: CGFloat = (15 ~~ 12) private var name: UILabel! private var icon: UIImageView! private var status: UILabel! func configure(with app: RequestedApp) { name.text = app.name status.text = app.status if app.type != .myAppstore { if let url = URL(string: app.image) { icon.af.setImage(withURL: url, placeholderImage: #imageLiteral(resourceName: "placeholderIcon"), filter: Global.roundedFilter(from: iconSize), imageTransition: .crossDissolve(0.2)) } } else { icon.image = #imageLiteral(resourceName: "blank_icon") } } required init?(coder aDecoder: NSCoder) { super.init(coder: aDecoder) } override init(frame: CGRect) { super.init(frame: frame) self.setup() } func setup() { theme_backgroundColor = Color.veryVeryLightGray contentView.theme_backgroundColor = Color.veryVeryLightGray contentView.layer.cornerRadius = 6 contentView.layer.borderWidth = 1 / UIScreen.main.scale contentView.layer.theme_borderColor = Color.borderCgColor layer.backgroundColor = UIColor.clear.cgColor // Name name = UILabel() name.theme_textColor = Color.title name.font = .systemFont(ofSize: 18.5 ~~ 16.5) name.numberOfLines = 1 name.makeDynamicFont() // Icon icon = UIImageView() icon.layer.borderWidth = 1 / UIScreen.main.scale icon.layer.theme_borderColor = Color.borderCgColor icon.contentMode = .scaleToFill icon.layer.cornerRadius = Global.cornerRadius(from: iconSize) // Status status = UILabel() status.theme_textColor = Color.darkGray status.font = .systemFont(ofSize: 14 ~~ 13) status.numberOfLines = 2 status.makeDynamicFont() contentView.addSubview(name) contentView.addSubview(icon) contentView.addSubview(status) constrain(name, status, icon) { name, status, icon in icon.width ~== iconSize icon.height ~== icon.width icon.left ~== icon.superview!.left ~+ margin icon.centerY ~== icon.superview!.centerY (name.left ~== icon.right ~+ (15 ~~ 12)) ~ Global.notMaxPriority name.right ~== name.superview!.right ~- margin name.top ~== icon.top ~+ 5 status.left ~== name.left status.top ~== name.bottom ~+ (2 ~~ 0) status.right ~<= status.superview!.right ~- margin } } }

ef746b6f3608ff6b1be58632629669829856e852

// // MoviesViewController.swift // Flickster // // Created by Priscilla Lok on 2/4/16. // Copyright © 2016 Priscilla Lok. All rights reserved. // import UIKit import AFNetworking import M13ProgressSuite class MoviesViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, UISearchBarDelegate, UITabBarDelegate { @IBOutlet weak var backgroundLayerView: UIView! @IBOutlet weak var tabBar: UITabBar! @IBOutlet weak var offlineView: UIView! @IBOutlet weak var tableView: UITableView! @IBOutlet weak var searchBar: UISearchBar! var searchResults: [NSDictionary]? var useSearchResults: Bool? var movies: [NSDictionary]? var topRatedMovies: [NSDictionary]? var nowPlayingMovies: [NSDictionary]? var refreshControl: UIRefreshControl = UIRefreshControl() override func viewDidLoad() { super.viewDidLoad() //set color schemes let primaryColor: UIColor = UIColor(red: 0.05, green: 0.14, blue: 0.22, alpha: 1.0) let secondaryColor: UIColor = UIColor(red: 0.42, green: 0.52, blue: 0.62, alpha: 1.0) self.backgroundLayerView.backgroundColor = primaryColor self.tableView.backgroundColor = primaryColor self.tableView.separatorStyle = UITableViewCellSeparatorStyle.None let textSearchField: UITextField = self.searchBar.valueForKey("_searchField") as! UITextField textSearchField.backgroundColor = primaryColor textSearchField.textColor = secondaryColor self.searchBar.barTintColor = secondaryColor UIBarButtonItem.appearanceWhenContainedInInstancesOfClasses([UISearchBar.self]).tintColor = primaryColor self.tabBar.barTintColor = primaryColor UITabBar.appearance().tintColor = UIColor(red: 0.32, green: 0.42, blue: 0.52, alpha: 1.0) //initialize and set up tableview tableView.dataSource = self tableView.delegate = self self.offlineView.hidden = true makeRequestToAPI() //initialize and set up refresh control refreshControl.addTarget(self, action: "refreshControlAction:", forControlEvents: UIControlEvents.ValueChanged) tableView.insertSubview(refreshControl, atIndex: 0) //initialize and set up search bar self.searchBar.delegate = self useSearchResults = false //initialize and set up tab bar self.tabBar.delegate = self self.tabBar.selectedItem = self.tabBar.items![0] } override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() } //# MARK: Obtain movie data methods func makeRequestToAPI() { var nowPlayingRequestDone = false var topRatedRequestDone = false self.navigationController?.showProgress() self.navigationController?.setProgress(0, animated: true) //now_playing API call let apiKey = "a07e22bc18f5cb106bfe4cc1f83ad8ed" let url = NSURL(string: "https://api.themoviedb.org/3/movie/now_playing?api_key=\(apiKey)") let request = NSURLRequest(URL: url!, cachePolicy: NSURLRequestCachePolicy.ReturnCacheDataElseLoad, timeoutInterval: 60.0) let session = NSURLSession( configuration: NSURLSessionConfiguration.defaultSessionConfiguration(), delegate: nil, delegateQueue: NSOperationQueue.mainQueue()) let task : NSURLSessionDataTask = session.dataTaskWithRequest(request, completionHandler: {(dataOrNil, response, error) in if error != nil { self.offlineView.hidden = false return } if let data = dataOrNil { if let responseDictionary = try! NSJSONSerialization.JSONObjectWithData(data, options: []) as? NSDictionary { self.nowPlayingMovies = responseDictionary["results"] as? [NSDictionary] //assign movies based on which tab is selected if (self.tabBar.items?.indexOf(self.tabBar.selectedItem!))! == 0{ self.movies = self.nowPlayingMovies } else { self.movies = self.topRatedMovies } self.searchResults = self.movies self.tableView.reloadData() } self.offlineView.hidden = true } nowPlayingRequestDone = true self.refreshControl.endRefreshing() if nowPlayingRequestDone == true && topRatedRequestDone == true { self.navigationController?.setProgress(1, animated: true) self.navigationController?.setProgress(0, animated: false) self.navigationController?.finishProgress() self.tableView.reloadData() } }) task.resume() //top_rated API call let topRatedUrl = NSURL(string: "https://api.themoviedb.org/3/movie/top_rated?api_key=\(apiKey)") let topRatedRequest = NSURLRequest(URL: topRatedUrl!, cachePolicy: NSURLRequestCachePolicy.ReturnCacheDataElseLoad, timeoutInterval: 60.0) let topRatedSession = NSURLSession( configuration: NSURLSessionConfiguration.defaultSessionConfiguration(), delegate: nil, delegateQueue: NSOperationQueue.mainQueue()) let topRatedTask : NSURLSessionDataTask = topRatedSession.dataTaskWithRequest(topRatedRequest, completionHandler: {(dataOrNil, response, error) in if error != nil { self.offlineView.hidden = false return } if let data = dataOrNil { if let responseDictionary = try! NSJSONSerialization.JSONObjectWithData(data, options: []) as? NSDictionary { self.topRatedMovies = responseDictionary["results"] as? [NSDictionary] if (self.tabBar.items?.indexOf(self.tabBar.selectedItem!))! == 0{ self.movies = self.nowPlayingMovies } else { self.movies = self.topRatedMovies } self.searchResults = self.movies self.tableView.reloadData() } self.offlineView.hidden = true } topRatedRequestDone = true self.refreshControl.endRefreshing() if nowPlayingRequestDone == true && topRatedRequestDone == true { self.navigationController?.setProgress(1, animated: true) self.navigationController?.setProgress(0, animated: false) self.navigationController?.finishProgress() self.tableView.reloadData() } }) topRatedTask.resume() } // Makes a network request to get updated data func refreshControlAction(refreshControl: UIRefreshControl) { makeRequestToAPI() self.tableView.reloadData() } //# MARK: Navigation methods override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) { let vc = segue.destinationViewController as! MovieDetailsViewController let indexPath = tableView.indexPathForCell(sender as! UITableViewCell) let currentMovies: [NSDictionary]? = self.getCurrentMovies() if currentMovies != nil { let movie = currentMovies![(indexPath?.row)!] if let posterPath = movie["poster_path"] as? String { let posterBaseUrl = "http://image.tmdb.org/t/p/w500" let posterUrl = posterBaseUrl + posterPath vc.posterUrl = posterUrl } let title = movie["title"] as? String vc.movieTitle = title let rating = movie["vote_average"] as? Double vc.rating = rating let releaseDate = movie["release_date"] as? String vc.releaseDate = releaseDate let overview = movie["overview"] as? String vc.overview = overview } } //# MARK: TableView Methods func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return self.getCurrentMovies().count } func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCellWithIdentifier("MovieCell", forIndexPath: indexPath) as! MovieCell cell.selectionStyle = .Gray var movie :NSDictionary = [:] //determine which array to parse movie from if self.useSearchResults == false { movie = movies![indexPath.row] } else { movie = self.searchResults![indexPath.row] } let title = movie["title"] as! String if let posterPath = movie["poster_path"] as? String { let posterBaseUrl = "http://image.tmdb.org/t/p/w500" let posterUrl = NSURL(string: posterBaseUrl + posterPath) let imageRequest = NSURLRequest(URL: posterUrl!) //set image in cell cell.posterView.setImageWithURLRequest( imageRequest, placeholderImage: nil, success: { (imageRequest, imageResponse, image) -> Void in // imageResponse will be nil if the image is cached if imageResponse != nil { print("Image was NOT cached, fade in image") cell.posterView.alpha = 0.0 cell.posterView.image = image UIView.animateWithDuration(0.3, animations: { () -> Void in cell.posterView.alpha = 1.0 }) } else { print("Image was cached so just update the image") cell.posterView.image = image } }, failure: { (imageRequest, imageResponse, error) -> Void in }) cell.posterView.contentMode = .ScaleAspectFill } else { // No poster image. Can either set to nil (no image) or a default movie poster image // that you include as an asset cell.posterView.image = nil } //set title cell.titleLabel.text = title //set star ratings cell.starRatingView.settings.fillMode = .Half cell.starRatingView.rating = (movie["vote_average"] as? Double)!/2.0 return cell } //# MARK: Tab Bar Methods //tab bar for selection between now_playing and top_rated movies func tabBar(tabBar: UITabBar, didSelectItem item: UITabBarItem) { let selectedIndex = tabBar.items?.indexOf(item) if selectedIndex == 0 { self.movies = self.nowPlayingMovies } else { self.movies = self.topRatedMovies } self.tableView.reloadData() } //# MARK: Search Methods func searchBar(searchBar: UISearchBar, textDidChange searchText: String) { self.getSearchResultsForSearchText(searchText) } func searchBarTextDidBeginEditing(searchBar: UISearchBar) { self.useSearchResults = true self.searchBar.showsCancelButton = true self.getSearchResultsForSearchText(searchBar.text!) } //function to either get search results or entire list of movies func getCurrentMovies() -> [NSDictionary] { if self.useSearchResults == true { if self.searchResults != nil { return self.searchResults! } else { return [] } } else { if self.movies != nil{ return self.movies! } else { return [] } } } func getSearchResultsForSearchText(searchText: String) { //clear search results self.searchResults?.removeAll() if searchText.characters.count == 0 { //no search text, default to all movies for movie in self.movies! { self.searchResults?.append(movie) } } else { for movie in self.getMoviesForSearchText(searchText) { self.searchResults?.append(movie) } } self.tableView.reloadData() } func getMoviesForSearchText(text: String) -> [NSDictionary] { let predicate: NSPredicate = NSPredicate(format: "title contains[c] %@", text) let results: [NSDictionary] = (self.movies! as NSArray).filteredArrayUsingPredicate(predicate) as! [NSDictionary] return results } func searchBarCancelButtonClicked(searchBar: UISearchBar) { self.useSearchResults = false self.searchBar.text = "" self.searchBar.endEditing(true) self.searchBar.showsCancelButton = false self.tableView.reloadData() } func searchBarSearchButtonClicked(searchBar: UISearchBar) { self.useSearchResults = true self.view.endEditing(true) self.searchBar.showsCancelButton = false self.tableView.reloadData() } /* // MARK: - Navigation // In a storyboard-based application, you will often want to do a little preparation before navigation override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) { // Get the new view controller using segue.destinationViewController. // Pass the selected object to the new view controller. } */ }

fcf0cfd8c67a1133281fd694a214e35427166466

// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -parse-as-library %import-libdispatch) | %FileCheck %s // REQUIRES: executable_test // REQUIRES: concurrency // REQUIRES: libdispatch // rdar://76038845 // REQUIRES: concurrency_runtime // UNSUPPORTED: back_deployment_runtime import Dispatch // For sleep #if canImport(Darwin) import Darwin #elseif canImport(Glibc) import Glibc #endif @available(SwiftStdlib 5.5, *) enum TL { @TaskLocal static var number: Int = 0 @TaskLocal static var other: Int = 0 } @available(SwiftStdlib 5.5, *) @discardableResult func printTaskLocal<V>( _ key: TaskLocal<V>, _ expected: V? = nil, file: String = #file, line: UInt = #line ) -> V? { let value = key.get() print("\(key) (\(value)) at \(file):\(line)") if let expected = expected { assert("\(expected)" == "\(value)", "Expected [\(expected)] but found: \(value), at \(file):\(line)") } return expected } // ==== ------------------------------------------------------------------------ @available(SwiftStdlib 5.5, *) func copyTo_sync_noWait() { print(#function) TL.$number.withValue(1111) { TL.$number.withValue(2222) { TL.$other.withValue(9999) { Task { printTaskLocal(TL.$number) // CHECK: TaskLocal<Int>(defaultValue: 0) (2222) printTaskLocal(TL.$other) // CHECK: TaskLocal<Int>(defaultValue: 0) (9999) TL.$number.withValue(3333) { printTaskLocal(TL.$number) // CHECK: TaskLocal<Int>(defaultValue: 0) (3333) printTaskLocal(TL.$other) // CHECK: TaskLocal<Int>(defaultValue: 0) (9999) } } } } } sleep(1) } @available(SwiftStdlib 5.5, *) func copyTo_sync_noValues() { Task { printTaskLocal(TL.$number) // CHECK: TaskLocal<Int>(defaultValue: 0) (0) } sleep(1) } /// Similar to tests in `async_task_locals_copy_to_async_ but without any task involved at the top level. @available(SwiftStdlib 5.5, *) @main struct Main { static func main() { copyTo_sync_noWait() copyTo_sync_noValues() } }

5b5b8d5a2f0f7c36261c98538c2bc9bd51485366

/* Copyright 2019 FUJITSU CLOUD TECHNOLOGIES LIMITED All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ import XCTest @testable import NCMB /// NCMBFieldTypeConverter のテストクラスです。 final class NCMBFieldTypeConverterTests: NCMBTestCase { func test_convertToFieldValue_NCMBIncrementOperator() { var object : [String : Any] = [:] object["__op"] = "Increment" object["amount"] = 42 let incrementOperator = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((incrementOperator! as! NCMBIncrementOperator).amount as! Int, 42) } func test_convertToFieldValue_NCMBAddOperator() { var object : [String : Any] = [:] object["__op"] = "Add" object["objects"] = ["takanokun"] let addOperator = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((addOperator! as! NCMBAddOperator).elements.count, 1) XCTAssertEqual((addOperator! as! NCMBAddOperator).elements[0] as! String, "takanokun") } func test_convertToFieldValue_NCMBAddUniqueOperator() { var object : [String : Any] = [:] object["__op"] = "AddUnique" object["objects"] = ["takanokun"] let addUniqueOperator = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((addUniqueOperator! as! NCMBAddUniqueOperator).elements.count, 1) XCTAssertEqual((addUniqueOperator! as! NCMBAddUniqueOperator).elements[0] as! String, "takanokun") } func test_convertToFieldValue_NCMBRemoveOperator() { var object : [String : Any] = [:] object["__op"] = "Remove" object["objects"] = ["takanokun"] let removeOperator = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((removeOperator! as! NCMBRemoveOperator).elements.count, 1) XCTAssertEqual((removeOperator! as! NCMBRemoveOperator).elements[0] as! String, "takanokun") } func test_convertToFieldValue_NCMBAddRelationOperator() { var object : [String : Any] = [:] object["__op"] = "AddRelation" object["className"] = "TestClass" var pointerJson : [String : Any] = [:] pointerJson["__type"] = "Pointer" pointerJson["className"] = "TestClass" pointerJson["objectId"] = "hogeHOGE12345678" object["objects"] = [pointerJson] let addRelationOperator = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((addRelationOperator! as! NCMBAddRelationOperator).elements.count, 1) XCTAssertEqual((addRelationOperator! as! NCMBAddRelationOperator).elements[0] , NCMBPointer(className: "TestClass", objectId: "hogeHOGE12345678")) } func test_convertToFieldValue_NCMBRemoveRelationOperator() { var object : [String : Any] = [:] object["__op"] = "RemoveRelation" object["className"] = "TestClass" var pointerJson : [String : Any] = [:] pointerJson["__type"] = "Pointer" pointerJson["className"] = "TestClass" pointerJson["objectId"] = "hogeHOGE12345678" object["objects"] = [pointerJson] let removeRelationOperator = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((removeRelationOperator! as! NCMBRemoveRelationOperator).elements.count, 1) XCTAssertEqual((removeRelationOperator! as! NCMBRemoveRelationOperator).elements[0] , NCMBPointer(className: "TestClass", objectId: "hogeHOGE12345678")) } func test_convertToFieldValue_Date() { var object : [String : Any] = [:] object["__type"] = "Date" object["iso"] = "1986-02-04T12:34:56.789Z" let date = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual(date! as! Date, Date(timeIntervalSince1970: 507904496.789)) } func test_convertToFieldValue_NCMBPointer() { var object : [String : Any] = [:] object["__type"] = "Pointer" object["className"] = "TestClass" object["objectId"] = "abcde12345" let pointer = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((pointer! as! NCMBPointer).className, "TestClass") XCTAssertEqual((pointer! as! NCMBPointer).objectId, "abcde12345") } func test_convertToFieldValue_NCMBRelation() { var object : [String : Any] = [:] object["__type"] = "Relation" object["className"] = "TestClass" let relation = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((relation! as! NCMBRelation).className, "TestClass") } func test_convertToFieldValue_NCMBGeoPoint() { var object : [String : Any] = [:] object["__type"] = "GeoPoint" object["latitude"] = Double(35.6666269) object["longitude"] = Double(139.765607) let geoPoint = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertEqual((geoPoint! as! NCMBGeoPoint).latitude, Double(35.6666269)) XCTAssertEqual((geoPoint! as! NCMBGeoPoint).longitude, Double(139.765607)) } // func test_convertToFieldValue_NCMBObjectField() { // TBD // } func test_convertToFieldValue_Int() { let object : Int = 42 let int = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertNil(int) } func test_convertToFieldValue_String() { let object : String = "takanokun" let string = NCMBFieldTypeConverter.convertToFieldValue(object: object) XCTAssertNil(string) } func test_converToObject_NCMBIncrementOperator() { let incrementOperator = NCMBIncrementOperator(amount: 42) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: incrementOperator) XCTAssertEqual(object!["__op"]! as! String, "Increment") XCTAssertEqual(object!["amount"]! as! Int, 42) } func test_converToObject_NCMBAddOperator() { let addOperator = NCMBAddOperator(elements: ["takanokun", "takano_san"]) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: addOperator) XCTAssertEqual(object!["__op"]! as! String, "Add") XCTAssertEqual((object!["objects"]! as! Array<String>).count, 2) XCTAssertEqual((object!["objects"]! as! Array<String>)[0], "takanokun") XCTAssertEqual((object!["objects"]! as! Array<String>)[1], "takano_san") } func test_converToObject_NCMBAddUniqueOperator() { let addUniqueOperator = NCMBAddUniqueOperator(elements: ["takanokun", "takano_san"]) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: addUniqueOperator) XCTAssertEqual(object!["__op"]! as! String, "AddUnique") XCTAssertEqual((object!["objects"]! as! Array<String>).count, 2) XCTAssertEqual((object!["objects"]! as! Array<String>)[0], "takanokun") XCTAssertEqual((object!["objects"]! as! Array<String>)[1], "takano_san") } func test_converToObject_NCMBRemoveOperator() { let removeOperator = NCMBRemoveOperator(elements: ["takanokun", "takano_san"]) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: removeOperator) XCTAssertEqual(object!["__op"]! as! String, "Remove") XCTAssertEqual((object!["objects"]! as! Array<String>).count, 2) XCTAssertEqual((object!["objects"]! as! Array<String>)[0], "takanokun") XCTAssertEqual((object!["objects"]! as! Array<String>)[1], "takano_san") } func test_converToObject_NCMBAddRelationOperator() { let JsontoObject1 = NCMBPointer(className: "TestClass", objectId: "hogeHOGE12345678") let JsontoObject2 = NCMBPointer(className: "TestClass", objectId: "hogeHOGE90123456") let addRelationOperator = NCMBAddRelationOperator(elements: [JsontoObject1,JsontoObject2]) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: addRelationOperator) XCTAssertEqual(object!["__op"]! as! String, "AddRelation") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>).count, 2) XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0].count, 3) XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0]["__type"] as! String, "Pointer") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0]["className"] as! String, "TestClass") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0]["objectId"] as! String, "hogeHOGE12345678") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1].count, 3) XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1]["__type"] as! String, "Pointer") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1]["className"] as! String, "TestClass") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1]["objectId"] as! String, "hogeHOGE90123456") } func test_converToObject_NCMBRemoveRelationOperator() { let JsontoObject1 = NCMBPointer(className: "TestClass", objectId: "hogeHOGE12345678") let JsontoObject2 = NCMBPointer(className: "TestClass", objectId: "hogeHOGE90123456") let removeRelationOperator = NCMBRemoveRelationOperator(elements: [JsontoObject1,JsontoObject2]) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: removeRelationOperator) XCTAssertEqual(object!["__op"]! as! String, "RemoveRelation") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>).count, 2) XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0].count, 3) XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0]["__type"] as! String, "Pointer") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0]["className"] as! String, "TestClass") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[0]["objectId"] as! String, "hogeHOGE12345678") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1].count, 3) XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1]["__type"] as! String, "Pointer") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1]["className"] as! String, "TestClass") XCTAssertEqual((object!["objects"]! as! Array<Dictionary<String,Any>>)[1]["objectId"] as! String, "hogeHOGE90123456") } func test_converToObject_Date() { let date = Date(timeIntervalSince1970: 507904496.789) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: date) XCTAssertEqual(object!["__type"]! as! String, "Date") XCTAssertEqual(object!["iso"]! as! String, "1986-02-04T12:34:56.789Z") } func test_converToObject_NCMBPointer() { let pointer = NCMBPointer(className: "TestClass", objectId: "abcde12345") let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: pointer) XCTAssertEqual(object!["__type"]! as! String, "Pointer") XCTAssertEqual(object!["className"]! as! String, "TestClass") XCTAssertEqual(object!["objectId"]! as! String, "abcde12345") } func test_converToObject_NCMBRelation() { let relation = NCMBRelation(className: "TestClass") let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: relation) XCTAssertEqual(object!["__type"]! as! String, "Relation") XCTAssertEqual(object!["className"]! as! String, "TestClass") } func test_converToObject_NCMBGeoPoint() { let geoPoint = NCMBGeoPoint(latitude: 35.6666269, longitude: 139.765607) let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: geoPoint) XCTAssertEqual(object!["__type"]! as! String, "GeoPoint") XCTAssertEqual(object!["latitude"]! as! Double, Double(35.6666269)) XCTAssertEqual(object!["longitude"]! as! Double, Double(139.765607)) } // func test_converToObject_NCMBObjectField() { // TBD // } func test_converToObject_Int() { let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: 42) XCTAssertNil(object) } func test_converToObject_String() { let object : [String : Any]? = NCMBFieldTypeConverter.converToObject(value: "takanokun") XCTAssertNil(object) } static var allTests = [ ("test_convertToFieldValue_NCMBIncrementOperator", test_convertToFieldValue_NCMBIncrementOperator), ("test_convertToFieldValue_NCMBAddOperator", test_convertToFieldValue_NCMBAddOperator), ("test_convertToFieldValue_NCMBAddUniqueOperator", test_convertToFieldValue_NCMBAddUniqueOperator), ("test_convertToFieldValue_NCMBRemoveOperator", test_convertToFieldValue_NCMBRemoveOperator), ("test_convertToFieldValue_NCMBAddRelationOperator", test_convertToFieldValue_NCMBAddRelationOperator), ("test_convertToFieldValue_NCMBRemoveRelationOperator", test_convertToFieldValue_NCMBRemoveRelationOperator), ("test_convertToFieldValue_Date", test_convertToFieldValue_Date), ("test_convertToFieldValue_NCMBPointer", test_convertToFieldValue_NCMBPointer), ("test_convertToFieldValue_NCMBRelation", test_convertToFieldValue_NCMBRelation), ("test_convertToFieldValue_NCMBGeoPoint", test_convertToFieldValue_NCMBGeoPoint), // ("test_convertToFieldValue_NCMBObjectField", test_convertToFieldValue_NCMBObjectField), ("test_convertToFieldValue_Int", test_convertToFieldValue_Int), ("test_convertToFieldValue_String", test_convertToFieldValue_String), ("test_converToObject_NCMBIncrementOperator", test_converToObject_NCMBIncrementOperator), ("test_converToObject_NCMBAddOperator", test_converToObject_NCMBAddOperator), ("test_converToObject_NCMBAddUniqueOperator", test_converToObject_NCMBAddUniqueOperator), ("test_converToObject_NCMBRemoveOperator", test_converToObject_NCMBRemoveOperator), ("test_converToObject_NCMBAddRelationOperator", test_converToObject_NCMBAddRelationOperator), ("test_converToObject_NCMBRemoveRelationOperator", test_converToObject_NCMBRemoveRelationOperator), ("test_converToObject_Date", test_converToObject_Date), ("test_converToObject_NCMBPointer", test_converToObject_NCMBPointer), ("test_converToObject_NCMBRelation", test_converToObject_NCMBRelation), ("test_converToObject_NCMBGeoPoint", test_converToObject_NCMBGeoPoint), // ("test_converToObject_NCMBObjectField", test_converToObject_NCMBObjectField), ("test_converToObject_Int", test_converToObject_Int), ("test_converToObject_String", test_converToObject_String), ] }

48ee7a8c1c0a9e2f9a03c412b84c91412007dfe8

// // Extensions.swift // TCalculator // // Created by Dominic Beger on 24.08.16. // Copyright © 2016 Dominic Beger. All rights reserved. // import Foundation extension String { // At least Swift has extension properties. But the fact that it's necessary to create a custom property for a String-length is indeed creepy. var length: Int { return characters.count } subscript (i: Int) -> Character { return self[self.startIndex.advancedBy(i)] } subscript (i: Int) -> String { return String(self[i]) } subscript (r: Range<Int>) -> String { let start = startIndex.advancedBy(r.startIndex) let end = start.advancedBy(r.endIndex - r.startIndex) return self[Range(start ..< end)] } func isLetter() -> Bool { guard self.length == 1 else { return false } let letters = NSCharacterSet.letterCharacterSet() let range = self.rangeOfCharacterFromSet(letters) return range?.count > 0 } func isDigit() -> Bool { guard self.length == 1 else { return false } let digits = NSCharacterSet.decimalDigitCharacterSet() let range = self.rangeOfCharacterFromSet(digits) return range?.count > 0 } func isMathematicOperator() -> Bool { guard self.length == 1 else { return false } return "+-*/%^!".containsString(self) } func isBracket() -> Bool { guard self.length == 1 else { return false } return "()".containsString(self) } func replace(index: Int, _ newChar: Character) -> String { var chars = Array(self.characters) chars[index] = newChar let modifiedString = String(chars) return modifiedString } } extension Dictionary { func containsKey(key: Key) -> Bool { return self[key] != nil } } extension TCToken { func isOpeningBracket() -> Bool { return self.type == TCTokenType.Bracket && (self as! TCGenericToken<String>).value == "("; } func isClosingBracket() -> Bool { return self.type == TCTokenType.Bracket && (self as! TCGenericToken<String>).value == ")"; } }

e2578f84c5778e0079ecb6fe7bcf35a960696d99

// RUN: %target-run-simple-swift // REQUIRES: executable_test // An end-to-end test that we can differentiate property accesses, with custom // VJPs for the properties specified in various ways. import StdlibUnittest var E2EDifferentiablePropertyTests = TestSuite("E2EDifferentiableProperty") struct TangentSpace : VectorProtocol { let x, y: Float } extension TangentSpace : Differentiable { typealias TangentVector = TangentSpace } struct Space { /// `x` is a computed property with a custom vjp. var x: Float { @differentiable(vjp: vjpX) get { storedX } set { storedX = newValue } } func vjpX() -> (Float, (Float) -> TangentSpace) { return (x, { v in TangentSpace(x: v, y: 0) } ) } private var storedX: Float @differentiable var y: Float init(x: Float, y: Float) { self.storedX = x self.y = y } } extension Space : Differentiable { typealias TangentVector = TangentSpace mutating func move(along direction: TangentSpace) { x.move(along: direction.x) y.move(along: direction.y) } } E2EDifferentiablePropertyTests.test("computed property") { let actualGrad = gradient(at: Space(x: 0, y: 0)) { (point: Space) -> Float in return 2 * point.x } let expectedGrad = TangentSpace(x: 2, y: 0) expectEqual(expectedGrad, actualGrad) } E2EDifferentiablePropertyTests.test("stored property") { let actualGrad = gradient(at: Space(x: 0, y: 0)) { (point: Space) -> Float in return 3 * point.y } let expectedGrad = TangentSpace(x: 0, y: 3) expectEqual(expectedGrad, actualGrad) } struct GenericMemberWrapper<T : Differentiable> : Differentiable { // Stored property. @differentiable var x: T func vjpX() -> (T, (T.TangentVector) -> GenericMemberWrapper.TangentVector) { return (x, { TangentVector(x: $0) }) } } E2EDifferentiablePropertyTests.test("generic stored property") { let actualGrad = gradient(at: GenericMemberWrapper<Float>(x: 1)) { point in return 2 * point.x } let expectedGrad = GenericMemberWrapper<Float>.TangentVector(x: 2) expectEqual(expectedGrad, actualGrad) } struct ProductSpaceSelfTangent : VectorProtocol { let x, y: Float } extension ProductSpaceSelfTangent : Differentiable { typealias TangentVector = ProductSpaceSelfTangent } E2EDifferentiablePropertyTests.test("fieldwise product space, self tangent") { let actualGrad = gradient(at: ProductSpaceSelfTangent(x: 0, y: 0)) { (point: ProductSpaceSelfTangent) -> Float in return 5 * point.y } let expectedGrad = ProductSpaceSelfTangent(x: 0, y: 5) expectEqual(expectedGrad, actualGrad) } struct ProductSpaceOtherTangentTangentSpace : VectorProtocol { let x, y: Float } extension ProductSpaceOtherTangentTangentSpace : Differentiable { typealias TangentVector = ProductSpaceOtherTangentTangentSpace } struct ProductSpaceOtherTangent { var x, y: Float } extension ProductSpaceOtherTangent : Differentiable { typealias TangentVector = ProductSpaceOtherTangentTangentSpace mutating func move(along direction: ProductSpaceOtherTangentTangentSpace) { x.move(along: direction.x) y.move(along: direction.y) } } E2EDifferentiablePropertyTests.test("fieldwise product space, other tangent") { let actualGrad = gradient(at: ProductSpaceOtherTangent(x: 0, y: 0)) { (point: ProductSpaceOtherTangent) -> Float in return 7 * point.y } let expectedGrad = ProductSpaceOtherTangentTangentSpace(x: 0, y: 7) expectEqual(expectedGrad, actualGrad) } E2EDifferentiablePropertyTests.test("computed property") { struct TF_544 : Differentiable { var value: Float @differentiable var computed: Float { get { value } set { value = newValue } } } let actualGrad = gradient(at: TF_544(value: 2.4)) { x in return x.computed * x.computed } let expectedGrad = TF_544.TangentVector(value: 4.8) expectEqual(expectedGrad, actualGrad) } runAllTests()

269b4ef374f6f0ccf7e8777fed98eef9cd9ee1dc

// Automatically generated by xdrgen // DO NOT EDIT or your changes may be overwritten import Foundation // === xdr source ============================================================ // enum ManageContractRequestResultCode // { // // codes considered as "success" for the operation // SUCCESS = 0, // // // codes considered as "failure" for the operation // MALFORMED = -1, // NOT_FOUND = -2, // not found contract request, when try to remove // TOO_MANY_CONTRACTS = -3, // NOT_ALLOWED_TO_REMOVE = -4, // only contract creator can remove contract // DETAILS_TOO_LONG = -5, // CONTRACT_CREATE_TASKS_NOT_FOUND = -6 // key-value not set // }; // =========================================================================== public enum ManageContractRequestResultCode: Int32, XDREnum { case success = 0 case malformed = -1 case notFound = -2 case tooManyContracts = -3 case notAllowedToRemove = -4 case detailsTooLong = -5 case contractCreateTasksNotFound = -6 }

ed2d29b29751650d3edf8bdbb6517c54b4f6450b

// // CoreGraphics+Z.swift // ZKit // // Created by Kaz Yoshikawa on 12/12/16. // Copyright © 2016 Electricwoods LLC. All rights reserved. // import Foundation import CoreGraphics import QuartzCore import simd infix operator • infix operator × extension CGRect { public init(size: CGSize) { self.init(origin: .zero, size: size) } public var cgPath: CGPath { return CGPath(rect: self, transform: nil) } public func cgPath(cornerRadius: CGFloat) -> CGPath { // +7-------------6+ // 0 5 // | | // 1 4 // +2-------------3+ let cornerRadius = min(size.width * 0.5, size.height * 0.5, cornerRadius) let path = CGMutablePath() path.move(to: minXmidY + CGPoint(x: 0, y: cornerRadius)) // (0) path.addLine(to: minXmaxY - CGPoint(x: 0, y: cornerRadius)) // (1) path.addQuadCurve(to: minXmaxY + CGPoint(x: cornerRadius, y: 0), control: minXmaxY) // (2) path.addLine(to: maxXmaxY - CGPoint(x: cornerRadius, y: 0)) // (3) path.addQuadCurve(to: maxXmaxY - CGPoint(x: 0, y: cornerRadius), control: maxXmaxY) // (4) path.addLine(to: maxXminY + CGPoint(x: 0, y: cornerRadius)) // (5) path.addQuadCurve(to: maxXminY - CGPoint(x: cornerRadius, y: 0), control: maxXminY) // (6) path.addLine(to: minXminY + CGPoint(x: cornerRadius, y: 0)) // (7) path.addQuadCurve(to: minXminY + CGPoint(x: 0, y: cornerRadius), control: minXminY) // (0) path.closeSubpath() return path } public var minXminY: CGPoint { return CGPoint(x: minX, y: minY) } public var midXminY: CGPoint { return CGPoint(x: midX, y: minY) } public var maxXminY: CGPoint { return CGPoint(x: maxX, y: minY) } public var minXmidY: CGPoint { return CGPoint(x: minX, y: midY) } public var midXmidY: CGPoint { return CGPoint(x: midX, y: midY) } public var maxXmidY: CGPoint { return CGPoint(x: maxX, y: midY) } public var minXmaxY: CGPoint { return CGPoint(x: minX, y: maxY) } public var midXmaxY: CGPoint { return CGPoint(x: midX, y: maxY) } public var maxXmaxY: CGPoint { return CGPoint(x: maxX, y: maxY) } public func aspectFill(_ size: CGSize) -> CGRect { let result: CGRect let margin: CGFloat let horizontalRatioToFit = size.width / size.width let verticalRatioToFit = size.height / size.height let imageHeightWhenItFitsHorizontally = horizontalRatioToFit * size.height let imageWidthWhenItFitsVertically = verticalRatioToFit * size.width if (imageHeightWhenItFitsHorizontally > size.height) { margin = (imageHeightWhenItFitsHorizontally - size.height) * 0.5 result = CGRect(x: minX, y: minY - margin, width: size.width * horizontalRatioToFit, height: size.height * horizontalRatioToFit) } else { margin = (imageWidthWhenItFitsVertically - size.width) * 0.5 result = CGRect(x: minX - margin, y: minY, width: size.width * verticalRatioToFit, height: size.height * verticalRatioToFit) } return result } public func aspectFit(_ size: CGSize) -> CGRect { let widthRatio = self.size.width / size.width let heightRatio = self.size.height / size.height let ratio = min(widthRatio, heightRatio) let width = size.width * ratio let height = size.height * ratio let xmargin = (self.size.width - width) / 2.0 let ymargin = (self.size.height - height) / 2.0 return CGRect(x: minX + xmargin, y: minY + ymargin, width: width, height: height) } public func transform(to rect: CGRect) -> CGAffineTransform { var t = CGAffineTransform.identity t = t.translatedBy(x: -self.minX, y: -self.minY) t = t.translatedBy(x: rect.minX, y: rect.minY) t = t.scaledBy(x: 1 / self.width, y: 1 / self.height) t = t.scaledBy(x: rect.width, y: rect.height) return t } static public func + (lhs: CGRect, rhs: CGPoint) -> CGRect { return CGRect(origin: lhs.origin + rhs, size: lhs.size) } static public func - (lhs: CGRect, rhs: CGPoint) -> CGRect { return CGRect(origin: lhs.origin - rhs, size: lhs.size) } static public func + (lhs: CGRect, rhs: CGSize) -> CGRect { return CGRect(origin: lhs.origin, size: lhs.size + rhs) } static public func - (lhs: CGRect, rhs: CGSize) -> CGRect { return CGRect(origin: lhs.origin, size: lhs.size - rhs) } } extension CGSize { public func aspectFit(_ size: CGSize) -> CGSize { let widthRatio = self.width / size.width let heightRatio = self.height / size.height let ratio = (widthRatio < heightRatio) ? widthRatio : heightRatio let width = size.width * ratio let height = size.height * ratio return CGSize(width: width, height: height) } static public func - (lhs: CGSize, rhs: CGSize) -> CGSize { return CGSize(width: lhs.width - rhs.width, height: lhs.height - rhs.height) } static public func + (lhs: CGSize, rhs: CGSize) -> CGSize { return CGSize(width: lhs.width + rhs.width, height: lhs.height + rhs.height) } static public func * (lhs: CGSize, rhs: CGFloat) -> CGSize { return CGSize(width: lhs.width * rhs, height: lhs.height * rhs) } static public func / (lhs: CGSize, rhs: CGFloat) -> CGSize { return CGSize(width: lhs.width / rhs, height: lhs.height / rhs) } static public func * (lhs: CGSize, rhs: CGSize) -> CGSize { return CGSize(width: lhs.width * rhs.width , height: lhs.height * rhs.height) } static public func / (lhs: CGSize, rhs: CGSize) -> CGSize { return CGSize(width: lhs.width / rhs.width , height: lhs.height / rhs.height) } } extension CGAffineTransform { static public func * (lhs: CGAffineTransform, rhs: CGAffineTransform) -> CGAffineTransform { return lhs.concatenating(rhs) } } extension float4x4 { public init(affineTransform: CGAffineTransform) { let t = CATransform3DMakeAffineTransform(affineTransform) self.init( SIMD4<Float>(Float(t.m11), Float(t.m12), Float(t.m13), Float(t.m14)), SIMD4<Float>(Float(t.m21), Float(t.m22), Float(t.m23), Float(t.m24)), SIMD4<Float>(Float(t.m31), Float(t.m32), Float(t.m33), Float(t.m34)), SIMD4<Float>(Float(t.m41), Float(t.m42), Float(t.m43), Float(t.m44))) } } // MARK: - public protocol FloatCovertible { var floatValue: Float { get } } extension CGFloat: FloatCovertible { public var floatValue: Float { return Float(self) } } extension Int: FloatCovertible { public var floatValue: Float { return Float(self) } } extension Float: FloatCovertible { public var floatValue: Float { return self } } // MARK: - public protocol CGFloatCovertible { var cgFloatValue: CGFloat { get } } extension CGFloat: CGFloatCovertible { public var cgFloatValue: CGFloat { return self } } extension Int: CGFloatCovertible { public var cgFloatValue: CGFloat { return CGFloat(self) } } extension Float: CGFloatCovertible { public var cgFloatValue: CGFloat { return CGFloat(self) } } // MARK: - extension CGPoint { static public func - (lhs: CGPoint, rhs: CGPoint) -> CGPoint { return CGPoint(x: lhs.x - rhs.x, y: lhs.y - rhs.y) } static public func + (lhs: CGPoint, rhs: CGPoint) -> CGPoint { return CGPoint(x: lhs.x + rhs.x, y: lhs.y + rhs.y) } static public func * (lhs: CGPoint, rhs: CGFloat) -> CGPoint { return CGPoint(x: lhs.x * rhs, y: lhs.y * rhs) } static public func / (lhs: CGPoint, rhs: CGFloat) -> CGPoint { return CGPoint(x: lhs.x / rhs, y: lhs.y / rhs) } static public func • (lhs: CGPoint, rhs: CGPoint) -> CGFloat { // dot product return lhs.x * rhs.x + lhs.y * rhs.y } static public func × (lhs: CGPoint, rhs: CGPoint) -> CGFloat { // cross product return lhs.x * rhs.y - lhs.y * rhs.x } public var length²: CGFloat { return (x * x) + (y * y) } public var length: CGFloat { return sqrt(self.length²) } public var normalized: CGPoint { return self / length } static public func length²(_ lhs: CGPoint, _ rhs: CGPoint) -> CGFloat { return pow(rhs.x - lhs.x, 2.0) + pow(rhs.y - lhs.y, 2.0) } static public func length(_ lhs: CGPoint, _ rhs: CGPoint) -> CGFloat { return sqrt(length²(lhs, rhs)) } } extension CGPoint { public init<X: CGFloatCovertible, Y: CGFloatCovertible>(_ x: X, _ y: Y) { self.init(x: x.cgFloatValue, y: y.cgFloatValue) } } extension CGSize { public init<W: CGFloatCovertible, H: CGFloatCovertible>(_ width: W, _ height: H) { self.init(width: width.cgFloatValue, height: height.cgFloatValue) } } extension CGRect { public init<X: CGFloatCovertible, Y: CGFloatCovertible, W: CGFloatCovertible, H: CGFloatCovertible>(_ x: X, _ y: Y, _ width: W, _ height: H) { self.init(origin: CGPoint(x, y), size: CGSize(width, height)) } }

0a4f73a9b5d59584390dfcd500615674b7d71094

// // SessionAgent.swift // NuguAgents // // Created by MinChul Lee on 2020/05/28. // Copyright (c) 2019 SK Telecom Co., Ltd. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // import Foundation import NuguCore public final class SessionAgent: SessionAgentProtocol { // CapabilityAgentable public var capabilityAgentProperty: CapabilityAgentProperty = CapabilityAgentProperty(category: .session, version: "1.0") // private private let directiveSequencer: DirectiveSequenceable private let contextManager: ContextManageable private let sessionManager: SessionManageable // Handleable Directive private lazy var handleableDirectiveInfos = [ DirectiveHandleInfo(namespace: capabilityAgentProperty.name, name: "Set", blockingPolicy: BlockingPolicy(medium: .none, isBlocking: false), directiveHandler: handleSet) ] public init( contextManager: ContextManageable, directiveSequencer: DirectiveSequenceable, sessionManager: SessionManageable ) { self.contextManager = contextManager self.directiveSequencer = directiveSequencer self.sessionManager = sessionManager contextManager.add(delegate: self) directiveSequencer.add(directiveHandleInfos: handleableDirectiveInfos.asDictionary) } deinit { directiveSequencer.remove(directiveHandleInfos: handleableDirectiveInfos.asDictionary) } } // MARK: - ContextInfoDelegate extension SessionAgent: ContextInfoDelegate { public func contextInfoRequestContext(completion: (ContextInfo?) -> Void) { let payload: [String: AnyHashable?] = [ "version": capabilityAgentProperty.version, "list": sessionManager.activeSessions.map { ["sessionId": $0.sessionId, "playServiceId": $0.playServiceId] } ] completion( ContextInfo(contextType: .capability, name: capabilityAgentProperty.name, payload: payload.compactMapValues { $0 }) ) } } // MARK: - Private(Directive) private extension SessionAgent { func handleSet() -> HandleDirective { return { [weak self] directive, completion in guard let item = try? JSONDecoder().decode(SessionAgentItem.self, from: directive.payload) else { completion(.failed("Invalid payload")) return } defer { completion(.finished) } let session = Session(sessionId: item.sessionId, dialogRequestId: directive.header.dialogRequestId, playServiceId: item.playServiceId) self?.sessionManager.set(session: session) } } }

67f2f4a27cfd9699ad7cff2f6c55f033890aaa91

// // ParameterAdjustmentView.swift // Core Image Explorer // // Created by Warren Moore on 1/10/15. // Copyright (c) 2015 objc.io. All rights reserved. // import UIKit let kSliderMarginX: CGFloat = 20 let kSliderMarginY: CGFloat = 8 let kSliderHeight: CGFloat = 48 protocol ParameterAdjustmentDelegate { func parameterValueDidChange(_ param: ScalarFilterParameter) } class ParameterAdjustmentView: UIView { var parameters: [ScalarFilterParameter]! var sliderViews = [LabeledSliderView]() func setAdjustmentDelegate(_ delegate: ParameterAdjustmentDelegate) { for sliderView in sliderViews { sliderView.delegate = delegate } } init(frame: CGRect, parameters: [ScalarFilterParameter]) { super.init(frame: frame) self.parameters = parameters addSubviews() } required init(coder aDecoder: NSCoder) { fatalError("init(coder:) has not been implemented") } func addSubviews() { var yOffset: CGFloat = kSliderMarginY for param in parameters { let frame = CGRect(x: 0, y: yOffset, width: UIScreen.main.bounds.width, height: kSliderHeight) let sliderView = LabeledSliderView(frame: frame, parameter: param) sliderView.translatesAutoresizingMaskIntoConstraints = false addSubview(sliderView) sliderViews.append(sliderView) addConstraint(NSLayoutConstraint(item: sliderView, attribute: .leading, relatedBy: .equal, toItem: self, attribute: .leading, multiplier: 1, constant: kSliderMarginX)) addConstraint(NSLayoutConstraint(item: sliderView, attribute: .top, relatedBy: .equal, toItem: self, attribute: .top, multiplier: 1, constant: yOffset)) addConstraint(NSLayoutConstraint(item: sliderView, attribute: .width, relatedBy: .equal, toItem: self, attribute: .width, multiplier: 1, constant: -kSliderMarginX * 2)) addConstraint(NSLayoutConstraint(item: sliderView, attribute: .height, relatedBy: .equal, toItem: self, attribute: .height, multiplier: 0, constant: kSliderHeight)) yOffset += (kSliderHeight + kSliderMarginY) } } }

b971c05b8c3624fa7673ff3e1797d4b69c97d18b

// // Created by Daniel Heredia on 2/27/18. // Copyright © 2018 Daniel Heredia. All rights reserved. // // The heavy pill import Foundation let bottlesNumber = 20 let secretHeavyBottle = 19 /// Get the total weight of a collection of pills /// of different bottles. For the purposes of this problem /// the code inside this method must be considered a blackbox. /// /// - Parameter bottlePills: Amounts of pills for every bottle, every item is the amount of pills from the bottle with that index /// - Returns: The total weight or nil if the number of brought items is different from `bottlesNumber` func weight(bottlePills: [Int]) -> Double? { if bottlePills.count != bottlesNumber { return nil } let lightWeight = 1.0 let heavyWeight = 1.1 var totalWeight = 0.0 for i in 0..<bottlePills.count { let pillsNumber = bottlePills[i] let pillWeight = i == secretHeavyBottle ? heavyWeight : lightWeight totalWeight += Double(pillsNumber) * pillWeight } // The small fraction is added because sometimes // float numbers result of an addition can't be // represented accurately. // Example // .2 + .1 = 0.30000000000000004 return totalWeight + 0.00000001 } /// Find the bottle with heaviest pills /// /// - Returns: The index of the bottle with heaviest pills func findHeavierBottle() -> Int { var bottlePills = [Int]() for i in 1...bottlesNumber { bottlePills.append(i) } let realWeight = weight(bottlePills: bottlePills)! let idealWeight = Double(bottlesNumber * (bottlesNumber + 1) / 2) let remainder = realWeight - idealWeight return Int(remainder * 10) - 1 } let heavierBottle = findHeavierBottle() print("Index of the bottle with heaviest pills: \(heavierBottle)")

46fb86dba1a7cf382f1928eacf883ceadfa42a43

// // ConstellationController.swift // App // // Created by 晋先森 on 2018/8/5. // import Foundation import Vapor import FluentPostgreSQL import SwiftSoup import Fluent class ConstellationController: RouteCollection { var startUrl = "https://www.meiguoshenpo.com/baiyang/" var type = "xingzuo" private var constells: [ConstellationContainer]? private var types: [ConstellationType]? func boot(router: Router) throws { router.group("sp") { (group) in group.get("xingzuo", use: getListHandler) } } } extension ConstellationController { //*[@id="PAGE_LEFT"] private func getListHandler(_ req: Request) throws -> Future<Response> { return try getHTMLResponse(req, url: startUrl).flatMap(to: Response.self, { (html) in let soup = try SwiftSoup.parse(html) // 白羊 金牛 双子 巨蟹 ... let allXingzuo = try soup.select("div[class='astro_box']").select("a") self.constells = try allXingzuo.map({ (xingzuo) in let link = try xingzuo.attr("href") let key = try xingzuo.attr("title") let abbr = try xingzuo.attr("class") let name = try xingzuo.text() return ConstellationContainer(name: name, link: link, key: key, abbr: abbr) }) // 白羊座 运势 百科 爱情 事业 性格 排行 故事 名人 let eleTypes = try soup.select("div[class='index_left']").select("li").select("a") self.types = try eleTypes.map { element -> ConstellationType in let link = try element.attr("href") let key = try element.attr("title") let name = try element.text() return ConstellationType(name: name, link: link, key: key) } struct Result: Content { var targetUrl: String var constells: [ConstellationContainer]? var types: [ConstellationType]? } let data = Result(targetUrl: self.startUrl,constells: self.constells, types: self.types) return try ResponseJSON<Result>(data: data).encode(for: req) }) } } fileprivate struct ConstellationContainer: Content { var name: String? var link: String? var key: String? var abbr: String? } fileprivate struct ConstellationType: Content { var name: String? var link: String? var key: String? }

62eb078d9cd2dacd11f50ba0d035b622f2cef60f

// // ProfileSummary.swift // SwiftUI-07(Profile) // // Created by pgq on 2020/3/17. // Copyright © 2020 pq. All rights reserved. // import SwiftUI struct ProfileSummary: View { var profile: Profile static let goalFormat: DateFormatter = { let formatter = DateFormatter() formatter.dateStyle = .long formatter.timeStyle = .none return formatter }() var body: some View { List { Text(profile.username) .bold() .font(.title) Text("Notifications: \(self.profile.prefersNotifications ? "On": "Off" )") Text("Seasonal Photos: \(self.profile.seasonalPhoto.rawValue)") Text("Goal Date: \(self.profile.goalDate, formatter: Self.goalFormat)") VStack(alignment: .leading) { Text("Completed Badges") .font(.headline) ScrollView { HStack { HikeBadge(name: "First Hike") HikeBadge(name: "First Hike") .hueRotation(Angle(degrees: 90)) HikeBadge(name: "First Hike") .hueRotation(Angle(degrees: 45)) } } .frame(height: 140) } VStack(alignment: .leading) { Text("Recnt Hikes") .font(.headline) HikeView(hike: hikeData[0]) } } } } struct ProfileSummary_Previews: PreviewProvider { static var previews: some View { ProfileSummary(profile: Profile.default) } }