repo_name
stringlengths 6
91
| path
stringlengths 8
968
| copies
stringclasses 210
values | size
stringlengths 2
7
| content
stringlengths 61
1.01M
| license
stringclasses 15
values | hash
stringlengths 32
32
| line_mean
float64 6
99.8
| line_max
int64 12
1k
| alpha_frac
float64 0.3
0.91
| ratio
float64 2
9.89
| autogenerated
bool 1
class | config_or_test
bool 2
classes | has_no_keywords
bool 2
classes | has_few_assignments
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ziligy/SnapLocation | SnapLocation/BlurredBackgroundView.swift | 1 | 1339 | //
// BlurredBackgroundView.swift
//
// Created by Jeff on 12/4/15.
// Copyright © 2015 Jeff Greenberg. All rights reserved.
//
import UIKit
/// UIView that's a blurred image for background display
public class BlurredBackgroundView: UIView {
private var imageView: UIImageView!
private var effectView: UIVisualEffectView!
public func getBlurEffect() -> UIBlurEffect {
return (self.effectView.effect as! UIBlurEffect)
}
convenience init(frame: CGRect, img: UIImage) {
self.init(frame: frame)
self.setImageWithBlurEffect(img)
}
override init(frame: CGRect) {
super.init(frame: frame)
}
public convenience required init?(coder aDecoder: NSCoder) {
self.init(frame: CGRectZero)
}
/// create blurred background based on image
/// adds image & effect as subviews
private func setImageWithBlurEffect(img: UIImage) {
let blurEffect = UIBlurEffect(style: UIBlurEffectStyle.Dark)
effectView = UIVisualEffectView(effect: blurEffect)
imageView = UIImageView(image: img)
addSubview(imageView)
addSubview(effectView)
}
public override func layoutSubviews() {
super.layoutSubviews()
imageView.frame = bounds
effectView.frame = bounds
}
}
| mit | 2f85cb9b8961bf5d053180182598bb48 | 25.76 | 68 | 0.656951 | 4.830325 | false | false | false | false |
overtake/TelegramSwift | packages/TGUIKit/Sources/GridNode.swift | 1 | 61950 | import Cocoa
import AVFoundation
public struct GridNodeInsertItem {
public let index: Int
public let item: GridItem
public let previousIndex: Int?
public init(index: Int, item: GridItem, previousIndex: Int?) {
self.index = index
self.item = item
self.previousIndex = previousIndex
}
}
public struct GridNodeUpdateItem {
public let index: Int
public let previousIndex: Int
public let item: GridItem
public init(index: Int, previousIndex: Int, item: GridItem) {
self.index = index
self.previousIndex = previousIndex
self.item = item
}
}
public enum GridNodeScrollToItemPosition {
case top
case bottom
case center
}
public struct GridNodeScrollToItem {
public let index: Int
public let position: GridNodeScrollToItemPosition
public let transition: ContainedViewLayoutTransition
public let directionHint: GridNodePreviousItemsTransitionDirectionHint
public let adjustForSection: Bool
public let adjustForTopInset: Bool
public init(index: Int, position: GridNodeScrollToItemPosition, transition: ContainedViewLayoutTransition, directionHint: GridNodePreviousItemsTransitionDirectionHint, adjustForSection: Bool, adjustForTopInset: Bool = false) {
self.index = index
self.position = position
self.transition = transition
self.directionHint = directionHint
self.adjustForSection = adjustForSection
self.adjustForTopInset = adjustForTopInset
}
}
public enum GridNodeLayoutType: Equatable {
case fixed(itemSize: CGSize, lineSpacing: CGFloat)
case balanced(idealHeight: CGFloat)
public static func ==(lhs: GridNodeLayoutType, rhs: GridNodeLayoutType) -> Bool {
switch lhs {
case let .fixed(itemSize, lineSpacing):
if case .fixed(itemSize, lineSpacing) = rhs {
return true
} else {
return false
}
case let .balanced(idealHeight):
if case .balanced(idealHeight) = rhs {
return true
} else {
return false
}
}
}
}
public struct GridNodeLayout: Equatable {
public let size: CGSize
public let insets: NSEdgeInsets
public let scrollIndicatorInsets: NSEdgeInsets?
public let preloadSize: CGFloat
public let type: GridNodeLayoutType
public init(size: CGSize, insets: NSEdgeInsets, scrollIndicatorInsets: NSEdgeInsets? = nil, preloadSize: CGFloat, type: GridNodeLayoutType) {
self.size = size
self.insets = insets
self.scrollIndicatorInsets = scrollIndicatorInsets
self.preloadSize = preloadSize
self.type = type
}
public static func ==(lhs: GridNodeLayout, rhs: GridNodeLayout) -> Bool {
return lhs.size.equalTo(rhs.size) && NSEdgeInsetsEqual(lhs.insets, rhs.insets) && lhs.preloadSize.isEqual(to: rhs.preloadSize) && lhs.type == rhs.type
}
}
public struct GridNodeUpdateLayout {
public let layout: GridNodeLayout
public let transition: ContainedViewLayoutTransition
public init(layout: GridNodeLayout, transition: ContainedViewLayoutTransition) {
self.layout = layout
self.transition = transition
}
}
/*private func binarySearch(_ inputArr: [GridNodePresentationItem], searchItem: CGFloat) -> Int? {
if inputArr.isEmpty {
return nil
}
var lowerPosition = inputArr[0].frame.origin.y + inputArr[0].frame.size.height
var upperPosition = inputArr[inputArr.count - 1].frame.origin.y
if lowerPosition > upperPosition {
return nil
}
while (true) {
let currentPosition = (lowerIndex + upperIndex) / 2
if (inputArr[currentIndex] == searchItem) {
return currentIndex
} else if (lowerIndex > upperIndex) {
return nil
} else {
if (inputArr[currentIndex] > searchItem) {
upperIndex = currentIndex - 1
} else {
lowerIndex = currentIndex + 1
}
}
}
}*/
public enum GridNodeStationaryItems {
case none
case all
case indices(Set<Int>)
}
public struct GridNodeTransaction {
public let deleteItems: [Int]
public let insertItems: [GridNodeInsertItem]
public let updateItems: [GridNodeUpdateItem]
public let scrollToItem: GridNodeScrollToItem?
public let updateLayout: GridNodeUpdateLayout?
public let itemTransition: ContainedViewLayoutTransition
public let stationaryItems: GridNodeStationaryItems
public let updateFirstIndexInSectionOffset: Int?
public init(deleteItems: [Int], insertItems: [GridNodeInsertItem], updateItems: [GridNodeUpdateItem], scrollToItem: GridNodeScrollToItem?, updateLayout: GridNodeUpdateLayout?, itemTransition: ContainedViewLayoutTransition, stationaryItems: GridNodeStationaryItems, updateFirstIndexInSectionOffset: Int?) {
self.deleteItems = deleteItems
self.insertItems = insertItems
self.updateItems = updateItems
self.scrollToItem = scrollToItem
self.updateLayout = updateLayout
self.itemTransition = itemTransition
self.stationaryItems = stationaryItems
self.updateFirstIndexInSectionOffset = updateFirstIndexInSectionOffset
}
}
private struct GridNodePresentationItem {
let index: Int
let frame: CGRect
}
private struct GridNodePresentationSection {
let section: GridSection
let frame: CGRect
}
private struct GridNodePresentationLayout {
let layout: GridNodeLayout
let contentOffset: CGPoint
let contentSize: CGSize
let items: [GridNodePresentationItem]
let sections: [GridNodePresentationSection]
}
public enum GridNodePreviousItemsTransitionDirectionHint {
case up
case down
}
private struct GridNodePresentationLayoutTransition {
let layout: GridNodePresentationLayout
let directionHint: GridNodePreviousItemsTransitionDirectionHint
let transition: ContainedViewLayoutTransition
}
public struct GridNodeCurrentPresentationLayout {
public let layout: GridNodeLayout
public let contentOffset: CGPoint
public let contentSize: CGSize
}
private final class GridNodeItemLayout {
let contentSize: CGSize
let items: [GridNodePresentationItem]
let sections: [GridNodePresentationSection]
init(contentSize: CGSize, items: [GridNodePresentationItem], sections: [GridNodePresentationSection]) {
self.contentSize = contentSize
self.items = items
self.sections = sections
}
}
public struct GridNodeDisplayedItemRange: Equatable {
public let loadedRange: Range<Int>?
public let visibleRange: Range<Int>?
public static func ==(lhs: GridNodeDisplayedItemRange, rhs: GridNodeDisplayedItemRange) -> Bool {
return lhs.loadedRange == rhs.loadedRange && lhs.visibleRange == rhs.visibleRange
}
}
private struct WrappedGridSection: Hashable {
let section: GridSection
init(_ section: GridSection) {
self.section = section
}
var hashValue: Int {
return self.section.hashValue
}
static func ==(lhs: WrappedGridSection, rhs: WrappedGridSection) -> Bool {
return lhs.section.isEqual(to: rhs.section)
}
}
public struct GridNodeVisibleItems {
public let top: (Int, GridItem)?
public let bottom: (Int, GridItem)?
public let topVisible: (Int, GridItem)?
public let bottomVisible: (Int, GridItem)?
public let topSectionVisible: GridSection?
public let count: Int
}
private struct WrappedGridItemNode: Hashable {
let node: View
var hashValue: Int {
return node.hashValue
}
static func ==(lhs: WrappedGridItemNode, rhs: WrappedGridItemNode) -> Bool {
return lhs.node === rhs.node
}
}
open class GridNode: ScrollView, InteractionContentViewProtocol, AppearanceViewProtocol {
private var gridLayout = GridNodeLayout(size: CGSize(), insets: NSEdgeInsets(), preloadSize: 0.0, type: .fixed(itemSize: CGSize(), lineSpacing: 0.0))
private var firstIndexInSectionOffset: Int = 0
private var items: [GridItem] = []
private var itemNodes: [Int: GridItemNode] = [:]
private var sectionNodes: [WrappedGridSection: View] = [:]
private var itemLayout = GridNodeItemLayout(contentSize: CGSize(), items: [], sections: [])
private var cachedNodes:[GridItemNode] = []
private var applyingContentOffset = false
public var visibleItemsUpdated: ((GridNodeVisibleItems) -> Void)?
public var presentationLayoutUpdated: ((GridNodeCurrentPresentationLayout, ContainedViewLayoutTransition) -> Void)?
public final var floatingSections = false
private let document: View
public override init(frame frameRect: NSRect) {
document = View(frame: NSMakeRect(0, 0, frameRect.width, frameRect.height))
super.init(frame: frameRect)
document.backgroundColor = .clear
deltaCorner = 45
self.autoresizesSubviews = true;
// self.autoresizingMask = [NSAutoresizingMaskOptions.width, NSAutoresizingMaskOptions.height]
self.hasVerticalScroller = true
self.documentView = document
}
required public init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
public func updateLocalizationAndTheme(theme: PresentationTheme) {
guard let documentView = documentView else {return}
layer?.backgroundColor = presentation.colors.background.cgColor
for view in documentView.subviews {
if let view = view as? AppearanceViewProtocol {
view.updateLocalizationAndTheme(theme: theme)
}
}
}
public func transaction(_ transaction: GridNodeTransaction, completion: (GridNodeDisplayedItemRange) -> Void) {
if transaction.deleteItems.isEmpty && transaction.insertItems.isEmpty && transaction.scrollToItem == nil && transaction.updateItems.isEmpty && (transaction.updateLayout == nil || transaction.updateLayout!.layout == self.gridLayout && (transaction.updateFirstIndexInSectionOffset == nil || transaction.updateFirstIndexInSectionOffset == self.firstIndexInSectionOffset)) {
if let presentationLayoutUpdated = self.presentationLayoutUpdated {
presentationLayoutUpdated(GridNodeCurrentPresentationLayout(layout: self.gridLayout, contentOffset: documentOffset, contentSize: self.itemLayout.contentSize), .immediate)
}
completion(self.displayedItemRange())
return
}
if let updateFirstIndexInSectionOffset = transaction.updateFirstIndexInSectionOffset {
self.firstIndexInSectionOffset = updateFirstIndexInSectionOffset
}
var layoutTransactionOffset: CGFloat = 0.0
if let updateLayout = transaction.updateLayout {
layoutTransactionOffset += updateLayout.layout.insets.top - self.gridLayout.insets.top
self.gridLayout = updateLayout.layout
}
for updatedItem in transaction.updateItems {
self.items[updatedItem.previousIndex] = updatedItem.item
if let itemNode = self.itemNodes[updatedItem.previousIndex] {
updatedItem.item.update(node: itemNode)
}
}
var removedNodes: [GridItemNode] = []
if !transaction.deleteItems.isEmpty || !transaction.insertItems.isEmpty {
let deleteItems = transaction.deleteItems.sorted()
for deleteItemIndex in deleteItems.reversed() {
self.items.remove(at: deleteItemIndex)
if let itemNode = self.itemNodes[deleteItemIndex] {
removedNodes.append(itemNode)
self.removeItemNodeWithIndex(deleteItemIndex, removeNode: false)
} else {
self.removeItemNodeWithIndex(deleteItemIndex, removeNode: true)
}
}
var remappedDeletionItemNodes: [Int: GridItemNode] = [:]
for (index, itemNode) in self.itemNodes {
var indexOffset = 0
for deleteIndex in deleteItems {
if deleteIndex < index {
indexOffset += 1
} else {
break
}
}
remappedDeletionItemNodes[index - indexOffset] = itemNode
}
let insertItems = transaction.insertItems.sorted(by: { $0.index < $1.index })
if self.items.count == 0 && !insertItems.isEmpty {
if insertItems[0].index != 0 {
fatalError("transaction: invalid insert into empty list")
}
}
for insertedItem in insertItems {
self.items.insert(insertedItem.item, at: insertedItem.index)
}
let sortedInsertItems = transaction.insertItems.sorted(by: { $0.index < $1.index })
var remappedInsertionItemNodes: [Int: GridItemNode] = [:]
for (index, itemNode) in remappedDeletionItemNodes {
var indexOffset = 0
for insertedItem in sortedInsertItems {
if insertedItem.index <= index + indexOffset {
indexOffset += 1
}
}
remappedInsertionItemNodes[index + indexOffset] = itemNode
}
self.itemNodes = remappedInsertionItemNodes
}
let previousLayoutWasEmpty = self.itemLayout.items.isEmpty
self.itemLayout = self.generateItemLayout()
let generatedScrollToItem: GridNodeScrollToItem?
if let scrollToItem = transaction.scrollToItem {
generatedScrollToItem = scrollToItem
} else if previousLayoutWasEmpty {
generatedScrollToItem = GridNodeScrollToItem(index: 0, position: .top, transition: .immediate, directionHint: .up, adjustForSection: true, adjustForTopInset: true)
} else {
generatedScrollToItem = nil
}
self.applyPresentaionLayoutTransition(self.generatePresentationLayoutTransition(stationaryItems: transaction.stationaryItems, layoutTransactionOffset: layoutTransactionOffset, scrollToItem: generatedScrollToItem), removedNodes: removedNodes, updateLayoutTransition: transaction.updateLayout?.transition, itemTransition: transaction.itemTransition, completion: completion)
}
var rows: Int {
return items.count / inRowCount
}
var inRowCount: Int {
var count: Int = 0
if let range = displayedItemRange().visibleRange {
let y: CGFloat? = itemNodes[range.lowerBound]?.frame.minY
for item in itemNodes {
if item.value.frame.minY == y {
count += 1
}
}
} else {
return 1
}
return count
}
private var previousScroll:ScrollPosition?
public var scrollHandler:(_ scrollPosition:ScrollPosition) ->Void = {_ in} {
didSet {
previousScroll = nil
}
}
open override func viewDidMoveToSuperview() {
if superview != nil {
NotificationCenter.default.addObserver(forName: NSView.boundsDidChangeNotification, object: self.contentView, queue: nil, using: { [weak self] notification in
if let strongSelf = self {
if !strongSelf.applyingContentOffset {
strongSelf.applyPresentaionLayoutTransition(strongSelf.generatePresentationLayoutTransition(layoutTransactionOffset: 0.0), removedNodes: [], updateLayoutTransition: nil, itemTransition: .immediate, completion: { _ in })
}
let reqCount = 1
if let range = strongSelf.displayedItemRange().visibleRange {
let range = NSMakeRange(range.lowerBound / strongSelf.inRowCount, range.upperBound / strongSelf.inRowCount - range.lowerBound / strongSelf.inRowCount)
let scroll = strongSelf.scrollPosition()
if (!strongSelf.clipView.isAnimateScrolling) {
if(scroll.current.rect != strongSelf.previousScroll?.rect) {
switch(scroll.current.direction) {
case .top:
if(range.location <= reqCount) {
strongSelf.scrollHandler(scroll.current)
strongSelf.previousScroll = scroll.current
}
case .bottom:
if(strongSelf.rows - (range.location + range.length) <= reqCount) {
strongSelf.scrollHandler(scroll.current)
strongSelf.previousScroll = scroll.current
}
case .none:
strongSelf.scrollHandler(scroll.current)
strongSelf.previousScroll = scroll.current
}
}
}
}
strongSelf.reflectScrolledClipView(strongSelf.contentView)
}
})
} else {
NotificationCenter.default.removeObserver(self)
}
}
open override func setFrameSize(_ newSize: NSSize) {
super.setFrameSize(newSize)
}
private func displayedItemRange() -> GridNodeDisplayedItemRange {
var minIndex: Int?
var maxIndex: Int?
for index in self.itemNodes.keys {
if minIndex == nil || minIndex! > index {
minIndex = index
}
if maxIndex == nil || maxIndex! < index {
maxIndex = index
}
}
if let minIndex = minIndex, let maxIndex = maxIndex {
return GridNodeDisplayedItemRange(loadedRange: minIndex ..< maxIndex, visibleRange: minIndex ..< maxIndex)
} else {
return GridNodeDisplayedItemRange(loadedRange: nil, visibleRange: nil)
}
}
private func generateItemLayout() -> GridNodeItemLayout {
if CGFloat(0.0).isLess(than: gridLayout.size.width) && CGFloat(0.0).isLess(than: gridLayout.size.height) && !self.items.isEmpty {
var contentSize = CGSize(width: gridLayout.size.width, height: 0.0)
var items: [GridNodePresentationItem] = []
var sections: [GridNodePresentationSection] = []
switch gridLayout.type {
case let .fixed(itemSize, lineSpacing):
// let s = floorToScreenPixels(backingScaleFactor, gridLayout.size.width/floor(gridLayout.size.width/itemSize.width))
// let itemSize = NSMakeSize(s, s)
let itemsInRow = Int(gridLayout.size.width / itemSize.width)
let itemsInRowWidth = CGFloat(itemsInRow) * itemSize.width
let remainingWidth = max(0.0, gridLayout.size.width - itemsInRowWidth)
let itemSpacing = floorToScreenPixels(backingScaleFactor, remainingWidth / CGFloat(itemsInRow + 1))
var incrementedCurrentRow = false
var nextItemOrigin = CGPoint(x: itemSpacing, y: 0.0)
var index = 0
var previousSection: GridSection?
for item in self.items {
let section = item.section
var keepSection = true
if let previousSection = previousSection, let section = section {
keepSection = previousSection.isEqual(to: section)
} else if (previousSection != nil) != (section != nil) {
keepSection = false
}
if !keepSection {
if incrementedCurrentRow {
nextItemOrigin.x = itemSpacing
nextItemOrigin.y += itemSize.height + lineSpacing
incrementedCurrentRow = false
}
if let section = section {
sections.append(GridNodePresentationSection(section: section, frame: CGRect(origin: CGPoint(x: 0.0, y: nextItemOrigin.y), size: CGSize(width: gridLayout.size.width, height: section.height))))
nextItemOrigin.y += section.height
contentSize.height += section.height
}
}
previousSection = section
if !incrementedCurrentRow {
incrementedCurrentRow = true
contentSize.height += itemSize.height + lineSpacing
}
if index == 0 {
let itemsInRow = Int(gridLayout.size.width) / Int(itemSize.width)
let normalizedIndexOffset = self.firstIndexInSectionOffset % itemsInRow
nextItemOrigin.x += (itemSize.width + itemSpacing) * CGFloat(normalizedIndexOffset)
}
items.append(GridNodePresentationItem(index: index, frame: CGRect(origin: nextItemOrigin, size: itemSize)))
index += 1
nextItemOrigin.x += itemSize.width + itemSpacing
if nextItemOrigin.x + itemSize.width > gridLayout.size.width {
nextItemOrigin.x = itemSpacing
nextItemOrigin.y += itemSize.height + lineSpacing
incrementedCurrentRow = false
}
}
case let .balanced(idealHeight):
var weights: [Int] = []
for item in self.items {
weights.append(Int(item.aspectRatio * 100))
}
var totalItemSize: CGFloat = 0.0
for i in 0 ..< self.items.count {
totalItemSize += self.items[i].aspectRatio * idealHeight
}
let numberOfRows = max(Int(round(totalItemSize / gridLayout.size.width)), 1)
let partition = linearPartitionForWeights(weights, numberOfPartitions:numberOfRows)
var i = 0
var offset = CGPoint(x: 0.0, y: 0.0)
var previousItemSize: CGFloat = 0.0
var contentMaxValueInScrollDirection: CGFloat = 0.0
let maxWidth = gridLayout.size.width
let minimumInteritemSpacing: CGFloat = 1.0
let minimumLineSpacing: CGFloat = 1.0
let viewportWidth: CGFloat = gridLayout.size.width
let preferredRowSize = idealHeight
var rowIndex = -1
for row in partition {
rowIndex += 1
var summedRatios: CGFloat = 0.0
var j = i
var n = i + row.count
while j < n {
summedRatios += self.items[j].aspectRatio
j += 1
}
var rowSize = gridLayout.size.width - (CGFloat(row.count - 1) * minimumInteritemSpacing)
if rowIndex == partition.count - 1 {
if row.count < 2 {
rowSize = floor(viewportWidth / 3.0) - (CGFloat(row.count - 1) * minimumInteritemSpacing)
} else if row.count < 3 {
rowSize = floor(viewportWidth * 2.0 / 3.0) - (CGFloat(row.count - 1) * minimumInteritemSpacing)
}
}
j = i
n = i + row.count
while j < n {
let preferredAspectRatio = self.items[j].aspectRatio
let actualSize = CGSize(width: round(rowSize / summedRatios * (preferredAspectRatio)), height: preferredRowSize)
var frame = CGRect(x: offset.x, y: offset.y, width: actualSize.width, height: actualSize.height)
if frame.origin.x + frame.size.width >= maxWidth - 2.0 {
frame.size.width = max(1.0, maxWidth - frame.origin.x)
}
items.append(GridNodePresentationItem(index: j, frame: frame))
offset.x += actualSize.width + minimumInteritemSpacing
previousItemSize = actualSize.height
contentMaxValueInScrollDirection = frame.maxY
j += 1
}
if row.count > 0 {
offset = CGPoint(x: 0.0, y: offset.y + previousItemSize + minimumLineSpacing)
}
i += row.count
}
contentSize = CGSize(width: gridLayout.size.width, height: contentMaxValueInScrollDirection)
}
return GridNodeItemLayout(contentSize: contentSize, items: items, sections: sections)
} else {
return GridNodeItemLayout(contentSize: CGSize(), items: [], sections: [])
}
}
private func generatePresentationLayoutTransition(stationaryItems: GridNodeStationaryItems = .none, layoutTransactionOffset: CGFloat, scrollToItem: GridNodeScrollToItem? = nil) -> GridNodePresentationLayoutTransition {
if CGFloat(0.0).isLess(than: gridLayout.size.width) && CGFloat(0.0).isLess(than: gridLayout.size.height) && !self.itemLayout.items.isEmpty {
var transitionDirectionHint: GridNodePreviousItemsTransitionDirectionHint = .up
var transition: ContainedViewLayoutTransition = .immediate
let contentOffset: CGPoint
var updatedStationaryItems = stationaryItems
if scrollToItem != nil {
updatedStationaryItems = .none
}
switch updatedStationaryItems {
case .none:
if let scrollToItem = scrollToItem {
let itemFrame = self.itemLayout.items[scrollToItem.index]
var additionalOffset: CGFloat = 0.0
if scrollToItem.adjustForSection {
var adjustForSection: GridSection?
if scrollToItem.index == 0 {
if let itemSection = self.items[scrollToItem.index].section {
adjustForSection = itemSection
}
} else {
let itemSection = self.items[scrollToItem.index].section
let previousSection = self.items[scrollToItem.index - 1].section
if let itemSection = itemSection, let previousSection = previousSection {
if !itemSection.isEqual(to: previousSection) {
adjustForSection = itemSection
}
} else if let itemSection = itemSection {
adjustForSection = itemSection
}
}
if let adjustForSection = adjustForSection {
additionalOffset = -adjustForSection.height
}
if scrollToItem.adjustForTopInset {
additionalOffset += -gridLayout.insets.top
}
} else if scrollToItem.adjustForTopInset {
additionalOffset = -gridLayout.insets.top
}
let displayHeight = max(0.0, self.gridLayout.size.height - self.gridLayout.insets.top - self.gridLayout.insets.bottom)
var verticalOffset: CGFloat
switch scrollToItem.position {
case .top:
verticalOffset = itemFrame.frame.minY + additionalOffset
case .center:
verticalOffset = floor(itemFrame.frame.minY + itemFrame.frame.size.height / 2.0 - displayHeight / 2.0 - self.gridLayout.insets.top) + additionalOffset
case .bottom:
verticalOffset = itemFrame.frame.maxY - displayHeight + additionalOffset
}
if verticalOffset > self.itemLayout.contentSize.height + self.gridLayout.insets.bottom - self.gridLayout.size.height {
verticalOffset = self.itemLayout.contentSize.height + self.gridLayout.insets.bottom - self.gridLayout.size.height
}
if verticalOffset < -self.gridLayout.insets.top {
verticalOffset = -self.gridLayout.insets.top
}
transitionDirectionHint = scrollToItem.directionHint
transition = scrollToItem.transition
contentOffset = CGPoint(x: 0.0, y: verticalOffset)
} else {
if !layoutTransactionOffset.isZero {
var verticalOffset = self.contentOffset.y - layoutTransactionOffset
if verticalOffset > self.itemLayout.contentSize.height + self.gridLayout.insets.bottom - self.gridLayout.size.height {
verticalOffset = self.itemLayout.contentSize.height + self.gridLayout.insets.bottom - self.gridLayout.size.height
}
if verticalOffset < -self.gridLayout.insets.top {
verticalOffset = -self.gridLayout.insets.top
}
contentOffset = CGPoint(x: 0.0, y: verticalOffset)
} else {
contentOffset = self.contentOffset
}
}
case let .indices(stationaryItemIndices):
var selectedContentOffset: CGPoint?
for (index, itemNode) in self.itemNodes {
if stationaryItemIndices.contains(index) {
//let currentScreenOffset = itemNode.frame.origin.y - self.scrollView.contentOffset.y
selectedContentOffset = CGPoint(x: 0.0, y: self.itemLayout.items[index].frame.origin.y - itemNode.frame.origin.y + self.contentOffset.y)
break
}
}
if let selectedContentOffset = selectedContentOffset {
contentOffset = selectedContentOffset
} else {
contentOffset = documentOffset
}
case .all:
var selectedContentOffset: CGPoint?
for (index, itemNode) in self.itemNodes {
//let currentScreenOffset = itemNode.frame.origin.y - self.scrollView.contentOffset.y
selectedContentOffset = CGPoint(x: 0.0, y: self.itemLayout.items[index].frame.origin.y - itemNode.frame.origin.y + self.contentOffset.y)
break
}
if let selectedContentOffset = selectedContentOffset {
contentOffset = selectedContentOffset
} else {
contentOffset = documentOffset
}
}
let lowerDisplayBound = contentOffset.y - self.gridLayout.preloadSize
let upperDisplayBound = contentOffset.y + self.gridLayout.size.height + self.gridLayout.preloadSize
var presentationItems: [GridNodePresentationItem] = []
var validSections = Set<WrappedGridSection>()
for item in self.itemLayout.items {
if item.frame.origin.y < lowerDisplayBound {
continue
}
if item.frame.origin.y + item.frame.size.height > upperDisplayBound {
break
}
presentationItems.append(item)
if self.floatingSections {
if let section = self.items[item.index].section {
validSections.insert(WrappedGridSection(section))
}
}
}
var presentationSections: [GridNodePresentationSection] = []
for section in self.itemLayout.sections {
if section.frame.origin.y < lowerDisplayBound {
if !validSections.contains(WrappedGridSection(section.section)) {
continue
}
}
if section.frame.origin.y + section.frame.size.height > upperDisplayBound {
break
}
presentationSections.append(section)
}
return GridNodePresentationLayoutTransition(layout: GridNodePresentationLayout(layout: self.gridLayout, contentOffset: contentOffset, contentSize: self.itemLayout.contentSize, items: presentationItems, sections: presentationSections), directionHint: transitionDirectionHint, transition: transition)
} else {
return GridNodePresentationLayoutTransition(layout: GridNodePresentationLayout(layout: self.gridLayout, contentOffset: CGPoint(), contentSize: self.itemLayout.contentSize, items: [], sections: []), directionHint: .up, transition: .immediate)
}
}
private func lowestSectionNode() -> View? {
var lowestHeaderNode: View?
var lowestHeaderNodeIndex: Int?
for (_, headerNode) in self.sectionNodes {
if let index = self.subviews.index(of: headerNode) {
if lowestHeaderNodeIndex == nil || index < lowestHeaderNodeIndex! {
lowestHeaderNodeIndex = index
lowestHeaderNode = headerNode
}
}
}
return lowestHeaderNode
}
private func applyPresentaionLayoutTransition(_ presentationLayoutTransition: GridNodePresentationLayoutTransition, removedNodes: [GridItemNode], updateLayoutTransition: ContainedViewLayoutTransition?, itemTransition: ContainedViewLayoutTransition, completion: (GridNodeDisplayedItemRange) -> Void) {
var previousItemFrames: [WrappedGridItemNode: CGRect]?
var saveItemFrames = false
switch presentationLayoutTransition.transition {
case .animated:
saveItemFrames = true
case .immediate:
break
}
if case .animated = itemTransition {
saveItemFrames = true
}
if saveItemFrames {
var itemFrames: [WrappedGridItemNode: CGRect] = [:]
let contentOffset = self.contentOffset
for (_, itemNode) in self.itemNodes {
itemFrames[WrappedGridItemNode(node: itemNode)] = itemNode.frame.offsetBy(dx: 0.0, dy: -contentOffset.y)
}
for (_, sectionNode) in self.sectionNodes {
itemFrames[WrappedGridItemNode(node: sectionNode)] = sectionNode.frame.offsetBy(dx: 0.0, dy: -contentOffset.y)
}
for itemNode in removedNodes {
itemFrames[WrappedGridItemNode(node: itemNode)] = itemNode.frame.offsetBy(dx: 0.0, dy: -contentOffset.y)
}
previousItemFrames = itemFrames
}
applyingContentOffset = true
self.documentView?.setFrameSize(presentationLayoutTransition.layout.contentSize)
self.contentView.contentInsets = presentationLayoutTransition.layout.layout.insets
if !documentOffset.equalTo(presentationLayoutTransition.layout.contentOffset) || self.bounds.size != presentationLayoutTransition.layout.layout.size {
//self.scrollView.contentOffset = presentationLayoutTransition.layout.contentOffset
self.contentView.bounds = CGRect(origin: presentationLayoutTransition.layout.contentOffset, size: self.contentView.bounds.size)
}
reflectScrolledClipView(contentView)
applyingContentOffset = false
let lowestSectionNode: View? = self.lowestSectionNode()
var existingItemIndices = Set<Int>()
for item in presentationLayoutTransition.layout.items {
existingItemIndices.insert(item.index)
if let itemNode = self.itemNodes[item.index] {
if itemNode.frame != item.frame {
itemNode.frame = item.frame
}
} else {
let cachedNode = !cachedNodes.isEmpty ? cachedNodes.removeFirst() : nil
let itemNode = self.items[item.index].node(layout: presentationLayoutTransition.layout.layout, gridNode: self, cachedNode: cachedNode)
itemNode.frame = item.frame
self.addItemNode(index: item.index, itemNode: itemNode, lowestSectionNode: lowestSectionNode)
}
}
var existingSections = Set<WrappedGridSection>()
for i in 0 ..< presentationLayoutTransition.layout.sections.count {
let section = presentationLayoutTransition.layout.sections[i]
let wrappedSection = WrappedGridSection(section.section)
existingSections.insert(wrappedSection)
var sectionFrame = section.frame
if self.floatingSections {
var maxY = CGFloat.greatestFiniteMagnitude
if i != presentationLayoutTransition.layout.sections.count - 1 {
maxY = presentationLayoutTransition.layout.sections[i + 1].frame.minY - sectionFrame.height
}
sectionFrame.origin.y = max(sectionFrame.minY, min(maxY, presentationLayoutTransition.layout.contentOffset.y + presentationLayoutTransition.layout.layout.insets.top))
}
if let sectionNode = self.sectionNodes[wrappedSection] {
sectionNode.frame = sectionFrame
document.addSubview(sectionNode)
} else {
let sectionNode = section.section.node()
sectionNode.frame = sectionFrame
self.addSectionNode(section: wrappedSection, sectionNode: sectionNode)
}
}
if let previousItemFrames = previousItemFrames, case let .animated(duration, curve) = presentationLayoutTransition.transition {
let contentOffset = presentationLayoutTransition.layout.contentOffset
var offset: CGFloat?
for (index, itemNode) in self.itemNodes {
if let previousFrame = previousItemFrames[WrappedGridItemNode(node: itemNode)], existingItemIndices.contains(index) {
let currentFrame = itemNode.frame.offsetBy(dx: 0.0, dy: -presentationLayoutTransition.layout.contentOffset.y)
offset = previousFrame.origin.y - currentFrame.origin.y
break
}
}
if offset == nil {
var previousUpperBound: CGFloat?
var previousLowerBound: CGFloat?
for (_, frame) in previousItemFrames {
if previousUpperBound == nil || previousUpperBound! > frame.minY {
previousUpperBound = frame.minY
}
if previousLowerBound == nil || previousLowerBound! < frame.maxY {
previousLowerBound = frame.maxY
}
}
var updatedUpperBound: CGFloat?
var updatedLowerBound: CGFloat?
for item in presentationLayoutTransition.layout.items {
let frame = item.frame.offsetBy(dx: 0.0, dy: -contentOffset.y)
if updatedUpperBound == nil || updatedUpperBound! > frame.minY {
updatedUpperBound = frame.minY
}
if updatedLowerBound == nil || updatedLowerBound! < frame.maxY {
updatedLowerBound = frame.maxY
}
}
for section in presentationLayoutTransition.layout.sections {
let frame = section.frame.offsetBy(dx: 0.0, dy: -contentOffset.y)
if updatedUpperBound == nil || updatedUpperBound! > frame.minY {
updatedUpperBound = frame.minY
}
if updatedLowerBound == nil || updatedLowerBound! < frame.maxY {
updatedLowerBound = frame.maxY
}
}
if let updatedUpperBound = updatedUpperBound, let updatedLowerBound = updatedLowerBound {
switch presentationLayoutTransition.directionHint {
case .up:
offset = -(updatedLowerBound - (previousUpperBound ?? 0.0))
case .down:
offset = -(updatedUpperBound - (previousLowerBound ?? presentationLayoutTransition.layout.layout.size.height))
}
}
}
if let offset = offset {
let timingFunction: CAMediaTimingFunctionName = curve.timingFunction
for (index, itemNode) in self.itemNodes where existingItemIndices.contains(index) {
itemNode.layer!.animatePosition(from: CGPoint(x: 0.0, y: offset), to: CGPoint(), duration: duration, timingFunction: timingFunction, additive: true)
}
for (wrappedSection, sectionNode) in self.sectionNodes where existingSections.contains(wrappedSection) {
sectionNode.layer!.animatePosition(from: CGPoint(x: 0.0, y: offset), to: CGPoint(), duration: duration, timingFunction: timingFunction, additive: true)
}
for index in self.itemNodes.keys {
if !existingItemIndices.contains(index) {
let itemNode = self.itemNodes[index]!
if let previousFrame = previousItemFrames[WrappedGridItemNode(node: itemNode)] {
self.removeItemNodeWithIndex(index, removeNode: false)
let position = CGPoint(x: previousFrame.midX, y: previousFrame.midY)
itemNode.layer!.animatePosition(from: CGPoint(x: position.x, y: position.y + contentOffset.y), to: CGPoint(x: position.x, y: position.y + contentOffset.y - offset), duration: duration, timingFunction: timingFunction, removeOnCompletion: false, completion: { [weak itemNode] _ in
itemNode?.removeFromSuperview()
})
} else {
self.removeItemNodeWithIndex(index, removeNode: true)
}
}
}
for itemNode in removedNodes {
if let previousFrame = previousItemFrames[WrappedGridItemNode(node: itemNode)] {
let position = CGPoint(x: previousFrame.midX, y: previousFrame.midY)
itemNode.layer!.animatePosition(from: CGPoint(x: position.x, y: position.y + contentOffset.y), to: CGPoint(x: position.x, y: position.y + contentOffset.y - offset), duration: duration, timingFunction: timingFunction, removeOnCompletion: false, completion: { [weak itemNode] _ in
itemNode?.removeFromSuperview()
})
} else {
itemNode.removeFromSuperview()
}
}
for wrappedSection in self.sectionNodes.keys {
if !existingSections.contains(wrappedSection) {
let sectionNode = self.sectionNodes[wrappedSection]!
if let previousFrame = previousItemFrames[WrappedGridItemNode(node: sectionNode)] {
self.removeSectionNodeWithSection(wrappedSection, removeNode: false)
let position = CGPoint(x: previousFrame.midX, y: previousFrame.midY)
sectionNode.layer!.animatePosition(from: CGPoint(x: position.x, y: position.y + contentOffset.y), to: CGPoint(x: position.x, y: position.y + contentOffset.y - offset), duration: duration, timingFunction: timingFunction, removeOnCompletion: false, completion: { [weak sectionNode] _ in
sectionNode?.removeFromSuperview()
})
} else {
self.removeSectionNodeWithSection(wrappedSection, removeNode: true)
}
}
}
} else {
for index in self.itemNodes.keys {
if !existingItemIndices.contains(index) {
self.removeItemNodeWithIndex(index)
}
}
for wrappedSection in self.sectionNodes.keys {
if !existingSections.contains(wrappedSection) {
self.removeSectionNodeWithSection(wrappedSection)
}
}
for itemNode in removedNodes {
itemNode.removeFromSuperview()
}
}
} else if let previousItemFrames = previousItemFrames, case let .animated(duration, curve) = itemTransition {
let timingFunction: CAMediaTimingFunctionName = curve.timingFunction
for index in self.itemNodes.keys {
let itemNode = self.itemNodes[index]!
if !existingItemIndices.contains(index) {
if let _ = previousItemFrames[WrappedGridItemNode(node: itemNode)] {
self.removeItemNodeWithIndex(index, removeNode: false)
itemNode.layer!.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, timingFunction: CAMediaTimingFunctionName.easeIn, removeOnCompletion: false)
itemNode.layer!.animateScale(from: 1.0, to: 0.1, duration: 0.2, timingFunction: CAMediaTimingFunctionName.easeIn, removeOnCompletion: false, completion: { [weak itemNode] _ in
itemNode?.removeFromSuperview()
})
} else {
self.removeItemNodeWithIndex(index, removeNode: true)
}
} else if let previousFrame = previousItemFrames[WrappedGridItemNode(node: itemNode)] {
itemNode.layer!.animatePosition(from: CGPoint(x: previousFrame.midX, y: previousFrame.midY), to: itemNode.layer!.position, duration: duration, timingFunction: timingFunction)
} else {
itemNode.layer!.animateAlpha(from: 0.0, to: 1.0, duration: 0.12, timingFunction: CAMediaTimingFunctionName.easeIn)
itemNode.layer!.animateSpring(from: 0.1 as NSNumber, to: 1.0 as NSNumber, keyPath: "transform.scale", duration: 0.5)
}
}
for itemNode in removedNodes {
if let _ = previousItemFrames[WrappedGridItemNode(node: itemNode)] {
itemNode.layer!.animateAlpha(from: 1.0, to: 0.0, duration: 0.18, timingFunction: CAMediaTimingFunctionName.easeIn, removeOnCompletion: false)
itemNode.layer!.animateScale(from: 1.0, to: 0.1, duration: 0.18, timingFunction: CAMediaTimingFunctionName.easeIn, removeOnCompletion: false, completion: { [weak itemNode] _ in
itemNode?.removeFromSuperview()
})
} else {
itemNode.removeFromSuperview()
cachedNodes.append(itemNode)
}
}
for wrappedSection in self.sectionNodes.keys {
let sectionNode = self.sectionNodes[wrappedSection]!
if !existingSections.contains(wrappedSection) {
if let _ = previousItemFrames[WrappedGridItemNode(node: sectionNode)] {
self.removeSectionNodeWithSection(wrappedSection, removeNode: false)
sectionNode.layer!.animateAlpha(from: 1.0, to: 0.0, duration: duration, timingFunction: timingFunction, removeOnCompletion: false, completion: { [weak sectionNode] _ in
sectionNode?.removeFromSuperview()
})
} else {
self.removeSectionNodeWithSection(wrappedSection, removeNode: true)
}
} else if let previousFrame = previousItemFrames[WrappedGridItemNode(node: sectionNode)] {
sectionNode.layer!.animatePosition(from: CGPoint(x: previousFrame.midX, y: previousFrame.midY), to: sectionNode.layer!.position, duration: duration, timingFunction: timingFunction)
} else {
sectionNode.layer!.animateAlpha(from: 0.0, to: 1.0, duration: 0.2, timingFunction: CAMediaTimingFunctionName.easeIn)
}
}
} else {
for index in self.itemNodes.keys {
if !existingItemIndices.contains(index) {
self.removeItemNodeWithIndex(index)
}
}
for wrappedSection in self.sectionNodes.keys {
if !existingSections.contains(wrappedSection) {
self.removeSectionNodeWithSection(wrappedSection)
}
}
for itemNode in removedNodes {
itemNode.removeFromSuperview()
cachedNodes.append(itemNode)
}
}
completion(self.displayedItemRange())
self.updateItemNodeVisibilititesAndScrolling()
if let visibleItemsUpdated = self.visibleItemsUpdated {
if presentationLayoutTransition.layout.items.count != 0 {
let topIndex = presentationLayoutTransition.layout.items.first!.index
let bottomIndex = presentationLayoutTransition.layout.items.last!.index
var topVisible: (Int, GridItem) = (topIndex, self.items[topIndex])
let bottomVisible: (Int, GridItem) = (bottomIndex, self.items[bottomIndex])
let lowerDisplayBound = presentationLayoutTransition.layout.contentOffset.y
//let upperDisplayBound = presentationLayoutTransition.layout.contentOffset.y + self.gridLayout.size.height
for item in presentationLayoutTransition.layout.items {
if lowerDisplayBound.isLess(than: item.frame.maxY) {
topVisible = (item.index, self.items[item.index])
break
}
}
var topSectionVisible: GridSection?
for section in presentationLayoutTransition.layout.sections {
if lowerDisplayBound.isLess(than: section.frame.maxY) {
if self.itemLayout.items[topVisible.0].frame.minY > section.frame.minY {
topSectionVisible = section.section
}
break
}
}
visibleItemsUpdated(GridNodeVisibleItems(top: (topIndex, self.items[topIndex]), bottom: (bottomIndex, self.items[bottomIndex]), topVisible: topVisible, bottomVisible: bottomVisible, topSectionVisible: topSectionVisible, count: self.items.count))
} else {
visibleItemsUpdated(GridNodeVisibleItems(top: nil, bottom: nil, topVisible: nil, bottomVisible: nil, topSectionVisible: nil, count: self.items.count))
}
}
if let presentationLayoutUpdated = self.presentationLayoutUpdated {
presentationLayoutUpdated(GridNodeCurrentPresentationLayout(layout: presentationLayoutTransition.layout.layout, contentOffset: presentationLayoutTransition.layout.contentOffset, contentSize: presentationLayoutTransition.layout.contentSize), updateLayoutTransition ?? presentationLayoutTransition.transition)
}
}
private func addItemNode(index: Int, itemNode: GridItemNode, lowestSectionNode: View?) {
assert(self.itemNodes[index] == nil)
self.itemNodes[index] = itemNode
if itemNode.superview == nil {
if let lowestSectionNode = lowestSectionNode {
document.addSubview(itemNode, positioned: .below, relativeTo: lowestSectionNode)
} else {
document.addSubview(itemNode)
}
}
}
private func addSectionNode(section: WrappedGridSection, sectionNode: View) {
assert(self.sectionNodes[section] == nil)
self.sectionNodes[section] = sectionNode
if sectionNode.superview == nil {
document.addSubview(sectionNode)
}
}
private func removeItemNodeWithIndex(_ index: Int, removeNode: Bool = true) {
if let itemNode = self.itemNodes.removeValue(forKey: index) {
if removeNode {
itemNode.removeFromSuperview()
cachedNodes.append(itemNode)
}
}
}
private func removeSectionNodeWithSection(_ section: WrappedGridSection, removeNode: Bool = true) {
if let sectionNode = self.sectionNodes.removeValue(forKey: section) {
if removeNode {
sectionNode.removeFromSuperview()
}
}
}
public var itemsCount: Int {
return self.items.count
}
public var isEmpty: Bool {
return self.items.isEmpty
}
private func updateItemNodeVisibilititesAndScrolling() {
let visibleRect = self.contentView.bounds
let isScrolling = self.clipView.isScrolling
for (_, itemNode) in self.itemNodes {
let visible = itemNode.frame.intersects(visibleRect)
if itemNode.isVisibleInGrid != visible {
itemNode.isVisibleInGrid = visible
}
if itemNode.isGridScrolling != isScrolling {
itemNode.isGridScrolling = isScrolling
}
}
}
public func forEachItemNode(_ f: (View) -> Void) {
for (_, node) in self.itemNodes {
f(node)
}
}
public func contentInteractionView(for stableId: AnyHashable, animateIn: Bool) -> NSView? {
for (_, node) in itemNodes {
if node.stableId == stableId {
return node
}
}
return nil;
}
public func interactionControllerDidFinishAnimation(interactive: Bool, for stableId: AnyHashable) {
}
public func addAccesoryOnCopiedView(for stableId: AnyHashable, view: NSView) {
}
public func videoTimebase(for stableId: AnyHashable) -> CMTimebase? {
return nil
}
public func applyTimebase(for stableId: AnyHashable, timebase: CMTimebase?) {
}
public func forEachRow(_ f: ([View]) -> Void) {
var row: [View] = []
var previousMinY: CGFloat?
for index in self.itemNodes.keys.sorted() {
let itemNode = self.itemNodes[index]!
if let previousMinY = previousMinY, !previousMinY.isEqual(to: itemNode.frame.minY) {
if !row.isEmpty {
f(row)
row.removeAll()
}
}
previousMinY = itemNode.frame.minY
row.append(itemNode)
}
if !row.isEmpty {
f(row)
}
}
public func itemNodeAtPoint(_ point: CGPoint) -> View? {
for (_, node) in self.itemNodes {
if node.frame.contains(point) {
return node
}
}
return nil
}
open override func layout() {
super.layout()
gridLayout = GridNodeLayout(size: frame.size, insets: gridLayout.insets, scrollIndicatorInsets:gridLayout.scrollIndicatorInsets, preloadSize: gridLayout.preloadSize, type: gridLayout.type)
self.itemLayout = generateItemLayout()
applyPresentaionLayoutTransition(generatePresentationLayoutTransition(layoutTransactionOffset: 0), removedNodes: [], updateLayoutTransition: nil, itemTransition: .immediate, completion: {_ in})
}
public func removeAllItems() ->Void {
self.items.removeAll()
self.itemLayout = generateItemLayout()
applyPresentaionLayoutTransition(generatePresentationLayoutTransition(layoutTransactionOffset: 0.0), removedNodes: [], updateLayoutTransition: nil, itemTransition: .immediate, completion: { _ in })
}
}
private func NH_LP_TABLE_LOOKUP(_ table: inout [Int], _ i: Int, _ j: Int, _ rowsize: Int) -> Int {
return table[i * rowsize + j]
}
private func NH_LP_TABLE_LOOKUP_SET(_ table: inout [Int], _ i: Int, _ j: Int, _ rowsize: Int, _ value: Int) {
table[i * rowsize + j] = value
}
private func linearPartitionTable(_ weights: [Int], numberOfPartitions: Int) -> [Int] {
let n = weights.count
let k = numberOfPartitions
let tableSize = n * k;
var tmpTable = Array<Int>(repeatElement(0, count: tableSize))
let solutionSize = (n - 1) * (k - 1)
var solution = Array<Int>(repeatElement(0, count: solutionSize))
for i in 0 ..< n {
let offset = i != 0 ? NH_LP_TABLE_LOOKUP(&tmpTable, i - 1, 0, k) : 0
NH_LP_TABLE_LOOKUP_SET(&tmpTable, i, 0, k, Int(weights[i]) + offset)
}
for j in 0 ..< k {
NH_LP_TABLE_LOOKUP_SET(&tmpTable, 0, j, k, Int(weights[0]))
}
for i in 1 ..< n {
for j in 1 ..< k {
var currentMin = 0
var minX = Int.max
for x in 0 ..< i {
let c1 = NH_LP_TABLE_LOOKUP(&tmpTable, x, j - 1, k)
let c2 = NH_LP_TABLE_LOOKUP(&tmpTable, i, 0, k) - NH_LP_TABLE_LOOKUP(&tmpTable, x, 0, k)
let cost = max(c1, c2)
if x == 0 || cost < currentMin {
currentMin = cost;
minX = x
}
}
NH_LP_TABLE_LOOKUP_SET(&tmpTable, i, j, k, currentMin)
NH_LP_TABLE_LOOKUP_SET(&solution, i - 1, j - 1, k - 1, minX)
}
}
return solution
}
private func linearPartitionForWeights(_ weights: [Int], numberOfPartitions: Int) -> [[Int]] {
var n = weights.count
var k = numberOfPartitions
if k <= 0 {
return []
}
if k >= n {
var partition: [[Int]] = []
for weight in weights {
partition.append([weight])
}
return partition
}
if n == 1 {
return [weights]
}
var solution = linearPartitionTable(weights, numberOfPartitions: numberOfPartitions)
let solutionRowSize = numberOfPartitions - 1
k = k - 2;
n = n - 1;
var answer: [[Int]] = []
while k >= 0 {
if n < 1 {
answer.insert([], at: 0)
} else {
var currentAnswer: [Int] = []
var i = NH_LP_TABLE_LOOKUP(&solution, n - 1, k, solutionRowSize) + 1
let range = n + 1
while i < range {
currentAnswer.append(weights[i])
i += 1
}
answer.insert(currentAnswer, at: 0)
n = NH_LP_TABLE_LOOKUP(&solution, n - 1, k, solutionRowSize)
}
k = k - 1
}
var currentAnswer: [Int] = []
var i = 0
let range = n + 1
while i < range {
currentAnswer.append(weights[i])
i += 1
}
answer.insert(currentAnswer, at: 0)
return answer
}
| gpl-2.0 | 3809772ea8d7f5f5b64f9414394de971 | 43.50431 | 379 | 0.568039 | 5.893265 | false | false | false | false |
jxxcarlson/exploring_swift | IOSGraphicsApp/IOSGraphicsApp/ViewController.swift | 1 | 1560 | //
// ViewController.swift
// IOSGraphicsApp
//
// Created by James Carlson on 6/21/15.
// Copyright © 2015 James Carlson. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
let graphicsView = GraphicsView()
let backgroundLabel = UILabel()
let statusLabel = UILabel()
func setupLabels() {
// Background label
let backgroundFrame = CGRect(x:0, y:0, width: 380, height: 640)
backgroundLabel.frame = backgroundFrame
let g: CGFloat = 0.2
backgroundLabel.backgroundColor = UIColor(red: g, green: g, blue: g, alpha: 1.0)
self.view.addSubview(backgroundLabel)
// Status label
let labelFrame = CGRect(x: 20, y: 395, width: 335, height: 50)
statusLabel.frame = labelFrame
statusLabel.font = UIFont(name: "Courier", size: 18)
statusLabel.textColor = UIColor.whiteColor()
statusLabel.backgroundColor = UIColor.blackColor()
self.view.addSubview(statusLabel)
statusLabel.text = " Welcome!"
}
func setupGraphicsView() {
self.view.addSubview(graphicsView)
let graphicsFrame = CGRect(x: 20, y: 40, width: 330, height: 330)
graphicsView.frame = graphicsFrame
}
override func viewDidLoad() {
super.viewDidLoad()
setupLabels()
setupGraphicsView()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
}
}
| mit | fdfe5167587ee8f6f5aa7cc6613b8050 | 23.359375 | 88 | 0.603592 | 4.724242 | false | false | false | false |
PrateekVarshney/AppTour | AppTourDemo/ViewController.swift | 1 | 2208 | //
// ViewController.swift
// AppTourDemo
//
// Created by Prateek Varshney on 20/04/17.
// Copyright © 2017 PrateekVarshney. All rights reserved.
//
import UIKit
import AppTour
class ViewController: UIViewController, AppTourDelegate {
@IBOutlet var titleLabel : UILabel!
@IBOutlet var nextButton : UIButton!
let appTour : AppTour = AppTour()
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
appTour.delegate = self
appTour.tintAlpha = 0.65
appTour.actionButton.displaysActionButton = true
appTour.textLabel.displaysTextLabel = true
appTour.shouldBlurBackground = false
appTour.textLabel.font = UIFont.boldSystemFont(ofSize: 22.0)
appTour.actionButton.layer.cornerRadius = 5.0
appTour.actionButton.clipsToBounds = true
appTour.actionButton.font = UIFont.boldSystemFont(ofSize: 22.0)
}
override func viewDidAppear(_ animated: Bool) {
appTour.textLabel.textForLabel = "This text is to make a user aware that this is a label which shows some information about the image."
appTour.actionButton.actionButtonTitle = "GOT IT"
let firstAppTourView = appTour.showOnBoardingView(viewController: self, view: self.titleLabel, isViewInTable: false, tableObj: nil, indexPath: nil)
firstAppTourView.tag = 1
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
func onBoardingCleared(view: UIView?) {
print("Onboarding removed : \(String(describing: view?.tag))")
if view?.tag == 1
{
appTour.textLabel.textForLabel = "This text is to make a user aware that this is a button which performs some action."
appTour.actionButton.actionButtonTitle = "GOT IT"
let secondAppTourView = appTour.showOnBoardingView(viewController: self, view: self.nextButton, isViewInTable: false, tableObj: nil, indexPath: nil)
secondAppTourView.tag = 2
}
}
}
| mit | c7a7dcfc1ed2eda380a0d2c688ff65c2 | 34.596774 | 160 | 0.668328 | 4.756466 | false | false | false | false |
optimizely/objective-c-sdk | Pods/Mixpanel-swift/Mixpanel/WebSocket.swift | 2 | 34263 | //////////////////////////////////////////////////////////////////////////////////////////////////
//
// Websocket.swift
//
// Created by Dalton Cherry on 7/16/14.
// Copyright (c) 2014-2015 Dalton Cherry.
//
// 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 CoreFoundation
import Security
let WebsocketDidConnectNotification = "WebsocketDidConnectNotification"
let WebsocketDidDisconnectNotification = "WebsocketDidDisconnectNotification"
let WebsocketDisconnectionErrorKeyName = "WebsocketDisconnectionErrorKeyName"
protocol WebSocketDelegate: class {
func websocketDidConnect(_ socket: WebSocket)
func websocketDidDisconnect(_ socket: WebSocket, error: NSError?)
func websocketDidReceiveMessage(_ socket: WebSocket, text: String)
func websocketDidReceiveData(_ socket: WebSocket, data: Data)
}
protocol WebSocketPongDelegate: class {
func websocketDidReceivePong(_ socket: WebSocket)
}
class WebSocket: NSObject, StreamDelegate {
enum OpCode: UInt8 {
case continueFrame = 0x0
case textFrame = 0x1
case binaryFrame = 0x2
// 3-7 are reserved.
case connectionClose = 0x8
case ping = 0x9
case pong = 0xA
// B-F reserved.
}
enum CloseCode: UInt16 {
case normal = 1000
case goingAway = 1001
case protocolError = 1002
case protocolUnhandledType = 1003
// 1004 reserved.
case noStatusReceived = 1005
//1006 reserved.
case encoding = 1007
case policyViolated = 1008
case messageTooBig = 1009
}
static let ErrorDomain = "WebSocket"
enum InternalErrorCode: UInt16 {
// 0-999 WebSocket status codes not used
case outputStreamWriteError = 1
}
// Where the callback is executed. It defaults to the main UI thread queue.
var callbackQueue = DispatchQueue.main
var optionalProtocols: [String]?
// MARK: - Constants
let headerWSUpgradeName = "Upgrade"
let headerWSUpgradeValue = "websocket"
let headerWSHostName = "Host"
let headerWSConnectionName = "Connection"
let headerWSConnectionValue = "Upgrade"
let headerWSProtocolName = "Sec-WebSocket-Protocol"
let headerWSVersionName = "Sec-WebSocket-Version"
let headerWSVersionValue = "13"
let headerWSKeyName = "Sec-WebSocket-Key"
let headerOriginName = "Origin"
let headerWSAcceptName = "Sec-WebSocket-Accept"
let BUFFER_MAX = 4096
let FinMask: UInt8 = 0x80
let OpCodeMask: UInt8 = 0x0F
let RSVMask: UInt8 = 0x70
let MaskMask: UInt8 = 0x80
let PayloadLenMask: UInt8 = 0x7F
let MaxFrameSize: Int = 32
let httpSwitchProtocolCode = 101
let supportedSSLSchemes = ["wss", "https"]
class WSResponse {
var isFin = false
var code: OpCode = .continueFrame
var bytesLeft = 0
var frameCount = 0
var buffer: NSMutableData?
}
// MARK: - Delegates
/// Responds to callback about new messages coming in over the WebSocket
/// and also connection/disconnect messages.
weak var delegate: WebSocketDelegate?
/// Recives a callback for each pong message recived.
weak var pongDelegate: WebSocketPongDelegate?
// MARK: - Block based API.
var onConnect: (() -> Void)?
var onDisconnect: ((NSError?) -> Void)?
var onText: ((String) -> Void)?
var onData: ((Data) -> Void)?
var onPong: (() -> Void)?
var headers = [String: String]()
var voipEnabled = false
var selfSignedSSL = false
var security: SSLSecurity?
var enabledSSLCipherSuites: [SSLCipherSuite]?
var origin: String?
var timeout = 5
var isConnected: Bool {
return connected
}
var currentURL: URL { return url }
// MARK: - Private
private var url: URL
private var inputStream: InputStream?
private var outputStream: OutputStream?
private var connected = false
private var isConnecting = false
private var writeQueue = OperationQueue()
private var readStack = [WSResponse]()
private var inputQueue = [Data]()
private var fragBuffer: Data?
private var certValidated = false
private var didDisconnect = false
private var readyToWrite = false
private let mutex = NSLock()
private let notificationCenter = NotificationCenter.default
private var canDispatch: Bool {
mutex.lock()
let canWork = readyToWrite
mutex.unlock()
return canWork
}
/// The shared processing queue used for all WebSocket.
private static let sharedWorkQueue = DispatchQueue(label: "com.vluxe.starscream.websocket", attributes: [])
init(url: URL, protocols: [String]? = nil) {
self.url = url
self.origin = url.absoluteString
writeQueue.maxConcurrentOperationCount = 1
optionalProtocols = protocols
}
/// Connect to the WebSocket server on a background thread.
func connect() {
guard !isConnecting else { return }
didDisconnect = false
isConnecting = true
createHTTPRequest()
isConnecting = false
}
/**
Disconnect from the server. I send a Close control frame to the server, then expect the server to respond with a Close control frame
and close the socket from its end. I notify my delegate once the socket has been closed.
If you supply a non-nil `forceTimeout`, I wait at most that long (in seconds) for the server to close the socket.
After the timeout expires, I close the socket and notify my delegate.
If you supply a zero (or negative) `forceTimeout`,
I immediately close the socket (without sending a Close control frame) and notify my delegate.
- Parameter forceTimeout: Maximum time to wait for the server to close the socket.
*/
func disconnect(forceTimeout: TimeInterval? = nil) {
switch forceTimeout {
case .some(let seconds) where seconds > 0:
callbackQueue.asyncAfter(deadline: .now() + Double(Int64(seconds * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)) {
[weak self] in
self?.disconnectStream(nil)
}
fallthrough
case .none:
writeError(CloseCode.normal.rawValue)
default:
disconnectStream(nil)
break
}
}
func write(string: String, completion: (() -> ())? = nil) {
guard isConnected else { return }
dequeueWrite(string.data(using: String.Encoding.utf8)!, code: .textFrame, writeCompletion: completion)
}
func write(data: Data, completion: (() -> ())? = nil) {
guard isConnected else { return }
dequeueWrite(data, code: .binaryFrame, writeCompletion: completion)
}
func write(_ ping: Data, completion: (() -> ())? = nil) {
guard isConnected else { return }
dequeueWrite(ping, code: .ping, writeCompletion: completion)
}
private func createHTTPRequest() {
let urlRequest = CFHTTPMessageCreateRequest(kCFAllocatorDefault, "GET" as CFString,
url as CFURL, kCFHTTPVersion1_1).takeRetainedValue()
var port = url.port
if port == nil {
if supportedSSLSchemes.contains(url.scheme!) {
port = 443
} else {
port = 80
}
}
addHeader(urlRequest, key: headerWSUpgradeName, val: headerWSUpgradeValue)
addHeader(urlRequest, key: headerWSConnectionName, val: headerWSConnectionValue)
if let protocols = optionalProtocols {
addHeader(urlRequest, key: headerWSProtocolName, val: protocols.joined(separator: ","))
}
addHeader(urlRequest, key: headerWSVersionName, val: headerWSVersionValue)
addHeader(urlRequest, key: headerWSKeyName, val: generateWebSocketKey())
if let origin = origin {
addHeader(urlRequest, key: headerOriginName, val: origin)
}
addHeader(urlRequest, key: headerWSHostName, val: "\(url.host!):\(port!)")
for (key, value) in headers {
addHeader(urlRequest, key: key, val: value)
}
if let cfHTTPMessage = CFHTTPMessageCopySerializedMessage(urlRequest) {
let serializedRequest = cfHTTPMessage.takeRetainedValue()
initStreamsWithData(serializedRequest as Data, Int(port!))
}
}
private func addHeader(_ urlRequest: CFHTTPMessage, key: String, val: String) {
CFHTTPMessageSetHeaderFieldValue(urlRequest, key as CFString, val as CFString)
}
private func generateWebSocketKey() -> String {
var key = ""
let seed = 16
for _ in 0..<seed {
let uni = UnicodeScalar(UInt32(97 + arc4random_uniform(25)))
key += "\(Character(uni!))"
}
let data = key.data(using: String.Encoding.utf8)
let baseKey = data?.base64EncodedString(options: NSData.Base64EncodingOptions(rawValue: 0))
return baseKey!
}
private func initStreamsWithData(_ data: Data, _ port: Int) {
//higher level API we will cut over to at some point
//NSStream.getStreamsToHostWithName(url.host, port: url.port.integerValue, inputStream: &inputStream, outputStream: &outputStream)
var readStream: Unmanaged<CFReadStream>?
var writeStream: Unmanaged<CFWriteStream>?
let h = url.host! as NSString
CFStreamCreatePairWithSocketToHost(nil, h, UInt32(port), &readStream, &writeStream)
inputStream = readStream!.takeRetainedValue()
outputStream = writeStream!.takeRetainedValue()
guard let inStream = inputStream, let outStream = outputStream else { return }
inStream.delegate = self
outStream.delegate = self
if supportedSSLSchemes.contains(url.scheme!) {
inStream.setProperty(StreamSocketSecurityLevel.negotiatedSSL as AnyObject, forKey: Stream.PropertyKey.socketSecurityLevelKey)
outStream.setProperty(StreamSocketSecurityLevel.negotiatedSSL as AnyObject, forKey: Stream.PropertyKey.socketSecurityLevelKey)
} else {
certValidated = true //not a https session, so no need to check SSL pinning
}
if voipEnabled {
inStream.setProperty(StreamNetworkServiceTypeValue.voIP as AnyObject, forKey: Stream.PropertyKey.networkServiceType)
outStream.setProperty(StreamNetworkServiceTypeValue.voIP as AnyObject, forKey: Stream.PropertyKey.networkServiceType)
}
if selfSignedSSL {
let settings: [NSObject: NSObject] = [kCFStreamSSLValidatesCertificateChain: NSNumber(value: false),
kCFStreamSSLPeerName: kCFNull]
inStream.setProperty(settings, forKey: kCFStreamPropertySSLSettings as Stream.PropertyKey)
outStream.setProperty(settings, forKey: kCFStreamPropertySSLSettings as Stream.PropertyKey)
}
if let cipherSuites = self.enabledSSLCipherSuites {
if let sslContextIn = CFReadStreamCopyProperty(inputStream,
CFStreamPropertyKey(rawValue: kCFStreamPropertySSLContext)) as! SSLContext?,
let sslContextOut = CFWriteStreamCopyProperty(outputStream,
CFStreamPropertyKey(rawValue: kCFStreamPropertySSLContext)) as! SSLContext? {
let resIn = SSLSetEnabledCiphers(sslContextIn, cipherSuites, cipherSuites.count)
let resOut = SSLSetEnabledCiphers(sslContextOut, cipherSuites, cipherSuites.count)
if resIn != errSecSuccess {
let error = self.errorWithDetail("Error setting ingoing cypher suites", code: UInt16(resIn))
disconnectStream(error)
return
}
if resOut != errSecSuccess {
let error = self.errorWithDetail("Error setting outgoing cypher suites", code: UInt16(resOut))
disconnectStream(error)
return
}
}
}
CFReadStreamSetDispatchQueue(inStream, WebSocket.sharedWorkQueue)
CFWriteStreamSetDispatchQueue(outStream, WebSocket.sharedWorkQueue)
inStream.open()
outStream.open()
self.mutex.lock()
self.readyToWrite = true
self.mutex.unlock()
let bytes = UnsafeRawPointer((data as NSData).bytes).assumingMemoryBound(to: UInt8.self)
var out = timeout * 1000000 // wait 5 seconds before giving up
writeQueue.addOperation { [weak self] in
while !outStream.hasSpaceAvailable {
usleep(100) // wait until the socket is ready
out -= 100
if out < 0 {
self?.cleanupStream()
self?.doDisconnect(self?.errorWithDetail("write wait timed out", code: 2))
return
} else if outStream.streamError != nil {
return // disconnectStream will be called.
}
}
outStream.write(bytes, maxLength: data.count)
}
}
func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
if let sec = security, !certValidated && [.hasBytesAvailable, .hasSpaceAvailable].contains(eventCode) {
let trust = aStream.property(forKey: kCFStreamPropertySSLPeerTrust as Stream.PropertyKey) as AnyObject
let domain = aStream.property(forKey: kCFStreamSSLPeerName as Stream.PropertyKey) as? String
if sec.isValid(trust as! SecTrust, domain: domain) {
certValidated = true
} else {
let error = errorWithDetail("Invalid SSL certificate", code: 1)
disconnectStream(error)
return
}
}
if eventCode == .hasBytesAvailable {
if aStream == inputStream {
processInputStream()
}
} else if eventCode == .errorOccurred {
disconnectStream(aStream.streamError as NSError?)
} else if eventCode == .endEncountered {
disconnectStream(nil)
}
}
private func disconnectStream(_ error: NSError?) {
if error == nil {
writeQueue.waitUntilAllOperationsAreFinished()
} else {
writeQueue.cancelAllOperations()
}
cleanupStream()
doDisconnect(error)
}
private func cleanupStream() {
outputStream?.delegate = nil
inputStream?.delegate = nil
if let stream = inputStream {
CFReadStreamSetDispatchQueue(stream, nil)
stream.close()
}
if let stream = outputStream {
CFWriteStreamSetDispatchQueue(stream, nil)
stream.close()
}
outputStream = nil
inputStream = nil
}
private func processInputStream() {
let buf = NSMutableData(capacity: BUFFER_MAX)
let buffer = UnsafeMutableRawPointer(mutating: buf!.bytes).assumingMemoryBound(to: UInt8.self)
let length = inputStream!.read(buffer, maxLength: BUFFER_MAX)
guard length > 0 else { return }
var process = false
if inputQueue.isEmpty {
process = true
}
inputQueue.append(Data(bytes: buffer, count: length))
if process {
dequeueInput()
}
}
private func dequeueInput() {
while !inputQueue.isEmpty {
let data = inputQueue[0]
var work = data
if let fragBuffer = fragBuffer {
var combine = NSData(data: fragBuffer) as Data
combine.append(data)
work = combine
self.fragBuffer = nil
}
let buffer = UnsafeRawPointer((work as NSData).bytes).assumingMemoryBound(to: UInt8.self)
let length = work.count
if !connected {
processTCPHandshake(buffer, bufferLen: length)
} else {
processRawMessagesInBuffer(buffer, bufferLen: length)
}
inputQueue = inputQueue.filter { $0 != data }
}
}
private func processTCPHandshake(_ buffer: UnsafePointer<UInt8>, bufferLen: Int) {
let code = processHTTP(buffer, bufferLen: bufferLen)
switch code {
case 0:
connected = true
guard canDispatch else {return}
callbackQueue.async { [weak self] in
guard let s = self else { return }
s.onConnect?()
s.delegate?.websocketDidConnect(s)
s.notificationCenter.post(name: NSNotification.Name(WebsocketDidConnectNotification), object: self)
}
case -1:
fragBuffer = Data(bytes: buffer, count: bufferLen)
break // do nothing, we are going to collect more data
default:
doDisconnect(errorWithDetail("Invalid HTTP upgrade", code: UInt16(code)))
}
}
private func processHTTP(_ buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int {
let CRLFBytes = [UInt8(ascii: "\r"), UInt8(ascii: "\n"), UInt8(ascii: "\r"), UInt8(ascii: "\n")]
var k = 0
var totalSize = 0
for i in 0..<bufferLen {
if buffer[i] == CRLFBytes[k] {
k += 1
if k == 3 {
totalSize = i + 1
break
}
} else {
k = 0
}
}
if totalSize > 0 {
let code = validateResponse(buffer, bufferLen: totalSize)
if code != 0 {
return code
}
totalSize += 1 //skip the last \n
let restSize = bufferLen - totalSize
if restSize > 0 {
processRawMessagesInBuffer(buffer + totalSize, bufferLen: restSize)
}
return 0 //success
}
return -1 // Was unable to find the full TCP header.
}
private func validateResponse(_ buffer: UnsafePointer<UInt8>, bufferLen: Int) -> Int {
let response = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, false).takeRetainedValue()
CFHTTPMessageAppendBytes(response, buffer, bufferLen)
let code = CFHTTPMessageGetResponseStatusCode(response)
if code != httpSwitchProtocolCode {
return code
}
if let cfHeaders = CFHTTPMessageCopyAllHeaderFields(response) {
let headers = cfHeaders.takeRetainedValue() as NSDictionary
if let acceptKey = headers[headerWSAcceptName as NSString] as? NSString {
if acceptKey.length > 0 {
return 0
}
}
}
return -1
}
private static func readUint16(_ buffer: UnsafePointer<UInt8>, offset: Int) -> UInt16 {
return (UInt16(buffer[offset + 0]) << 8) | UInt16(buffer[offset + 1])
}
private static func readUint64(_ buffer: UnsafePointer<UInt8>, offset: Int) -> UInt64 {
var value = UInt64(0)
for i in 0...7 {
value = (value << 8) | UInt64(buffer[offset + i])
}
return value
}
private static func writeUint16(_ buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt16) {
buffer[offset + 0] = UInt8(value >> 8)
buffer[offset + 1] = UInt8(value & 0xff)
}
private static func writeUint64(_ buffer: UnsafeMutablePointer<UInt8>, offset: Int, value: UInt64) {
for i in 0...7 {
buffer[offset + i] = UInt8((value >> (8*UInt64(7 - i))) & 0xff)
}
}
private func processOneRawMessage(inBuffer buffer: UnsafeBufferPointer<UInt8>) -> UnsafeBufferPointer<UInt8> {
let response = readStack.last
guard let baseAddress = buffer.baseAddress else {return emptyBuffer}
let bufferLen = buffer.count
if response != nil && bufferLen < 2 {
fragBuffer = Data(buffer: buffer)
return emptyBuffer
}
if let response = response, response.bytesLeft > 0 {
var len = response.bytesLeft
var extra = bufferLen - response.bytesLeft
if response.bytesLeft > bufferLen {
len = bufferLen
extra = 0
}
response.bytesLeft -= len
response.buffer?.append(Data(bytes: baseAddress, count: len))
_ = processResponse(response)
return buffer.fromOffset(bufferLen - extra)
} else {
let isFin = (FinMask & baseAddress[0])
let receivedOpcode = OpCode(rawValue: (OpCodeMask & baseAddress[0]))
let isMasked = (MaskMask & baseAddress[1])
let payloadLen = (PayloadLenMask & baseAddress[1])
var offset = 2
if (isMasked > 0 || (RSVMask & baseAddress[0]) > 0) && receivedOpcode != .pong {
let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("masked and rsv data is not currently supported", code: errCode))
writeError(errCode)
return emptyBuffer
}
let isControlFrame = (receivedOpcode == .connectionClose || receivedOpcode == .ping)
if !isControlFrame && (receivedOpcode != .binaryFrame && receivedOpcode != .continueFrame &&
receivedOpcode != .textFrame && receivedOpcode != .pong) {
let errCode = CloseCode.protocolError.rawValue
let detail = (receivedOpcode != nil) ? "unknown opcode: \(receivedOpcode!)" : "unknown opcode"
doDisconnect(errorWithDetail(detail, code: errCode))
writeError(errCode)
return emptyBuffer
}
if isControlFrame && isFin == 0 {
let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("control frames can't be fragmented", code: errCode))
writeError(errCode)
return emptyBuffer
}
if receivedOpcode == .connectionClose {
var code = CloseCode.normal.rawValue
if payloadLen == 1 {
code = CloseCode.protocolError.rawValue
} else if payloadLen > 1 {
code = WebSocket.readUint16(baseAddress, offset: offset)
if code < 1000 || (code > 1003 && code < 1007) || (code > 1011 && code < 3000) {
code = CloseCode.protocolError.rawValue
}
offset += 2
}
var closeReason = "connection closed by server"
if payloadLen > 2 {
let len = Int(payloadLen - 2)
if len > 0 {
let bytes = baseAddress + offset
if let customCloseReason = String(data: Data(bytes: bytes, count: len), encoding: .utf8) {
closeReason = customCloseReason
} else {
code = CloseCode.protocolError.rawValue
}
}
}
doDisconnect(errorWithDetail(closeReason, code: code))
writeError(code)
return emptyBuffer
}
if isControlFrame && payloadLen > 125 {
writeError(CloseCode.protocolError.rawValue)
return emptyBuffer
}
var dataLength = UInt64(payloadLen)
if dataLength == 127 {
dataLength = WebSocket.readUint64(baseAddress, offset: offset)
offset += MemoryLayout<UInt64>.size
} else if dataLength == 126 {
dataLength = UInt64(WebSocket.readUint16(baseAddress, offset: offset))
offset += MemoryLayout<UInt16>.size
}
if bufferLen < offset || UInt64(bufferLen - offset) < dataLength {
fragBuffer = Data(bytes: baseAddress, count: bufferLen)
return emptyBuffer
}
var len = dataLength
if dataLength > UInt64(bufferLen) {
len = UInt64(bufferLen-offset)
}
let data = Data(bytes: baseAddress+offset, count: Int(len))
if receivedOpcode == .pong {
if canDispatch {
callbackQueue.async { [weak self] in
guard let s = self else { return }
s.onPong?()
s.pongDelegate?.websocketDidReceivePong(s)
}
}
return buffer.fromOffset(offset + Int(len))
}
var response = readStack.last
if isControlFrame {
response = nil // Don't append pings.
}
if isFin == 0 && receivedOpcode == .continueFrame && response == nil {
let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("continue frame before a binary or text frame", code: errCode))
writeError(errCode)
return emptyBuffer
}
var isNew = false
if response == nil {
if receivedOpcode == .continueFrame {
let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("first frame can't be a continue frame",
code: errCode))
writeError(errCode)
return emptyBuffer
}
isNew = true
response = WSResponse()
response!.code = receivedOpcode!
response!.bytesLeft = Int(dataLength)
response!.buffer = NSMutableData(data: data)
} else {
if receivedOpcode == .continueFrame {
response!.bytesLeft = Int(dataLength)
} else {
let errCode = CloseCode.protocolError.rawValue
doDisconnect(errorWithDetail("second and beyond of fragment message must be a continue frame",
code: errCode))
writeError(errCode)
return emptyBuffer
}
response!.buffer!.append(data)
}
if let response = response {
response.bytesLeft -= Int(len)
response.frameCount += 1
response.isFin = isFin > 0 ? true : false
if isNew {
readStack.append(response)
}
_ = processResponse(response)
}
let step = Int(offset + numericCast(len))
return buffer.fromOffset(step)
}
}
private func processRawMessagesInBuffer(_ pointer: UnsafePointer<UInt8>, bufferLen: Int) {
var buffer = UnsafeBufferPointer(start: pointer, count: bufferLen)
repeat {
buffer = processOneRawMessage(inBuffer: buffer)
} while buffer.count >= 2
if !buffer.isEmpty {
fragBuffer = Data(buffer: buffer)
}
}
private func processResponse(_ response: WSResponse) -> Bool {
if response.isFin && response.bytesLeft <= 0 {
if response.code == .ping {
let data = response.buffer! // local copy so it is perverse for writing
dequeueWrite(data as Data, code: .pong)
} else if response.code == .textFrame {
let str: NSString? = NSString(data: response.buffer! as Data, encoding: String.Encoding.utf8.rawValue)
if str == nil {
writeError(CloseCode.encoding.rawValue)
return false
}
if canDispatch {
callbackQueue.async { [weak self] in
guard let s = self else { return }
s.onText?(str! as String)
s.delegate?.websocketDidReceiveMessage(s, text: str! as String)
}
}
} else if response.code == .binaryFrame {
if canDispatch {
let data = response.buffer! // local copy so it is perverse for writing
callbackQueue.async { [weak self] in
guard let s = self else { return }
s.onData?(data as Data)
s.delegate?.websocketDidReceiveData(s, data: data as Data)
}
}
}
readStack.removeLast()
return true
}
return false
}
private func errorWithDetail(_ detail: String, code: UInt16) -> NSError {
var details = [String: String]()
details[NSLocalizedDescriptionKey] = detail
return NSError(domain: WebSocket.ErrorDomain, code: Int(code), userInfo: details)
}
private func writeError(_ code: UInt16) {
let buf = NSMutableData(capacity: MemoryLayout<UInt16>.size)
let buffer = UnsafeMutableRawPointer(mutating: buf!.bytes).assumingMemoryBound(to: UInt8.self)
WebSocket.writeUint16(buffer, offset: 0, value: code)
dequeueWrite(Data(bytes: buffer, count: MemoryLayout<UInt16>.size), code: .connectionClose)
}
private func dequeueWrite(_ data: Data, code: OpCode, writeCompletion: (() -> ())? = nil) {
writeQueue.addOperation { [weak self] in
//stream isn't ready, let's wait
guard let s = self else { return }
var offset = 2
let dataLength = data.count
let frame = NSMutableData(capacity: dataLength + s.MaxFrameSize)
let buffer = UnsafeMutableRawPointer(frame!.mutableBytes).assumingMemoryBound(to: UInt8.self)
buffer[0] = s.FinMask | code.rawValue
if dataLength < 126 {
buffer[1] = CUnsignedChar(dataLength)
} else if dataLength <= Int(UInt16.max) {
buffer[1] = 126
WebSocket.writeUint16(buffer, offset: offset, value: UInt16(dataLength))
offset += MemoryLayout<UInt16>.size
} else {
buffer[1] = 127
WebSocket.writeUint64(buffer, offset: offset, value: UInt64(dataLength))
offset += MemoryLayout<UInt64>.size
}
buffer[1] |= s.MaskMask
let maskKey = UnsafeMutablePointer<UInt8>(buffer + offset)
_ = SecRandomCopyBytes(kSecRandomDefault, Int(MemoryLayout<UInt32>.size), maskKey)
offset += MemoryLayout<UInt32>.size
for i in 0..<dataLength {
buffer[offset] = data[i] ^ maskKey[i % MemoryLayout<UInt32>.size]
offset += 1
}
var total = 0
while true {
guard let outStream = s.outputStream else { break }
let writeBuffer = UnsafeRawPointer(frame!.bytes+total).assumingMemoryBound(to: UInt8.self)
let len = outStream.write(writeBuffer, maxLength: offset-total)
if len < 0 {
var error: Error?
if let streamError = outStream.streamError {
error = streamError
} else {
let errCode = InternalErrorCode.outputStreamWriteError.rawValue
error = s.errorWithDetail("output stream error during write", code: errCode)
}
s.doDisconnect(error as NSError?)
break
} else {
total += len
}
if total >= offset {
if let queue = self?.callbackQueue, let callback = writeCompletion {
queue.async {
callback()
}
}
break
}
}
}
}
private func doDisconnect(_ error: NSError?) {
guard !didDisconnect else { return }
didDisconnect = true
connected = false
guard canDispatch else {return}
callbackQueue.async { [weak self] in
guard let s = self else { return }
s.onDisconnect?(error)
s.delegate?.websocketDidDisconnect(s, error: error)
let userInfo = error.map { [WebsocketDisconnectionErrorKeyName: $0] }
s.notificationCenter.post(name: NSNotification.Name(WebsocketDidDisconnectNotification), object: self, userInfo: userInfo)
}
}
// MARK: - Deinit
deinit {
mutex.lock()
readyToWrite = false
mutex.unlock()
cleanupStream()
}
}
private extension Data {
init(buffer: UnsafeBufferPointer<UInt8>) {
self.init(bytes: buffer.baseAddress!, count: buffer.count)
}
}
private extension UnsafeBufferPointer {
func fromOffset(_ offset: Int) -> UnsafeBufferPointer<Element> {
return UnsafeBufferPointer<Element>(start: baseAddress?.advanced(by: offset), count: count - offset)
}
}
private let emptyBuffer = UnsafeBufferPointer<UInt8>(start: nil, count: 0)
| apache-2.0 | 695c903deaa9932f507c3d59f8359efd | 39.935484 | 139 | 0.575081 | 5.474197 | false | false | false | false |
avito-tech/Marshroute | Example/NavigationDemo/VIPER/SearchResults/Assembly/SearchResultsAssemblyImpl.swift | 1 | 1697 | import UIKit
import Marshroute
final class SearchResultsAssemblyImpl: BaseAssembly, SearchResultsAssembly {
// MARK: - SearchResultsAssembly
func module(categoryId: CategoryId, routerSeed: RouterSeed)
-> UIViewController
{
let router = SearchResultsRouterIphone(
assemblyFactory: assemblyFactory,
routerSeed: routerSeed
)
return module(categoryId: categoryId, router: router)
}
func ipadModule(categoryId: CategoryId, routerSeed: RouterSeed)
-> UIViewController
{
let router = SearchResultsRouterIpad(
assemblyFactory: assemblyFactory,
routerSeed: routerSeed
)
return module(categoryId: categoryId, router: router)
}
// MARK - Private
private func module(categoryId: CategoryId, router: SearchResultsRouter)
-> UIViewController
{
let interactor = SearchResultsInteractorImpl(
categoryId: categoryId,
categoriesProvider: serviceFactory.categoriesProvider(),
searchResultsProvider: serviceFactory.searchResultsProvider()
)
let presenter = SearchResultsPresenter(
interactor: interactor,
router: router
)
presenter.applicationModuleInput = assemblyFactory.applicationAssembly().sharedModuleInput()
let viewController = SearchResultsViewController(
peekAndPopUtility: marshrouteStack.peekAndPopUtility
)
viewController.addDisposable(presenter)
presenter.view = viewController
return viewController
}
}
| mit | f930729d18616852f0789d337d8dda4d | 29.854545 | 100 | 0.641721 | 6.734127 | false | false | false | false |
NikKovIos/NKVPhonePicker | Sources/Models/Country.swift | 1 | 7459 | //
// Be happy and free :)
//
// Nik Kov
// nik-kov.com
//
#if os(iOS)
import Foundation
import UIKit
open class Country: NSObject {
// MARK: - Properties
/// Ex: "RU"
@objc public var countryCode: String
/// Ex: "7"
@objc public var phoneExtension: String
/// Ex: "Russia"
@objc public var name: String {
return NKVLocalizationHelper.countryName(by: countryCode) ?? ""
}
/// Ex: "### ## ######"
@objc public var formatPattern: String
/// A flag image for this country. May be nil.
public var flag: UIImage? {
return NKVSourcesHelper.flag(for: NKVSource(country: self))
}
// MARK: - Initialization
public init(countryCode: String,
phoneExtension: String,
formatPattern: String = "###################") {
self.countryCode = countryCode
self.phoneExtension = phoneExtension
self.formatPattern = formatPattern
}
// MARK: - Country entities
/// A Country entity of the current iphone's localization region code
/// or nil if it not exist.
public static var currentCountry: Country? {
guard let currentCountryCode = NKVLocalizationHelper.currentCode else {
return nil
}
return Country.country(for: NKVSource(countryCode: currentCountryCode))
}
/// An empty country entity for test or other purposes.
/// "_unknown" country code returns a "question" flag.
public static var empty: Country {
return Country(countryCode: "_unknown", phoneExtension: "")
}
// MARK: - Methods
/// A main method for fetching a country
///
/// - Parameter source: Any of the source, look **NKVSourceType**
/// - Returns: A Country entity or nil if there is no exist for the source
public class func country(`for` source: NKVSource) -> Country? {
switch source {
case .country(let country):
return country
case .code(let code):
for country in NKVSourcesHelper.countries {
if code.code.lowercased() == country.countryCode.lowercased() {
return country
}
}
case .phoneExtension(let phoneExtension):
var matchingCountries = [Country]()
let phoneExtension = phoneExtension.phoneExtension.cutPluses
for country in NKVSourcesHelper.countries {
if phoneExtension == country.phoneExtension {
matchingCountries.append(country)
}
}
// If phone extension does not match any specific country, see if prefix of the extension is a match so we can pinpoint the country by local area code
if matchingCountries.count == 0 {
for country in NKVSourcesHelper.countries {
var tempPhoneExtension = phoneExtension
while tempPhoneExtension.count > 0 {
if tempPhoneExtension == country.phoneExtension {
matchingCountries.append(country)
break
} else {
tempPhoneExtension.remove(at: tempPhoneExtension.index(before: tempPhoneExtension.endIndex))
}
}
}
}
// We have multiple countries for same phone extension. We decide which one to pick here.
if matchingCountries.count > 0 {
let matchingPhoneExtension = matchingCountries.first!.phoneExtension
if phoneExtension.count > 1 {
// Deciding which country to pick based on local area code.
do {
if let file = Bundle(for: NKVPhonePickerTextField.self).url(forResource: "Countries.bundle/Data/localAreaCodes", withExtension: "json") {
let data = try Data(contentsOf: file)
let json = try JSONSerialization.jsonObject(with: data, options: [])
if let array = json as? [String : [AnyObject]] {
if array.index(forKey: matchingPhoneExtension) != nil {
// Found countries with given phone extension.
for country in array[array.index(forKey: matchingPhoneExtension)!].value {
if let areaCodes = country["localAreaCodes"] as? [String] {
if phoneExtension.hasPrefix(matchingPhoneExtension) {
var localAreaCode = String(phoneExtension.dropFirst(matchingPhoneExtension.count))
localAreaCode = String(localAreaCode.prefix(areaCodes.first!.count))
if areaCodes.contains(localAreaCode) {
// Found a specific country with given phone extension and local area code.
if let currentCountry = country["countryCode"] as? String {
return Country.country(for: NKVSource(countryCode: currentCountry))
}
}
}
}
}
}
}
} else {
print("NKVPhonePickerTextField >>> Can't find a bundle for the local area codes")
}
} catch {
print("NKVPhonePickerTextField >>> \(error.localizedDescription)")
}
}
// Deciding which country to pick based on country priority.
if let countryPriorities = NKVPhonePickerTextField.samePhoneExtensionCountryPriorities {
if let prioritizedCountry = countryPriorities[matchingPhoneExtension] {
return Country.country(for: NKVSource(countryCode: prioritizedCountry))
}
}
return matchingCountries.first
}
}
return nil
}
/// Returns a countries array from the country codes.
///
/// - Parameter countryCodes: For example: ["FR", "EN"]
public class func countriesBy(countryCodes: [String]) -> [Country] {
return countryCodes.map { code in
if let country = Country.country(for: NKVSource(countryCode: code)) {
return country
} else {
print("⚠️ Country >>> Can't find a country for country code: \(code).\r Replacing it with dummy country. Please check your country ID or update a country database.")
return Country.empty
}
}
}
}
// MARK: - Equitable
extension Country {
/// Making entities comparable
static public func ==(lhs: Country, rhs: Country) -> Bool {
return lhs.countryCode == rhs.countryCode
}
}
#endif
| mit | 4c77d3e914f5f7211c2d06aaefff3fea | 41.6 | 181 | 0.5167 | 5.983146 | false | false | false | false |
svanimpe/around-the-table | Tests/AroundTheTableTests/Models/GameTests.swift | 1 | 15108 | import BSON
import Foundation
import XCTest
@testable import AroundTheTable
class GameTests: XCTestCase {
static var allTests: [(String, (GameTests) -> () throws -> Void)] {
return [
("testParseXML", testParseXML),
("testParseXMLNoID", testParseXMLNoID),
("testParseXMLNoName", testParseXMLNoName),
("testParseXMLZeroYear", testParseXMLZeroYear),
("testParseXMLNoMinPlayers", testParseXMLNoMinPlayers),
("testParseXMLNoMaxPlayers", testParseXMLNoMaxPlayers),
("testParseXMLZeroPlayerCount", testParseXMLZeroPlayerCount),
("testParseXMLZeroMinPlayers", testParseXMLZeroMinPlayers),
("testParseXMLZeroMaxPlayers", testParseXMLZeroMaxPlayers),
("testParseXMLInvertedPlayerCount", testParseXMLInvertedPlayerCount),
("testParseXMLNoMinPlaytime", testParseXMLNoMinPlaytime),
("testParseXMLNoMaxPlaytime", testParseXMLNoMaxPlaytime),
("testParseXMLZeroPlaytime", testParseXMLZeroPlaytime),
("testParseXMLZeroMinPlaytime", testParseXMLZeroMinPlaytime),
("testParseXMLZeroMaxPlaytime", testParseXMLZeroMaxPlaytime),
("testParseXMLInvertedPlaytime", testParseXMLInvertedPlaytime),
("testParseXMLNoImage", testParseXMLNoImage),
("testParseXMLNoThumbnail", testParseXMLNoThumbnail),
("testEncode", testEncode),
("testEncodeSkipsNilValues", testEncodeSkipsNilValues),
("testDecode", testDecode),
("testDecodeNotADocument", testDecodeNotADocument),
("testDecodeMissingID", testDecodeMissingID),
("testDecodeMissingCreationDate", testDecodeMissingCreationDate),
("testDecodeMissingName", testDecodeMissingName),
("testDecodeMissingNames", testDecodeMissingNames),
("testDecodeMissingYear", testDecodeMissingID),
("testDecodeMissingPlayerCount", testDecodeMissingPlayerCount),
("testDecodeMissingPlayingTime", testDecodeMissingPlayingTime)
]
}
private let now = Date()
private let picture = URL(string: "https://cf.geekdo-images.com/original/img/ME73s_0dstlA4qLpLEBvPyvq8gE=/0x0/pic3090929.jpg")!
private let thumbnail = URL(string: "https://cf.geekdo-images.com/thumb/img/7X5vG9KruQ9CmSMVZ3rmiSSqTCM=/fit-in/200x150/pic3090929.jpg")!
/* XML */
func testParseXML() throws {
guard let data = loadFixture(file: "xml/valid.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssert(result.id == 192457)
XCTAssert(result.name == "Cry Havoc")
XCTAssert(result.names == ["Cry Havoc"])
XCTAssert(result.yearPublished == 2016)
XCTAssert(result.playerCount == 2...4)
XCTAssert(result.playingTime == 60...120)
XCTAssert(result.picture == picture)
XCTAssert(result.thumbnail == thumbnail)
}
func testParseXMLNoID() throws {
guard let data = loadFixture(file: "xml/no-id.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLNoName() throws {
guard let data = loadFixture(file: "xml/no-name.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLZeroYear() throws {
guard let data = loadFixture(file: "xml/zero-year.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLNoMinPlayers() throws {
guard let data = loadFixture(file: "xml/no-minplayers.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLNoMaxPlayers() throws {
guard let data = loadFixture(file: "xml/no-maxplayers.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLZeroPlayerCount() throws {
guard let data = loadFixture(file: "xml/zero-playercount.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLZeroMinPlayers() throws {
guard let data = loadFixture(file: "xml/zero-minplayers.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssert(result.playerCount == 4...4)
}
func testParseXMLZeroMaxPlayers() throws {
guard let data = loadFixture(file: "xml/zero-maxplayers.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssert(result.playerCount == 2...2)
}
func testParseXMLInvertedPlayerCount() throws {
guard let data = loadFixture(file: "xml/inverted-playercount.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssert(result.playerCount == 2...4)
}
func testParseXMLNoMinPlaytime() throws {
guard let data = loadFixture(file: "xml/no-minplaytime.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLNoMaxPlaytime() throws {
guard let data = loadFixture(file: "xml/no-maxplaytime.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLZeroPlaytime() throws {
guard let data = loadFixture(file: "xml/zero-playtime.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
XCTAssertThrowsError(try Game(xml: node))
}
func testParseXMLZeroMinPlaytime() throws {
guard let data = loadFixture(file: "xml/zero-minplaytime.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssert(result.playingTime == 120...120)
}
func testParseXMLZeroMaxPlaytime() throws {
guard let data = loadFixture(file: "xml/zero-maxplaytime.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssert(result.playingTime == 60...60)
}
func testParseXMLInvertedPlaytime() throws {
guard let data = loadFixture(file: "xml/inverted-playtime.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssert(result.playingTime == 60...120)
}
func testParseXMLNoImage() throws {
guard let data = loadFixture(file: "xml/no-image.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssertNil(result.picture)
}
func testParseXMLNoThumbnail() throws {
guard let data = loadFixture(file: "xml/no-thumbnail.xml") else {
return XCTFail()
}
let xml = try XMLDocument(data: data, options: [])
guard let node = try xml.nodes(forXPath: "/items/item").first else {
return XCTFail()
}
let result = try Game(xml: node)
XCTAssertNil(result.thumbnail)
}
/* BSON */
func testEncode() {
let input = Game(id: 1,
name: "game", names: ["game", "spiel"],
yearPublished: 2000,
playerCount: 2...4,
playingTime: 45...60,
picture: picture, thumbnail: thumbnail)
let expected: Document = [
"_id": 1,
"creationDate": input.creationDate,
"name": "game",
"names": ["game", "spiel"],
"yearPublished": 2000,
"playerCount": 2...4,
"playingTime": 45...60,
"picture": picture,
"thumbnail": thumbnail
]
XCTAssert(input.typeIdentifier == expected.typeIdentifier)
XCTAssert(input.document == expected)
}
func testEncodeSkipsNilValues() {
let input = Game(id: 1,
name: "game", names: ["game", "spiel"],
yearPublished: 2000,
playerCount: 2...4,
playingTime: 45...60,
picture: nil, thumbnail: nil)
let expected: Document = [
"_id": 1,
"creationDate": input.creationDate,
"name": "game",
"names": ["game", "spiel"],
"yearPublished": 2000,
"playerCount": 2...4,
"playingTime": 45...60
]
XCTAssert(input.typeIdentifier == expected.typeIdentifier)
XCTAssert(input.document == expected)
}
func testDecode() throws {
let input: Document = [
"_id": 1,
"creationDate": now,
"name": "game",
"names": ["game", "spiel"],
"yearPublished": 2000,
"playerCount": 2...4,
"playingTime": 45...60,
"picture": picture,
"thumbnail": thumbnail
]
guard let result = try Game(input) else {
return XCTFail()
}
XCTAssert(result.id == 1)
assertDatesEqual(result.creationDate, now)
XCTAssert(result.name == "game")
XCTAssert(result.names == ["game", "spiel"])
XCTAssert(result.yearPublished == 2000)
XCTAssert(result.playerCount == 2...4)
XCTAssert(result.playingTime == 45...60)
XCTAssert(result.picture == picture)
XCTAssert(result.thumbnail == thumbnail)
}
func testDecodeNotADocument() throws {
let input: Primitive = 1
let result = try Game(input)
XCTAssertNil(result)
}
func testDecodeMissingID() {
let input: Document = [
"creationDate": now,
"name": "game",
"names": ["game", "spiel"],
"yearPublished": 2000,
"playerCount": 2...4,
"playingTime": 45...60
]
XCTAssertThrowsError(try Game(input))
}
func testDecodeMissingCreationDate() {
let input: Document = [
"_id": 1,
"name": "game",
"names": ["game", "spiel"],
"yearPublished": 2000,
"playerCount": 2...4,
"playingTime": 45...60
]
XCTAssertThrowsError(try Game(input))
}
func testDecodeMissingName() {
let input: Document = [
"_id": 1,
"creationDate": now,
"names": ["game", "spiel"],
"yearPublished": 2000,
"playerCount": 2...4,
"playingTime": 45...60
]
XCTAssertThrowsError(try Game(input))
}
func testDecodeMissingNames() {
let input: Document = [
"_id": 1,
"creationDate": now,
"name": "game",
"yearPublished": 2000,
"playerCount": 2...4,
"playingTime": 45...60
]
XCTAssertThrowsError(try Game(input))
}
func testDecodeMissingYear() {
let input: Document = [
"_id": 1,
"creationDate": now,
"name": "game",
"names": ["game", "spiel"],
"playerCount": 2...4,
"playingTime": 45...60
]
XCTAssertThrowsError(try Game(input))
}
func testDecodeMissingPlayerCount() {
let input: Document = [
"_id": 1,
"creationDate": now,
"name": "game",
"names": ["game", "spiel"],
"yearPublished": 2000,
"playingTime": 45...60
]
XCTAssertThrowsError(try Game(input))
}
func testDecodeMissingPlayingTime() {
let input: Document = [
"_id": 1,
"creationDate": now,
"name": "game",
"names": ["game", "spiel"],
"yearPublished": 2000,
"playerCount": 2...4
]
XCTAssertThrowsError(try Game(input))
}
}
| bsd-2-clause | 444b7081a5c6ef649df6f5f17e203015 | 34.885986 | 141 | 0.555269 | 4.83456 | false | true | false | false |
adamnemecek/AudioKit | Playgrounds/Hello World.playground/Contents.swift | 1 | 391 | //: Run this playground to test that AudioKit is working
import AudioKit
import AudioKitEX
import Foundation
var greeting = "Hello, playground"
let osc = PlaygroundOscillator()
let engine = AudioEngine()
engine.output = osc
try! engine.start()
osc.play()
while true {
osc.frequency = Float.random(in: 200...800)
osc.amplitude = Float.random(in: 0.0...0.3)
usleep(100000)
}
| mit | 465d2032befb2a1ab1a9f7278997a52a | 17.619048 | 56 | 0.713555 | 3.522523 | false | false | false | false |
yarshure/Surf | Surf/RuleResultsViewController.swift | 1 | 10821 | //
// RuleResultsViewController.swift
// Surf
//
// Created by yarshure on 16/2/14.
// Copyright © 2016年 yarshure. All rights reserved.
//
import UIKit
import NetworkExtension
import SwiftyJSON
import SFSocket
class RuleResultsViewController: SFTableViewController {
var results:[SFRuleResult] = []
override func viewDidLoad() {
super.viewDidLoad()
self.title = "Rule Test Results"
recent()
//test()
// Uncomment the following line to preserve selection between presentations
// self.clearsSelectionOnViewWillAppear = false
// Uncomment the following line to display an Edit button in the navigation bar for this view controller.
// self.navigationItem.rightBarButtonItem = self.editButtonItem()
let item = UIBarButtonItem.init(image: UIImage.init(named: "760-refresh-3-toolbar"), style: .plain, target: self, action: #selector(RuleResultsViewController.refreshAction(_:)))
self.navigationItem.rightBarButtonItem = item
}
func refreshAction(_ sender:AnyObject){
recent()
}
// func test() {
// let path = Bundle.main.path(forResource: "1.txt", ofType: nil)
// if let data = try! Data.init(contentsOf: path) {
// processData(data: data)
// }
// }
func recent(){
// Send a simple IPC message to the provider, handle the response.
//AxLogger.log("send Hello Provider")
if let m = SFVPNManager.shared.manager, m.isEnabled{
let date = NSDate()
let me = SFVPNXPSCommand.RULERESULT.rawValue + "|\(date)"
if let session = m.connection as? NETunnelProviderSession,
let message = me.data(using: .utf8), m.connection.status == .connected
{
do {
try session.sendProviderMessage(message) { [weak self] response in
if response != nil {
self!.processData(data: response!)
} else {
self!.alertMessageAction("Got a nil response from the provider",complete: nil)
}
}
} catch {
alertMessageAction("Failed to Get result ",complete: nil)
}
}else {
alertMessageAction("Connection not Started",complete: nil)
}
}else {
alertMessageAction("VPN not running",complete: nil)
}
}
func processData(data:Data) {
results.removeAll()
//let responseString = NSString(data: response!, encoding: NSUTF8StringEncoding)
let obj = JSON.init(data: data)
if obj.error == nil {
if obj.type == .array {
for item in obj {
//{"api.smoot.apple.com":{"Name":"apple.com","Type":"DOMAIN-SUFFIX","Proxy":"jp","Policy":"Proxy"}}
let json = item.1
for (k,v) in json {
let rule = SFRuler()
rule.mapObject(v)
//let policy = v["Policy"].stringValue
let result = SFRuleResult.init(request: k, r: rule)
results.append(result)
}
}
}
if results.count > 0 {
tableView.reloadData()
}else {
alertMessageAction("Don't have Record yet!",complete: nil)
}
}
//mylog("Received response from the provider: \(responseString)")
//self.registerStatus()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
// MARK: - Table view data source
override func numberOfSections(in tableView: UITableView) -> Int {
return 1
}
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
// #warning Incomplete implementation, return the number of rows
return results.count
}
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: "rule", for: indexPath as IndexPath)
// Configure the cell...
let x = results[indexPath.row]
cell.textLabel?.text = x.req
var proxyName = ""
if x.result.proxyName == "" {
proxyName = x.result.name
}else {
proxyName = x.result.proxyName
}
let timing = String.init(format: " timing: %.04f sec", x.result.timming)
if x.result.type == .final {
cell.detailTextLabel?.text = x.result.type.description + " " + x.result.policy.description + "->" + proxyName + timing
}else {
cell.detailTextLabel?.text = x.result.type.description + " " + x.result.name + "->" + proxyName + timing
}
cell.updateUI()
return cell
}
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
changeRule()
}
func changeRule() {
var style:UIAlertControllerStyle = .alert
let deviceIdiom = UIScreen.main.traitCollection.userInterfaceIdiom
switch deviceIdiom {
case .pad:
style = .alert
default:
style = .actionSheet
break
}
guard let indexPath = tableView.indexPathForSelectedRow else {return}
let result = results[indexPath.row]
let alert = UIAlertController.init(title: "Alert", message: "Please Select Policy", preferredStyle: style)
let action = UIAlertAction.init(title: "PROXY", style: .default) {[unowned self ] (action:UIAlertAction) -> Void in
result.result.proxyName = "Proxy"
self.updateResult(rr: result)
self.tableView.deselectRow(at: indexPath, animated: true)
}
let action1 = UIAlertAction.init(title: "REJECT", style: .default) { [unowned self ] (action:UIAlertAction) -> Void in
result.result.proxyName = "REJECT"
self.updateResult(rr: result)
self.tableView.deselectRow(at: indexPath, animated: true)
}
let action2 = UIAlertAction.init(title: "DIRECT", style: .default) { [unowned self ] (action:UIAlertAction) -> Void in
result.result.proxyName = "DIRECT"
self.updateResult(rr: result)
self.tableView.deselectRow(at: indexPath, animated: true)
}
let cancle = UIAlertAction.init(title: "Cancel", style: .cancel) { [unowned self ] (action:UIAlertAction) -> Void in
self.tableView.deselectRow(at: indexPath, animated: true)
}
alert.addAction(action)
alert.addAction(action1)
alert.addAction(action2)
alert.addAction(cancle)
self.present(alert, animated: true) { () -> Void in
}
}
func updateResult(rr:SFRuleResult){
var r:[String:AnyObject] = [:]
r["request"] = rr.req as AnyObject?
r["ruler"] = rr.result.resp() as AnyObject?
let j = JSON(r)
var data:Data
do {
try data = j.rawData()
}catch let error as NSError {
//AxLogger.log("ruleResultData error \(error.localizedDescription)")
//let x = error.localizedDescription
//data = error.localizedDescription.dataUsingEncoding(NSUTF8StringEncoding)!// NSData()
alertMessageAction("error :\(error.localizedDescription)", complete: {
})
return
}
let me = SFVPNXPSCommand.UPDATERULE.rawValue + "|"
var message = Data.init()
message.append(me.data(using: .utf8)!)
if let m = SFVPNManager.shared.manager, m.connection.status == .connected {
if let session = m.connection as? NETunnelProviderSession
{
do {
try session.sendProviderMessage(message) { [weak self] response in
if let r = String.init(data: response!, encoding: String.Encoding.utf8) {
print("change policy : \(r)")
//self!.alertMessageAction(r,complete: nil)
} else {
self!.alertMessageAction("Failed to Change Policy",complete: nil)
}
}
} catch let e as NSError{
alertMessageAction("Failed to Change Proxy,reason \(e.description)",complete: nil)
}
}
}
}
/*
// Override to support conditional editing of the table view.
override func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
// Return false if you do not want the specified item to be editable.
return true
}
*/
/*
// Override to support editing the table view.
override func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
if editingStyle == .Delete {
// Delete the row from the data source
tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Fade)
} else if editingStyle == .Insert {
// Create a new instance of the appropriate class, insert it into the array, and add a new row to the table view
}
}
*/
/*
// Override to support rearranging the table view.
override func tableView(tableView: UITableView, moveRowAtIndexPath fromIndexPath: NSIndexPath, toIndexPath: NSIndexPath) {
}
*/
/*
// Override to support conditional rearranging of the table view.
override func tableView(tableView: UITableView, canMoveRowAtIndexPath indexPath: NSIndexPath) -> Bool {
// Return false if you do not want the item to be re-orderable.
return true
}
*/
/*
// MARK: - Navigation
// In a storyboard-based application, you will often want to do a little preparation before navigation
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
// Get the new view controller using segue.destination.
// Pass the selected object to the new view controller.
}
*/
}
| bsd-3-clause | b1fb23f7499ed2e7c924172d946631b6 | 37.091549 | 185 | 0.565539 | 5.078873 | false | false | false | false |
palle-k/SocketKit | Sources/Socket.swift | 2 | 11913 | //
// Socket.swift
// SocketKit
//
// Created by Palle Klewitz on 10.04.16.
// Copyright © 2016 Palle Klewitz.
//
// 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 CoreFoundation
import Darwin
import Foundation
/**
The Socket protocol provides an interface for a network socket,
which is an endpoint in network communication.
The user can communicate through the streams provided by the socket.
Incoming data can be retrieved through the input stream and data can be written
to the network with the output stream.
*/
public protocol Socket : class
{
/**
Host address of the peer.
Only used for outgoing connections.
*/
var hostAddress: String? { get }
/**
The input stream of the socket.
Incoming data can be read from it.
If the socket uses non-blocking I/O,
a delegate should be used to receive notifications about
incoming data.
*/
var inputStream: InputStream! { get }
/**
The output stream of the socket.
Can write data to the socket.
If the socket uses non-blocking I/O,
the operation may fail and a
.WouldBlock or .Again IOError may be thrown.
The operation must then be tried again.
*/
var outputStream: OutputStream! { get }
/**
Indicates, if non-blocking I/O is used
or en-/disables non-blocking I/O.
If non-blocking I/O is used, reading
from the socket may not return any data
and writing may fail because it would otherwise
block the current thread.
In this case, a .WouldBlock or .Again
IOError will be thrown.
The operation must be repeated until it was successful.
For read operations, the delegate of the stream should be used
for efficient reading.
- parameter new: Specifies, if the socket should be non-blocking or not.
A value of true sets the socket to nonblocking mode, false to blocking mode.
- returns: true, if the socket is nonblocking, false if it is blocking.
*/
var nonblocking: Bool { get set }
/**
Checks if the socket is open.
The socket is open if at least one of the streams associated with this socket is open.
*/
var open:Bool { get }
/**
Manually closes the socket
and releases any ressources related to it.
Subsequent calls of the streams' read and write
functions will fail.
*/
func close()
/**
Checks the status of the streams which read and write from and to this socket.
If both streams are closed, the socket will be closed.
*/
func checkStreams()
}
/**
Extension for stream checking.
*/
public extension Socket
{
/**
Checks the status of the streams which read and write from and to this socket.
If both streams are closed, the socket will be closed.
*/
func checkStreams()
{
if !inputStream.open && !outputStream.open
{
close()
}
}
}
/**
A socket which internally uses POSIX APIs
This may include UDP, TCP or RAW sockets.
*/
internal protocol POSIXSocket : Socket
{
/**
The POSIX-socket handle of this socket.
Input and output streams use this for read
and write operations.
*/
var handle: Int32 { get }
/**
The address of the socket.
Contains port and ip information
*/
var address: sockaddr { get }
}
/**
Socket: Endpoint of a TCP/IP connection.
Data can be read from the socket with the input stream
provided as a property of a socket instance.
Data can be written to the socket with the output stream
provided as a property of a socket instance.
*/
open class TCPSocket : POSIXSocket, CustomStringConvertible
{
/**
The POSIX-socket handle of this socket.
Input and output streams use this for read
and write operations.
*/
internal let handle: Int32
/**
The address of the socket.
Contains port and ip information
*/
internal var address: sockaddr
/**
Host address of the peer.
Only used for outgoing connections.
*/
open fileprivate(set) var hostAddress: String?
/**
Indicates, if non-blocking I/O is used
or en-/disables non-blocking I/O.
If non-blocking I/O is used, reading
from the socket may not return any data
and writing may fail because it would otherwise
block the current thread.
In this case, a .WouldBlock or .Again IOError will be thrown.
The operation must be repeated until it was successful.
For read operations, the delegate of the stream should be used
for efficient reading.
- parameter new: Specifies, if the socket should be non-blocking or not.
A value of true sets the socket to nonblocking mode, false to blocking mode.
- returns: true, if the socket is nonblocking, false if it is blocking.
*/
open var nonblocking: Bool
{
get
{
let flags = fcntl(handle, F_GETFL, 0)
return (flags & O_NONBLOCK) != 0
}
set (new)
{
let flags = fcntl(handle, F_GETFL, 0)
_ = fcntl(handle, F_SETFL, new ? (flags | O_NONBLOCK) : (flags & ~O_NONBLOCK))
}
}
/**
The input stream of the socket.
Incoming data can be read from it.
If the socket uses non-blocking I/O,
a delegate should be used to receive notifications about
incoming data.
*/
open fileprivate(set) var inputStream: InputStream!
/**
The output stream of the socket.
Can write data to the socket.
If the socket uses non-blocking I/O,
the operation may fail and a
.WouldBlock or .Again IOError may be thrown.
The operation must then be tried again.
*/
open fileprivate(set) var outputStream: OutputStream!
/**
Returns the IP address of the peer
to which this socket is connected to.
The result is a IPv4 or IPv6 address
depending on the IP protocol version used.
*/
open var peerIP:String?
{
if address.sa_family == sa_family_t(AF_INET)
{
let ptr = UnsafeMutablePointer<CChar>.allocate(capacity: Int(INET_ADDRSTRLEN))
var address_in = sockaddr_cast(&address)
inet_ntop(AF_INET, &address_in.sin_addr, ptr, socklen_t(INET_ADDRSTRLEN))
return String(cString: ptr)
}
else if address.sa_family == sa_family_t(AF_INET6)
{
let ptr = UnsafeMutablePointer<CChar>.allocate(capacity: Int(INET6_ADDRSTRLEN))
var address_in = sockaddr_cast(&address)
inet_ntop(AF_INET, &address_in.sin_addr, ptr, socklen_t(INET6_ADDRSTRLEN))
return String(cString: ptr)
}
return nil
}
/**
Checks if the socket is open.
The socket is open if at least one of the streams associated with this socket is open.
*/
open var open:Bool
{
return inputStream.open || outputStream.open
}
/**
A textual representation of self.
*/
open var description: String
{
return "Socket (host: \(self.hostAddress ?? "unknown"), ip: \(self.peerIP ?? "unknown"), \(self.open ? "open" : "closed"))\n\t-> \(self.inputStream)\n\t<- \(self.outputStream)"
}
/**
Initializes the socket and connects to the address specified in `host`.
The `host` address must be an IPv4 address.
- parameter host: IPv4 peer address string
- parameter port: Port to which the socket should connect.
- throws: A SocketError if the socket could not be connected.
*/
public convenience init(ipv4host host: String, port: UInt16) throws
{
let handle = Darwin.socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)
guard handle >= 0
else
{
_ = Darwin.close(handle)
throw SocketError.open
}
var address = sockaddr_in()
address.sin_len = __uint8_t(MemoryLayout<sockaddr_in>.size)
address.sin_family = sa_family_t(AF_INET)
address.sin_port = htons(port)
address.sin_addr = in_addr(s_addr: inet_addr(host))
let success = connect(handle, [sockaddr_in_cast(&address)], socklen_t(MemoryLayout<sockaddr_in>.size))
guard success >= 0
else
{
_ = Darwin.close(handle)
throw SocketError.open
}
self.init(handle: handle, address: sockaddr())
hostAddress = host
}
/**
Initializes a socket with a given host address and TCP port
The socket will automatically connect to the given host.
- parameter address: The host address of the server to connect to.
- parameter port: The TCP port on which the server should be connected.
*/
public init?(address: String, port: UInt16) throws
{
var readStreamRef:Unmanaged<CFReadStream>?
var writeStreamRef:Unmanaged<CFWriteStream>?
CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, address as CFString!, UInt32(port), &readStreamRef, &writeStreamRef)
guard
let readStream = readStreamRef?.takeRetainedValue(),
let writeStream = writeStreamRef?.takeRetainedValue()
else { return nil }
CFReadStreamOpen(readStream)
CFWriteStreamOpen(writeStream)
guard let handle = CFReadStreamCopyProperty(readStream, CFStreamPropertyKey.socketNativeHandle) as? Int32 else { return nil }
self.handle = handle
var sockaddress = sockaddr()
var sockaddrlen = socklen_t(MemoryLayout<sockaddr>.size)
getpeername(handle, &sockaddress, &sockaddrlen)
self.address = sockaddress
}
/**
Initializes a socket with the given handle and address.
The handle must be the value of a POSIX-socket.
The socket address should contain information about the
peer to which this socket is connected.
- parameter handle: The POSIX-socket handle.
- parameter address: The peer address.
*/
internal init(handle: Int32, address: sockaddr)
{
self.handle = handle
self.address = address
var one:Int32 = 1
setsockopt(self.handle, SOL_SOCKET, SO_NOSIGPIPE, &one, UInt32(MemoryLayout<Int32>.size))
nonblocking = false
// let success_nodelay = setsockopt(handle, IPPROTO_TCP, TCP_NODELAY, &one, socklen_t(sizeof(Int32)))
// DEBUG && success_nodelay < 0 ?-> print("Failed to set TCP_NODELAY.")
inputStream = SocketInputStreamImpl(socket: self, handle: handle)
outputStream = SocketOutputStreamImpl(socket: self, handle: handle)
}
/**
The socket is closed when deallocated.
*/
deinit
{
close()
}
/**
Manually closes the socket
and releases any ressources related to it.
Subsequent calls of the streams' read and write
functions will fail.
*/
open func close()
{
DEBUG ?-> print("Closing socket...")
inputStream.close()
outputStream.close()
_ = Darwin.close(handle)
}
/**
Checks the status of the streams which read and write from and to this socket.
If both streams are closed, the socket will be closed.
*/
open func checkStreams()
{
DEBUG ?-> print("Checking streams. input stream: \(inputStream.open ? "open" : "closed"), output stream: \(outputStream.open ? "open" : "closed")")
if !inputStream.open && !outputStream.open
{
close()
}
}
}
/**
Compares two sockets.
If the handles of the left and right socket are
equal, true is returned, otherwise falls will be returned.
- parameter left: First socket to compare
- parameter right: Second socket to compare
- returns: The comparison result from the comparison of the two sockets.
*/
internal func == (left: POSIXSocket, right: POSIXSocket) -> Bool
{
return left.handle == right.handle
}
| mit | c6939ff0c50c9cecbb9a73104d51a4f3 | 20.897059 | 178 | 0.709453 | 3.693643 | false | false | false | false |
qiuncheng/study-for-swift | learn-rx-swift/Chocotastic-starter/Pods/RxSwift/RxSwift/Observables/Implementations/Debunce.swift | 5 | 2629 | //
// Debunce.swift
// Rx
//
// Created by Krunoslav Zaher on 9/11/16.
// Copyright © 2016 Krunoslav Zaher. All rights reserved.
//
import Foundation
class DebounceSink<O: ObserverType>
: Sink<O>
, ObserverType
, LockOwnerType
, SynchronizedOnType {
typealias Element = O.E
typealias ParentType = Debounce<Element>
private let _parent: ParentType
let _lock = NSRecursiveLock()
// state
private var _id = 0 as UInt64
private var _value: Element? = nil
let cancellable = SerialDisposable()
init(parent: ParentType, observer: O) {
_parent = parent
super.init(observer: observer)
}
func run() -> Disposable {
let subscription = _parent._source.subscribe(self)
return Disposables.create(subscription, cancellable)
}
func on(_ event: Event<Element>) {
synchronizedOn(event)
}
func _synchronized_on(_ event: Event<Element>) {
switch event {
case .next(let element):
_id = _id &+ 1
let currentId = _id
_value = element
let scheduler = _parent._scheduler
let dueTime = _parent._dueTime
let d = SingleAssignmentDisposable()
self.cancellable.disposable = d
d.disposable = scheduler.scheduleRelative(currentId, dueTime: dueTime, action: self.propagate)
case .error:
_value = nil
forwardOn(event)
dispose()
case .completed:
if let value = _value {
_value = nil
forwardOn(.next(value))
}
forwardOn(.completed)
dispose()
}
}
func propagate(_ currentId: UInt64) -> Disposable {
_lock.lock(); defer { _lock.unlock() } // {
let originalValue = _value
if let value = originalValue, _id == currentId {
_value = nil
forwardOn(.next(value))
}
// }
return Disposables.create()
}
}
class Debounce<Element> : Producer<Element> {
fileprivate let _source: Observable<Element>
fileprivate let _dueTime: RxTimeInterval
fileprivate let _scheduler: SchedulerType
init(source: Observable<Element>, dueTime: RxTimeInterval, scheduler: SchedulerType) {
_source = source
_dueTime = dueTime
_scheduler = scheduler
}
override func run<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
let sink = DebounceSink(parent: self, observer: observer)
sink.disposable = sink.run()
return sink
}
}
| mit | c1392ced9f0756767a31362311968407 | 24.269231 | 106 | 0.581811 | 4.684492 | false | false | false | false |
cocoascientist/Jetstream | JetstreamCore/Model/Conditions.swift | 1 | 3509 | //
// Conditions+JSON.swift
// Jetstream
//
// Created by Andrew Shepard on 11/20/16.
// Copyright © 2016 Andrew Shepard. All rights reserved.
//
import Foundation
import CoreData
public class Conditions: NSManagedObject, Decodable {
@NSManaged public var icon: String
@NSManaged public var details: String
@NSManaged public var summary: String
@NSManaged public var time: Date
@NSManaged public var sunrise: Date?
@NSManaged public var sunset: Date?
@NSManaged public var apparentTemperature: Double
@NSManaged public var temperature: Double
@NSManaged public var humidity: Double
@NSManaged public var dewPoint: Double
@NSManaged public var cloudCover: Double
@NSManaged public var visibility: Double
@NSManaged public var windSpeed: Double
@NSManaged public var windBearing: UInt16
@NSManaged public var lastUpdated: Date
enum WrapperKeys: String, CodingKey {
case currently
case daily
}
enum CurrentlyKeys: String, CodingKey {
case icon
case temperature
case dewPoint
case humidity
case windSpeed
case windBearing
case summary
case cloudCover
case visibility
case apparentTemperature
}
enum DailyKeys: String, CodingKey {
case data
case details = "summary"
}
private struct SunTime: Codable {
enum CodingKeys: String, CodingKey {
case sunset = "sunsetTime"
case sunrise = "sunriseTime"
}
let sunset: Double
let sunrise: Double
}
public required convenience init(from decoder: Decoder) throws {
guard let context = decoder.userInfo[.context] as? NSManagedObjectContext else { fatalError() }
guard let entity = NSEntityDescription.entity(forEntityName: "Conditions", in: context) else { fatalError() }
self.init(entity: entity, insertInto: context)
let wrapper = try decoder.container(keyedBy: WrapperKeys.self)
let currently = try wrapper.nestedContainer(keyedBy: CurrentlyKeys.self, forKey: .currently)
self.icon = try currently.decode(String.self, forKey: .icon)
self.summary = try currently.decode(String.self, forKey: .summary)
self.temperature = try currently.decode(Double.self, forKey: .temperature)
self.apparentTemperature = try currently.decode(Double.self, forKey: .apparentTemperature)
self.dewPoint = try currently.decode(Double.self, forKey: .dewPoint)
self.humidity = try currently.decode(Double.self, forKey: .humidity)
self.visibility = try currently.decode(Double.self, forKey: .cloudCover)
self.cloudCover = try currently.decode(Double.self, forKey: .visibility)
self.windSpeed = try currently.decode(Double.self, forKey: .windSpeed)
self.windBearing = try currently.decode(UInt16.self, forKey: .windBearing)
let daily = try wrapper.nestedContainer(keyedBy: DailyKeys.self, forKey: .daily)
self.details = try daily.decode(String.self, forKey: .details)
let suntimes = try daily.decode([SunTime].self, forKey: .data)
self.sunset = Date(timeIntervalSince1970: suntimes.first?.sunset ?? 0)
self.sunrise = Date(timeIntervalSince1970: suntimes.first?.sunrise ?? 0)
self.lastUpdated = Date()
}
}
| mit | 47a8cfad827a734fec8945dab3ce5be5 | 33.732673 | 117 | 0.656784 | 4.818681 | false | false | false | false |
jgrantr/GRNetworkKit | Example/Pods/PromiseKit/Sources/Catchable.swift | 1 | 7986 | import Dispatch
/// Provides `catch` and `recover` to your object that conforms to `Thenable`
public protocol CatchMixin: Thenable
{}
public extension CatchMixin {
/**
The provided closure executes when this promise rejects.
Rejecting a promise cascades: rejecting all subsequent promises (unless
recover is invoked) thus you will typically place your catch at the end
of a chain. Often utility promises will not have a catch, instead
delegating the error handling to the caller.
- Parameter on: The queue to which the provided closure dispatches.
- Parameter policy: The default policy does not execute your handler for cancellation errors.
- Parameter execute: The handler to execute if this promise is rejected.
- Returns: A promise finalizer.
- SeeAlso: [Cancellation](http://promisekit.org/docs/)
*/
@discardableResult
func `catch`(on: DispatchQueue? = conf.Q.return, policy: CatchPolicy = conf.catchPolicy, _ body: @escaping(Error) -> Void) -> PMKFinalizer {
let finalizer = PMKFinalizer()
pipe {
switch $0 {
case .rejected(let error):
guard policy == .allErrors || !error.isCancelled else {
fallthrough
}
on.async {
body(error)
finalizer.pending.resolve(())
}
case .fulfilled:
finalizer.pending.resolve(())
}
}
return finalizer
}
}
public class PMKFinalizer {
let pending = Guarantee<Void>.pending()
/// `finally` is the same as `ensure`, but it is not chainable
public func finally(_ body: @escaping () -> Void) {
pending.guarantee.done(body)
}
}
public extension CatchMixin {
/**
The provided closure executes when this promise rejects.
Unlike `catch`, `recover` continues the chain.
Use `recover` in circumstances where recovering the chain from certain errors is a possibility. For example:
firstly {
CLLocationManager.requestLocation()
}.recover { error in
guard error == CLError.unknownLocation else { throw error }
return .value(CLLocation.chicago)
}
- Parameter on: The queue to which the provided closure dispatches.
- Parameter body: The handler to execute if this promise is rejected.
- SeeAlso: [Cancellation](http://promisekit.org/docs/)
*/
func recover<U: Thenable>(on: DispatchQueue? = conf.Q.map, policy: CatchPolicy = conf.catchPolicy, _ body: @escaping(Error) throws -> U) -> Promise<T> where U.T == T {
let rp = Promise<U.T>(.pending)
pipe {
switch $0 {
case .fulfilled(let value):
rp.box.seal(.fulfilled(value))
case .rejected(let error):
if policy == .allErrors || !error.isCancelled {
on.async {
do {
let rv = try body(error)
guard rv !== rp else { throw PMKError.returnedSelf }
rv.pipe(to: rp.box.seal)
} catch {
rp.box.seal(.rejected(error))
}
}
} else {
rp.box.seal(.rejected(error))
}
}
}
return rp
}
/**
The provided closure executes when this promise rejects.
This variant of `recover` requires the handler to return a Guarantee, thus it returns a Guarantee itself and your closure cannot `throw`.
Note it is logically impossible for this to take a `catchPolicy`, thus `allErrors` are handled.
- Parameter on: The queue to which the provided closure dispatches.
- Parameter body: The handler to execute if this promise is rejected.
- SeeAlso: [Cancellation](http://promisekit.org/docs/)
*/
@discardableResult
func recover(on: DispatchQueue? = conf.Q.map, _ body: @escaping(Error) -> Guarantee<T>) -> Guarantee<T> {
let rg = Guarantee<T>(.pending)
pipe {
switch $0 {
case .fulfilled(let value):
rg.box.seal(value)
case .rejected(let error):
on.async {
body(error).pipe(to: rg.box.seal)
}
}
}
return rg
}
/**
The provided closure executes when this promise resolves, whether it rejects or not.
firstly {
UIApplication.shared.networkActivityIndicatorVisible = true
}.done {
//…
}.ensure {
UIApplication.shared.networkActivityIndicatorVisible = false
}.catch {
//…
}
- Parameter on: The queue to which the provided closure dispatches.
- Parameter body: The closure that executes when this promise resolves.
- Returns: A new promise, resolved with this promise’s resolution.
*/
func ensure(on: DispatchQueue? = conf.Q.return, _ body: @escaping () -> Void) -> Promise<T> {
let rp = Promise<T>(.pending)
pipe { result in
on.async {
body()
rp.box.seal(result)
}
}
return rp
}
/**
Consumes the Swift unused-result warning.
- Note: You should `catch`, but in situations where you know you don’t need a `catch`, `cauterize` makes your intentions clear.
*/
func cauterize() {
self.catch {
Swift.print("PromiseKit:cauterized-error:", $0)
}
}
}
public extension CatchMixin where T == Void {
/**
The provided closure executes when this promise rejects.
This variant of `recover` is specialized for `Void` promises and de-errors your chain returning a `Guarantee`, thus you cannot `throw` and you must handle all errors including cancellation.
- Parameter on: The queue to which the provided closure dispatches.
- Parameter body: The handler to execute if this promise is rejected.
- SeeAlso: [Cancellation](http://promisekit.org/docs/)
*/
@discardableResult
func recover(on: DispatchQueue? = conf.Q.map, _ body: @escaping(Error) -> Void) -> Guarantee<Void> {
let rg = Guarantee<Void>(.pending)
pipe {
switch $0 {
case .fulfilled:
rg.box.seal(())
case .rejected(let error):
on.async {
body(error)
rg.box.seal(())
}
}
}
return rg
}
/**
The provided closure executes when this promise rejects.
This variant of `recover` ensures that no error is thrown from the handler and allows specifying a catch policy.
- Parameter on: The queue to which the provided closure dispatches.
- Parameter body: The handler to execute if this promise is rejected.
- SeeAlso: [Cancellation](http://promisekit.org/docs/)
*/
func recover(on: DispatchQueue? = conf.Q.map, policy: CatchPolicy = conf.catchPolicy, _ body: @escaping(Error) throws -> Void) -> Promise<Void> {
let rg = Promise<Void>(.pending)
pipe {
switch $0 {
case .fulfilled:
rg.box.seal(.fulfilled(()))
case .rejected(let error):
if policy == .allErrors || !error.isCancelled {
on.async {
do {
rg.box.seal(.fulfilled(try body(error)))
} catch {
rg.box.seal(.rejected(error))
}
}
} else {
rg.box.seal(.rejected(error))
}
}
}
return rg
}
}
| mit | dccc8a57313be2eb2ce9917f39c97bab | 34.775785 | 194 | 0.554901 | 4.936881 | false | false | false | false |
byu-oit/ios-byuSuite | byuSuite/Apps/YTime/controller/YTimeRootViewController.swift | 1 | 8754 | //
// YTimeRootViewController.swift
// byuSuite
//
// Created by Eric Romrell on 5/18/17.
// Copyright © 2017 Brigham Young University. All rights reserved.
//
import CoreLocation
private let TIMESHEETS_SEGUE_ID = "showTimesheets"
private let CALENDAR_SEGUE_ID = "showCalendar"
class YTimeRootViewController: ByuViewController2, UITableViewDataSource, CLLocationManagerDelegate, YTimePunchDelegate {
private struct UI {
static var fadeDuration = 0.25
}
//MARK: Outlets
@IBOutlet private weak var tableView: UITableView!
@IBOutlet private weak var viewTimesheetButton: UIBarButtonItem!
//MARK: Properties
private var refreshControl = UIRefreshControl()
private var timesheet: YTimeTimesheet?
private var punch: YTimePunch? //This object will hold a punch from the time that the button is tapped, through when the location is discovered, and finally until it is sent off to the web service.
private var punchLocation: CLLocation? //This will contain the last valid known location of the user. If location services aren't enabled, this should be nil.
private var locationManager: CLLocationManager!
private var loadingView: LoadingView?
override func viewDidLoad() {
super.viewDidLoad()
//Set up the location manager and start receiving updates
locationManager = CLLocationManager()
locationManager.delegate = self
locationManager.requestWhenInUseAuthorization()
tableView.hideEmptyCells()
refreshControl = tableView.addDefaultRefreshControl(target: self, action: #selector(loadData))
loadData()
}
override func viewWillAppear(_ animated: Bool) {
locationManager.startUpdatingLocation()
NotificationCenter.default.addObserver(self, selector: #selector(viewWillEnterForeground), name: .UIApplicationWillEnterForeground, object: nil)
}
override func viewDidAppear(_ animated: Bool) {
//Query status of Location Services to display error if disabled when returning to view from PunchView.
if CLLocationManager.locationServicesEnabled() == false {
showLocationError()
}
}
override func viewWillDisappear(_ animated: Bool) {
locationManager.stopUpdatingLocation()
NotificationCenter.default.removeObserver(self)
}
@objc func viewWillEnterForeground() {
//Reload the data on the screen
spinner?.startAnimating()
tableView.isUserInteractionEnabled = false
tableView.alpha = 0
loadData()
}
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
if segue.identifier == TIMESHEETS_SEGUE_ID, let vc = segue.destination.childViewControllers.first as? YTimeJobsViewController, let jobs = timesheet?.jobs {
vc.jobs = jobs
} else if segue.identifier == CALENDAR_SEGUE_ID, let vc = segue.destination.childViewControllers.first as? YTimeCalendarViewController, let job = timesheet?.jobs.first {
//Use the first job, as this segue will only ever happen when the user only has one job
vc.job = job
}
}
deinit {
locationManager?.delegate = nil
}
//MARK: UITableViewDataSource/Delegate callbacks
func numberOfSections(in tableView: UITableView) -> Int {
//The first section contains all of the jobs, the second contains the hour summaries
return 2
}
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
//Return 2 for the weekly and period summaries
return section == 0 ? timesheet?.jobs.count ?? 0 : 2
}
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
if indexPath.section == 0 {
tableView.estimatedRowHeight = 100
return UITableViewAutomaticDimension
} else {
return 45
}
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
if indexPath.section == 0, let cell = tableView.dequeueReusableCell(for: indexPath, identifier: "jobCell") as? YTimeJobTableViewCell {
cell.delegate = self
cell.job = timesheet?.jobs[indexPath.row]
return cell
} else {
let cell = tableView.dequeueReusableCell(for: indexPath, identifier: "paySummary")
if indexPath.row == 0 {
cell.textLabel?.text = "Week Total:"
cell.detailTextLabel?.text = timesheet?.weeklyTotal
} else {
cell.textLabel?.text = "Pay Period Total:"
cell.detailTextLabel?.text = timesheet?.periodTotal
}
return cell
}
}
//MARK: CLLocationMangerDelegate callbacks
func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
if status == .denied || status == .restricted {
//Disable the table view so that nobody can quickly create a punch while we're segueing
self.tableView.isUserInteractionEnabled = false
//Remove queued punch and location
self.punchLocation = nil
self.punch = nil
showLocationError()
} else {
manager.startUpdatingLocation()
}
}
func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
punchLocation = locations.last
punchIfReady()
}
//MARK: YTimePunchDelegate callback
func createPunch(punchIn: Bool, job: YTimeJob, sender: Any) {
if let employeeRecord = job.employeeRecord {
let startRequest: (() -> Void) = {
self.loadingView = self.displayLoadingView(message: "Submitting Punch...")
//Disable the table to prevent inadvertent multiple taps
self.tableView.isUserInteractionEnabled = false
//Set value of punch only after confirmation has been given in case of duplicate punch.
self.punch = YTimePunch(employeeRecord: employeeRecord, clockingIn: punchIn)
//We are now ready to punch whenever a location has been found
self.punchIfReady()
}
if punchIn == job.clockedIn {
//Verify that they want to double punch
let status = punchIn ? "in" : "out"
displayActionSheet(from: sender, title: "You are already clocked \(status). Please confirm that you would like to clock \(status) again.", actions: [
UIAlertAction(title: "Confirm", style: .default, handler: { (_) in
startRequest()
})
])
} else {
startRequest()
}
}
}
//MARK: Listeners
@objc func loadData() {
YTimeClient.getTimesheet { (sheet, error) in
//If refreshing the table, end the refresh control. If loading view for first time, stop the spinner and make the table visible.
self.refreshControl.endRefreshing()
self.spinner?.stopAnimating()
UIView.animate(withDuration: UI.fadeDuration) {
self.tableView.isUserInteractionEnabled = true
self.tableView.alpha = 1
}
if let sheet = sheet {
self.timesheet = sheet
self.viewTimesheetButton.isEnabled = true
} else {
//If the timesheet has previously been loaded let the user stay on this screen.
if self.timesheet == nil {
super.displayAlert(error: error)
} else {
super.displayAlert(error: error, alertHandler: nil)
}
}
self.tableView.reloadData()
}
}
@IBAction func didTapTimesheetButton(_ sender: Any) {
if timesheet?.jobs.count ?? 0 > 1 {
performSegue(withIdentifier: TIMESHEETS_SEGUE_ID, sender: sender)
} else {
performSegue(withIdentifier: CALENDAR_SEGUE_ID, sender: sender)
}
}
//MARK: Private functions
private func punchIfReady() {
if let location = punchLocation, let punch = punch {
punch.location = location
//Reset the punch location so that it will not be cached and sent again for a future punch.
self.punch = nil
self.punchLocation = nil
YTimeClient.createPunch(punch) { (sheet, error) in
self.loadingView?.removeFromSuperview()
self.tableView.isUserInteractionEnabled = true
if let sheet = sheet {
self.timesheet = sheet
self.showToast(message: "Your punch was submitted successfully.", dismissDelay: 5)
self.viewTimesheetButton.isEnabled = true
} else {
super.displayAlert(error: error, alertHandler: nil)
}
self.tableView.reloadData()
}
}
}
private func showLocationError() {
let alert = UIAlertController(title: "Location Services Required", message: "In order to use the Y-Time feature, location services must be enabled. Please change your settings to allow for this.", preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "OK", style: .cancel, handler: { (_) in
self.popBack()
}))
alert.addAction(UIAlertAction(title: "Settings", style: .default, handler: { (_) in
//Pop back so that they have to reenter the feature (and go through the same location permission requirements)
self.popBack()
if let url = URL(string: UIApplicationOpenSettingsURLString) {
UIApplication.open(url: url)
}
}))
//Only display the alert if the root View Controller is currently displayed
if self.view.window != nil {
present(alert, animated: true)
}
}
}
| apache-2.0 | 6dc223bc7bad16af3673ab6d2e2ad9de | 32.795367 | 222 | 0.725123 | 4.182035 | false | false | false | false |
Hout/Period | Pod/Classes/PeriodOperators.swift | 1 | 2350 | //
// PeriodOperators.swift
// Pods
//
// Created by Jeroen Houtzager on 09/11/15.
//
//
extension NSDate {
/// Returns `true` when the receiver date is within the period.
///
/// - Parameters:
/// - period: the period to evaluate the date against
///
/// - Returns: `true` if the date is within the period, `false` if it is before the start date or after the end date.
///
/// - Note: start- and end dates are part of the period!
public func inPeriod(period: Period) -> Bool {
if self.compare(period.startDate) == NSComparisonResult.OrderedAscending {
return false
}
if self.compare(period.endDate) == NSComparisonResult.OrderedDescending {
return false
}
return true
}
}
extension Period {
/// Returns `true` when the receiver period is within the given period.
///
/// - Parameters:
/// - period: the period to evaluate the receiver against
///
/// - Returns: `true` if the receiver period is completely within the given period,
/// `false` if the receiver start date is before `period` start date or the receiver end date is after `period` end date.
///
/// - Note: start- and end dates are part of the period!
public func inPeriod(period: Period) -> Bool {
if startDate.compare(period.startDate) == NSComparisonResult.OrderedAscending {
return false
}
if endDate.compare(period.endDate) == NSComparisonResult.OrderedDescending {
return false
}
return true
}
/// Returns `true` when the receiver period overlaps the given period.
///
/// - Parameters:
/// - period: the period to evaluate the receiver against
///
/// - Returns: `true` if the receiver period overlaps within the given period,
/// `false` if the receiver ends before `period` or the receiver starts after `period`.
///
/// - Note: start- and end dates are part of the period!
public func overlapsPeriod(period: Period) -> Bool {
if startDate.compare(period.endDate) == NSComparisonResult.OrderedDescending {
return false
}
if endDate.compare(period.startDate) == NSComparisonResult.OrderedAscending {
return false
}
return true
}
}
| mit | 8c394ed00addf820fd7f067c38b49fdf | 33.057971 | 129 | 0.619574 | 4.598826 | false | false | false | false |
coinbase/coinbase-ios-sdk | Tests/Integration/UserResourceSpec.swift | 1 | 2816 | //
// UserSpec.swift
// Coinbase
//
// Copyright © 2018 Coinbase, Inc. All rights reserved.
//
@testable import CoinbaseSDK
import Quick
import Nimble
import OHHTTPStubs
class UserResourceSpec: QuickSpec, IntegrationSpecProtocol {
override func spec() {
describe("UserResource") {
let userResource = specVar { Coinbase(accessToken: StubConstants.accessToken).userResource }
describe("current") {
itBehavesLikeResource(with: "auth_user.json",
requestedBy: { comp in userResource().current(completion: comp) },
expectationsForRequest: request(ofMethod: .get) && url(withPath: "/user") && hasAuthorization(),
expectationsForResult: successfulResult(ofType: User.self))
}
describe("get(by: ") {
let userID = "user_id"
itBehavesLikeResource(with: "user_by_id.json",
requestedBy: { comp in userResource().get(by: userID, completion: comp) },
expectationsForRequest: request(ofMethod: .get) && url(withPath: "/users/\(userID)") && hasAuthorization(),
expectationsForResult: successfulResult(ofType: User.self))
}
describe("authorizationInfo") {
itBehavesLikeResource(with: "auth_info.json",
requestedBy: { comp in userResource().authorizationInfo(completion: comp) },
expectationsForRequest: request(ofMethod: .get) && url(withPath: "/user/auth") && hasAuthorization(),
expectationsForResult: successfulResult(ofType: AuthorizationInfo.self))
}
describe("updateCurrent") {
let newName = "newName"
let timeZone = "newTimeZone"
let nativeCurrency = "newNativeCurrency"
let expectedBody = [
"name": newName,
"time_zone": timeZone,
"native_currency": nativeCurrency
]
itBehavesLikeResource(with: "auth_user.json",
requestedBy: { comp in userResource().updateCurrent(name: newName, timeZone: timeZone, nativeCurrency: nativeCurrency, completion: comp) },
expectationsForRequest: request(ofMethod: .put) && url(withPath: "/user") && hasAuthorization() && hasBody(parameters: expectedBody),
expectationsForResult: successfulResult(ofType: User.self))
}
}
}
}
| apache-2.0 | b6a1aafed86eeda688d8fefd25524fc3 | 48.385965 | 177 | 0.528952 | 5.926316 | false | false | false | false |
uasys/swift | test/IRGen/protocol_metadata.swift | 4 | 6760 | // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -primary-file %s -emit-ir -disable-objc-attr-requires-foundation-module | %FileCheck %s
// REQUIRES: CPU=x86_64
// REQUIRES: objc_interop
protocol A { func a() }
protocol B { func b() }
protocol C : class { func c() }
@objc protocol O { func o() }
@objc protocol OPT {
@objc optional func opt()
@objc optional static func static_opt()
@objc optional var prop: O { get }
@objc optional subscript (x: O) -> O { get }
}
protocol AB : A, B { func ab() }
protocol ABO : A, B, O { func abo() }
// CHECK: @_T017protocol_metadata1AMp = hidden constant %swift.protocol {
// -- size 72
// -- flags: 1 = Swift | 2 = Not Class-Constrained | 4 = Needs Witness Table
// CHECK-SAME: i32 72, i32 7,
// CHECK-SAME: i16 1, i16 1,
// CHECK-SAME: i32 trunc (i64 sub (i64 ptrtoint ([1 x %swift.protocol_requirement]* [[A_REQTS:@.*]] to i64), i64 ptrtoint (i32* getelementptr inbounds (%swift.protocol, %swift.protocol* @_T017protocol_metadata1AMp, i32 0, i32 12) to i64)) to i32)
// CHECK-SAME: }
// CHECK: @_T017protocol_metadata1BMp = hidden constant %swift.protocol {
// CHECK-SAME: i32 72, i32 7,
// CHECK-SAME: i16 1, i16 1,
// CHECK-SAME: i32 trunc (i64 sub (i64 ptrtoint ([1 x %swift.protocol_requirement]* [[B_REQTS:@.*]] to i64), i64 ptrtoint (i32* getelementptr inbounds (%swift.protocol, %swift.protocol* @_T017protocol_metadata1BMp, i32 0, i32 12) to i64)) to i32)
// CHECK: }
// CHECK: @_T017protocol_metadata1CMp = hidden constant %swift.protocol {
// -- flags: 1 = Swift | 4 = Needs Witness Table
// CHECK-SAME: i32 72, i32 5,
// CHECK-SAME: i16 1, i16 1,
// CHECK-SAME: i32 trunc (i64 sub (i64 ptrtoint ([1 x %swift.protocol_requirement]* [[C_REQTS:@.*]] to i64), i64 ptrtoint (i32* getelementptr inbounds (%swift.protocol, %swift.protocol* @_T017protocol_metadata1CMp, i32 0, i32 12) to i64)) to i32)
// CHECK-SAME: }
// -- @objc protocol O uses ObjC symbol mangling and layout
// CHECK: @_PROTOCOL__TtP17protocol_metadata1O_ = private constant { {{.*}} i32, [1 x i8*]*, i8*, i8* } {
// CHECK-SAME: @_PROTOCOL_INSTANCE_METHODS__TtP17protocol_metadata1O_,
// -- size, flags: 1 = Swift
// CHECK-SAME: i32 96, i32 1
// CHECK-SAME: @_PROTOCOL_METHOD_TYPES__TtP17protocol_metadata1O_
// CHECK-SAME: }
// CHECK: [[A_REQTS]] = internal unnamed_addr constant [1 x %swift.protocol_requirement] [%swift.protocol_requirement { i32 17, i32 0 }]
// CHECK: [[B_REQTS]] = internal unnamed_addr constant [1 x %swift.protocol_requirement] [%swift.protocol_requirement { i32 17, i32 0 }]
// CHECK: [[C_REQTS]] = internal unnamed_addr constant [1 x %swift.protocol_requirement] [%swift.protocol_requirement { i32 17, i32 0 }]
// -- @objc protocol OPT uses ObjC symbol mangling and layout
// CHECK: @_PROTOCOL__TtP17protocol_metadata3OPT_ = private constant { {{.*}} i32, [4 x i8*]*, i8*, i8* } {
// CHECK-SAME: @_PROTOCOL_INSTANCE_METHODS_OPT__TtP17protocol_metadata3OPT_,
// CHECK-SAME: @_PROTOCOL_CLASS_METHODS_OPT__TtP17protocol_metadata3OPT_,
// -- size, flags: 1 = Swift
// CHECK-SAME: i32 96, i32 1
// CHECK-SAME: @_PROTOCOL_METHOD_TYPES__TtP17protocol_metadata3OPT_
// CHECK-SAME: }
// -- inheritance lists for refined protocols
// CHECK: [[AB_INHERITED:@.*]] = private constant { {{.*}}* } {
// CHECK: i64 2,
// CHECK: %swift.protocol* @_T017protocol_metadata1AMp,
// CHECK: %swift.protocol* @_T017protocol_metadata1BMp
// CHECK: }
// CHECK: [[AB_REQTS:@.*]] = internal unnamed_addr constant [3 x %swift.protocol_requirement] [%swift.protocol_requirement zeroinitializer, %swift.protocol_requirement zeroinitializer, %swift.protocol_requirement { i32 17, i32 0 }]
// CHECK: @_T017protocol_metadata2ABMp = hidden constant %swift.protocol {
// CHECK-SAME: [[AB_INHERITED]]
// CHECK-SAME: i32 72, i32 7,
// CHECK-SAME: i16 3, i16 3,
// CHECK-SAME: i32 trunc (i64 sub (i64 ptrtoint ([3 x %swift.protocol_requirement]* [[AB_REQTS]] to i64), i64 ptrtoint (i32* getelementptr inbounds (%swift.protocol, %swift.protocol* @_T017protocol_metadata2ABMp, i32 0, i32 12) to i64)) to i32)
// CHECK-SAME: }
// CHECK: [[ABO_INHERITED:@.*]] = private constant { {{.*}}* } {
// CHECK: i64 3,
// CHECK: %swift.protocol* @_T017protocol_metadata1AMp,
// CHECK: %swift.protocol* @_T017protocol_metadata1BMp,
// CHECK: {{.*}}* @_PROTOCOL__TtP17protocol_metadata1O_
// CHECK: }
protocol Comprehensive {
associatedtype Assoc : A
init()
func instanceMethod()
static func staticMethod()
var instance: Assoc { get set }
static var global: Assoc { get set }
}
// CHECK: [[COMPREHENSIVE_REQTS:@.*]] = internal unnamed_addr constant [11 x %swift.protocol_requirement]
// CHECK-SAME: [%swift.protocol_requirement { i32 6, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 7, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 2, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 17, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 1, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 19, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 20, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 21, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 3, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 4, i32 0 },
// CHECK-SAME: %swift.protocol_requirement { i32 5, i32 0 }]
func reify_metadata<T>(_ x: T) {}
// CHECK: define hidden swiftcc void @_T017protocol_metadata0A6_types{{[_0-9a-zA-Z]*}}F
func protocol_types(_ a: A,
abc: A & B & C,
abco: A & B & C & O) {
// CHECK: store %swift.protocol* @_T017protocol_metadata1AMp
// CHECK: call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(i1 true, %swift.type* null, i64 1, %swift.protocol** {{%.*}})
reify_metadata(a)
// CHECK: store %swift.protocol* @_T017protocol_metadata1AMp
// CHECK: store %swift.protocol* @_T017protocol_metadata1BMp
// CHECK: store %swift.protocol* @_T017protocol_metadata1CMp
// CHECK: call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(i1 false, %swift.type* null, i64 3, %swift.protocol** {{%.*}})
reify_metadata(abc)
// CHECK: store %swift.protocol* @_T017protocol_metadata1AMp
// CHECK: store %swift.protocol* @_T017protocol_metadata1BMp
// CHECK: store %swift.protocol* @_T017protocol_metadata1CMp
// CHECK: [[O_REF:%.*]] = load i8*, i8** @"\01l_OBJC_PROTOCOL_REFERENCE_$__TtP17protocol_metadata1O_"
// CHECK: [[O_REF_BITCAST:%.*]] = bitcast i8* [[O_REF]] to %swift.protocol*
// CHECK: store %swift.protocol* [[O_REF_BITCAST]]
// CHECK: call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(i1 false, %swift.type* null, i64 4, %swift.protocol** {{%.*}})
reify_metadata(abco)
}
| apache-2.0 | 8a0f75837d1888fa48198321de201b67 | 51.403101 | 248 | 0.670414 | 3.148579 | false | false | false | false |
ibm-cloud-security/appid-clientsdk-swift | Source/IBMCloudAppID/internal/SecurityUtils.swift | 1 | 10424 | /* * Copyright 2016, 2017 IBM Corp.
* 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
internal class SecurityUtils {
private static func getKeyBitsFromKeyChain(_ tag:String) throws -> Data {
let keyAttr : [NSString:AnyObject] = [
kSecClass : kSecClassKey,
kSecAttrApplicationTag: tag as AnyObject,
kSecAttrKeyType : kSecAttrKeyTypeRSA,
kSecReturnData : true as AnyObject
]
var result: AnyObject?
let status = SecItemCopyMatching(keyAttr as CFDictionary, &result)
guard status == errSecSuccess else {
throw AppIDError.generalError
}
return result as! Data
}
internal static func generateKeyPairAttrs(_ keySize:Int, publicTag:String, privateTag:String) -> [NSString:AnyObject] {
let privateKeyAttr : [NSString:AnyObject] = [
kSecAttrIsPermanent : true as AnyObject,
kSecAttrApplicationTag : privateTag as AnyObject,
kSecAttrKeyClass : kSecAttrKeyClassPrivate,
kSecAttrAccessible: AppID.secAttrAccess.rawValue
]
let publicKeyAttr : [NSString:AnyObject] = [
kSecAttrIsPermanent : true as AnyObject,
kSecAttrApplicationTag : publicTag as AnyObject,
kSecAttrKeyClass : kSecAttrKeyClassPublic,
kSecAttrAccessible: AppID.secAttrAccess.rawValue
]
let keyPairAttr : [NSString:AnyObject] = [
kSecAttrKeyType : kSecAttrKeyTypeRSA,
kSecAttrAccessible: AppID.secAttrAccess.rawValue,
kSecAttrKeySizeInBits : keySize as AnyObject,
kSecPublicKeyAttrs : publicKeyAttr as AnyObject,
kSecPrivateKeyAttrs : privateKeyAttr as AnyObject
]
return keyPairAttr
}
internal static func generateKeyPair(_ keySize:Int, publicTag:String, privateTag:String) throws {
//make sure keys are deleted
_ = SecurityUtils.deleteKeyFromKeyChain(publicTag)
_ = SecurityUtils.deleteKeyFromKeyChain(privateTag)
var status:OSStatus = noErr
var privateKey:SecKey?
var publicKey:SecKey?
let keyPairAttr = generateKeyPairAttrs(keySize, publicTag: publicTag, privateTag: privateTag)
status = SecKeyGeneratePair(keyPairAttr as CFDictionary, &publicKey, &privateKey)
if (status != errSecSuccess) {
throw AppIDError.generalError
}
}
static func getKeyRefFromKeyChain(_ tag:String) throws -> SecKey {
let keyAttr : [NSString:AnyObject] = [
kSecClass : kSecClassKey,
kSecAttrApplicationTag: tag as AnyObject,
kSecAttrKeyType : kSecAttrKeyTypeRSA,
kSecReturnRef : kCFBooleanTrue
]
var result: AnyObject?
let status = SecItemCopyMatching(keyAttr as CFDictionary, &result)
guard status == errSecSuccess else {
throw AppIDError.generalError
}
return result as! SecKey
}
internal static func getItemFromKeyChain(_ label:String) -> String? {
let query: [NSString: AnyObject] = [
kSecClass: kSecClassGenericPassword,
kSecAttrService: label as AnyObject,
kSecReturnData: kCFBooleanTrue
]
var results: AnyObject?
let status = SecItemCopyMatching(query as CFDictionary, &results)
if status == errSecSuccess {
let data = results as! Data
let password = String(data: data, encoding: String.Encoding.utf8)!
return password
}
return nil
}
public static func getJWKSHeader() throws ->[String:Any] {
let publicKey = try? SecurityUtils.getKeyBitsFromKeyChain(AppIDConstants.publicKeyIdentifier)
guard let unWrappedPublicKey = publicKey, let pkModulus : Data = getPublicKeyMod(unWrappedPublicKey), let pkExponent : Data = getPublicKeyExp(unWrappedPublicKey) else {
throw AppIDError.generalError
}
let mod:String = Utils.base64StringFromData(pkModulus, isSafeUrl: true)
let exp:String = Utils.base64StringFromData(pkExponent, isSafeUrl: true)
let publicKeyJSON : [String:Any] = [
"e" : exp as AnyObject,
"n" : mod as AnyObject,
"kty" : AppIDConstants.JSON_RSA_VALUE
]
return publicKeyJSON
}
private static func getPublicKeyMod(_ publicKeyBits: Data) -> Data? {
var iterator : Int = 0
iterator += 1 // TYPE - bit stream - mod + exp
_ = derEncodingGetSizeFrom(publicKeyBits, at:&iterator) // Total size
iterator += 1 // TYPE - bit stream mod
let mod_size : Int = derEncodingGetSizeFrom(publicKeyBits, at:&iterator)
// Ensure we got an exponent size
guard mod_size != -1, let range = Range(NSMakeRange(iterator, mod_size)) else {
return nil
}
return publicKeyBits.subdata(in: range)
}
//Return public key exponent
private static func getPublicKeyExp(_ publicKeyBits: Data) -> Data? {
var iterator : Int = 0
iterator += 1 // TYPE - bit stream - mod + exp
_ = derEncodingGetSizeFrom(publicKeyBits, at:&iterator) // Total size
iterator += 1// TYPE - bit stream mod
let mod_size : Int = derEncodingGetSizeFrom(publicKeyBits, at:&iterator)
iterator += mod_size
iterator += 1 // TYPE - bit stream exp
let exp_size : Int = derEncodingGetSizeFrom(publicKeyBits, at:&iterator)
//Ensure we got an exponent size
guard exp_size != -1, let range = Range(NSMakeRange(iterator, exp_size)) else {
return nil
}
return publicKeyBits.subdata(in: range)
}
private static func derEncodingGetSizeFrom(_ buf : Data, at iterator: inout Int) -> Int{
// Have to cast the pointer to the right size
//let pointer = UnsafePointer<UInt8>((buf as NSData).bytes)
//let count = buf.count
// Get our buffer pointer and make an array out of it
//let buffer = UnsafeBufferPointer<UInt8>(start:pointer, count:count)
let data = buf//[UInt8](buffer)
var itr : Int = iterator
var num_bytes :UInt8 = 1
var ret : Int = 0
if (data[itr] > 0x80) {
num_bytes = data[itr] - 0x80
itr += 1
}
for i in 0 ..< Int(num_bytes) {
ret = (ret * 0x100) + Int(data[itr + i])
}
iterator = itr + Int(num_bytes)
return ret
}
internal static func signString(_ payloadString:String, keyIds ids:(publicKey: String, privateKey: String), keySize: Int) throws -> String {
do {
let privateKeySec = try getKeyRefFromKeyChain(ids.privateKey)
guard let payloadData : Data = payloadString.data(using: String.Encoding.utf8) else {
throw AppIDError.generalError
}
let signedData = try signData(payloadData, privateKey:privateKeySec)
//return signedData.base64EncodedString()
return Utils.base64StringFromData(signedData, isSafeUrl: true)
}
catch {
throw AppIDError.generalError
}
}
private static func signData(_ data:Data, privateKey:SecKey) throws -> Data {
func doSha256(_ dataIn:Data) throws -> Data {
var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
dataIn.withUnsafeBytes {
_ = CC_SHA256($0, CC_LONG(dataIn.count), &hash)
}
return Data(bytes: hash)
}
guard let digest:Data = try? doSha256(data), let signedData: NSMutableData = NSMutableData(length: SecKeyGetBlockSize(privateKey)) else {
throw AppIDError.generalError
}
var signedDataLength: Int = signedData.length
let digestBytes: UnsafePointer<UInt8> = ((digest as NSData).bytes).bindMemory(to: UInt8.self, capacity: digest.count)
let digestlen = digest.count
let mutableBytes: UnsafeMutablePointer<UInt8> = signedData.mutableBytes.assumingMemoryBound(to: UInt8.self)
let signStatus:OSStatus = SecKeyRawSign(privateKey, SecPadding.PKCS1SHA256, digestBytes, digestlen,
mutableBytes, &signedDataLength)
guard signStatus == errSecSuccess else {
throw AppIDError.generalError
}
return signedData as Data
}
internal static func saveItemToKeyChain(_ data:String, label: String) -> Bool{
guard let stringData = data.data(using: String.Encoding.utf8) else {
return false
}
let key: [NSString: AnyObject] = [
kSecClass: kSecClassGenericPassword,
kSecAttrService: label as AnyObject,
kSecValueData: stringData as AnyObject
]
var status = SecItemAdd(key as CFDictionary, nil)
if(status != errSecSuccess){
if(SecurityUtils.removeItemFromKeyChain(label) == true) {
status = SecItemAdd(key as CFDictionary, nil)
}
}
return status == errSecSuccess
}
internal static func removeItemFromKeyChain(_ label: String) -> Bool{
let delQuery : [NSString:AnyObject] = [
kSecClass: kSecClassGenericPassword,
kSecAttrService: label as AnyObject
]
let delStatus:OSStatus = SecItemDelete(delQuery as CFDictionary)
return delStatus == errSecSuccess
}
internal static func deleteKeyFromKeyChain(_ tag:String) -> Bool{
let delQuery : [NSString:AnyObject] = [
kSecClass : kSecClassKey,
kSecAttrApplicationTag : tag as AnyObject
]
let delStatus:OSStatus = SecItemDelete(delQuery as CFDictionary)
return delStatus == errSecSuccess
}
}
| apache-2.0 | 7f7f479d20bd58893027ee9cd69f3776 | 36.228571 | 176 | 0.630276 | 5.09233 | false | false | false | false |
midmirror/MetaBrowser | MetaBrowser/MetaBrowser/Class/View/BottomToolbar.swift | 1 | 3095 | //
// BottomBar.swift
// MetaBrowser
//
// Created by midmirror on 17/6/22.
// Copyright © 2017年 midmirror. All rights reserved.
//
import UIKit
class BottomToolbar: UIToolbar {
typealias BackClosure = () -> Void
typealias ForwardClosure = () -> Void
typealias FunctionClosure = () -> Void
typealias HomeClosure = () -> Void
typealias PageClosure = () -> Void
var backClosure: BackClosure?
var forwardClosure:ForwardClosure?
var functionClosure: FunctionClosure?
var homeClosure: HomeClosure?
var pageClosure: PageClosure?
override init(frame: CGRect) {
super.init(frame: frame)
let icon = MetaBrowserIcon.init(color: .black, size: 25)
let spaceItem = UIBarButtonItem.init(barButtonSystemItem: .flexibleSpace, target: self, action: nil)
let backItem = UIBarButtonItem.init(image: icon.image(code: MetaBrowserIcon.back), style: UIBarButtonItemStyle.plain, target: self, action: #selector(goBack))
let forwardItem = UIBarButtonItem.init(image: icon.image(code: MetaBrowserIcon.forward), style: UIBarButtonItemStyle.plain, target: self, action: #selector(goForward))
let functionItem = UIBarButtonItem.init(image: icon.image(code: MetaBrowserIcon.function), style: UIBarButtonItemStyle.plain, target: self, action: #selector(touchFunction))
let homeItem = UIBarButtonItem.init(image: icon.image(code: MetaBrowserIcon.home), style: UIBarButtonItemStyle.plain, target: self, action: #selector(touchHome))
let pageItem = UIBarButtonItem.init(image: icon.image(code: MetaBrowserIcon.page), style: UIBarButtonItemStyle.plain, target: self, action: #selector(touchPage))
self.items = [backItem, spaceItem, forwardItem, spaceItem, functionItem, spaceItem, homeItem, spaceItem, pageItem]
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
func whenGoBack(closure: @escaping BackClosure) {
backClosure = closure
}
func whenGoForward(closure: @escaping ForwardClosure) {
forwardClosure = closure
}
func whenTouchFunction(closure: @escaping FunctionClosure) {
functionClosure = closure
}
func whenTouchHome(closure: @escaping HomeClosure) {
homeClosure = closure
}
func whenTouchPage(closure: @escaping PageClosure) {
pageClosure = closure
}
func goBack() {
if let backClosure = self.backClosure {
backClosure()
}
}
func goForward() {
if let forwardClosure = self.forwardClosure {
forwardClosure()
}
}
func touchFunction() {
if let functionClosure = self.functionClosure {
functionClosure()
}
}
func touchHome() {
if let homeClosure = self.homeClosure {
homeClosure()
}
}
func touchPage() {
if let pageClosure = self.pageClosure {
pageClosure()
}
}
}
| gpl-3.0 | df13b97a2d0561b673dbc1b4edb06bd6 | 31.893617 | 181 | 0.648771 | 4.656627 | false | false | false | false |
Alecrim/AlecrimAsyncKit | Sources/Error+Extensions.swift | 1 | 788 | //
// Errors.swift
// AlecrimAsyncKit
//
// Created by Vanderlei Martinelli on 09/03/18.
// Copyright © 2018 Alecrim. All rights reserved.
//
import Foundation
// MARK: -
extension Error {
internal var isUserCancelled: Bool {
let error = self as NSError
return error.domain == NSCocoaErrorDomain && error.code == NSUserCancelledError
}
}
//extension CustomNSError {
// internal var isUserCancelled: Bool {
// return type(of: self).errorDomain == NSCocoaErrorDomain && self.errorCode == NSUserCancelledError
// }
//}
// MAR: -
fileprivate let _userCancelledError = NSError(domain: NSCocoaErrorDomain, code: NSUserCancelledError, userInfo: nil)
extension Error {
internal static var userCancelled: Error { return _userCancelledError }
}
| mit | f56807291214514d2e01d41ddc89c99b | 23.59375 | 116 | 0.701398 | 4.324176 | false | false | false | false |
sublimter/Meijiabang | KickYourAss/KickYourAss/ArtistDetailFile/artistdDetailCell/ZXY_ChangeUserSexCell.swift | 3 | 1113 | //
// ZXY_ChangeUserSexCell.swift
// KickYourAss
//
// Created by 宇周 on 15/2/11.
// Copyright (c) 2015年 多思科技. All rights reserved.
//
import UIKit
let ZXY_ChangeUserSexCellID = "ZXY_ChangeUserSexCellID"
typealias ZXY_ChangeUserSexCellBlock = (flag: Int) -> Void
class ZXY_ChangeUserSexCell: UITableViewCell {
@IBOutlet weak var girlFlag: UIImageView!
@IBOutlet weak var boyFlag: UIImageView!
var userSelectBoyOrGirlBlock : ZXY_ChangeUserSexCellBlock!
override func awakeFromNib() {
super.awakeFromNib()
// Initialization code
}
override func setSelected(selected: Bool, animated: Bool) {
super.setSelected(selected, animated: animated)
// Configure the view for the selected state
}
@IBAction func selectGirl(sender: AnyObject) {
self.userSelectBoyOrGirlBlock(flag: 2)
girlFlag.hidden = false
boyFlag.hidden = true
}
@IBAction func selectBoy(sender: AnyObject) {
self.userSelectBoyOrGirlBlock(flag: 1)
girlFlag.hidden = true
boyFlag.hidden = false
}
}
| mit | 5a0ee97fff9c1a51387a645ee3542f78 | 25.166667 | 63 | 0.676979 | 4.040441 | false | false | false | false |
codesman/toolbox | Sources/VaporToolbox/DockerBuild.swift | 1 | 2085 | import Console
public final class DockerBuild: Command {
public let id = "build"
public let signature: [Argument] = []
public let help: [String] = [
"Builds the Docker application."
]
public let console: ConsoleProtocol
public init(console: ConsoleProtocol) {
self.console = console
}
public func run(arguments: [String]) throws {
do {
_ = try console.backgroundExecute("which docker")
} catch ConsoleError.subexecute(_, _) {
console.info("Visit https://www.docker.com/products/docker-toolbox")
throw ToolboxError.general("Docker not installed.")
}
do {
let contents = try console.backgroundExecute("ls .")
if !contents.contains("Dockerfile") {
throw ToolboxError.general("No Dockerfile found")
}
} catch ConsoleError.subexecute(_) {
throw ToolboxError.general("Could not check for Dockerfile")
}
let swiftVersion: String
do {
swiftVersion = try console.backgroundExecute("cat .swift-version").trim()
} catch {
throw ToolboxError.general("Could not determine Swift version from .swift-version file.")
}
let buildBar = console.loadingBar(title: "Building Docker image")
buildBar.start()
do {
let imageName = DockerBuild.imageName(version: swiftVersion)
_ = try console.backgroundExecute("docker build --rm -t \(imageName) --build-arg SWIFT_VERSION=\(swiftVersion) .")
buildBar.finish()
} catch ConsoleError.subexecute(_, let message) {
buildBar.fail()
throw ToolboxError.general("Docker build failed: \(message.trim())")
}
if console.confirm("Would you like to run the Docker image now?") {
let build = DockerRun(console: console)
try build.run(arguments: arguments)
}
}
static func imageName(version: String) -> String {
return "qutheory/swift:\(version)"
}
}
| mit | 97d1d9b72647a4b1e501892c336876fe | 31.578125 | 126 | 0.598561 | 4.771167 | false | false | false | false |
alessiobrozzi/firefox-ios | Client/Frontend/Browser/HomePageHelper.swift | 6 | 2539 | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import Foundation
import Shared
import XCGLogger
private let log = Logger.browserLogger
struct HomePageConstants {
static let HomePageURLPrefKey = "HomePageURLPref"
static let DefaultHomePageURLPrefKey = PrefsKeys.KeyDefaultHomePageURL
static let HomePageButtonIsInMenuPrefKey = PrefsKeys.KeyHomePageButtonIsInMenu
}
class HomePageHelper {
let prefs: Prefs
var currentURL: URL? {
get {
return HomePageAccessors.getHomePage(prefs)
}
set {
if let url = newValue, url.isWebPage(includeDataURIs: false) && !url.isLocal {
prefs.setString(url.absoluteString, forKey: HomePageConstants.HomePageURLPrefKey)
} else {
prefs.removeObjectForKey(HomePageConstants.HomePageURLPrefKey)
}
}
}
var defaultURLString: String? {
return HomePageAccessors.getDefaultHomePageString(prefs)
}
var isHomePageAvailable: Bool { return currentURL != nil }
init(prefs: Prefs) {
self.prefs = prefs
}
func openHomePage(_ tab: Tab) {
guard let url = currentURL else {
// this should probably never happen.
log.error("User requested a homepage that wasn't a valid URL")
return
}
tab.loadRequest(URLRequest(url: url))
}
func openHomePage(inTab tab: Tab, withNavigationController navigationController: UINavigationController?) {
if isHomePageAvailable {
openHomePage(tab)
} else {
setHomePage(toTab: tab, withNavigationController: navigationController)
}
}
func setHomePage(toTab tab: Tab, withNavigationController navigationController: UINavigationController?) {
let alertController = UIAlertController(
title: Strings.SetHomePageDialogTitle,
message: Strings.SetHomePageDialogMessage,
preferredStyle: UIAlertControllerStyle.alert)
alertController.addAction(UIAlertAction(title: Strings.SetHomePageDialogNo, style: .cancel, handler: nil))
alertController.addAction(UIAlertAction(title: Strings.SetHomePageDialogYes, style: .default) { _ in
self.currentURL = tab.url as URL?
})
navigationController?.present(alertController, animated: true, completion: nil)
}
}
| mpl-2.0 | c9e61cf0d059213f99e604f7055a7868 | 34.263889 | 114 | 0.675857 | 5.067864 | false | false | false | false |
goldmoment/UIViewStuff | UIViewStuff/Classes/USGradientLayer.swift | 1 | 2523 | //
// USGradientLayer.swift
// UIViewStuff
//
// Created by Vien Van Nguyen on 2/28/17.
//
//
import UIKit
public typealias USGradientPoint = (x: CGPoint, y: CGPoint)
public enum USGradientType {
case leftRight
case rightLeft
case topBottom
case bottomTop
case topLeftBottomRight
case bottomRightTopLeft
case topRightBottomLeft
case bottomLeftTopRight
func draw() -> USGradientPoint {
switch self {
case .leftRight:
return (x: CGPoint(x: 0, y: 0.5), y: CGPoint(x: 1, y: 0.5))
case .rightLeft:
return (x: CGPoint(x: 1, y: 0.5), y: CGPoint(x: 0, y: 0.5))
case .topBottom:
return (x: CGPoint(x: 0.5, y: 0), y: CGPoint(x: 0.5, y: 1))
case .bottomTop:
return (x: CGPoint(x: 0.5, y: 1), y: CGPoint(x: 0.5, y: 0))
case .topLeftBottomRight:
return (x: CGPoint(x: 0, y: 0), y: CGPoint(x: 1, y: 1))
case .bottomRightTopLeft:
return (x: CGPoint(x: 1, y: 1), y: CGPoint(x: 0, y: 0))
case .topRightBottomLeft:
return (x: CGPoint(x: 1, y: 0), y: CGPoint(x: 0, y: 1))
case .bottomLeftTopRight:
return (x: CGPoint(x: 0, y: 1), y: CGPoint(x: 1, y: 0))
}
}
}
public class USGradientLayer : CAGradientLayer {
public var gradientType: USGradientType? {
didSet {
applyPoint()
}
}
public convenience init(_ colors: [Any], gradientType: USGradientType? = .leftRight) {
self.init()
self.colors = colors.map({ (color) -> CGColor in
if let color = color as? Int {
return UIColor.init(UInt(color)).cgColor
}
if let color = color as? UIColor {
return color.cgColor
}
return UIColor.clear.cgColor
})
self.gradientType = gradientType
applyPoint()
}
private func applyPoint() {
if let gradientPoint = gradientType?.draw() {
startPoint = gradientPoint.x
endPoint = gradientPoint.y
}
}
}
public extension UIView {
public func addGradientLayer(_ colors: [Any], gradientType: USGradientType? = .leftRight) -> USGradientLayer {
let gradientLayer = USGradientLayer(colors, gradientType: gradientType)
gradientLayer.frame = self.layer.bounds
self.layer.addSublayer(gradientLayer)
return gradientLayer
}
}
| mit | f759c5119ff8aa7e96cca6ebde0ada2d | 28 | 114 | 0.559255 | 4.030351 | false | false | false | false |
alexbasson/swift-experiment | SwiftExperimentTests/Helpers/Mocks/MockJSONClient.swift | 1 | 756 | import Foundation
import SwiftExperiment
class MockJSONClient: JSONClientInterface {
class SendRequestParams {
var request: NSURLRequest!
var closure: JSONClientClosure!
init(request: NSURLRequest, closure: JSONClientClosure) {
self.request = request
self.closure = closure
}
}
var sendRequestInvocation = Invocation(wasReceived: false, params: nil)
func sendRequest(request: NSURLRequest, closure: JSONClientClosure) {
sendRequestInvocation.wasReceived = true
sendRequestInvocation.params = SendRequestParams(request: request, closure: closure)
}
}
extension MockJSONClient: Mockable {
func resetSentMessages() {
sendRequestInvocation.wasReceived = false
sendRequestInvocation.params = nil
}
} | mit | 193c553a7b43cb17854c8ebaaf5a3946 | 27.037037 | 88 | 0.757937 | 4.815287 | false | false | false | false |
beryu/DoneHUD | Source/DoneHUD.swift | 2 | 2437 | //
// DoneHUD.swift
// DoneHUD
//
// Created by Ryuta Kibe on 2015/08/23.
// Copyright (c) 2015 blk. All rights reserved.
//
import UIKit
open class DoneHUD: NSObject {
fileprivate static let sharedObject = DoneHUD()
let doneView = DoneView()
public static func showInView(_ view: UIView) {
DoneHUD.sharedObject.showInView(view, message: nil)
}
public static func showInView(_ view: UIView, message: String?) {
DoneHUD.sharedObject.showInView(view, message: message)
}
fileprivate func showInView(_ view: UIView, message: String?) {
// Set size of done view
let doneViewWidth = min(view.frame.width, view.frame.height) / 2
var originX: CGFloat, originY: CGFloat
if (UIDevice.current.systemVersion as NSString).floatValue >= 8.0 {
originX = (view.frame.width - doneViewWidth) / 2
originY = (view.frame.height - doneViewWidth) / 2
} else {
let isLandscape = UIDevice.current.orientation.isLandscape
originX = ((isLandscape ? view.frame.height : view.frame.width) - doneViewWidth) / 2
originY = ((isLandscape ? view.frame.width : view.frame.height) - doneViewWidth) / 2
}
let doneViewFrame = CGRect(
x: originX,
y: originY,
width: doneViewWidth,
height: doneViewWidth)
self.doneView.layer.cornerRadius = 8
self.doneView.frame = doneViewFrame
// Set message
self.doneView.setMessage(message)
// Start animation
self.doneView.alpha = 0
view.addSubview(self.doneView)
UIView.animate(withDuration: 0.2, animations: { () -> Void in
self.doneView.alpha = 1
}, completion: { (result: Bool) -> Void in
self.doneView.drawCheck({ () -> Void in
let delayTime = DispatchTime.now() + Double(Int64(0.5 * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)
DispatchQueue.main.asyncAfter(deadline: delayTime) {
UIView.animate(withDuration: 0.2, animations: { () -> Void in
self.doneView.alpha = 0
}, completion: { (result: Bool) -> Void in
self.doneView.removeFromSuperview()
self.doneView.clear()
})
}
})
})
}
}
| mit | a1056c3509517ae5edb88da36717972a | 36.492308 | 117 | 0.570784 | 4.55514 | false | false | false | false |
danielsaidi/KeyboardKit | Sources/KeyboardKit/Input/KeyboardInput.swift | 1 | 2022 | //
// KeyboardInputRow.swift
// KeyboardKit
//
// Created by Daniel Saidi on 2021-02-03.
// Copyright © 2021 Daniel Saidi. All rights reserved.
//
import Foundation
/**
This struct represents a keyboard input item, with an upper
and a lowercased string.
You can either create an instance with just a string, which
is the regular way of working with input sets. However, the
struct also supports specific casings, which means that you
can use it to create unicode keyboards as well.
*/
public struct KeyboardInput: Equatable {
public init(_ char: String) {
self.neutral = char
self.uppercased = char.uppercased()
self.lowercased = char.lowercased()
}
public init(
neutral: String,
uppercased: String,
lowercased: String) {
self.neutral = neutral
self.uppercased = uppercased
self.lowercased = lowercased
}
public let neutral: String
public let uppercased: String
public let lowercased: String
func character(for casing: KeyboardCasing) -> String {
switch casing {
case .lowercased: return lowercased
case .uppercased, .capsLocked: return uppercased
case .neutral: return neutral
}
}
}
/**
This typealias represents a list of keyboard inputs.
*/
public typealias KeyboardInputRow = [KeyboardInput]
public extension KeyboardInputRow {
init(_ row: [String]) {
self = row.map { KeyboardInput($0) }
}
func characters(for casing: KeyboardCasing = .lowercased) -> [String] {
map { $0.character(for: casing) }
}
}
/**
This typealias represents a list of keyboard input rows.
*/
public typealias KeyboardInputRows = [KeyboardInputRow]
public extension KeyboardInputRows {
init(_ rows: [[String]]) {
self = rows.map { KeyboardInputRow($0) }
}
func characters(for casing: KeyboardCasing = .lowercased) -> [[String]] {
map { $0.characters(for: casing) }
}
}
| mit | ccd36a0dcc23ed1c378172fb28dcd506 | 23.950617 | 77 | 0.649678 | 4.461369 | false | false | false | false |
Aster0id/Swift-StudyNotes | Swift-StudyNotes/AppDelegate.swift | 1 | 941 | //
// AppDelegate.swift
// Swift-StudyNotes
//
// Created by 牛萌 on 15/5/14.
// Copyright (c) 2015年 Aster0id.Team. All rights reserved.
//
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
var l1s1 = Lesson1Section1()
l1s1.run(false)
var l2s1 = Lesson2Section1()
l2s1.run(false)
var l2s2 = Lesson2Section2()
l2s2.run(false)
var l2s3 = Lesson2Section3()
l2s3.run(false)
var l2s4 = Lesson2Section4()
l2s4.run(false)
var l2s5 = Lesson2Section5()
l2s5.run(false)
var l2s6 = Lesson2Section6()
l2s6.run(true)
return true
}
}
| mit | 53b2949f2317642c69ad26e63463b96c | 19.326087 | 127 | 0.572193 | 3.652344 | false | false | false | false |
hoowang/WKRefreshDemo | RefreshToolkit/Other/ScrollViewCategory.swift | 1 | 971 | //
// ScrollViewCategory.swift
// WKRefreshDemo
//
// Created by hooge on 16/4/28.
// Copyright © 2016年 hooge. All rights reserved.
//
import UIKit
public extension UIScrollView{
var wk_InsetTop: CGFloat {
set {
var insets: UIEdgeInsets = self.contentInset
insets.top = newValue
self.contentInset = insets
}
get {
return self.contentInset.top
}
}
var wk_InsetBottom: CGFloat {
set {
var insets: UIEdgeInsets = self.contentInset
insets.bottom = newValue
self.contentInset = insets
}
get {
return self.contentInset.top
}
}
var wk_OffsetY: CGFloat {
set {
var offset: CGPoint = self.contentOffset
offset.y = newValue
self.contentOffset = offset
}
get {
return self.contentOffset.y
}
}
} | mit | 0829f7b42c0cbd2aab231f7e194ff614 | 20.533333 | 56 | 0.527893 | 4.768473 | false | false | false | false |
karyjan/KMediaPlayer | KMediaPlayer/VolumeView.swift | 1 | 1691 | //
// VolumeView.swift
// MobilePlayer
//
// Created by Toygar Dündaralp on 25/06/15.
// Copyright (c) 2015 MovieLaLa. All rights reserved.
//
import UIKit
import MediaPlayer
private let defaultIncreaseVolumeTintColor = UIColor.blackColor()
private let defaultReduceVolumeTintColor = UIColor.blackColor()
class VolumeView: UIView {
let volumeSlider = MPVolumeView(frame: CGRect(x: -22, y: 50, width: 110, height: 50))
let increaseVolumeImage = UIImageView(frame: CGRect(x: 10, y: 0, width: 20, height: 20))
let reduceVolumeImage = UIImageView(frame: CGRect(x: 10, y: 130, width: 20, height: 20))
init(
increaseVolumeTintColor: UIColor = defaultIncreaseVolumeTintColor,
reduceVolumeTintColor: UIColor = defaultReduceVolumeTintColor) {
super.init(frame: CGRectZero)
layer.cornerRadius = 5
layer.borderColor = UIColor.grayColor().CGColor
layer.borderWidth = 0.5
layer.masksToBounds = true
backgroundColor = UIColor.whiteColor()
volumeSlider.transform = CGAffineTransformMakeRotation(CGFloat(-M_PI_2))
volumeSlider.showsRouteButton = false
addSubview(volumeSlider)
increaseVolumeImage.contentMode = .ScaleAspectFit;
increaseVolumeImage.image = UIImage(named: "MLIncreaseVolume")
increaseVolumeImage.tintColor = increaseVolumeTintColor
addSubview(increaseVolumeImage)
reduceVolumeImage.contentMode = .ScaleAspectFit;
reduceVolumeImage.image = UIImage(named: "MLReduceVolume")
reduceVolumeImage.tintColor = reduceVolumeTintColor
addSubview(reduceVolumeImage)
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
}
| apache-2.0 | 5018c7cba36e73f59746f5a531e9f9c5 | 36.555556 | 90 | 0.739053 | 4.617486 | false | false | false | false |
Jamol/Nutil | Sources/http/Http1xResponse.swift | 1 | 6473 | //
// Http1xResponse.swift
// Nutil
//
// Created by Jamol Bao on 11/12/16.
// Copyright © 2015 Jamol Bao. All rights reserved.
//
import Foundation
class Http1xResponse : TcpConnection, HttpResponse, HttpParserDelegate, MessageSender {
fileprivate let parser = HttpParser()
fileprivate var version = "HTTP/1.1"
enum State: Int, Comparable {
case idle
case receivingRequest
case waitForResponse
case sendingHeader
case sendingBody
case completed
case error
case closed
}
fileprivate var state = State.idle
fileprivate var cbData: DataCallback?
fileprivate var cbHeader: EventCallback?
fileprivate var cbRequest: EventCallback?
fileprivate var cbReponse: EventCallback?
fileprivate var cbError: ErrorCallback?
fileprivate var cbSend: EventCallback?
fileprivate var message = HttpMessage()
override init() {
super.init()
parser.delegate = self
message.sender = self
}
convenience init(version: String) {
self.init()
self.version = version
}
fileprivate func setState(_ state: State) {
self.state = state
}
fileprivate func cleanup() {
super.close()
}
override func attachFd(_ fd: SOCKET_FD, _ initData: UnsafeRawPointer?, _ initSize: Int) -> KMError {
setState(.receivingRequest)
return super.attachFd(fd, initData, initSize)
}
func addHeader(_ name: String, _ value: String) {
message.addHeader(name, value)
}
func addHeader(_ name: String, _ value: Int) {
message.addHeader(name, value)
}
func sendResponse(_ statusCode: Int, _ desc: String?) -> KMError {
infoTrace("Http1xResponse.sendResponse, status=\(statusCode), state=\(state)")
if state != .waitForResponse {
return .invalidState
}
let rsp = message.buildHeader(statusCode, desc, version)
setState(.sendingHeader)
let ret = send(rsp)
if ret < 0 {
errTrace("Http1xResponse.sendResponse, failed to send response")
setState(.error)
return .sockError
} else if sendBufferEmpty() {
if message.hasBody {
setState(.sendingBody)
socket.async {
self.cbSend?()
}
} else {
setState(.completed)
socket.async {
self.cbReponse?()
}
}
}
return .noError
}
func sendData(_ data: UnsafeRawPointer?, _ len: Int) -> Int {
if !sendBufferEmpty() || state != .sendingBody {
return 0
}
let ret = message.sendData(data, len)
if ret >= 0 {
if message.isCompleted && sendBufferEmpty() {
setState(.completed)
socket.async {
self.cbReponse?()
}
}
} else if ret < 0 {
setState(.error)
}
return ret
}
func sendString(_ str: String) -> Int {
return sendData(UnsafePointer<UInt8>(str), str.utf8.count)
}
override func reset() {
super.reset()
parser.reset()
message.reset()
setState(.receivingRequest)
}
override func close() {
cleanup()
}
override func handleInputData(_ data: UnsafeMutablePointer<UInt8>, _ len: Int) -> Bool {
let ret = parser.parse(data: data, len: len)
if ret != len {
warnTrace("Http1xResponse.handleInputData, ret=\(ret), len=\(len)")
}
return true
}
override func handleOnSend() {
super.handleOnSend()
if state == .sendingHeader {
if message.hasBody {
setState(.sendingBody)
} else {
setState(.completed)
cbReponse?()
return
}
cbSend?()
} else if state == .sendingBody {
if message.isCompleted {
setState(.completed)
cbReponse?()
return
}
cbSend?()
}
}
override func handleOnError(err: KMError) {
infoTrace("Http1xResponse.handleOnError, err=\(err)")
onHttpError(err: err)
}
func onHttpData(data: UnsafeMutableRawPointer, len: Int) {
//infoTrace("onData, len=\(len), total=\(parser.bodyBytesRead)")
cbData?(data, len)
}
func onHttpHeaderComplete() {
infoTrace("Http1xResponse.onHeaderComplete, method=\(parser.method), url=\(parser.urlString)")
cbHeader?()
}
func onHttpComplete() {
infoTrace("Http1xResponse.onRequestComplete, bodyReceived=\(parser.bodyBytesRead)")
setState(.waitForResponse)
cbRequest?()
}
func onHttpError(err: KMError) {
infoTrace("Http1xResponse.onHttpError")
if state < State.completed {
setState(.error)
cbError?(err)
} else {
setState(.closed)
}
}
}
extension Http1xResponse {
@discardableResult func onData(_ cb: @escaping (UnsafeMutableRawPointer, Int) -> Void) -> Self {
cbData = cb
return self
}
@discardableResult func onHeaderComplete(_ cb: @escaping () -> Void) -> Self {
cbHeader = cb
return self
}
@discardableResult func onRequestComplete(_ cb: @escaping () -> Void) -> Self {
cbRequest = cb
return self
}
@discardableResult func onResponseComplete(_ cb: @escaping () -> Void) -> Self {
cbReponse = cb
return self
}
@discardableResult func onError(_ cb: @escaping (KMError) -> Void) -> Self {
cbError = cb
return self
}
@discardableResult func onSend(_ cb: @escaping () -> Void) -> Self {
cbSend = cb
return self
}
func getMethod() -> String {
return parser.method
}
func getPath() -> String {
return parser.url.path
}
func getVersion() -> String {
return parser.version
}
func getHeader(_ name: String) -> String? {
return parser.headers[name]
}
func getParam(_ name: String) -> String? {
return nil
}
}
| mit | fd5657f767ca3dec3ad0064af84ff36e | 25.743802 | 104 | 0.544345 | 4.779911 | false | false | false | false |
mercadopago/px-ios | MercadoPagoSDK/MercadoPagoSDK/Core/Extensions/NSDictionary+Additions.swift | 1 | 1643 | import Foundation
extension NSDictionary {
func toJsonString() -> String {
do {
let jsonData = try JSONSerialization.data(withJSONObject: self, options: .prettyPrinted)
if let jsonString = String(data: jsonData, encoding: String.Encoding.utf8) {
return jsonString
}
return ""
} catch {
return error.localizedDescription
}
}
func parseToQuery() -> String {
if !NSDictionary.isNullOrEmpty(self) {
var parametersString = ""
for (key, value) in self {
if let key = key as? String,
let value = value as? String {
parametersString += key + "=" + value + "&"
}
}
let range = parametersString.index(before: parametersString.endIndex)
parametersString = String(parametersString[..<range])
return parametersString.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!
} else {
return ""
}
}
func parseToLiteral() -> [String: Any] {
var anyDict = [String: Any]()
for (key, value) in self {
if let keyValue = key as? String {
anyDict[keyValue] = value
}
}
return anyDict
}
static func isNullOrEmpty(_ value: NSDictionary?) -> Bool {
return value == nil || value?.count == 0
}
func isKeyValid(_ dictKey: String) -> Bool {
let dictValue: Any? = self[dictKey]
return (dictValue == nil || dictValue is NSNull) ? false : true
}
}
| mit | 2bfd1129e9fd296e00ae381aac860c74 | 31.215686 | 100 | 0.53804 | 5.15047 | false | false | false | false |
ArslanBilal/GesturesDemo | GesturesDemo/GesturesDemo/PinchViewController.swift | 1 | 1666 | //
// PinchViewController.swift
// GesturesDemo
//
// Created by Bilal Arslan on 02/02/15.
// Copyright (c) 2015 Bilal Arslan. All rights reserved.
//
import UIKit
class PinchViewController: UIViewController {
@IBOutlet var testView:UIView!
@IBOutlet var label: UILabel!
override func viewDidLoad() {
/// Tab Changing Swipe Gestures
var leftSwipeGesture = UISwipeGestureRecognizer(target: self, action: "jumpToOtherTab:")
leftSwipeGesture.direction = UISwipeGestureRecognizerDirection.Left
view.addGestureRecognizer(leftSwipeGesture)
var rightSwipeGesture = UISwipeGestureRecognizer(target: self, action: "jumpToOtherTab:")
rightSwipeGesture.direction = UISwipeGestureRecognizerDirection.Right
view.addGestureRecognizer(rightSwipeGesture)
var pinchGesture = UIPinchGestureRecognizer(target: self, action: "handlePinchWithGestureRecognizer:")
testView.addGestureRecognizer(pinchGesture)
}
func handlePinchWithGestureRecognizer(gestureRecognizer: UIPinchGestureRecognizer) -> Void {
self.view.bringSubviewToFront(label)
self.testView.transform = CGAffineTransformScale(self.testView.transform, gestureRecognizer.scale, gestureRecognizer.scale)
gestureRecognizer.scale = 1.0;
}
func jumpToOtherTab(gestureRecognizer: UISwipeGestureRecognizer) -> Void {
if gestureRecognizer.direction == UISwipeGestureRecognizerDirection.Left
{
tabBarController?.selectedIndex = 4
}
else
{
tabBarController?.selectedIndex = 2
}
}
}
| mit | cf23c160f1af0b9cff2df1019cbf1a0c | 33.708333 | 131 | 0.702281 | 5.764706 | false | true | false | false |
sarahspins/Loop | WatchApp Extension/Models/WatchContext.swift | 1 | 2846 | //
// WatchContext.swift
// Naterade
//
// Created by Nathan Racklyeft on 11/25/15.
// Copyright © 2015 Nathan Racklyeft. All rights reserved.
//
import Foundation
import HealthKit
final class WatchContext: NSObject, RawRepresentable {
typealias RawValue = [String: AnyObject]
private let version = 2
var preferredGlucoseUnit: HKUnit?
var glucose: HKQuantity?
var glucoseTrend: GlucoseTrend?
var eventualGlucose: HKQuantity?
var glucoseDate: NSDate?
var loopLastRunDate: NSDate?
var lastNetTempBasalDose: Double?
var lastNetTempBasalDate: NSDate?
var recommendedBolusDose: Double?
var COB: Double?
var IOB: Double?
var reservoir: Double?
var reservoirPercentage: Double?
var batteryPercentage: Double?
override init() {
super.init()
}
required init?(rawValue: RawValue) {
super.init()
guard rawValue["v"] as? Int == version else {
return nil
}
if let unitString = rawValue["gu"] as? String {
let unit = HKUnit(fromString: unitString)
preferredGlucoseUnit = unit
if let glucoseValue = rawValue["gv"] as? Double {
glucose = HKQuantity(unit: unit, doubleValue: glucoseValue)
}
if let glucoseValue = rawValue["egv"] as? Double {
eventualGlucose = HKQuantity(unit: unit, doubleValue: glucoseValue)
}
}
if let rawTrend = rawValue["gt"] as? Int {
glucoseTrend = GlucoseTrend(rawValue: rawTrend)
}
glucoseDate = rawValue["gd"] as? NSDate
IOB = rawValue["iob"] as? Double
reservoir = rawValue["r"] as? Double
reservoirPercentage = rawValue["rp"] as? Double
batteryPercentage = rawValue["bp"] as? Double
loopLastRunDate = rawValue["ld"] as? NSDate
lastNetTempBasalDose = rawValue["ba"] as? Double
lastNetTempBasalDate = rawValue["bad"] as? NSDate
recommendedBolusDose = rawValue["rbo"] as? Double
COB = rawValue["cob"] as? Double
}
var rawValue: RawValue {
var raw: [String: AnyObject] = [
"v": version
]
raw["ba"] = lastNetTempBasalDose
raw["bad"] = lastNetTempBasalDate
raw["bp"] = batteryPercentage
raw["cob"] = COB
if let unit = preferredGlucoseUnit {
raw["egv"] = eventualGlucose?.doubleValueForUnit(unit)
raw["gu"] = unit.unitString
raw["gv"] = glucose?.doubleValueForUnit(unit)
}
raw["gt"] = glucoseTrend?.rawValue
raw["gd"] = glucoseDate
raw["iob"] = IOB
raw["ld"] = loopLastRunDate
raw["r"] = reservoir
raw["rbo"] = recommendedBolusDose
raw["rp"] = reservoirPercentage
return raw
}
}
| apache-2.0 | 52b3fccad5d44cf5103f1e3c69bab61e | 26.621359 | 83 | 0.6 | 4.679276 | false | false | false | false |
KalpeshTalkar/KPhotoPickerController | KimagePickerExample/AppDelegate.swift | 1 | 6131 | //
// AppDelegate.swift
// KimagePickerExample
//
// Created by Kalpesh Talkar on 01/01/16.
// Copyright © 2016 Kalpesh Talkar. All rights reserved.
//
import UIKit
import CoreData
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Override point for customization after application launch.
return true
}
func applicationWillResignActive(application: UIApplication) {
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
}
func applicationDidEnterBackground(application: UIApplication) {
// Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
// If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}
func applicationWillEnterForeground(application: UIApplication) {
// Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
}
func applicationDidBecomeActive(application: UIApplication) {
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}
func applicationWillTerminate(application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
// Saves changes in the application's managed object context before the application terminates.
self.saveContext()
}
// MARK: - Core Data stack
lazy var applicationDocumentsDirectory: NSURL = {
// The directory the application uses to store the Core Data store file. This code uses a directory named "com.kalpesh.KimagePickerExample" in the application's documents Application Support directory.
let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
return urls[urls.count-1]
}()
lazy var managedObjectModel: NSManagedObjectModel = {
// The managed object model for the application. This property is not optional. It is a fatal error for the application not to be able to find and load its model.
let modelURL = NSBundle.mainBundle().URLForResource("KimagePickerExample", withExtension: "momd")!
return NSManagedObjectModel(contentsOfURL: modelURL)!
}()
lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator = {
// The persistent store coordinator for the application. This implementation creates and returns a coordinator, having added the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail.
// Create the coordinator and store
let coordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent("SingleViewCoreData.sqlite")
var failureReason = "There was an error creating or loading the application's saved data."
do {
try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil)
} catch {
// Report any error we got.
var dict = [String: AnyObject]()
dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"
dict[NSLocalizedFailureReasonErrorKey] = failureReason
dict[NSUnderlyingErrorKey] = error as NSError
let wrappedError = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
// Replace this with code to handle the error appropriately.
// abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
abort()
}
return coordinator
}()
lazy var managedObjectContext: NSManagedObjectContext = {
// Returns the managed object context for the application (which is already bound to the persistent store coordinator for the application.) This property is optional since there are legitimate error conditions that could cause the creation of the context to fail.
let coordinator = self.persistentStoreCoordinator
var managedObjectContext = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
managedObjectContext.persistentStoreCoordinator = coordinator
return managedObjectContext
}()
// MARK: - Core Data Saving support
func saveContext () {
if managedObjectContext.hasChanges {
do {
try managedObjectContext.save()
} catch {
// Replace this implementation with code to handle the error appropriately.
// abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
let nserror = error as NSError
NSLog("Unresolved error \(nserror), \(nserror.userInfo)")
abort()
}
}
}
}
| mit | cff51f4b80842a83d16992c14380a85f | 54.225225 | 291 | 0.721207 | 5.877277 | false | false | false | false |
Drakken-Engine/GameEngine | DrakkenEngine/dRenderer.swift | 1 | 3154 | //
// Renderer.swift
// Underground - Survivors
//
// Created by Allison Lindner on 03/09/15.
// Copyright © 2015 Allison Lindner. All rights reserved.
//
import Metal
import MetalKit
internal class dRenderer {
private var _rFactory: dRendererFactory?
private var _cBuffer: MTLCommandBuffer!
private var _rcEncoders: [Int : MTLRenderCommandEncoder] = [:]
private var _nextIndex: Int = 0
internal func startFrame(_ texture: MTLTexture) -> Int {
_cBuffer = dCore.instance.cQueue.makeCommandBuffer()
_cBuffer.enqueue()
if _rFactory == nil {
_rFactory = dRendererFactory()
}
let index = _nextIndex
let encoder = _cBuffer.makeRenderCommandEncoder(descriptor: _rFactory!.buildRenderPassDescriptor(texture))
encoder.setDepthStencilState(_rFactory?.buildDepthStencil())
encoder.setFrontFacing(.counterClockwise)
encoder.setCullMode(.back)
encoder.setFragmentSamplerState(_rFactory?.buildSamplerState(), at: 0)
_rcEncoders[index] = encoder
_nextIndex += 1
return index
}
internal func endFrame(_ id: Int) {
let encoder: MTLRenderCommandEncoder = _rcEncoders[id]!
encoder.endEncoding()
_rcEncoders.remove(at: _rcEncoders.index(forKey: id)!)
}
internal func encoder(withID id: Int) -> MTLRenderCommandEncoder {
return self._rcEncoders[id]!
}
internal func present(_ drawable: CAMetalDrawable) {
_cBuffer.present(drawable)
_cBuffer.commit()
_rcEncoders.removeAll()
}
internal func bind(_ buffer: dBufferable, encoderID: Int) {
if let encoder = _rcEncoders[encoderID] {
switch buffer.bufferType {
case .vertex:
encoder.setVertexBuffer(
buffer.buffer, offset: buffer.offset, at: buffer.index
)
case .fragment:
encoder.setFragmentBuffer(
buffer.buffer, offset: buffer.offset, at: buffer.index
)
}
} else {
fatalError("Invalid Encoder ID")
}
}
internal func bind(_ materialTexture: dMaterialTexture, encoderID: Int) {
if let encoder = _rcEncoders[encoderID] {
encoder.setFragmentTexture(materialTexture.texture.getTexture(), at: materialTexture.index)
} else {
fatalError("Invalid Encoder ID")
}
}
internal func bind(_ material: dMaterialData, encoderID: Int) {
if let encoder = _rcEncoders[encoderID] {
encoder.setRenderPipelineState(material.shader.rpState)
}
for buffer in material.buffers {
self.bind(buffer, encoderID: encoderID)
}
for texture in material.textures {
self.bind(texture, encoderID: encoderID)
}
}
internal func draw(_ mesh: dMeshData, encoderID: Int, modelMatrixBuffer: dBufferable) {
for buffer in mesh.buffers {
self.bind(buffer, encoderID: encoderID)
}
self.bind(modelMatrixBuffer, encoderID: encoderID)
if let encoder = _rcEncoders[encoderID] {
encoder.drawIndexedPrimitives(type: .triangle,
indexCount: mesh.indicesCount!,
indexType: .uint32,
indexBuffer: mesh.indicesBuffer!.buffer,
indexBufferOffset: 0,
instanceCount: modelMatrixBuffer.count)
}
}
}
| gpl-3.0 | 073cfa8d4e226ddbe855b3374d577e59 | 26.417391 | 108 | 0.679353 | 3.97604 | false | false | false | false |
NickChenHao/PhotoBrowser | PhotoBrowser/PhotoBrowser/Classes/Home/CHFlowLayout.swift | 1 | 834 | //
// CHFlowLayout.swift
// PhotoBrowser
//
// Created by nick on 16/4/28.
// Copyright © 2016年 nick. All rights reserved.
//
import UIKit
class CHFlowLayout: UICollectionViewFlowLayout {
override func prepareLayout() {
super.prepareLayout()
// 1.定义常量
let cols : CGFloat = 3
let margin : CGFloat = 10
// 2.计算item的WH
let itemWH = (UIScreen.mainScreen().bounds.width - (cols + 1) * margin) / cols
// 3.设置布局内容
itemSize = CGSize(width: itemWH, height: itemWH)
minimumInteritemSpacing = 0
minimumLineSpacing = margin
// 4.设置collectionView的属性
collectionView?.contentInset = UIEdgeInsets(top: margin + 64, left: margin, bottom: margin, right: margin)
}
}
| apache-2.0 | 96e772533cb9974965b4a0388bd48c48 | 24.645161 | 114 | 0.598742 | 4.344262 | false | false | false | false |
cbaker6/iOS-csr-swift | CertificateSigningRequest/Classes/CertificateSigningRequestConstants.swift | 3 | 6716 | //
// CertificateSigningRequestConstants.swift
// CertificateSigningRequest
//
// Created by Corey Baker on 10/8/17.
// Copyright © 2017 Network Reconnaissance Lab. All rights reserved.
//
import Foundation
import CommonCrypto
// Use e.g., https://misc.daniel-marschall.de/asn.1/oid-converter/online.php to convert OID (OBJECT IDENTIFIER) to ASN.1 DER hex forms
//Guide to translate OID's to bytes for ANS.1 (Look at comment section on page): https://msdn.microsoft.com/en-us/library/bb540809(v=vs.85).aspx
/* RSA */
let OBJECT_rsaEncryptionNULL:[UInt8] = [0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00]
// See: http://oid-info.com/get/1.2.840.113549.1.1.5
let SEQUENCE_OBJECT_sha1WithRSAEncryption:[UInt8] = [0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 1, 1, 5, 0x05, 0x00]
// See: http://oid-info.com/get/1.2.840.113549.1.1.11
let SEQUENCE_OBJECT_sha256WithRSAEncryption:[UInt8] = [0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 1, 1, 0x0B, 0x05, 0x00]
// See: http://oid-info.com/get/1.2.840.113549.1.1.13
let SEQUENCE_OBJECT_sha512WithRSAEncryption:[UInt8] = [0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 1, 1, 0x0D, 0x05, 0x00]
/* EC */
let OBJECT_ecEncryptionNULL:[UInt8] = [0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07]
let OBJECT_ecPubicKey:[UInt8] = [0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01]
let SEQUENCE_OBJECT_sha1WithECEncryption:[UInt8] = [0x30, 0x0A, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x01]
// See: http://www.oid-info.com/get/1.2.840.10045.4.3.2
let SEQUENCE_OBJECT_sha256WithECEncryption:[UInt8] = [0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02]
// See: http://oid-info.com/get/1.2.840.10045.4.3.4
let SEQUENCE_OBJECT_sha512WithECEncryption:[UInt8] = [0x30, 0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x04]
//Enums
public enum KeyAlgorithm {
case rsa(signatureType: signature), ec(signatureType: signature)
@available(iOS 10, macCatalyst 13.0, macOS 10.12, *)
public var secKeyAttrType: CFString {
let result: CFString
switch self {
case .rsa: result = kSecAttrKeyTypeRSA
case .ec: result = kSecAttrKeyTypeECSECPrimeRandom
}
return result
}
@available(iOS, deprecated: 10.0)
public var secKeyAttrTypeiOS9: CFString {
let result: CFString
switch self {
case .rsa: result = kSecAttrKeyTypeRSA
case .ec: result = kSecAttrKeyTypeEC
}
return result
}
public var availableKeySizes: [Int] {
let result: [Int]
switch self {
case .rsa: result = [512, 1024, 2048]
case .ec: result = [256]
}
return result
}
public enum signature {
case sha1, sha256, sha512
}
public var type:String{
let result: String
switch self {
case .rsa(signatureType: .sha1), .rsa(signatureType: .sha256), .rsa(signatureType: .sha512):
result = "RSA"
case .ec(signatureType: .sha1), .ec(signatureType: .sha256), .ec(signatureType: .sha512):
result = "EC"
}
return result
}
@available(iOS 10, macCatalyst 13.0, macOS 10.12, *)
public var signatureAlgorithm: SecKeyAlgorithm {
let result: SecKeyAlgorithm
switch self {
case .rsa(signatureType: .sha1):
result = .rsaSignatureMessagePKCS1v15SHA1
case .rsa(signatureType: .sha256):
result = .rsaSignatureMessagePKCS1v15SHA256
case .rsa(signatureType: .sha512):
result = .rsaSignatureMessagePKCS1v15SHA512
case .ec(signatureType: .sha1):
result = .ecdsaSignatureMessageX962SHA1
case .ec(signatureType: .sha256):
result = .ecdsaSignatureMessageX962SHA256
case .ec(signatureType: .sha512):
result = .ecdsaSignatureMessageX962SHA512
}
return result
}
@available(iOS, deprecated: 10.0)
public var digestLength: Int {
let result: Int32
switch self {
//case .rsa(signatureType: .md5), .ec(signatureType: .md5): result = CC_MD5_DIGEST_LENGTH
case .rsa(signatureType: .sha1), .ec(signatureType: .sha1): result = CC_SHA1_DIGEST_LENGTH
//case .rsa(signatureType: .sha224), .ec(signatureType: .sha224): result = CC_SHA224_DIGEST_LENGTH
case .rsa(signatureType: .sha256), .ec(signatureType: .sha256): result = CC_SHA256_DIGEST_LENGTH
//case .rsa(signatureType: .sha384), .ec(signatureType: .sha384): result = CC_SHA384_DIGEST_LENGTH
case .rsa(signatureType: .sha512), .ec(signatureType: .sha512): result = CC_SHA512_DIGEST_LENGTH
}
return Int(result)
}
@available(iOS, deprecated: 10.0)
public var padding: SecPadding {
let result: SecPadding
switch self {
case .rsa(signatureType: .sha1), .ec(signatureType: .sha1):
result = SecPadding.PKCS1SHA1
case .rsa(signatureType: .sha256), .ec(signatureType: .sha256):
result = SecPadding.PKCS1SHA256
case .rsa(signatureType: .sha512), .ec(signatureType: .sha512):
result = SecPadding.PKCS1SHA512
}
return result
}
var sequenceObjectEncryptionType: [UInt8]{
let result:[UInt8]
switch self {
case .rsa(signatureType: .sha1):
result = SEQUENCE_OBJECT_sha1WithRSAEncryption
case .rsa(signatureType: .sha256):
result = SEQUENCE_OBJECT_sha256WithRSAEncryption
case .rsa(signatureType: .sha512):
result = SEQUENCE_OBJECT_sha512WithRSAEncryption
case .ec(signatureType: .sha1):
result = SEQUENCE_OBJECT_sha1WithECEncryption
case .ec(signatureType: .sha256):
result = SEQUENCE_OBJECT_sha256WithECEncryption
case .ec(signatureType: .sha512):
result = SEQUENCE_OBJECT_sha512WithECEncryption
}
return result
}
var objectEncryptionKeyType: [UInt8]{
let result:[UInt8]
switch self {
case .rsa(signatureType: .sha1), .rsa(signatureType: .sha256), .rsa(signatureType: .sha512):
result = OBJECT_rsaEncryptionNULL
case .ec(signatureType: .sha1), .ec(signatureType: .sha256), .ec(signatureType: .sha512):
result = OBJECT_ecEncryptionNULL
}
return result
}
}
| mit | ef57bc1a8ffe230a071b7ffa3aaeeb93 | 35.693989 | 144 | 0.618615 | 3.374372 | false | false | false | false |
watson-developer-cloud/ios-sdk | Sources/DiscoveryV1/Models/Configuration.swift | 1 | 3565 | /**
* (C) Copyright IBM Corp. 2016, 2020.
*
* 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
/**
A custom configuration for the environment.
*/
public struct Configuration: Codable, Equatable {
/**
The unique identifier of the configuration.
*/
public var configurationID: String?
/**
The name of the configuration.
*/
public var name: String
/**
The creation date of the configuration in the format yyyy-MM-dd'T'HH:mm:ss.SSS'Z'.
*/
public var created: Date?
/**
The timestamp of when the configuration was last updated in the format yyyy-MM-dd'T'HH:mm:ss.SSS'Z'.
*/
public var updated: Date?
/**
The description of the configuration, if available.
*/
public var description: String?
/**
Document conversion settings.
*/
public var conversions: Conversions?
/**
An array of document enrichment settings for the configuration.
*/
public var enrichments: [Enrichment]?
/**
Defines operations that can be used to transform the final output JSON into a normalized form. Operations are
executed in the order that they appear in the array.
*/
public var normalizations: [NormalizationOperation]?
/**
Object containing source parameters for the configuration.
*/
public var source: Source?
// Map each property name to the key that shall be used for encoding/decoding.
private enum CodingKeys: String, CodingKey {
case configurationID = "configuration_id"
case name = "name"
case created = "created"
case updated = "updated"
case description = "description"
case conversions = "conversions"
case enrichments = "enrichments"
case normalizations = "normalizations"
case source = "source"
}
/**
Initialize a `Configuration` with member variables.
- parameter name: The name of the configuration.
- parameter description: The description of the configuration, if available.
- parameter conversions: Document conversion settings.
- parameter enrichments: An array of document enrichment settings for the configuration.
- parameter normalizations: Defines operations that can be used to transform the final output JSON into a
normalized form. Operations are executed in the order that they appear in the array.
- parameter source: Object containing source parameters for the configuration.
- returns: An initialized `Configuration`.
*/
public init(
name: String,
description: String? = nil,
conversions: Conversions? = nil,
enrichments: [Enrichment]? = nil,
normalizations: [NormalizationOperation]? = nil,
source: Source? = nil
)
{
self.name = name
self.description = description
self.conversions = conversions
self.enrichments = enrichments
self.normalizations = normalizations
self.source = source
}
}
| apache-2.0 | a1b1232501fea1098f018b519de76309 | 30.548673 | 114 | 0.670968 | 4.798116 | false | true | false | false |
gengzhenxing/SwiftDemo | MyDemo/MyHomeTableViewController.swift | 1 | 2579 | //
// MyHomeTableViewController.swift
// MyDemo
//
// Created by gengzhenxing on 15/12/27.
// Copyright © 2015年 gengzhenxing. All rights reserved.
//
import UIKit
import Alamofire
class MyHomeTableViewController: UITableViewController {
var result = [HomeInfoModel]()
var myCell:MyHomeTableViewCell!
override func viewDidLoad() {
super.viewDidLoad()
self.getHomeInfo()
self.tableView.tableFooterView = UIView()
myCell = tableView.dequeueReusableCellWithIdentifier("MyHomeTableViewCell") as! MyHomeTableViewCell
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
}
// MARK: - get network info
private func getHomeInfo() {
Alamofire.request(.GET, "http://news-at.zhihu.com/api/4/news/latest", parameters: nil)
.responseJSON { response in
if let JSON = response.result.value {
if let array:[Dictionary<String,AnyObject>] = JSON["stories"] as? [Dictionary<String,AnyObject>] {
self.result = array.map({ (item) -> HomeInfoModel in
let model = HomeInfoModel(dictionary:item)
return model
})
self.tableView.reloadData()
}
}
}
}
// MARK: - Table view data source
override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
return 1
}
override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return result.count
}
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell:MyHomeTableViewCell = tableView.dequeueReusableCellWithIdentifier("MyHomeTableViewCell", forIndexPath: indexPath) as! MyHomeTableViewCell
cell.configCellWithModel(self.result[indexPath.row])
return cell
}
// MARK: Table view delegate
override func tableView(tableView: UITableView, estimatedHeightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
let model = result[indexPath.row]
myCell.homeLabel.text = model.title
return myCell.contentView.systemLayoutSizeFittingSize(UILayoutFittingCompressedSize).height + 1
}
override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
}
}
| mit | bbfa909f364b16c9e1034b50248c785a | 32.454545 | 154 | 0.628106 | 5.624454 | false | false | false | false |
ontouchstart/swift3-playground | Shapes.playgroundbook/Contents/Sources/PlaygroundAPI/Grid.swift | 1 | 3908 | //
// Grid.swift
// Drawing
//
// Created by Ken Orr on 4/7/16.
// Copyright © 2016 Apple, Inc. All rights reserved.
//
import UIKit
internal class Grid {
internal var show = false {
didSet {
backingView.isHidden = !show
}
}
internal var backingView = GridView()
private var majorGridColor: Color {
get {
return backingView.majorGridColor
}
set {
backingView.minorGridColor = majorGridColor
}
}
private var minorGridColor: Color {
get {
return backingView.minorGridColor
}
set {
backingView.minorGridColor = minorGridColor
}
}
internal init() {
// make sure the grids visibility matches the show property's default.
backingView.isHidden = !show
}
}
internal class GridView: UIView {
internal var offsetToCenterInScreenPoints = Point(x: 0, y: 0)
internal var gridStrideInPoints = 10.0
private var majorGridColor = Color(white: 0.85, alpha: 1.0) {
didSet {
setNeedsDisplay()
}
}
private var minorGridColor = Color(white: 0.95, alpha: 1.0) {
didSet {
setNeedsDisplay()
}
}
private init() {
super.init(frame: CGRect.zero)
self.isOpaque = false
self.autoresizingMask = [.flexibleWidth, .flexibleHeight]
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
override func draw(_ rect: CGRect) {
drawGridLinesFor(axis: .x, dirtyRect: rect)
drawGridLinesFor(axis: .y, dirtyRect: rect)
}
private func drawGridLinesFor(axis: Axis, dirtyRect: CGRect) {
let centerPoint: Double
switch axis {
case .x:
centerPoint = offsetToCenterInScreenPoints.x
break
case .y:
centerPoint = offsetToCenterInScreenPoints.y
break
}
let firstStrokeWidth: CGFloat = 3.0
let otherThanFirstStrokeWidth: CGFloat = 1.0
var currentPoint = CGFloat(centerPoint)
var keepGoing = true
var iteration = 0
while (keepGoing) {
if iteration % 10 == 0 || (iteration + 1) % 10 == 0{
majorGridColor.uiColor.set()
} else {
minorGridColor.uiColor.set()
}
let strokeWidth = iteration == 0 ? firstStrokeWidth : otherThanFirstStrokeWidth
let x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat
switch axis {
case .x:
x = currentPoint - strokeWidth/2.0
y = dirtyRect.minY
width = strokeWidth
height = dirtyRect.height
break
case .y:
x = dirtyRect.minX
y = currentPoint - strokeWidth/2.0
width = dirtyRect.width
height = strokeWidth
break
}
UIRectFillUsingBlendMode(CGRect(x: x, y: y, width: width, height: height), .darken)
iteration += 1
let multiplier = iteration % 2 == 0 ? 1.0 : -1.0
currentPoint += CGFloat(gridStrideInPoints * (Double(iteration) * multiplier))
switch axis {
case .x:
keepGoing = dirtyRect.minX <= currentPoint && currentPoint <= dirtyRect.maxX
break
case .y:
keepGoing = dirtyRect.minY <= currentPoint && currentPoint <= dirtyRect.maxY
break
}
}
}
private enum Axis {
case x
case y
}
}
| mit | 38e1736a19fdf3ebda852994797d430d | 25.760274 | 95 | 0.514973 | 5.147563 | false | false | false | false |
turekj/ReactiveTODO | ReactiveTODOTests/DataAccess/Impl/TODONoteDataAccessObjectSpec.swift | 1 | 6702 | @testable import ReactiveTODO
import Nimble
import Quick
import RealmSwift
class TODONoteDataAccessObjectSpec: QuickSpec {
override func spec() {
describe("TODONoteDataAccessObject") {
Realm.Configuration
.defaultConfiguration
.inMemoryIdentifier = self.name
beforeEach {
let realm = try! Realm()
try! realm.write {
realm.deleteAll()
}
}
afterEach {
let realm = try! Realm()
try! realm.write {
realm.deleteAll()
}
}
let factory = TODONoteFactoryMock()
let sut = TODONoteDataAccessObject(factory: factory)
context("When creating a TODONote") {
it("Should save created note in database") {
let realm = try! Realm()
factory.guid = "FACTORY_GUID"
factory.completed = true
sut.createTODONote(NSDate(timeIntervalSince1970: 444),
note: "Creanote", priority: Priority.Urgent)
expect(realm.objects(TODONote.self).count).to(equal(1))
expect(realm.objects(TODONote.self).first).toNot(beNil())
expect(realm.objects(TODONote.self).first?.guid)
.to(equal("FACTORY_GUID"))
expect(realm.objects(TODONote.self).first?.date)
.to(equal(NSDate(timeIntervalSince1970: 444)))
expect(realm.objects(TODONote.self).first?.note)
.to(equal("Creanote"))
expect(realm.objects(TODONote.self).first?.priority)
.to(equal(Priority.Urgent))
expect(realm.objects(TODONote.self).first?.completed)
.to(beTrue())
}
it("Should return created note") {
factory.guid = "CREATED_GUID"
factory.completed = true
let result = sut.createTODONote(
NSDate(timeIntervalSince1970: 444),
note: "Creanote",
priority: Priority.Urgent)
expect(result.guid).to(equal("CREATED_GUID"))
expect(result.note).to(equal("Creanote"))
expect(result.date).to(
equal(NSDate(timeIntervalSince1970: 444)))
expect(result.priority).to(equal(Priority.Urgent))
expect(result.completed).to(beTrue())
}
}
context("When returning current TODONotes") {
it("Should return notes that are not complete") {
let realm = try! Realm()
let completedNote = TODONote()
completedNote.guid = "AWESOME_UNIQUE_GUID"
completedNote.date = NSDate(timeIntervalSince1970: 1970)
completedNote.note = "Awesome Note"
completedNote.priority = .Urgent
completedNote.completed = true
let notCompletedNote = TODONote()
notCompletedNote.guid = "AWESOME_UNIQUE_GUID_NOT_COMPLETED"
notCompletedNote.date = NSDate(timeIntervalSince1970: 111)
notCompletedNote.note = "Awesome Not Completed Note"
notCompletedNote.priority = .Low
notCompletedNote.completed = false
try! realm.write {
realm.add(completedNote)
realm.add(notCompletedNote)
}
let notes = sut.getCurrentTODONotes()
expect(notes.count).to(equal(1))
expect(notes.first?.guid)
.to(equal("AWESOME_UNIQUE_GUID_NOT_COMPLETED"))
expect(notes.first?.date)
.to(equal(NSDate(timeIntervalSince1970: 111)))
expect(notes.first?.note)
.to(equal("Awesome Not Completed Note"))
expect(notes.first?.priority).to(equal(Priority.Low))
expect(notes.first?.completed).to(beFalse())
}
it("Should order notes by ascending date") {
let realm = try! Realm()
let firstNote = TODONote()
firstNote.guid = "note_1_date"
firstNote.date = NSDate(timeIntervalSince1970: 222)
firstNote.note = "Note One"
firstNote.priority = .Urgent
firstNote.completed = false
let secondNote = TODONote()
secondNote.guid = "note_2_date"
secondNote.date = NSDate(timeIntervalSince1970: 111)
secondNote.note = "Note Two"
secondNote.priority = .Urgent
secondNote.completed = false
try! realm.write {
realm.add(firstNote)
realm.add(secondNote)
}
let notes = sut.getCurrentTODONotes()
expect(notes.count).to(equal(2))
expect(notes.first?.guid)
.to(equal("note_2_date"))
expect(notes.last?.guid)
.to(equal("note_1_date"))
}
}
context("When marking note as completed") {
it("Should set completed flag to true") {
let realm = try! Realm()
let note = TODONote()
note.guid = "completed_test_guid"
note.date = NSDate(timeIntervalSince1970: 222)
note.note = "Note to complete"
note.priority = .Urgent
note.completed = false
try! realm.write {
realm.add(note)
}
sut.completeTODONote("completed_test_guid")
let noteQuery = realm.objects(TODONote.self)
.filter("guid = 'completed_test_guid'")
expect(noteQuery.count).to(equal(1))
expect(noteQuery.first?.guid)
.to(equal("completed_test_guid"))
expect(noteQuery.first?.completed).to(beTrue())
}
}
}
}
}
| mit | 3ea80682fab006ffbfe6ebeb4e4931cf | 39.618182 | 79 | 0.472695 | 5.566445 | false | false | false | false |
alokc83/mix-ios-tutes | SideBarProject/SideBarProject/LeftMEnuViewController.swift | 1 | 2646 | //
// LeftMEnuViewController.swift
// SideBarProject
//
// Created by Alok Choudhary on 4/6/16.
// Copyright © 2016 Alok Choudhary. All rights reserved.
//
import UIKit
class LeftMEnuViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
override func viewDidLoad() {
super.viewDidLoad()
let tableView = UITableView(frame: CGRectMake(0, self.view.frame.size.height, self.view.frame.size.width, 54*5), style: UITableViewStyle.Plain)
//tableView.autoresizingMask = UIViewAutoresizing.FlexibleTopMargin | UIViewAutoresizing.FlexibleBottomMargin | UIViewAutoresizing.FlexibleWidth
tableView.delegate = self
tableView.dataSource = self
tableView.opaque = false
tableView.backgroundColor = UIColor.clearColor()
tableView.backgroundView = nil
tableView.separatorStyle = UITableViewCellSeparatorStyle.None
tableView.bounces = true
tableView.scrollsToTop = false
self.view.addSubview(tableView)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
//MARK: UItableView Delegate Method
func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
//
}
func numberOfSectionsInTableView(tableView: UITableView) -> Int {
return 1
}
func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return 4
}
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
//
let cellIdentifier = "menuCell"
var cell = tableView.dequeueReusableCellWithIdentifier(cellIdentifier)
if(cell == nil){
cell = UITableViewCell.init(style: .Default, reuseIdentifier: cellIdentifier)
cell?.backgroundColor = UIColor.clearColor()
//cell?.textLabel?.font = UIFont.fontNamesForFamilyName("HelveticaNeue")
cell?.textLabel?.textColor = UIColor.blackColor()
cell?.textLabel?.highlightedTextColor = UIColor.whiteColor()
cell?.backgroundView = UIView()
}
var titles = ["Home", "Calendar", "Profile", "Settings", "Log Out"]
//var images = ["IconHome", "IconCalendar", "IconProfile", "IconSettings", "IconProfile"]
cell?.textLabel?.text = titles[indexPath.row]
//cell?.imageView?.image = UIImage(named: images[indexPath.row])
return cell!
}
}
extension RESideMenuDelegate {
}
| bsd-3-clause | 55ce2e9ee89c907e7295811c59f54f55 | 32.910256 | 152 | 0.669565 | 5.332661 | false | false | false | false |
nicolastinkl/swift | ListerAProductivityAppBuiltinSwift/Lister/ListDocumentsViewController.swift | 1 | 18809 | /*
Copyright (C) 2014 Apple Inc. All Rights Reserved.
See LICENSE.txt for this sample’s licensing information
Abstract:
Handles displaying a list of available documents for users to open.
*/
import UIKit
import ListerKit
class ListDocumentsViewController: UITableViewController, ListViewControllerDelegate, NewListDocumentControllerDelegate {
// MARK: Types
struct MainStoryboard {
struct ViewControllerIdentifiers {
static let listViewController = "listViewController"
static let listViewNavigationController = "listViewNavigationController"
static let emptyViewController = "emptyViewController"
}
struct TableViewCellIdentifiers {
static let listDocumentCell = "listDocumentCell"
}
struct SegueIdentifiers {
static let newListDocument = "newListDocument"
}
}
var listInfos = ListInfo[]()
var documentMetadataQuery: NSMetadataQuery?
// MARK: View Life Cycle
override func viewDidLoad() {
super.viewDidLoad()
setNeedsStatusBarAppearanceUpdate()
navigationController.navigationBar.titleTextAttributes = [
NSFontAttributeName: UIFont.preferredFontForTextStyle(UIFontTextStyleHeadline),
NSForegroundColorAttributeName: List.Color.Gray.colorValue
]
ListCoordinator.sharedListCoordinator.updateDocumentStorageContainerURL()
let notificationCenter = NSNotificationCenter.defaultCenter()
notificationCenter.addObserver(self, selector: "handleListColorDidChangeNotification:", name: ListViewController.Notifications.ListColorDidChange.name, object: nil)
notificationCenter.addObserver(self, selector: "handleContentSizeCategoryDidChangeNotification:", name: UIContentSizeCategoryDidChangeNotification, object: nil)
// When the desired storage changes, start the query.
notificationCenter.addObserver(self, selector: "startQuery", name: ListCoordinator.Notifications.StorageDidChange.name, object: nil)
}
override func viewWillAppear(animated: Bool) {
super.viewWillAppear(animated)
navigationController.navigationBar.titleTextAttributes = [
NSFontAttributeName: UIFont.preferredFontForTextStyle(UIFontTextStyleHeadline),
NSForegroundColorAttributeName: List.Color.Gray.colorValue
]
navigationController.navigationBar.tintColor = List.Color.Gray.colorValue
navigationController.toolbar.tintColor = List.Color.Gray.colorValue
tableView.tintColor = List.Color.Gray.colorValue
}
override func viewDidAppear(animated: Bool) {
super.viewDidAppear(animated)
setupUserStoragePreferences()
}
// MARK: Lifetime
deinit {
let notificationCenter = NSNotificationCenter.defaultCenter()
// Lister notifications.
notificationCenter.removeObserver(self, name: ListViewController.Notifications.ListColorDidChange.name, object: nil)
notificationCenter.removeObserver(self, name: ListCoordinator.Notifications.StorageDidChange.name, object: nil)
// System notifications.
notificationCenter.removeObserver(self, name: UIContentSizeCategoryDidChangeNotification, object: nil)
notificationCenter.removeObserver(self, name: NSMetadataQueryDidFinishGatheringNotification, object: nil)
notificationCenter.removeObserver(self, name: NSMetadataQueryDidUpdateNotification, object: nil)
}
// MARK: Setup
func selectListWithListInfo(listInfo: ListInfo) {
if !splitViewController { return }
// A shared configuration function for list selection.
func configureListViewController(listViewController: ListViewController) {
if listInfo.isLoaded {
listViewController.configureWithListInfo(listInfo)
}
else {
listInfo.fetchInfoWithCompletionHandler {
listViewController.configureWithListInfo(listInfo)
}
}
listViewController.delegate = self
}
if splitViewController.collapsed {
let listViewController = storyboard.instantiateViewControllerWithIdentifier(MainStoryboard.ViewControllerIdentifiers.listViewController) as ListViewController
configureListViewController(listViewController)
showDetailViewController(listViewController, sender: self)
}
else {
let navigationController = storyboard.instantiateViewControllerWithIdentifier(MainStoryboard.ViewControllerIdentifiers.listViewNavigationController) as UINavigationController
let listViewController = navigationController.topViewController as ListViewController
configureListViewController(listViewController)
splitViewController.viewControllers = [splitViewController.viewControllers[0], UIViewController()]
showDetailViewController(navigationController, sender: self)
}
}
func setupUserStoragePreferences() {
let (storageOption, accountDidChange, cloudAvailable) = AppConfiguration.sharedConfiguration.storageState
if accountDidChange {
notifyUserOfAccountChange()
}
if cloudAvailable {
if storageOption == .NotSet {
promptUserForStorageOption()
}
else {
startQuery()
}
}
else {
AppConfiguration.sharedConfiguration.storageOption = .NotSet
}
}
// MARK: UITableViewDataSource
override func tableView(_: UITableView, numberOfRowsInSection section: Int) -> Int {
return listInfos.count
}
override func tableView(_: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier(MainStoryboard.TableViewCellIdentifiers.listDocumentCell, forIndexPath: indexPath) as ListCell
let listInfo = listInfos[indexPath.row]
cell.label.font = UIFont.preferredFontForTextStyle(UIFontTextStyleBody)
cell.listColor.backgroundColor = UIColor.clearColor()
// Show an empty string as the text since it may need to load.
cell.text = ""
// Once the list info has been loaded, update the associated cell's properties.
func infoHandler() {
cell.label.text = listInfo.name
cell.listColor.backgroundColor = listInfo.color!.colorValue
}
if listInfo.isLoaded {
infoHandler()
}
else {
listInfo.fetchInfoWithCompletionHandler(infoHandler)
}
return cell
}
// MARK: UITableViewDelegate
override func tableView(_: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
let listInfo = listInfos[indexPath.row]
if listInfo.isLoaded {
selectListWithListInfo(listInfo)
}
else {
listInfo.fetchInfoWithCompletionHandler {
self.selectListWithListInfo(listInfo)
}
}
}
override func tableView(_: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
return false
}
override func tableView(_: UITableView, canMoveRowAtIndexPath indexPath: NSIndexPath) -> Bool {
return false
}
// MARK: ListViewControllerDelegate
func listViewControllerDidDeleteList(listViewController: ListViewController) {
if !splitViewController.collapsed {
let emptyViewController = storyboard.instantiateViewControllerWithIdentifier(MainStoryboard.ViewControllerIdentifiers.emptyViewController) as UIViewController
splitViewController.showDetailViewController(emptyViewController, sender: nil)
}
// Make sure to deselect the row for the list document that was open, since we are in the process of deleting it.
tableView.deselectRowAtIndexPath(tableView.indexPathForSelectedRow(), animated: false)
deleteListAtURL(listViewController.documentURL)
}
// MARK: NewListDocumentControllerDelegate
func newListDocumentController(_: NewListDocumentController, didCreateDocumentWithListInfo listInfo: ListInfo) {
if AppConfiguration.sharedConfiguration.storageOption != .Cloud {
insertListInfo(listInfo) { index in
let indexPathForInsertedRow = NSIndexPath(forRow: index, inSection: 0)
self.tableView.insertRowsAtIndexPaths([indexPathForInsertedRow], withRowAnimation: .Automatic)
}
}
}
// MARK: UIStoryboardSegue Handling
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject) {
if segue.identifier == MainStoryboard.SegueIdentifiers.newListDocument {
let newListController = segue.destinationViewController as NewListDocumentController
newListController.delegate = self
}
}
// MARK: Convenience
func deleteListAtURL(url: NSURL) {
// Delete the requested document asynchronously.
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
ListCoordinator.sharedListCoordinator.deleteFileAtURL(url)
}
// Update the document list and remove the row from the table view.
removeListInfoWithProvider(url) { index in
let indexPathForRemoval = NSIndexPath(forRow: index, inSection: 0)
self.tableView.deleteRowsAtIndexPaths([indexPathForRemoval], withRowAnimation: .Automatic)
}
}
// MARK: List Management
func startQuery() {
documentMetadataQuery?.stopQuery()
if AppConfiguration.sharedConfiguration.storageOption == .Cloud {
startMetadataQuery()
}
else {
startLocalQuery()
}
}
func startLocalQuery() {
let documentsDirectory = ListCoordinator.sharedListCoordinator.documentsDirectory
let defaultManager = NSFileManager.defaultManager()
// Fetch the list documents from container documents directory.
let localDocumentURLs = defaultManager.contentsOfDirectoryAtURL(documentsDirectory, includingPropertiesForKeys: nil, options: .SkipsPackageDescendants, error: nil) as NSURL[]
processURLs(localDocumentURLs)
}
func processURLs(urls: NSURL[]) {
let previousListInfos = listInfos
// Processing metadata items doesn't involve much change in the size of the array, so we want to keep the
// same capacity.
listInfos.removeAll(keepCapacity: true)
sort(urls) { $0.lastPathComponent < $1.lastPathComponent }
for url in urls {
if url.pathExtension == AppConfiguration.listerFileExtension {
insertListInfoWithProvider(url)
}
}
processListInfoDifferences(previousListInfos)
}
func processMetadataItems() {
let previousListInfos = listInfos
// Processing metadata items doesn't involve much change in the size of the array, so we want to keep the
// same capacity.
listInfos.removeAll(keepCapacity: true)
let metadataItems = documentMetadataQuery!.results as NSMetadataItem[]
sort(metadataItems) { lhs, rhs in
return (lhs.valueForAttribute(NSMetadataItemFSNameKey) as String) < (rhs.valueForAttribute(NSMetadataItemFSNameKey) as String)
}
for metadataItem in metadataItems {
insertListInfoWithProvider(metadataItem)
}
processListInfoDifferences(previousListInfos)
}
func startMetadataQuery() {
if !documentMetadataQuery {
let metadataQuery = NSMetadataQuery()
documentMetadataQuery = metadataQuery
documentMetadataQuery!.searchScopes = [NSMetadataQueryUbiquitousDocumentsScope]
documentMetadataQuery!.predicate = NSPredicate(format: "(%K.pathExtension = %@)", argumentArray: [NSMetadataItemFSNameKey, AppConfiguration.listerFileExtension])
// observe the query
let notificationCenter = NSNotificationCenter.defaultCenter()
notificationCenter.addObserver(self, selector: "handleMetadataQueryUpdates:", name: NSMetadataQueryDidFinishGatheringNotification, object: metadataQuery)
notificationCenter.addObserver(self, selector: "handleMetadataQueryUpdates:", name: NSMetadataQueryDidUpdateNotification, object: metadataQuery)
}
documentMetadataQuery!.startQuery()
}
func handleMetadataQueryUpdates(NSNotification) {
documentMetadataQuery!.disableUpdates()
processMetadataItems()
documentMetadataQuery!.enableUpdates()
}
func processListInfoDifferences(previousListInfo: ListInfo[]) {
var insertionRows = NSIndexPath[]()
var deletionRows = NSIndexPath[]()
for (idx, listInfo) in enumerate(listInfos) {
if let found = find(previousListInfo, listInfo) {
listInfos[idx].color = previousListInfo[found].color
listInfos[idx].name = previousListInfo[found].name
} else {
let indexPath = NSIndexPath(forRow: idx, inSection: 0)
insertionRows.append(indexPath)
}
}
for (idx, listInfo) in enumerate(previousListInfo) {
if let found = find(listInfos, listInfo) {
listInfos[found].color = listInfo.color
listInfos[found].name = listInfo.name
} else {
let indexPath = NSIndexPath(forRow: idx, inSection: 0)
deletionRows.append(indexPath)
}
}
self.tableView.beginUpdates()
self.tableView.deleteRowsAtIndexPaths(deletionRows, withRowAnimation: .Automatic)
self.tableView.insertRowsAtIndexPaths(insertionRows, withRowAnimation: .Automatic)
self.tableView.endUpdates()
}
func insertListInfo(listInfo: ListInfo, completionHandler: (Int -> Void)? = nil) {
listInfos.append(listInfo)
sort(listInfos) { $0.name < $1.name }
let indexOfInsertedInfo = find(listInfos, listInfo)!
completionHandler?(indexOfInsertedInfo)
}
func removeListInfo(listInfo: ListInfo, completionHandler: (Int -> Void)? = nil) {
if let index = find(listInfos, listInfo) {
listInfos.removeAtIndex(index)
completionHandler?(index)
}
}
// ListInfoProvider objects are used to allow us to interact naturally with ListInfo objects that may originate from
// local URLs or NSMetadataItems representing document in the cloud.
func insertListInfoWithProvider(provider: ListInfoProvider, completionHandler: (Int -> Void)? = nil) {
let listInfo = ListInfo(provider: provider)
insertListInfo(listInfo, completionHandler: completionHandler)
}
func removeListInfoWithProvider(provider: ListInfoProvider, completionHandler: (Int -> Void)? = nil) {
let listInfo = ListInfo(provider: provider)
removeListInfo(listInfo, completionHandler: completionHandler)
}
// MARK: Notifications
// The color of the list was changed in the ListViewController, so we need to update the color in our list of documents.
func handleListColorDidChangeNotification(notification: NSNotification) {
let userInfo = notification.userInfo
let rawColor = userInfo[ListViewController.Notifications.ListColorDidChange.colorUserInfoKey] as Int
let url = userInfo[ListViewController.Notifications.ListColorDidChange.URLUserInfoKey] as NSURL
let color = List.Color.fromRaw(rawColor)!
let listInfo = ListInfo(provider: url)
if let index = find(listInfos, listInfo) {
listInfos[index].color = color
let indexPathForRow = NSIndexPath(forRow: index, inSection: 0)
let cell = tableView.cellForRowAtIndexPath(indexPathForRow) as ListCell
cell.listColor.backgroundColor = color.colorValue
}
}
func handleContentSizeCategoryDidChangeNotification(_: NSNotification) {
tableView.setNeedsLayout()
}
// MARK: User Storage Preference Related Alerts
func notifyUserOfAccountChange() {
let title = NSLocalizedString("iCloud Sign Out", comment: "")
let message = NSLocalizedString("You have signed out of the iCloud account previously used to store documents. Sign back in to access those documents.", comment: "")
let okActionTitle = NSLocalizedString("OK", comment: "")
let signedOutController = UIAlertController(title: title, message: message, preferredStyle: .Alert)
let action = UIAlertAction(title: okActionTitle, style: .Cancel, handler: nil)
signedOutController.addAction(action)
self.presentViewController(signedOutController, animated: true, completion: nil)
}
func promptUserForStorageOption() {
let title = NSLocalizedString("Choose Storage Option", comment: "")
let message = NSLocalizedString("Do you want to store documents in iCloud or only on this device?", comment: "")
let localOnlyActionTitle = NSLocalizedString("Local Only", comment: "")
let cloudActionTitle = NSLocalizedString("iCloud", comment: "")
let storageController = UIAlertController(title: title, message: message, preferredStyle: .Alert)
let localOption = UIAlertAction(title: localOnlyActionTitle, style: .Default) { localAction in
AppConfiguration.sharedConfiguration.storageOption = .Local
}
storageController.addAction(localOption)
let cloudOption = UIAlertAction(title: cloudActionTitle, style: .Default) { cloudAction in
AppConfiguration.sharedConfiguration.storageOption = .Cloud
}
storageController.addAction(cloudOption)
presentViewController(storageController, animated: true, completion: nil)
}
}
| mit | 0b0ad464baf7e26d7dcba4b1b9bb0db0 | 39.445161 | 186 | 0.666348 | 6.302614 | false | false | false | false |
bhargavg/Request | Examples/SimpleResponseParsing/main.swift | 1 | 759 | //
// main.swift
// SampleResponseParsing
//
// Created by Gurlanka, Bhargav (Agoda) on 30/06/17.
// Copyright © 2017 Gurlanka, Bhargav (Agoda). All rights reserved.
//
import Foundation
import Result
import Request
do {
let result = post(url: "https://httpbin.org/post", params: {
$0.body = .jsonArray(["foo", "bar"])
}).mapError({ .sessionError($0) })
.flatMap(HTTPBinResponse.from(response:))
print(result.value ?? "Failed with error")
}
do {
let result = get(url: "https://httpbin.org/get", params: {
$0.queryItems = ["bar": "foo"]
$0.headers = ["X-Foo": "Bar"]
}).mapError({ .sessionError($0) })
.flatMap(HTTPBinResponse.from(response:))
print(result.value ?? "Failed with error")
}
| mit | c2505dbd673344ad7028467465b08e0d | 23.451613 | 68 | 0.614776 | 3.281385 | false | false | false | false |
ufogxl/MySQLTest | Sources/login.swift | 1 | 3186 | //
// Login.swift
// GoodStudent
//
// Created by ufogxl on 16/11/7.
//
//
import Foundation
import PerfectLib
import PerfectHTTP
import MySQL
import ObjectMapper
fileprivate let container = ResponseContainer()
fileprivate let login_user = NSMutableDictionary()
fileprivate let errorContent = ErrorContent()
func login(_ request:HTTPRequest,response:HTTPResponse){
//读取网络请求的参数
let params = request.params()
phaseParams(params: params)
if !paramsValid(){
let errorStr = "参数错误"
errorContent.code = ErrCode.ARGUMENT_ERROR.hashValue
container.message = errorStr
container.data = errorContent
container.result = false
response.appendBody(string:container.toJSONString(prettyPrint: true)!)
response.completed()
return
}
guard let ary = getUser() else{
//数据库错误
return
}
//无此用户
if ary.count < 1{
errorContent.code = ErrCode.NO_SUCH_USER.hashValue
container.data = errorContent
container.result = false
container.message = "用户不存在"
response.appendBody(string:container.toJSONString(prettyPrint: true)!)
response.completed()
return
}
if (login_user as NSDictionary)["password"] as? String == ary.first!.u_pass{
let successstr = "登陆成功"
container.message = successstr
container.result = true
container.data = ary[0]
response.appendBody(string:container.toJSONString(prettyPrint: true)!)
response.completed()
return
}else{
let failstr = "用户名或密码错误"
errorContent.code = ErrCode.PASSWORD_ERROR.hashValue
container.message = failstr
container.data = errorContent
container.result = false
response.appendBody(string:container.toJSONString(prettyPrint: false)!)
response.completed()
return
}
}
//处理参数
fileprivate func phaseParams(params:[(String,String)]){
for i in 0..<params.count{
login_user.setObject(params[i].1, forKey: NSString(string: params[i].0))
}
}
//判断请求的参数是否输入正确
fileprivate func paramsValid() -> Bool{
if (login_user["userName"] == nil)||(login_user["password"] == nil){
return false
}
return true
}
//数据库查询操作
func getUser() -> [User]?{
let connected = mysql.connect(host: db_host, user: db_user, password: db_password, db: database,port:db_port)
guard connected else {
print(mysql.errorMessage())
return nil
}
defer {
mysql.close()
}
let querySuccess = mysql.query(statement: "SELECT id,u_name,u_pass FROM user WHERE u_name=\(login_user["userName"]!)")
guard querySuccess else {
return nil
}
let results = mysql.storeResults()!
var ary = [User]()
while let row = results.next() {
let user = User()
user.id = row[0]!
user.u_name = Int(row[1]!)
user.u_pass = row[2]!
ary.append(user)
}
return ary
}
| apache-2.0 | 850a6acfe6be56d5f5b6cbc34a8643bd | 22.538462 | 122 | 0.615359 | 4.22069 | false | false | false | false |
softwarenerd/Stately | Stately/Code/State.swift | 1 | 2672 | //
// State.swift
// Stately
//
// Created by Brian Lambert on 10/4/16.
// See the LICENSE.md file in the project root for license information.
//
import Foundation
// State error enumeration.
public enum StateError: Error {
case NameEmpty
}
// Types alias for a state change tuple.
public typealias StateChange = (state: State, object: AnyObject?)
// Type alias for a state enter action.
public typealias StateEnterAction = (AnyObject?) throws -> StateChange?
// State class.
public class State: Hashable {
// Gets the name of the state.
public let name: String
// The optional state enter action.
internal let stateEnterAction: StateEnterAction?
/// Initializes a new instance of the State class.
///
/// - Parameters:
/// - name: The name of the state. Each state must have a unique name.
public convenience init(name nameIn: String) throws {
try self.init(name: nameIn, stateEnterAction: nil)
}
/// Initializes a new instance of the State class.
///
/// - Parameters:
/// - name: The name of the state. Each state must have a unique name.
/// - stateEnterAction: The state enter action.
public convenience init(name nameIn: String, stateEnterAction stateEnterActionIn: @escaping StateEnterAction) throws {
try self.init(name: nameIn, stateEnterAction: StateEnterAction?(stateEnterActionIn))
}
/// Initializes a new instance of the State class.
///
/// - Parameters:
/// - name: The name of the state. Each state must have a unique name.
/// - stateAction: The optional state enter action.
private init(name nameIn: String, stateEnterAction stateEnterActionIn: StateEnterAction?) throws {
// Validate the state name.
if nameIn.isEmpty {
throw StateError.NameEmpty
}
// Initialize.
name = nameIn
stateEnterAction = stateEnterActionIn
}
/// Gets the hash value.
///
/// Hash values are not guaranteed to be equal across different executions of
/// your program. Do not save hash values to use during a future execution.
public var hashValue: Int {
get {
return name.hashValue
}
}
/// Returns a Boolean value indicating whether two values are equal.
///
/// Equality is the inverse of inequality. For any values `a` and `b`,
/// `a == b` implies that `a != b` is `false`.
///
/// - Parameters:
/// - lhs: A value to compare.
/// - rhs: Another value to compare.
public static func ==(lhs: State, rhs: State) -> Bool {
return lhs === rhs
}
}
| mit | 3208ed286cb89b8e8d0517f3e0ebddb6 | 30.809524 | 122 | 0.638099 | 4.521151 | false | false | false | false |
kfix/MacPin | Sources/MacPinIOS/AppDelegateIOS.swift | 1 | 7070 | import UIKit
import ObjectiveC
import WebKitPrivates
import Darwin
@main
public class MacPinAppDelegateIOS: NSObject, MacPinAppDelegate {
var browserController: BrowserViewController = MobileBrowserViewController() //frame: UIScreen.mainScreen().applicationFrame)
let window = UIWindow(frame: UIScreen.main.bounds) // total pixels w/ rotation
var prompter: Prompter? = nil
func application(_ application: UIApplication, openURL url: URL, sourceApplication: String?, annotation: AnyObject) -> Bool {
warn("`\(url)` -> AppScriptRuntime.shared.jsdelegate.launchURL()")
AppScriptRuntime.shared.emit(.launchURL, url.absoluteString ?? "")
return true //FIXME
}
public func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { // state not restored, UI not presented
application.registerUserNotificationSettings(UIUserNotificationSettings(types: [UIUserNotificationType.sound, UIUserNotificationType.alert, UIUserNotificationType.badge], categories: nil))
AppScriptRuntime.shared.setBrowserWindowClass(MobileBrowserViewController.self)
if !AppScriptRuntime.shared.loadMainScript() { // load main.js, if present
self.browserController.extend(AppScriptRuntime.shared.exports) // expose our default browser instance early on, because legacy
MobileBrowserViewController.self.exportSelf(AppScriptRuntime.shared.context.globalObject) // & the type for self-setup
AppScriptRuntime.shared.exports.setObject(MPWebView.self, forKeyedSubscript: "WebView" as NSString) // because legacy
AppScriptRuntime.shared.exports.setObject("", forKeyedSubscript: "launchedWithURL" as NSString)
AppScriptRuntime.shared.loadSiteApp() // load app.js, if present
AppScriptRuntime.shared.emit(.AppFinishedLaunching)
}
AppScriptRuntime.shared.emit(.AppWillFinishLaunching, self) // allow JS to replace our browserController
AppScriptRuntime.shared.context.evaluateScript("eval = null;") // security thru obscurity
return true
}
public func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { //state restored, but UI not presented yet
// launchOptions: http://nshipster.com/launch-options/
UIApplication.shared.statusBarStyle = .lightContent
window.backgroundColor = UIColor.white // visible behind status bar area when unobscured by page content
window.rootViewController = browserController as! UIViewController //adds the browserView to window.subviews
window.makeKeyAndVisible() // presentation is deferred until after didFinishLaunching
AppScriptRuntime.shared.emit(.AppFinishedLaunching, "FIXME: provide real launch URLs")
// airplay to an external screen on a mac or appletv
// https://developer.apple.com/library/ios/documentation/WindowsViews/Conceptual/WindowAndScreenGuide/UsingExternalDisplay/UsingExternalDisplay.html#//apple_ref/doc/uid/TP40012555-CH3-SW1
warn(CommandLine.arguments.description)
for (idx, arg) in CommandLine.arguments.enumerated() {
switch (arg) {
case "-i":
//open a JS console on the terminal, if present
if AppScriptRuntime.shared.eventCallbacks[.printToREPL, default: []].isEmpty {
if let repl_js = Bundle.main.url(forResource: "app_repl", withExtension: "js") {
warn("injecting TTY REPL")
AppScriptRuntime.shared.eventCallbacks[.printToREPL] = [
AppScriptRuntime.shared.loadCommonJSScript(repl_js.absoluteString).objectForKeyedSubscript("repl")
]
}
}
prompter = AppScriptRuntime.shared.REPL()
case "-t":
if idx + 1 >= CommandLine.arguments.count { // no arg after this one
prompter = browserController.tabs.first?.REPL() //open a JS console for the first tab WebView on the terminal, if present
break
}
if let tabnum = Int(CommandLine.arguments[idx + 1]), browserController.tabs.count >= tabnum { // next argv should be tab number
prompter = browserController.tabs[tabnum].REPL() // open a JS Console on the requested tab number
// FIXME skip one more arg
} else {
prompter = browserController.tabs.first?.REPL() //open a JS console for the first tab WebView on the terminal, if present
}
case let _ where (arg.hasPrefix("http:") || arg.hasPrefix("https:") || arg.hasPrefix("about:") || arg.hasPrefix("file:")):
warn("\(arg)")
//application(NSApp, openFile: arg) // LS will openFile AND argv.append() fully qualified URLs
default:
if arg != CommandLine.arguments[0] && !arg.hasPrefix("-psn_0_") { // Process Serial Number from LaunchServices open()
warn("unrecognized argv[]: `\(arg)`")
}
}
}
prompter?.start()
return true //FIXME
}
public func applicationDidBecomeActive(_ application: UIApplication) { // UI presented
//if application?.orderedDocuments?.count < 1 { showApplication(self) }
browserController.view.frame = UIScreen.main.bounds
if browserController.tabs.count < 1 { browserController.newTabPrompt() } //don't allow a tabless state
}
// need https://github.com/kemenaran/ios-presentError
// w/ http://nshipster.com/uialertcontroller/
/*
func application(application: NSApplication, willPresentError error: NSError) -> NSError {
//warn("`\(error.localizedDescription)` [\(error.domain)] [\(error.code)] `\(error.localizedFailureReason ?? String())` : \(error.userInfo)")
if error.domain == NSURLErrorDomain {
if let userInfo = error.userInfo {
if let errstr = userInfo[NSLocalizedDescriptionKey] as? String {
if let url = userInfo[NSURLErrorFailingURLStringErrorKey] as? String {
var newUserInfo = userInfo
newUserInfo[NSLocalizedDescriptionKey] = "\(errstr)\n\n\(url)" // add failed url to error message
let newerror = NSError(domain: error.domain, code: error.code, userInfo: newUserInfo)
return newerror
}
}
}
}
return error
}
*/
public func applicationWillTerminate(_ application: UIApplication) {
AppScriptRuntime.shared.emit(.AppShouldTerminate, self) // allow JS to clean up its refs
UserDefaults.standard.synchronize()
}
public func application(_ application: UIApplication, shouldSaveApplicationState coder: NSCoder) -> Bool { return false }
public func application(_ application: UIApplication, shouldRestoreApplicationState coder: NSCoder) -> Bool { return false }
//func applicationDidReceiveMemoryWarning(application: UIApplication) { close all hung tabs! }
public func application(_ application: UIApplication, didReceive notification: UILocalNotification) {
warn("user clicked notification")
// FIXME should be passing a [:]
if AppScriptRuntime.shared.anyHandled(.handleClickedNotification, [
"title": (notification.alertTitle ?? "") as NSString,
"subtitle": (notification.alertAction ?? "") as NSString,
"body": (notification.alertBody ?? "") as NSString,
]) {
warn("handleClickedNotification fired!")
}
}
//alerts do not display when app is already frontmost, cannot override this like on OSX
}
| gpl-3.0 | f12dc3bb37ea37fd987482cabeb864e0 | 49.863309 | 199 | 0.744696 | 4.364198 | false | false | false | false |
czj1127292580/weibo_swift | WeiBo_Swift/WeiBo_Swift/Class/Home/QRCode/QRCodeCardViewController.swift | 1 | 3969 | //
// QRCodeCardViewController.swift
// WeiBo_Swift
//
// Created by 岑志军 on 16/8/24.
// Copyright © 2016年 cen. All rights reserved.
//
import UIKit
class QRCodeCardViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
view.backgroundColor = UIColor.whiteColor()
navigationItem.title = "我的名片"
view.addSubview(iconView)
iconView.xmg_AlignInner(type: XMG_AlignType.Center, referView: view, size: CGSizeMake(200, 200))
let qrcodeImage = createQRCodeImage()
iconView.image = qrcodeImage
}
private func createQRCodeImage() -> UIImage?{
// 1.创建滤镜
let filter = CIFilter(name: "CIQRCodeGenerator")
// 2、还原滤镜默认属性
filter?.setDefaults()
// 3、设置需要生成的二维码数据
filter?.setValue("岑志军".dataUsingEncoding(NSUTF8StringEncoding), forKey: "inputMessage")
// 4、从滤镜中取出生成好的图片
let ciImage = filter?.outputImage
// 这个方法生层的图片比较模糊
// return UIImage(CIImage: ciImage!)
let bgImage = createNonInterpolatedUIImageFormCIImage(ciImage!, size: 300)
// 5、创建一个头像
let icon = UIImage(named: "czj.jpg")
// 6、合成图片（将二维码和头像进行合并）
let newImage = createImage(bgImage, iconImage: icon!)
// 7、返回生成好的二维码
return newImage
}
/**
合成图片
- parameter bgImage: 背景图片
- parameter iconImage: 头像
*/
private func createImage(bgImage: UIImage, iconImage: UIImage) -> UIImage {
// 1、开启图片上下文
UIGraphicsBeginImageContext(bgImage.size)
// 2、绘制背景图片
bgImage.drawInRect(CGRect(origin: CGPointZero, size: bgImage.size))
// 3、绘制头像
let width: CGFloat = 50
let height: CGFloat = width
let x = (bgImage.size.width - width) * 0.5
let y = (bgImage.size.height - height) * 0.5
iconImage.drawInRect(CGRect(x: x, y: y, width: width, height: height))
// 4、取出绘制好的图片
let newImage = UIGraphicsGetImageFromCurrentImageContext()
// 5、关闭上下文
UIGraphicsEndImageContext()
// 6、返回合成好的图片
return newImage!
}
/**
根据CIImage生成指定大小的高清UIImage
:param: image 指定CIImage
:param: size 指定大小
:returns: 生成好的图片
*/
private func createNonInterpolatedUIImageFormCIImage(image: CIImage, size: CGFloat) -> UIImage {
let extent: CGRect = CGRectIntegral(image.extent)
let scale: CGFloat = min(size/CGRectGetWidth(extent), size/CGRectGetHeight(extent))
// 1.创建bitmap;
let width = CGRectGetWidth(extent) * scale
let height = CGRectGetHeight(extent) * scale
let cs: CGColorSpaceRef = CGColorSpaceCreateDeviceGray()
let bitmapRef = CGBitmapContextCreate(nil, Int(width), Int(height), 8, 0, cs, 0)!
let context = CIContext(options: nil)
let bitmapImage: CGImageRef = context.createCGImage(image, fromRect: extent)!
CGContextSetInterpolationQuality(bitmapRef, CGInterpolationQuality.None)
CGContextScaleCTM(bitmapRef, scale, scale);
CGContextDrawImage(bitmapRef, extent, bitmapImage);
// 2.保存bitmap到图片
let scaledImage: CGImageRef = CGBitmapContextCreateImage(bitmapRef)!
return UIImage(CGImage: scaledImage)
}
// MARK: - 懒加载
private lazy var iconView: UIImageView = UIImageView()
}
| mit | 95add911c23a0ed8946d53afa770706a | 28.252033 | 104 | 0.598388 | 4.703268 | false | false | false | false |
srn214/Floral | Floral/Floral/Classes/Module/Community(研究院)/ViewModel/LDRecommendVM.swift | 1 | 3846 | //
// LDRecommendVM.swift
// Floral
//
// Created by LDD on 2019/7/18.
// Copyright © 2019 文刂Rn. All rights reserved.
//
import UIKit
class LDRecommendVM: RefreshViewModel {
struct Input {
let city: String
}
struct Output {
let banners: Driver<[BannerModel]>
let items: Driver<[CourseSectionModel]>
}
}
extension LDRecommendVM: ViewModelProtocol {
func transform(input: LDRecommendVM.Input) -> LDRecommendVM.Output {
let bannerList = BehaviorRelay<[BannerModel]>(value: [])
let itemList = BehaviorRelay<[CourseSectionModel]>(value: [])
var page = 0
/// 上拉刷新
let loadList = refreshOutput
.headerRefreshing
.flatMapLatest { (_) -> SharedSequence<DriverSharingStrategy, ([BannerModel], LDRecommendHotModel, [CourseSectionModel])> in
let loadBranner = RecommendApi
.bannerList
.request()
.mapObject([BannerModel].self)
.asDriver(onErrorJustReturn: [])
let loadHop = RecommendApi
.portalList
.request()
.mapObject(LDRecommendHotModel.self)
.asDriver(onErrorJustReturn: LDRecommendHotModel(limitedTimeFreeList: nil, latestRecommendList: nil))
let loadCategory = RecommendApi
.categoryList(page: page)
.request()
.mapObject([CourseSectionModel].self)
.asDriver(onErrorJustReturn: [])
return Driver.zip(loadBranner, loadHop, loadCategory)
}
/// 下拉刷新
let loadMore = refreshOutput
.footerRefreshing
.then(page += 1)
.flatMapLatest { [unowned self] in
RecommendApi
.categoryList(page: page)
.request()
.mapObject([CourseSectionModel].self)
.trackActivity(self.loading)
.trackError(self.refreshError)
.asDriverOnErrorJustComplete()
}
/// 绑定数据
loadList.drive(onNext: { (arg0) in
let (headerList, hotItem, categoryList) = arg0
bannerList.accept(headerList)
if let limited = hotItem.limitedTimeFreeList {
itemList.append(limited)
}
if let latest = hotItem.latestRecommendList {
itemList.append(latest)
}
itemList.accept(itemList.value + categoryList)
}).disposed(by: disposeBag)
loadMore
.drive(itemList.append)
.disposed(by: disposeBag)
// 头部刷新状态
loadList
.mapTo(false)
.drive(refreshInput.headerRefreshState)
.disposed(by: disposeBag)
// 尾部刷新状态
Driver.merge(
loadList.map { _ in
RxMJRefreshFooterState.default
},
loadMore.map { list in
if list.count > 0 {
return RxMJRefreshFooterState.default
} else {
return RxMJRefreshFooterState.noMoreData
}
})
.startWith(.hidden)
.drive(refreshInput.footerRefreshState)
.disposed(by: disposeBag)
let output = Output(banners: bannerList.asDriver(), items: itemList.asDriver())
return output
}
}
extension LDRecommendVM {
}
| mit | 2a94a4e664b37bfdba1c3c965e63bfea | 28.176923 | 136 | 0.502505 | 5.729607 | false | false | false | false |
MarcoSantarossa/SwiftyToggler | Source/FeaturesManager/FeaturesManager.swift | 1 | 7755 | //
// FeaturesManager.swift
//
// Copyright (c) 2017 Marco Santarossa (https://marcosantadev.com/)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
public final class FeaturesManager {
/// Static instance to use as singleton
public static let shared = FeaturesManager()
var featuresStatus: [FeatureStatus] {
return dict
.flatMap { FeatureStatus(name: $0.key, isEnabled: $0.value.feature.isEnabled) }
.sorted(by: { $0.name < $1.name })
}
fileprivate let featureChangesObserversPool: FeatureChangesObserversPoolProtocol
fileprivate let featuresListCoordinator: FeaturesListCoordinatorProtocol
fileprivate var dict = [String: FeatureProxyProtocol]()
init(featureChangesObserversPool: FeatureChangesObserversPoolProtocol = FeatureChangesObserversPool(),
featuresListCoordinator: FeaturesListCoordinatorProtocol = FeaturesListCoordinator()) {
self.featureChangesObserversPool = featureChangesObserversPool
self.featuresListCoordinator = featuresListCoordinator
}
fileprivate func findFeatureProxy(for name: String) throws -> FeatureProxyProtocol {
guard let proxy = dict[name] else {
throw SwiftyTogglerError.featureNotFound
}
return proxy
}
}
// MARK: - FeaturesManagerProtocol
extension FeaturesManager: FeaturesManagerProtocol {
/// Adds a new features. If the feature name already exists, it will replace the previous one.
/// - parameter feature: It's the feature which you want to add.
/// - parameter name: The feature name associated to the feature to add.
/// - parameter shouldRunWhenEnabled: Flag to run the feature as soon as it's enabled. By default is false.
public func add(feature: FeatureProtocol, name: String, shouldRunWhenEnabled: Bool = false) {
let proxy = FeatureProxy(feature: feature, shouldRunWhenEnabled: shouldRunWhenEnabled)
dict[name] = proxy
}
/// Updates the `shouldRunWhenEnabled` value of a feature. If the feature name doesn't exist, will be thrown an error `SwiftyTogglerError.featureNotFound`.
/// - parameter featureName: Feature name to update.
/// - parameter shouldRunWhenEnabled: Flag to run the feature as soon as it's enabled.
/// - throws: SwiftyTogglerError.featureNotFound if the feature name is not found.
public func update(featureName: String, shouldRunWhenEnabled: Bool) throws {
var proxy = try findFeatureProxy(for: featureName)
proxy.shouldRunWhenEnabled = shouldRunWhenEnabled
}
/// Removes a feature.
/// - parameter featureName: Feature name to remove.
public func remove(featureName: String) {
dict.removeValue(forKey: featureName)
}
/// Removes all the features.
public func removeAll() {
dict.removeAll()
}
/// Runs a feature.
/// - parameter featureName: Feature name to run.
/// - returns: `True` if the feature has been run, `False` if it hasn't been run because it is not enabled.
@discardableResult
public func run(featureName: String) throws -> Bool {
let proxy = try findFeatureProxy(for: featureName)
return proxy.run()
}
/// Checks if a feature is enabled.
/// - parameter featureName: Feature name to check.
/// - returns: `True` if the feature is enabled, `False` if it is not enabled.
public func isEnabled(featureName: String) throws -> Bool {
let proxy = try findFeatureProxy(for: featureName)
return proxy.isFeatureEnable
}
}
// MARK: - FeaturesManagerObserversProtocol
extension FeaturesManager: FeaturesManagerObserversProtocol {
/// Adds an observer for all features changes.
/// - parameter observer: Features changes observer.
public func addChangesObserver(_ observer: FeatureChangesObserver) {
featureChangesObserversPool.addObserver(observer, featureNames: nil)
}
/// Adds an observer for a specific feature changes.
/// - parameter observer: Feature changes observer.
/// - parameter featureName: Feature name to observer.
public func addChangesObserver(_ observer: FeatureChangesObserver, featureName: String) {
featureChangesObserversPool.addObserver(observer, featureNames: [featureName])
}
/// Adds an observer for an array of specific features changes.
/// - parameter observer: Features changes observer.
/// - parameter featureNames: Array of features name to observer.
public func addChangesObserver(_ observer: FeatureChangesObserver, featureNames: [String]) {
featureChangesObserversPool.addObserver(observer, featureNames: featureNames)
}
/// Removes an observer.
/// - parameter observer: Observer to remove.
/// - parameter featureNames: Array of features name to remove. If nil, the observer will be removed for all the features. By default is nil.
public func removeChangesObserver(_ observer: FeatureChangesObserver, featureNames: [String]? = nil) {
featureChangesObserversPool.removeObserver(observer, featureNames: featureNames)
}
}
// MARK: - FeaturesManagerFeaturesListPresenterProtocol
extension FeaturesManager: FeaturesManagerFeaturesListPresenterProtocol {
/// Presents the features list as modal in a new window.
/// - parameter window: Window where to attach the features list. By default, it's a new window created on top of existing ones.
/// - throws: SwiftyTogglerError.modalFeaturesListAlreadyPresented if there is already a modal features list.
public func presentModalFeaturesList(in window: UIWindow = UIWindow(frame: UIScreen.main.bounds)) throws {
try featuresListCoordinator.start(presentingMode: .modal(window))
}
/// Presents the features list inside a parent view controller.
/// - parameter viewController: View controller where to present the features list.
/// - parameter view: View where to present the features list. If nil, the features list will be added in the view controller's main view. By defeault, it's nil.
public func presentFeaturesList(in viewController: UIViewController, view: UIView? = nil) {
try? featuresListCoordinator.start(presentingMode: .inParent(viewController, view))
}
}
extension FeaturesManager: FeaturesManagerTogglerProtocol {
/// Enables/Disables a feature.
/// - parameter isEnabled: New feature value. If `True` the feature will be enabled, if `False` it will be disabled. If the value is `True` and the feature is already enabled or if the value is `False` and the feature is already disabled, this function doesn't do anything.
/// - parameter featureName: Feature name to update.
public func setEnable(_ isEnabled: Bool, featureName: String) throws {
var proxy = try findFeatureProxy(for: featureName)
proxy.isFeatureEnable = isEnabled
featureChangesObserversPool.notify(for: proxy.feature, featureName: featureName)
}
}
| mit | cb3bb9d2e3f9fb26a11ec5bf556ea6bb | 47.773585 | 277 | 0.751128 | 4.728659 | false | false | false | false |
prebid/prebid-mobile-ios | PrebidMobileTests/RenderingTests/Mocks/MockLocationManager.swift | 1 | 1481 | /* Copyright 2018-2021 Prebid.org, 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 CoreLocation
@testable import PrebidMobile
class MockLocationManagerSuccessful: PBMLocationManager {
static let testCoord = CLLocationCoordinate2D(latitude: 34.149335, longitude: -118.1328249)
static let testCoordsAreValid = true
static let testCity = "Pasadena"
static let testCountry = "USA"
static let testState = "CA"
static let testZipCode = "91601"
override class var shared: MockLocationManagerSuccessful {
return MockLocationManagerSuccessful(thread: Thread.current)
}
override var coordinatesAreValid:Bool {
get {
return MockLocationManagerSuccessful.testCoordsAreValid
}
}
override var coordinates:CLLocationCoordinate2D {
get {
return MockLocationManagerSuccessful.testCoord
}
}
}
class MockLocationManagerUnSuccessful : PBMLocationManager {}
| apache-2.0 | d7af8070965348b448a08aa5ef0e6b89 | 30.956522 | 95 | 0.734694 | 4.726688 | false | true | false | false |
lexchou/swallow | stdlib/core/Comparable.swift | 1 | 998 | /// Instances of conforming types can be compared using relational
/// operators, which define a `strict total order
/// <http://en.wikipedia.org/wiki/Total_order#Strict_total_order>`_.
///
/// A type conforming to `Comparable` need only supply the `<` and
/// `==` operators; default implementations of `<=`, `>`, `>=`, and
/// `!=` are supplied by the standard library::
///
/// struct Singular : Comparable {}
/// func ==(x: Singular, y: Singular) -> Bool { return true }
/// func <(x: Singular, y: Singular) -> Bool { return false }
///
/// **Axioms**, in addition to those of `Equatable`:
///
/// - `x == y` implies `x <= y`, `x >= y`, `!(x < y)`, and `!(x > y)`
/// - `x < y` implies `x <= y` and `y > x`
/// - `x > y` implies `x >= y` and `y < x`
/// - `x <= y` implies `y >= x`
/// - `x >= y` implies `y <= x`
protocol Comparable : _Comparable, Equatable {
func <=(lhs: Self, rhs: Self) -> Bool
func >=(lhs: Self, rhs: Self) -> Bool
func >(lhs: Self, rhs: Self) -> Bool
}
| bsd-3-clause | c7f01a1e4a36179c7d7177d649fe1130 | 40.583333 | 69 | 0.562124 | 3.272131 | false | false | false | false |
STMicroelectronics-CentralLabs/BlueSTSDK_iOS | BlueSTSDK/BlueSTSDK/Features/Predictive/BlueSTSDKFeaturePredictiveFrequencyDomainStatus.swift | 1 | 7581 | /*******************************************************************************
* COPYRIGHT(c) 2018 STMicroelectronics
*
* 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 STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
import Foundation
public class BlueSTSDKFeaturePredictiveFrequencyDomainStatus : BlueSTSDKFeaturePredictiveStatus{
private static let FEATURE_NAME = "PredictiveFrequencyDomainStatus"
private static func buildAccField(name:String)->BlueSTSDKFeatureField{
return BlueSTSDKFeatureField(name: name, unit: "m/s^2", type: .float,
min: NSNumber(value:0.0),
max: NSNumber(value:Float(1<<16)/10.0))
}
private static func buildFreqField(name:String)->BlueSTSDKFeatureField{
return BlueSTSDKFeatureField(name: name, unit: "Hz", type: .float,
min: NSNumber(value:0.0),
max: NSNumber(value:Float(1<<16)/100.0))
}
private static let FIELDS:[BlueSTSDKFeatureField] = [
BlueSTSDKFeaturePredictiveStatus.buildStatusField(name: "StatusAcc_X"),
BlueSTSDKFeaturePredictiveStatus.buildStatusField(name: "StatusAcc_Y"),
BlueSTSDKFeaturePredictiveStatus.buildStatusField(name: "StatusAcc_Z"),
BlueSTSDKFeaturePredictiveFrequencyDomainStatus.buildFreqField(name: "Freq_X"),
BlueSTSDKFeaturePredictiveFrequencyDomainStatus.buildFreqField(name: "Freq_Y"),
BlueSTSDKFeaturePredictiveFrequencyDomainStatus.buildFreqField(name: "Freq_Z"),
BlueSTSDKFeaturePredictiveFrequencyDomainStatus.buildAccField(name: "MaxAmplitude_X"),
BlueSTSDKFeaturePredictiveFrequencyDomainStatus.buildAccField(name: "MaxAmplitude_Y"),
BlueSTSDKFeaturePredictiveFrequencyDomainStatus.buildAccField(name: "MaxAmplitude_Z")
]
public override func getFieldsDesc() -> [BlueSTSDKFeatureField] {
return BlueSTSDKFeaturePredictiveFrequencyDomainStatus.FIELDS
}
public static func getStatusX(_ sample:BlueSTSDKFeatureSample)->Status{
return sample.extractStatus(index: 0)
}
public static func getStatusY(_ sample:BlueSTSDKFeatureSample)->Status{
return sample.extractStatus(index: 1)
}
public static func getStatusZ(_ sample:BlueSTSDKFeatureSample)->Status{
return sample.extractStatus(index: 2)
}
public static func getWorstXFrequency(_ sample:BlueSTSDKFeatureSample)->Float{
return sample.extractFloat(index: 3)
}
public static func getWorstYFrequency(_ sample:BlueSTSDKFeatureSample)->Float{
return sample.extractFloat(index: 4)
}
public static func getWorstZFrequency(_ sample:BlueSTSDKFeatureSample)->Float{
return sample.extractFloat(index: 5)
}
public static func getWorstXValue(_ sample:BlueSTSDKFeatureSample)->Float{
return sample.extractFloat(index: 6)
}
public static func getWorstYValue(_ sample:BlueSTSDKFeatureSample)->Float{
return sample.extractFloat(index: 7)
}
public static func getWorstZValue(_ sample:BlueSTSDKFeatureSample)->Float{
return sample.extractFloat(index: 8)
}
public static func getWorstXPoint(_ sample:BlueSTSDKFeatureSample)->(Float,Float){
return (getWorstXFrequency(sample),getWorstXValue(sample))
}
public static func getWorstYPoint(_ sample:BlueSTSDKFeatureSample)->(Float,Float){
return (getWorstYFrequency(sample),getWorstYValue(sample))
}
public static func getWorstZPoint(_ sample:BlueSTSDKFeatureSample)->(Float,Float){
return (getWorstZFrequency(sample),getWorstZValue(sample))
}
public override init(whitNode node: BlueSTSDKNode) {
super.init(whitNode: node, name: BlueSTSDKFeaturePredictiveFrequencyDomainStatus.FEATURE_NAME)
}
public override func extractData(_ timestamp: UInt64, data: Data,
dataOffset offset: UInt32) -> BlueSTSDKExtractResult {
let intOffset = Int(offset)
if((data.count-intOffset) < 12){
NSException(name: NSExceptionName(rawValue: "Invalid data"),
reason: "There are no 12 bytes available to read",
userInfo: nil).raise()
return BlueSTSDKExtractResult(whitSample: nil, nReadData: 0)
}
let uintOffset = UInt(offset)
let status = data[intOffset]
let freqX = Float((data as NSData).extractLeUInt16(fromOffset: uintOffset+1))/10.0
let valX = Float((data as NSData).extractLeUInt16(fromOffset: uintOffset+3))/100.0
let freqY = Float((data as NSData).extractLeUInt16(fromOffset: uintOffset+5))/10.0
let valY = Float((data as NSData).extractLeUInt16(fromOffset: uintOffset+7))/100.0
let freqZ = Float((data as NSData).extractLeUInt16(fromOffset: uintOffset+9))/10.0
let valZ = Float((data as NSData).extractLeUInt16(fromOffset: uintOffset+11))/100.0
let sample = BlueSTSDKFeatureSample(timestamp: timestamp,
data: [
BlueSTSDKFeaturePredictiveStatus.extractXStatus(status).toNumber(),
BlueSTSDKFeaturePredictiveStatus.extractYStatus(status).toNumber(),
BlueSTSDKFeaturePredictiveStatus.extractZStatus(status).toNumber(),
NSNumber(value: freqX),
NSNumber(value: freqY),
NSNumber(value: freqZ),
NSNumber(value: valX),
NSNumber(value: valY),
NSNumber(value: valZ) ])
return BlueSTSDKExtractResult(whitSample: sample, nReadData: 12)
}
}
| bsd-3-clause | f0013093d090dced991c1c27b4270467 | 49.879195 | 115 | 0.646485 | 5.509448 | false | false | false | false |
Shopify/mobile-buy-sdk-ios | Buy/Generated/Storefront/CartLinesRemovePayload.swift | 1 | 4205 | //
// CartLinesRemovePayload.swift
// Buy
//
// Created by Shopify.
// Copyright (c) 2017 Shopify Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
import Foundation
extension Storefront {
/// Return type for `cartLinesRemove` mutation.
open class CartLinesRemovePayloadQuery: GraphQL.AbstractQuery, GraphQLQuery {
public typealias Response = CartLinesRemovePayload
/// The updated cart.
@discardableResult
open func cart(alias: String? = nil, _ subfields: (CartQuery) -> Void) -> CartLinesRemovePayloadQuery {
let subquery = CartQuery()
subfields(subquery)
addField(field: "cart", aliasSuffix: alias, subfields: subquery)
return self
}
/// The list of errors that occurred from executing the mutation.
@discardableResult
open func userErrors(alias: String? = nil, _ subfields: (CartUserErrorQuery) -> Void) -> CartLinesRemovePayloadQuery {
let subquery = CartUserErrorQuery()
subfields(subquery)
addField(field: "userErrors", aliasSuffix: alias, subfields: subquery)
return self
}
}
/// Return type for `cartLinesRemove` mutation.
open class CartLinesRemovePayload: GraphQL.AbstractResponse, GraphQLObject {
public typealias Query = CartLinesRemovePayloadQuery
internal override func deserializeValue(fieldName: String, value: Any) throws -> Any? {
let fieldValue = value
switch fieldName {
case "cart":
if value is NSNull { return nil }
guard let value = value as? [String: Any] else {
throw SchemaViolationError(type: CartLinesRemovePayload.self, field: fieldName, value: fieldValue)
}
return try Cart(fields: value)
case "userErrors":
guard let value = value as? [[String: Any]] else {
throw SchemaViolationError(type: CartLinesRemovePayload.self, field: fieldName, value: fieldValue)
}
return try value.map { return try CartUserError(fields: $0) }
default:
throw SchemaViolationError(type: CartLinesRemovePayload.self, field: fieldName, value: fieldValue)
}
}
/// The updated cart.
open var cart: Storefront.Cart? {
return internalGetCart()
}
func internalGetCart(alias: String? = nil) -> Storefront.Cart? {
return field(field: "cart", aliasSuffix: alias) as! Storefront.Cart?
}
/// The list of errors that occurred from executing the mutation.
open var userErrors: [Storefront.CartUserError] {
return internalGetUserErrors()
}
func internalGetUserErrors(alias: String? = nil) -> [Storefront.CartUserError] {
return field(field: "userErrors", aliasSuffix: alias) as! [Storefront.CartUserError]
}
internal override func childResponseObjectMap() -> [GraphQL.AbstractResponse] {
var response: [GraphQL.AbstractResponse] = []
objectMap.keys.forEach {
switch($0) {
case "cart":
if let value = internalGetCart() {
response.append(value)
response.append(contentsOf: value.childResponseObjectMap())
}
case "userErrors":
internalGetUserErrors().forEach {
response.append($0)
response.append(contentsOf: $0.childResponseObjectMap())
}
default:
break
}
}
return response
}
}
}
| mit | 809ef268422e445417d721f8210f8a48 | 33.752066 | 120 | 0.719857 | 4.205 | false | false | false | false |
JohnCoates/Aerial | Aerial/Source/Models/Cache/VideoManager.swift | 1 | 6210 | //
// VideoManager.swift
// Aerial
//
// Created by Guillaume Louel on 08/10/2018.
// Copyright © 2018 John Coates. All rights reserved.
//
import Foundation
typealias VideoManagerCallback = (Int, Int) -> Void
typealias VideoProgressCallback = (Int, Int, Double) -> Void
final class VideoManager: NSObject {
static let sharedInstance = VideoManager()
var managerCallbacks = [VideoManagerCallback]()
var progressCallbacks = [VideoProgressCallback]()
/// Dictionary of CheckCellView, keyed by the video.id
private var checkCells = [String: CheckCellView]()
/// List of queued videos, by video.id
private var queuedVideos = [String]()
/// Dictionary of operations, keyed by the video.id
fileprivate var operations = [String: VideoDownloadOperation]()
/// Number of videos that were queued
private var totalQueued = 0
var stopAll = false
// var downloadItems: [VideoDownloadItem]
/// Serial OperationQueue for downloads
private let queue: OperationQueue = {
// swiftlint:disable:next identifier_name
let _queue = OperationQueue()
_queue.name = "videodownload"
_queue.maxConcurrentOperationCount = 1
return _queue
}()
// MARK: Tracking CheckCellView
func addCheckCellView(id: String, checkCellView: CheckCellView) {
checkCells[id] = checkCellView
}
func addCallback(_ callback:@escaping VideoManagerCallback) {
managerCallbacks.append(callback)
}
func addProgressCallback(_ callback:@escaping VideoProgressCallback) {
progressCallbacks.append(callback)
}
func updateAllCheckCellView() {
for view in checkCells {
view.value.adaptIndicators()
}
}
// Is the video queued for download ?
func isVideoQueued(id: String) -> Bool {
if queuedVideos.firstIndex(of: id) != nil {
return true
} else {
return false
}
}
@discardableResult
func queueDownload(_ video: AerialVideo) -> VideoDownloadOperation {
if stopAll {
stopAll = false
}
let operation = VideoDownloadOperation(video: video, delegate: self)
operations[video.id] = operation
queue.addOperation(operation)
queuedVideos.append(video.id) // Our Internal List of queued videos
markAsQueued(id: video.id) // Callback the CheckCellView
totalQueued += 1 // Increment our count
DispatchQueue.main.async {
// Callback the callbacks
for callback in self.managerCallbacks {
callback(self.totalQueued-self.queuedVideos.count, self.totalQueued)
}
}
return operation
}
// Callbacks for Items
func finishedDownload(id: String, success: Bool) {
// Manage our queuedVideo index
if let index = queuedVideos.firstIndex(of: id) {
queuedVideos.remove(at: index)
}
if queuedVideos.isEmpty {
totalQueued = 0
}
DispatchQueue.main.async {
// Callback the callbacks
for callback in self.managerCallbacks {
callback(self.totalQueued-self.queuedVideos.count, self.totalQueued)
}
}
// Then callback the CheckCellView
if let cell = checkCells[id] {
if success {
cell.markAsDownloaded()
} else {
cell.markAsNotDownloaded()
}
}
}
func markAsQueued(id: String) {
// Manage our queuedVideo index
if let cell = checkCells[id] {
cell.markAsQueued()
}
}
func updateProgress(id: String, progress: Double) {
if let cell = checkCells[id] {
cell.updateProgressIndicator(progress: progress)
}
DispatchQueue.main.async {
// Callback the callbacks
for callback in self.progressCallbacks {
callback(self.totalQueued-self.queuedVideos.count, self.totalQueued, progress)
}
}
}
/// Cancel all queued operations
func cancelAll() {
stopAll = true
queue.cancelAllOperations()
}
}
final class VideoDownloadOperation: AsynchronousOperation {
var video: AerialVideo
var download: VideoDownload?
init(video: AerialVideo, delegate: VideoManager) {
debugLog("Video queued \(video.name)")
self.video = video
}
override func main() {
let videoManager = VideoManager.sharedInstance
if videoManager.stopAll {
return
}
debugLog("Starting download for \(video.name)")
DispatchQueue.main.async {
self.download = VideoDownload(video: self.video, delegate: self)
self.download!.startDownload()
}
}
override func cancel() {
defer { finish() }
let videoManager = VideoManager.sharedInstance
if let _ = self.download {
self.download!.cancel()
} else {
videoManager.finishedDownload(id: self.video.id, success: false)
}
self.download = nil
super.cancel()
// finish()
}
}
extension VideoDownloadOperation: VideoDownloadDelegate {
func videoDownload(_ videoDownload: VideoDownload,
finished success: Bool, errorMessage: String?) {
debugLog("Finished")
defer { finish() }
let videoManager = VideoManager.sharedInstance
if success {
// Call up to clean the view
videoManager.finishedDownload(id: videoDownload.video.id, success: true)
} else {
if let _ = errorMessage {
errorLog(errorMessage!)
}
videoManager.finishedDownload(id: videoDownload.video.id, success: false)
}
}
func videoDownload(_ videoDownload: VideoDownload, receivedBytes: Int, progress: Float) {
// Call up to update the view
let videoManager = VideoManager.sharedInstance
videoManager.updateProgress(id: videoDownload.video.id, progress: Double(progress))
}
}
| mit | d35d4e2878c9a10048e67b816daaa41b | 28.850962 | 94 | 0.610726 | 5.118714 | false | false | false | false |
germc/IBM-Ready-App-for-Retail | iOS/ReadyAppRetail/ReadyAppRetail/Views/CarouselCollectionView/CarouselCollectionViewFlowLayout.swift | 2 | 1105 | /*
Licensed Materials - Property of IBM
© Copyright IBM Corporation 2015. All Rights Reserved.
*/
import UIKit
class CarouselCollectionViewFlowLayout: UICollectionViewFlowLayout {
override init() {
super.init()
}
required init(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
}
/**
This method sets up various properties of the carousel collectionview
*/
override func prepareLayout() {
if let collectionView = self.collectionView {
collectionView.pagingEnabled = true
self.scrollDirection = .Horizontal
self.minimumLineSpacing = 0
let viewSize = collectionView.bounds.size
setItemSize(viewSize)
}
}
/**
This method sets the item size for each cell of the carousel collectionview.
:param: viewSize <#viewSize description#>
*/
private func setItemSize(viewSize: CGSize){
let itemSize = CGSize(width: viewSize.width - minimumLineSpacing, height: viewSize.height)
self.itemSize = itemSize
}
}
| epl-1.0 | bbbe9b7757b3ac346ef209b7aa1b8ff9 | 25.285714 | 98 | 0.639493 | 5.411765 | false | false | false | false |
openHPI/xikolo-ios | iOS/Extensions/UIAlertViewController+customView.swift | 1 | 2910 | //
// Created for xikolo-ios under GPL-3.0 license.
// Copyright © HPI. All rights reserved.
//
import UIKit
// Heavily inspired by https://stackoverflow.com/a/47925120/7414898
extension UIAlertController {
/// Creates a `UIAlertController` with a custom `UIView` instead the message text.
/// - Note: In case anything goes wrong during replacing the message string with the custom view, a fallback message will
/// be used as normal message string.
///
/// - Parameters:
/// - title: The title text of the alert controller
/// - customView: A `UIView` which will be displayed in place of the message string.
/// - fallbackMessage: An optional fallback message string, which will be displayed in case something went wrong with inserting the custom view.
/// - preferredStyle: The preferred style of the `UIAlertController`.
convenience init(title: String?, customView: UIView, fallbackMessage: String?, preferredStyle: UIAlertController.Style) {
let marker = "__CUSTOM_CONTENT_MARKER__"
self.init(title: title, message: marker, preferredStyle: preferredStyle)
// Try to find the message label in the alert controller's view hierarchy
if let customContentPlaceholder = self.view.findLabel(withText: marker), let customContainer = customContentPlaceholder.superview {
// The message label was found. Add the custom view over it and fix the auto layout...
customContainer.addSubview(customView)
customView.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
customView.leadingAnchor.constraint(equalTo: customContainer.leadingAnchor),
customView.trailingAnchor.constraint(equalTo: customContainer.trailingAnchor),
customContentPlaceholder.topAnchor.constraint(equalTo: customView.topAnchor, constant: -8),
customContentPlaceholder.heightAnchor.constraint(equalTo: customView.heightAnchor),
])
customContentPlaceholder.text = ""
} else { // In case something fishy is going on, fall back to the standard behaviour and display a fallback message string
self.message = fallbackMessage
}
}
}
private extension UIView {
/// Searches a `UILabel` with the given text in the view's subviews hierarchy.
///
/// - Parameter text: The label text to search
/// - Returns: A `UILabel` in the view's subview hierarchy, containing the searched text or `nil` if no `UILabel` was found.
func findLabel(withText text: String) -> UILabel? {
if let label = self as? UILabel, label.text == text {
return label
}
for subview in self.subviews {
if let found = subview.findLabel(withText: text) {
return found
}
}
return nil
}
}
| gpl-3.0 | b146241e849c6fc47a7de0535a6d57f7 | 43.075758 | 150 | 0.675834 | 5.076789 | false | false | false | false |
tutao/tutanota | app-ios/tutanota/Sources/Utils/UIColor+utils.swift | 1 | 2282 | import UIKit
public extension UIColor {
/// Convenience constructor to initialize from a hex color string.
/// Supported formats:
/// #RGB
/// #RRGGBB
/// #RRGGBBAA
convenience init?(hex: String) {
var color: UInt32 = 0
if parseColorCode(hex, &color) {
let r = CGFloat(redPart(color)) / 255.0
let g = CGFloat(greenPart(color)) / 255.0
let b = CGFloat(bluePart(color)) / 255.0
let a = CGFloat(alphaPart(color)) / 255
self.init(red: r, green: g, blue: b, alpha: a)
return
}
return nil
}
func isLight() -> Bool {
var r: CGFloat = 0
var g: CGFloat = 0
var b: CGFloat = 0
let success: Bool = self.getRed(&r, green: &g, blue: &b, alpha: nil)
// lines with assertions are removed in release builds
assert(success, "Invalid UI Color")
// Counting the perceptive luminance
// human eye favors green color...
let lightness = 0.299*r + 0.587*g + 0.114*b
return lightness >= 0.5
}
}
/** Parse a #RGB or #RRGGBB #RRGGBBAA color code into an 0xRRGGBBAA int */
private func parseColorCode(_ code: String, _ rrggbbaa: UnsafeMutablePointer<UInt32>?) -> Bool {
if code.first != "#" || (code.count != 4 && code.count != 7 && code.count != 9) {
return false
}
let start = code.index(code.startIndex, offsetBy: 1)
var hexString = String(code[start...]).uppercased()
// input was #RGB
if hexString.count == 3 {
hexString = expandShortHex(hex: hexString)
}
// input was #RGB or #RRGGBB, set alpha channel to max
if hexString.count != 8 {
hexString += "FF"
}
return Scanner(string: hexString).scanHexInt32(rrggbbaa)
}
private func expandShortHex(hex: String) -> String {
assert(hex.count == 3, "hex string must be exactly 3 characters")
var hexCode = ""
for char in hex {
hexCode += String(repeating: char, count: 2)
}
return hexCode
}
private func redPart(_ rrggbbaa: UInt32) -> UInt8 {
return UInt8((rrggbbaa >> 24) & 0xff)
}
private func greenPart(_ rrggbbaa: UInt32) -> UInt8 {
return UInt8((rrggbbaa >> 16) & 0xff)
}
private func bluePart(_ rrggbbaa: UInt32) -> UInt8 {
return UInt8((rrggbbaa >> 8) & 0xff)
}
private func alphaPart(_ rrggbbaa: UInt32) -> UInt8 {
return UInt8(rrggbbaa & 0xff)
}
| gpl-3.0 | a2a59ed0f932dfc5103cc69964c3f3da | 24.355556 | 96 | 0.631025 | 3.510769 | false | false | false | false |
material-motion/material-motion-swift | src/interactions/Tossable.swift | 2 | 2993 | /*
Copyright 2016-present The Material Motion Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import Foundation
import UIKit
/**
Allows a view to be tossed by a gesture recognizer and animated to a destination using a spring.
Composed of two sub-interactions: Draggable and Spring.
The spring interaction will be disabled while the drag interaction is active. The spring
interaction is enabled once the drag interaction comes to rest.
**Affected properties**
- `view.layer.position`
**Constraints**
CGPoint constraints may be applied to this interaction. Common constraints include:
- `{ $0.xLocked(to: somePosition) }`
- `{ $0.yLocked(to: somePosition) }`
*/
public final class Tossable: Interaction, Stateful {
/**
The interaction governing drag behaviors.
*/
public let draggable: Draggable
/**
The interaction governing the spring animation.
*/
public let spring: Spring<CGPoint>
public init(spring: Spring<CGPoint> = Spring(), draggable: Draggable = Draggable()) {
self.spring = spring
self.draggable = draggable
}
public func add(to view: UIView,
withRuntime runtime: MotionRuntime,
constraints: ConstraintApplicator<CGPoint>? = nil) {
let position = runtime.get(view.layer).position
// Order matters:
//
// 1. When we hand off from the gesture to the spring we want Tossable's state to still be
// "active", so we observe the spring's state first and observe draggable's state last; this
// ensures that the spring interaction is active before the draggable interaction is at rest.
// 2. The spring's initial velocity must be set before it's re-enabled.
// 3. The spring must be registered before draggable in case draggable's gesture is already
// active and will want to immediately read the current state of the position property.
aggregateState.observe(state: spring.state, withRuntime: runtime)
runtime.add(draggable.finalVelocity, to: spring.initialVelocity)
runtime.toggle(spring, inReactionTo: draggable)
runtime.add(spring, to: position, constraints: constraints)
runtime.add(draggable, to: view, constraints: constraints)
aggregateState.observe(state: draggable.state, withRuntime: runtime)
}
/**
The current state of the interaction.
*/
public var state: MotionObservable<MotionState> {
return aggregateState.asStream()
}
let aggregateState = AggregateMotionState()
}
| apache-2.0 | 409df3728632f356c20da19955f797c0 | 32.629213 | 100 | 0.731039 | 4.604615 | false | false | false | false |
prajwalabove/LinuxCommandList | linuxcommands/DetailViewController.swift | 1 | 1421 | //
// DetailViewController.swift
// linuxcommands
//
// Created by Prajwal on 10/11/15.
// Copyright © 2015 Above Solutions India Pvt Ltd. All rights reserved.
//
import UIKit
let websearchURL:String = "https://www.google.co.in/#q="
class DetailViewController: UIViewController, UIWebViewDelegate {
@IBOutlet weak var webView: UIWebView!
var searchKey:String!
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
override func viewWillAppear(animated: Bool) {
super.viewWillAppear(animated)
self.title = self.searchKey
self.requestWebSearchWithKey(self.searchKey)
}
func requestWebSearchWithKey(searchKey:String) {
let encodedSearchKey = (searchKey+" in linux").stringByAddingPercentEncodingWithAllowedCharacters(.URLHostAllowedCharacterSet())
let searchURLString = websearchURL+encodedSearchKey!
if let url:NSURL = NSURL(string: searchURLString)! {
let requestObj:NSMutableURLRequest = NSMutableURLRequest(URL: url)
self.webView.loadRequest(requestObj)
}
}
// MARK: UIWebViewDelegate
func webViewDidFinishLoad(webView: UIWebView) {
}
}
| mit | 1d8028b9f0da9ddf8753905b078a22fb | 29.212766 | 136 | 0.683099 | 5.089606 | false | false | false | false |
satorun/designPattern | Builder/Builder/ViewController.swift | 1 | 932 | //
// ViewController.swift
// Builder
//
// Created by satorun on 2016/02/03.
// Copyright © 2016年 satorun. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
let textBuilder = TextBuilder()
let textDirector = Director(builder: textBuilder)
textDirector.construct()
let textResult = textBuilder.getResult()
print(textResult)
let htmlBuilder = HtmlBuilder()
let htmlDirector = Director(builder: htmlBuilder)
htmlDirector.construct()
let htmlResult = htmlBuilder.getResult()
print(htmlResult)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
| mit | d389d7fad7d1208aad173d1fb3a924cd | 24.108108 | 80 | 0.649085 | 4.813472 | false | false | false | false |
tschmidt64/EE464D | Music Lamp/ColorPickerViewController.swift | 1 | 2874 | //
// FirstViewController.swift
// Music Lamp
//
// Created by Taylor Schmidt on 1/30/17.
// Copyright © 2017 Taylor Schmidt. All rights reserved.
//
import UIKit
import SwiftHSVColorPicker
//import SwiftHTTP
import SwiftSocket
class ColorPickerViewController: UIViewController {
var selectedColor = UIColor.white
@IBOutlet weak var colorPicker: SwiftHSVColorPicker!
override func viewDidLoad() {
super.viewDidLoad()
colorPicker.setViewColor(selectedColor)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
@IBAction func setLightsButtonPressed(_ sender: Any) {
if let color = colorPicker.color {
sendLightColorRequest(color: color)
} else {
print("ERROR: Couldn't unwrap the color picker's color")
}
}
func sendLightColorRequest(color: UIColor) {
// IP = 192.168.43.26
// Make sure that socket calls are one at a time (synchronous), open and close for each call
let client = TCPClient(address: "192.168.43.26", port: 5001)
let msg = "api_call=add_theme&theme_id=2&special=0&color=0xFF0000&song=song.wav"
switch client.connect(timeout: 10) {
case .success:
switch client.send(string: msg) {
case .success:
guard let data = client.read(1024*10) else { return }
if let response = String(bytes: data, encoding: .utf8) {
print(response)
} else {
print("No response")
}
case .failure(let error):
print(error)
}
case .failure(let error):
print(error)
}
client.close()
}
/*
func sendLightColorRequest(color: UIColor) {
do {
// the url sent will be https://google.com?hello=world¶m2=value2
// let params = ["hello": "world", "param2": "value2"]
// IP = 192.168.43.26
// Make sure that socket calls are one at a time (synchronous), open and close for each call
let params = ["hello": "world", "param2": "value2"]
let boundary = "AaB03x"
let opt = try HTTP.POST("https://google.com", parameters: params)
print("Request:")
print("\(opt)")
opt.start { response in
if let err = response.error {
print("error: \(err.localizedDescription)")
return //also notify app of failure as needed
}
print("opt finished: \(response.description)")
}
} catch let error {
print("got an error creating the request: \(error)")
}
}
*/
}
| mit | 9f42382ef0edd56103dd3067cb156442 | 32.406977 | 104 | 0.558998 | 4.55309 | false | false | false | false |
frtlupsvn/Vietnam-To-Go | Pods/EZSwiftExtensions/Sources/UIViewControllerExtensions.swift | 1 | 6955 | //
// UIViewControllerExtensions.swift
// EZSwiftExtensions
//
// Created by Goktug Yilmaz on 15/07/15.
// Copyright (c) 2015 Goktug Yilmaz. All rights reserved.
//
import UIKit
extension UIViewController {
// MARK: - Notifications
//TODO: Document this part
public func addNotificationObserver(name: String, selector: Selector) {
NSNotificationCenter.defaultCenter().addObserver(self, selector: selector, name: name, object: nil)
}
public func removeNotificationObserver(name: String) {
NSNotificationCenter.defaultCenter().removeObserver(self, name: name, object: nil)
}
public func removeNotificationObserver() {
NSNotificationCenter.defaultCenter().removeObserver(self)
}
public func addKeyboardWillShowNotification() {
self.addNotificationObserver(UIKeyboardWillShowNotification, selector: "keyboardWillShowNotification:");
}
public func addKeyboardDidShowNotification() {
self.addNotificationObserver(UIKeyboardDidShowNotification, selector: "keyboardDidShowNotification:");
}
public func addKeyboardWillHideNotification() {
self.addNotificationObserver(UIKeyboardWillHideNotification, selector: "keyboardWillHideNotification:");
}
public func addKeyboardDidHideNotification() {
self.addNotificationObserver(UIKeyboardDidHideNotification, selector: "keyboardDidHideNotification:");
}
public func removeKeyboardWillShowNotification() {
self.removeNotificationObserver(UIKeyboardWillShowNotification);
}
public func removeKeyboardDidShowNotification() {
self.removeNotificationObserver(UIKeyboardDidShowNotification);
}
public func removeKeyboardWillHideNotification() {
self.removeNotificationObserver(UIKeyboardWillHideNotification);
}
public func removeKeyboardDidHideNotification() {
self.removeNotificationObserver(UIKeyboardDidHideNotification);
}
public func keyboardDidShowNotification(notification: NSNotification) {
let nInfo = notification.userInfo as! [String: NSValue]
let value = nInfo[UIKeyboardFrameEndUserInfoKey]
let frame = value?.CGRectValue()
keyboardDidShowWithFrame(frame!)
}
public func keyboardWillShowNotification(notification: NSNotification) {
let nInfo = notification.userInfo as! [String: NSValue]
let value = nInfo[UIKeyboardFrameEndUserInfoKey]
let frame = value?.CGRectValue()
keyboardWillShowWithFrame(frame!)
}
public func keyboardWillHideNotification(notification: NSNotification) {
let nInfo = notification.userInfo as! [String: NSValue]
let value = nInfo[UIKeyboardFrameEndUserInfoKey]
let frame = value?.CGRectValue()
keyboardWillHideWithFrame(frame!)
}
public func keyboardDidHideNotification(notification: NSNotification) {
let nInfo = notification.userInfo as! [String: NSValue]
let value = nInfo[UIKeyboardFrameEndUserInfoKey]
let frame = value?.CGRectValue()
keyboardDidHideWithFrame(frame!)
}
public func keyboardWillShowWithFrame(frame: CGRect) {
}
public func keyboardDidShowWithFrame(frame: CGRect) {
}
public func keyboardWillHideWithFrame(frame: CGRect) {
}
public func keyboardDidHideWithFrame(frame: CGRect) {
}
// MARK: - VC Container
/// EZSwiftExtensions
public var top: CGFloat {
get {
if let me = self as? UINavigationController {
return me.visibleViewController!.top
}
if let nav = self.navigationController {
if nav.navigationBarHidden {
return view.top
} else {
return nav.navigationBar.bottom
}
} else {
return view.top
}
}
}
/// EZSwiftExtensions
public var bottom: CGFloat {
get {
if let me = self as? UINavigationController {
return me.visibleViewController!.bottom
}
if let tab = tabBarController {
if tab.tabBar.hidden {
return view.bottom
} else {
return tab.tabBar.top
}
} else {
return view.bottom
}
}
}
/// EZSwiftExtensions
public var tabBarHeight: CGFloat {
get {
if let me = self as? UINavigationController {
return me.visibleViewController!.tabBarHeight
}
if let tab = self.tabBarController {
return tab.tabBar.frame.size.height
}
return 0
}
}
/// EZSwiftExtensions
public var navigationBarHeight: CGFloat {
get {
if let me = self as? UINavigationController {
return me.visibleViewController!.navigationBarHeight
}
if let nav = self.navigationController {
return nav.navigationBar.h
}
return 0
}
}
/// EZSwiftExtensions
public var navigationBarColor: UIColor? {
get {
if let me = self as? UINavigationController {
return me.visibleViewController!.navigationBarColor
}
return navigationController?.navigationBar.tintColor
} set(value) {
navigationController?.navigationBar.barTintColor = value
}
}
/// EZSwiftExtensions
public var navBar: UINavigationBar? {
get {
return navigationController?.navigationBar
}
}
/// EZSwiftExtensions
public var applicationFrame: CGRect {
get {
return CGRect(x: view.x, y: top, width: view.w, height: bottom - top)
}
}
// MARK: - VC Flow
/// EZSwiftExtensions
public func pushVC(vc: UIViewController) {
navigationController?.pushViewController(vc, animated: true)
}
/// EZSwiftExtensions
public func popVC() {
navigationController?.popViewControllerAnimated(true)
}
/// EZSwiftExtensions
public func presentVC(vc: UIViewController) {
presentViewController(vc, animated: true, completion: nil)
}
/// EZSwiftExtensions
public func dismissVC(completion completion: (() -> Void)? ) {
dismissViewControllerAnimated(true, completion: completion)
}
/// EZSwiftExtensions
public func addAsChildViewController(vc: UIViewController, toView: UIView){
vc.view.frame = toView.frame
toView.addSubview(vc.view)
self.addChildViewController(vc)
vc.didMoveToParentViewController(self)
}
}
| mit | e08896f1e7c6f24bf61ad14515bff5c8 | 29.774336 | 112 | 0.622717 | 6.198752 | false | false | false | false |
practicalswift/swift | validation-test/stdlib/CoreGraphics-execute.swift | 15 | 15274 | // RUN: %target-run-simple-swift
// REQUIRES: executable_test
// REQUIRES: objc_interop
// REQUIRES: OS=macosx
import CoreGraphics
import StdlibUnittest
let CoreGraphicsTests = TestSuite("CoreGraphics")
//===----------------------------------------------------------------------===//
// CGAffineTransform
//===----------------------------------------------------------------------===//
CoreGraphicsTests.test("CGAffineTransform/Equatable") {
checkEquatable([
CGAffineTransform(a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0),
CGAffineTransform.identity,
CGAffineTransform(a: 1, b: 10, c: 10, d: 1, tx: 0, ty: 0),
CGAffineTransform(a: 1, b: 10, c: 10, d: 1, tx: 0, ty: 0),
] as [CGAffineTransform],
oracle: { $0 / 2 == $1 / 2 })
}
//===----------------------------------------------------------------------===//
// CGColor
//===----------------------------------------------------------------------===//
CoreGraphicsTests.test("CGColor/Equatable") {
checkEquatable([
CGColor(red: 1, green: 0, blue: 0, alpha: 1),
CGColor(red: 1, green: 0, blue: 0, alpha: 0),
CGColor(red: 0, green: 1, blue: 0, alpha: 1),
CGColor(red: 0, green: 1, blue: 0, alpha: 0),
CGColor(red: 0, green: 0, blue: 1, alpha: 1),
CGColor(red: 0, green: 0, blue: 1, alpha: 0),
] as [CGColor],
oracle: { $0 == $1 })
}
CoreGraphicsTests.test("CGColor.components") {
let red = CGColor(red: 1, green: 0, blue: 0, alpha: 1)
let components = red.components!
expectEqual(components.count, 4)
expectEqual(components[0], 1)
expectEqual(components[1], 0)
expectEqual(components[2], 0)
expectEqual(components[3], 1)
}
CoreGraphicsTests.test("CGColor/ExpressibleByColorLiteral") {
let colorLit: CGColor = #colorLiteral(red: 0.25, green: 0.5, blue: 0.75,
alpha: 1.0)
let components = colorLit.components!
expectEqual(components.count, 4)
expectEqual(components[0], 0.25)
expectEqual(components[1], 0.50)
expectEqual(components[2], 0.75)
expectEqual(components[3], 1.0)
}
//===----------------------------------------------------------------------===//
// CGPoint
//===----------------------------------------------------------------------===//
CoreGraphicsTests.test("CGPoint/Equatable") {
checkEquatable([
CGPoint(x: 0, y: 0),
CGPoint(x: -1, y: -1),
CGPoint(x: -1, y: 0),
CGPoint(x: 0, y: -1),
CGPoint(x: 1, y: 1),
CGPoint(x: 1, y: 0),
CGPoint(x: 0, y: 1),
CGPoint(x: 1.nextUp, y: 1.nextUp),
CGPoint(x: 1.nextUp, y: 0),
CGPoint(x: 0, y: 1.nextUp),
CGPoint(x: CGFloat.greatestFiniteMagnitude, y: 0),
] as [CGPoint],
oracle: { $0 == $1 })
}
CoreGraphicsTests.test("CGPoint.init(x:y:)") {
var fractional = CGPoint()
fractional.x = 1.25
fractional.y = 2.25
var negativeFractional = CGPoint()
negativeFractional.x = -1.25
negativeFractional.y = -2.25
var integral = CGPoint()
integral.x = 1.0
integral.y = 2.0
var negativeIntegral = CGPoint()
negativeIntegral.x = -1.0
negativeIntegral.y = -2.0
// Initialize from floating point literals.
expectEqual(fractional, CGPoint(x: 1.25, y: 2.25))
expectEqual(negativeFractional, CGPoint(x: -1.25, y: -2.25))
// Initialize from integer literals.
expectEqual(integral, CGPoint(x: 1, y: 2))
expectEqual(negativeIntegral, CGPoint(x: -1, y: -2))
expectEqual(fractional, CGPoint(x: 1.25 as CGFloat, y: 2.25 as CGFloat))
expectEqual(fractional, CGPoint(x: 1.25 as Double, y: 2.25 as Double))
expectEqual(integral, CGPoint(x: 1 as Int, y: 2 as Int))
}
CoreGraphicsTests.test("CGPoint.dictionaryRepresentation, CGPoint.init(dictionaryRepresentation:)") {
let point = CGPoint(x: 1, y: 2)
let dict = point.dictionaryRepresentation
let newPoint = CGPoint(dictionaryRepresentation: dict)
expectEqual(point, newPoint)
}
CoreGraphicsTests.test("CGPoint.zero") {
expectEqual(0.0, CGPoint.zero.x)
expectEqual(0.0, CGPoint.zero.y)
}
//===----------------------------------------------------------------------===//
// CGSize
//===----------------------------------------------------------------------===//
CoreGraphicsTests.test("CGSize/Equatable") {
checkEquatable([
CGSize(width: 0, height: 0),
CGSize(width: -1, height: -1),
CGSize(width: -1, height: 0),
CGSize(width: 0, height: -1),
CGSize(width: 1, height: 1),
CGSize(width: 1, height: 0),
CGSize(width: 0, height: 1),
CGSize(width: 1.nextUp, height: 1.nextUp),
CGSize(width: 1.nextUp, height: 0),
CGSize(width: 0, height: 1.nextUp),
CGSize(width: CGFloat.greatestFiniteMagnitude, height: 0),
] as [CGSize],
oracle: { $0 == $1 })
}
CoreGraphicsTests.test("CGSize.init(width:height:)") {
var fractional = CGSize()
fractional.width = 1.25
fractional.height = 2.25
var negativeFractional = CGSize()
negativeFractional.width = -1.25
negativeFractional.height = -2.25
var integral = CGSize()
integral.width = 1.0
integral.height = 2.0
var negativeIntegral = CGSize()
negativeIntegral.width = -1.0
negativeIntegral.height = -2.0
// Initialize from floating point literals.
expectEqual(fractional, CGSize(width: 1.25, height: 2.25))
expectEqual(negativeFractional, CGSize(width: -1.25, height: -2.25))
// Initialize from integer literals.
expectEqual(integral, CGSize(width: 1, height: 2))
expectEqual(negativeIntegral, CGSize(width: -1, height: -2))
expectEqual(fractional, CGSize(width: 1.25 as CGFloat, height: 2.25 as CGFloat))
expectEqual(fractional, CGSize(width: 1.25 as Double, height: 2.25 as Double))
expectEqual(integral, CGSize(width: 1 as Int, height: 2 as Int))
}
CoreGraphicsTests.test("CGSize.dictionaryRepresentation, CGSize.init(dictionaryRepresentation:)") {
let size = CGSize(width: 3, height: 4)
let dict = size.dictionaryRepresentation
let newSize = CGSize(dictionaryRepresentation: dict)
expectEqual(size, newSize)
}
CoreGraphicsTests.test("CGSize.zero") {
expectEqual(0.0, CGSize.zero.width)
expectEqual(0.0, CGSize.zero.height)
}
//===----------------------------------------------------------------------===//
// CGRect
//===----------------------------------------------------------------------===//
CoreGraphicsTests.test("CGRect/Equatable") {
checkEquatable([
CGRect.null,
CGRect(x: 0, y: 0, width: 0, height: 0),
CGRect(x: 1.25, y: 2.25, width: 3.25, height: 4.25),
CGRect(x: -1.25, y: -2.25, width: -3.25, height: -4.25),
CGRect(x: 1, y: 2, width: 3, height: 4),
CGRect(x: -1, y: -2, width: -3, height: -4),
] as [CGRect],
oracle: { $0 == $1 })
}
CoreGraphicsTests.test("CGRect.init(x:y:width:height:)") {
var fractional = CGRect()
fractional.origin = CGPoint(x: 1.25, y: 2.25)
fractional.size = CGSize(width: 3.25, height: 4.25)
var negativeFractional = CGRect()
negativeFractional.origin = CGPoint(x: -1.25, y: -2.25)
negativeFractional.size = CGSize(width: -3.25, height: -4.25)
var integral = CGRect()
integral.origin = CGPoint(x: 1.0, y: 2.0)
integral.size = CGSize(width: 3.0, height: 4.0)
var negativeIntegral = CGRect()
negativeIntegral.origin = CGPoint(x: -1.0, y: -2.0)
negativeIntegral.size = CGSize(width: -3.0, height: -4.0)
// Initialize from floating point literals.
expectEqual(fractional, CGRect(x: 1.25, y: 2.25, width: 3.25, height: 4.25))
expectEqual(
negativeFractional,
CGRect(x: -1.25, y: -2.25, width: -3.25, height: -4.25))
// Initialize from integer literals.
expectEqual(integral, CGRect(x: 1, y: 2, width: 3, height: 4))
expectEqual(negativeIntegral, CGRect(x: -1, y: -2, width: -3, height: -4))
expectEqual(
fractional,
CGRect(
x: 1.25 as CGFloat, y: 2.25 as CGFloat,
width: 3.25 as CGFloat, height: 4.25 as CGFloat))
expectEqual(
fractional,
CGRect(
x: 1.25 as Double, y: 2.25 as Double,
width: 3.25 as Double, height: 4.25 as Double))
expectEqual(
integral,
CGRect(
x: 1 as Int, y: 2 as Int,
width: 3 as Int, height: 4 as Int))
}
CoreGraphicsTests.test("CGRect.init(origin:size:)") {
let point = CGPoint(x: 1.25, y: 2.25)
let size = CGSize(width: 3.25, height: 4.25)
expectEqual(
CGRect(x: 1.25, y: 2.25, width: 3.25, height: 4.25),
CGRect(origin: point, size: size))
}
CoreGraphicsTests.test("CGRect.dictionaryRepresentation, CGRect.init(dictionaryRepresentation:)") {
let point = CGPoint(x: 1, y: 2)
let size = CGSize(width: 3, height: 4)
let rect = CGRect(origin: point, size: size)
let dict = rect.dictionaryRepresentation
let newRect = CGRect(dictionaryRepresentation: dict)
expectEqual(rect, newRect)
}
CoreGraphicsTests.test("CGRect.isNull") {
expectFalse(CGRect.infinite.isNull)
expectTrue(CGRect.null.isNull)
expectFalse(CGRect.zero.isNull)
expectFalse(CGRect(x: 0, y: 0, width: 10, height: 20).isNull)
}
CoreGraphicsTests.test("CGRect.isEmpty") {
expectFalse(CGRect.infinite.isEmpty)
expectTrue(CGRect.null.isEmpty)
expectTrue(CGRect.zero.isEmpty)
expectFalse(CGRect(x: 0, y: 0, width: 10, height: 20).isEmpty)
}
CoreGraphicsTests.test("CGRect.isInfinite") {
expectTrue(CGRect.infinite.isInfinite)
expectFalse(CGRect.null.isInfinite)
expectFalse(CGRect.zero.isInfinite)
expectFalse(CGRect(x: 0, y: 0, width: 10, height: 20).isInfinite)
}
CoreGraphicsTests.test("CGRect.contains(CGPoint)") {
let rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
expectTrue(rect.contains(CGPoint(x: 15, y: 25)))
expectFalse(rect.contains(CGPoint(x: -15, y: 25)))
}
CoreGraphicsTests.test("CGRect.contains(CGRect)") {
let rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
let bigRect = CGRect(x: 1, y: 2, width: 101, height: 102)
expectTrue(bigRect.contains(rect))
expectFalse(rect.contains(bigRect))
}
CoreGraphicsTests.test("CGRect.divided()") {
let rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
let (slice, remainder) =
rect.divided(atDistance: 5, from: CGRectEdge.minXEdge)
expectEqual(CGRect(x: 11.25, y: 22.25, width: 5.0, height: 44.25), slice)
expectEqual(CGRect(x: 16.25, y: 22.25, width: 28.25, height: 44.25), remainder)
}
CoreGraphicsTests.test("CGRect.standardized") {
var unstandard = CGRect(x: 10, y: 20, width: -30, height: -50)
var standard = unstandard.standardized
expectEqual(CGPoint(x: 10, y: 20), unstandard.origin)
expectEqual(CGPoint(x: -20, y: -30), standard.origin)
expectEqual(CGSize(width: -30, height: -50), unstandard.size)
expectEqual(CGSize(width: 30, height: 50), standard.size)
expectEqual(unstandard, standard)
expectEqual(standard, standard.standardized)
expectEqual(30, unstandard.width)
expectEqual(30, standard.width)
expectEqual(50, unstandard.height)
expectEqual(50, standard.height)
expectEqual(-20, unstandard.minX)
expectEqual(-5, unstandard.midX)
expectEqual(10, unstandard.maxX)
expectEqual(-20, standard.minX)
expectEqual(-5, standard.midX)
expectEqual(10, standard.maxX)
expectEqual(-30, unstandard.minY)
expectEqual(-5, unstandard.midY)
expectEqual(20, unstandard.maxY)
expectEqual(-30, standard.minY)
expectEqual(-5, standard.midY)
expectEqual(20, standard.maxY)
}
CoreGraphicsTests.test("CGRect.insetBy(self:dx:dy:)") {
let rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
expectEqual(
CGRect(x: 12.25, y: 20.25, width: 31.25, height: 48.25),
rect.insetBy(dx: 1, dy: -2))
}
CoreGraphicsTests.test("CGRect.offsetBy(self:dx:dy:)") {
let rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
expectEqual(
CGRect(x: 14.25, y: 18.25, width: 33.25, height: 44.25),
rect.offsetBy(dx: 3, dy: -4))
}
CoreGraphicsTests.test("CGRect.integral") {
let rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
expectEqual(
CGRect(x: 11, y: 22, width: 34, height: 45),
rect.integral)
}
CoreGraphicsTests.test("CGRect.union(_:)") {
let smallRect = CGRect(x: 10, y: 25, width: 5, height: -5)
let bigRect = CGRect(x: 1, y: 2, width: 101, height: 102)
let distantRect = CGRect(x: 1000, y: 2000, width: 1, height: 1)
let rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
expectEqual(
CGRect(x: 10.0, y: 20.0, width: 34.5, height: 46.5),
rect.union(smallRect))
expectEqual(
CGRect(x: 1.0, y: 2.0, width: 101.0, height: 102.0),
rect.union(bigRect))
expectEqual(
CGRect(x: 11.25, y: 22.25, width: 989.75, height: 1978.75),
rect.union(distantRect))
expectEqual(
CGRect(x: 1.0, y: 2.0, width: 1000.0, height: 1999.0),
rect.union(smallRect).union(bigRect).union(distantRect))
}
CoreGraphicsTests.test("CGRect.intersection(_:)") {
let smallRect = CGRect(x: 10, y: 25, width: 5, height: -5)
let bigRect = CGRect(x: 1, y: 2, width: 101, height: 102)
let distantRect = CGRect(x: 1000, y: 2000, width: 1, height: 1)
var rect = CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25)
expectTrue(rect.intersects(smallRect))
expectEqual(
CGRect(x: 11.25, y: 22.25, width: 3.75, height: 2.75),
rect.intersection(smallRect))
expectTrue(rect.intersects(bigRect))
expectEqual(
CGRect(x: 11.25, y: 22.25, width: 33.25, height: 44.25),
rect.intersection(bigRect))
expectFalse(rect.intersects(distantRect))
expectEqual(CGRect.null, rect.intersection(distantRect))
expectFalse(
rect
.intersection(smallRect)
.intersection(bigRect)
.isEmpty)
expectTrue(
rect
.intersection(smallRect)
.intersection(bigRect)
.intersection(distantRect)
.isEmpty)
}
//===----------------------------------------------------------------------===//
// CGVector
//===----------------------------------------------------------------------===//
CoreGraphicsTests.test("CGVector/Equatable") {
checkEquatable([
CGVector(dx: 0, dy: 0),
CGVector(dx: -1, dy: -1),
CGVector(dx: -1, dy: 0),
CGVector(dx: 0, dy: -1),
CGVector(dx: 1, dy: 1),
CGVector(dx: 1, dy: 0),
CGVector(dx: 0, dy: 1),
CGVector(dx: 1.nextUp, dy: 1.nextUp),
CGVector(dx: 1.nextUp, dy: 0),
CGVector(dx: 0, dy: 1.nextUp),
CGVector(dx: CGFloat.greatestFiniteMagnitude, dy: 0),
] as [CGVector],
oracle: { $0 == $1 })
}
CoreGraphicsTests.test("CGVector.init(dx:dy:)") {
var fractional = CGVector()
fractional.dx = 1.25
fractional.dy = 2.25
var negativeFractional = CGVector()
negativeFractional.dx = -1.25
negativeFractional.dy = -2.25
var integral = CGVector()
integral.dx = 1.0
integral.dy = 2.0
var negativeIntegral = CGVector()
negativeIntegral.dx = -1.0
negativeIntegral.dy = -2.0
// Initialize from floating point literals.
expectEqual(fractional, CGVector(dx: 1.25, dy: 2.25))
expectEqual(negativeFractional, CGVector(dx: -1.25, dy: -2.25))
// Initialize from integer literals.
expectEqual(integral, CGVector(dx: 1, dy: 2))
expectEqual(negativeIntegral, CGVector(dx: -1, dy: -2))
expectEqual(fractional, CGVector(dx: 1.25 as CGFloat, dy: 2.25 as CGFloat))
expectEqual(fractional, CGVector(dx: 1.25 as Double, dy: 2.25 as Double))
expectEqual(integral, CGVector(dx: 1 as Int, dy: 2 as Int))
}
CoreGraphicsTests.test("CGVector.zero") {
expectEqual(0.0, CGVector.zero.dx)
expectEqual(0.0, CGVector.zero.dy)
}
runAllTests()
| apache-2.0 | 244d3d928a280d97f616d293e382f356 | 30.107943 | 101 | 0.627013 | 3.4463 | false | true | false | false |
iOSWizards/AwesomeMedia | Example/Pods/AwesomeCore/AwesomeCore/Classes/Model/Community.swift | 1 | 7179 | //
// Community.swift
// AwesomeCore
//
// Created by Leonardo Vinicius Kaminski Ferreira on 30/01/18.
//
import Foundation
public struct CommunityData: Codable {
public let communities: Communities
}
public struct CommunityRootData: Codable {
public let data: CommunityListData
}
public struct CommunityListData: Codable {
public let communities: [Community]
}
public struct Communities: Codable {
public let publicGroups: [Community]
public let tribeMembership: [Community]
public let privateGroups: [Community]
}
public struct Community: Codable {
public let url: String?
public let type: String?
public let productIds: [String]?
public var passphrase: String?
public let name: String?
public let id: String?
public let groupId: String?
public let description: String?
public let backgroundAsset: QuestAsset?
}
// MARK: - Coding keys
//extension Communities {
// private enum CodingKeys: String, CodingKey {
// case publicGroups = "public_pages"
// case tribeMembership = "tribe_memberships"
// case privateGroups = "private_groups"
// }
//}
//
//extension Community {
// private enum CodingKeys: String, CodingKey {
// case id
// case productId = "awc_product_id"
// case groupId = "group_id"
// case imageUrl = "image_url"
// case name
// case passphrase
// case type = "group_type"
// case url
// }
//}
// MARK: - Equatable
extension Communities {
public static func ==(lhs: Communities, rhs: Communities) -> Bool {
if lhs.publicGroups.first?.groupId != rhs.publicGroups.first?.groupId {
return false
}
return true
}
}
// MARK: - Community Swift
//import Foundation
//import RealmSwift
//import Realm
//
//public struct CommunityData: Decodable {
//
// public let communities: Communities
//}
//
//public class Communities: Object, Decodable {
//
// @objc dynamic var id = 0
// public var publicGroups = List<Community>()
// public var tribeMembership = List<Community>()
// public var privateGroups = List<Community>()
//
// // MARK: - Realm
//
// override public static func primaryKey() -> String? {
// return "id"
// }
//
// public convenience init(publicGroups: [Community], tribeMembership: [Community], privateGroups: [Community]) {
// self.init()
//
// self.privateGroups.append(objectsIn: privateGroups)
// self.publicGroups.append(objectsIn: publicGroups)
// self.tribeMembership.append(objectsIn: tribeMembership)
// }
//
// public convenience required init(from decoder: Decoder) throws {
// let container = try decoder.container(keyedBy: CodingKeys.self)
//
// let privateGroups = try container.decode([Community].self, forKey: .privateGroups)
// let publicGroups = try container.decode([Community].self, forKey: .publicGroups)
// let tribeMembership = try container.decode([Community].self, forKey: .tribeMembership)
//
// self.init(publicGroups: publicGroups, tribeMembership: tribeMembership, privateGroups: privateGroups)
// }
//
// public required init() {
// super.init()
// }
//
// public required init(value: Any, schema: RLMSchema) {
// super.init(value: value, schema: schema)
// }
//
// public required init(realm: RLMRealm, schema: RLMObjectSchema) {
// super.init(realm: realm, schema: schema)
// }
//
//}
//
//public class Community: Object, Codable {
//
// @objc dynamic public var id: Int = 0
// @objc dynamic public var productId: String = ""
// @objc dynamic public var groupId: String = ""
// @objc dynamic public var imageUrl: String = ""
// @objc dynamic public var name: String = ""
// @objc dynamic public var passphrase: String = ""
// @objc dynamic public var type: String = ""
// @objc dynamic public var url: String = ""
//
// public convenience init(id: Int, productId: String, groupId: String, imageUrl: String, name: String, passphrase: String, type: String, url: String) {
// self.init()
//
// self.id = id
// self.productId = productId
// self.groupId = groupId
// self.imageUrl = imageUrl
// self.name = name
// self.passphrase = passphrase
// self.type = type
// self.url = url
// }
//
// public convenience required init(from decoder: Decoder) throws {
// let container = try decoder.container(keyedBy: CodingKeys.self)
//
// let id = try container.decode(Int.self, forKey: .id)
// let productId = try container.decode(String.self, forKey: .productId)
// let groupId = try container.decode(String.self, forKey: .groupId)
// let imageUrl = try container.decode(String.self, forKey: .imageUrl)
// let name = try container.decode(String.self, forKey: .name)
// let passphrase = try container.decode(String.self, forKey: .passphrase)
// let type = try container.decode(String.self, forKey: .type)
// let url = try container.decode(String.self, forKey: .url)
//
// self.init(id: id, productId: productId, groupId: groupId, imageUrl: imageUrl, name: name, passphrase: passphrase, type: type, url: url)
// }
//
// // MARK: - Realm
//
// override public static func primaryKey() -> String? {
// return "url"
// }
//
// public required init() {
// super.init()
// }
//
// public required init(value: Any, schema: RLMSchema) {
// super.init(value: value, schema: schema)
// }
//
// public required init(realm: RLMRealm, schema: RLMObjectSchema) {
// super.init(realm: realm, schema: schema)
// }
//
//}
//
//// MARK: - Realm
//extension CommunityData {
// public func save() {
// let realm = try! Realm()
//
// try! realm.write {
// realm.create(Communities.self, value: communities, update: true)
// }
// }
//}
//
//extension Community {
// public static func list() -> Results<Community> {
// let realm = try! Realm()
// return realm.objects(Community.self)
// }
//}
//
//extension Communities {
// public static func list() -> Results<Communities> {
// let realm = try! Realm()
// return realm.objects(Communities.self)
// }
//}
//
//extension Communities {
// private enum CodingKeys: String, CodingKey {
// case publicGroups = "public_pages"
// case tribeMembership = "tribe_memberships"
// case privateGroups = "private_groups"
// }
//}
//
//extension Community {
// private enum CodingKeys: String, CodingKey {
// case id
// case productId = "awc_product_id"
// case groupId = "group_id"
// case imageUrl = "image_url"
// case name
// case passphrase
// case type = "group_type"
// case url
// }
//}
//
//// MARK: - Equatable
//extension Communities {
// public static func ==(lhs: Communities, rhs: Communities) -> Bool {
// if lhs.publicGroups.first?.groupId != rhs.publicGroups.first?.groupId {
// return false
// }
// return true
// }
//}
| mit | 693ed17cb6d6ff815080fc3c86ad294e | 28.422131 | 155 | 0.620839 | 3.863832 | false | false | false | false |
Fitbit/RxBluetoothKit | Source/Characteristic.swift | 1 | 9995 | import Foundation
import RxSwift
import CoreBluetooth
/// Characteristic is a class implementing ReactiveX which wraps CoreBluetooth functions related to interaction with [CBCharacteristic](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBCharacteristic_Class/)
public class Characteristic {
/// Intance of CoreBluetooth characteristic class
public let characteristic: CBCharacteristic
/// Service which contains this characteristic
public let service: Service
/// Current value of characteristic. If value is not present - it's `nil`.
public var value: Data? {
return characteristic.value
}
/// The Bluetooth UUID of the `Characteristic` instance.
public var uuid: CBUUID {
return characteristic.uuid
}
/// Flag which is set to true if characteristic is currently notifying
public var isNotifying: Bool {
return characteristic.isNotifying
}
/// Properties of characteristic. For more info about this refer to [CBCharacteristicProperties](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBCharacteristic_Class/#//apple_ref/c/tdef/CBCharacteristicProperties)
public var properties: CBCharacteristicProperties {
return characteristic.properties
}
/// Value of this property is an array of `Descriptor` objects. They provide more detailed information about characteristics value.
public var descriptors: [Descriptor]? {
return characteristic.descriptors?.map { Descriptor(descriptor: $0, characteristic: self) }
}
init(characteristic: CBCharacteristic, service: Service) {
self.characteristic = characteristic
self.service = service
}
convenience init(characteristic: CBCharacteristic, peripheral: Peripheral) throws {
let service = Service(peripheral: peripheral, service: try characteristic.unwrapService())
self.init(characteristic: characteristic, service: service)
}
/// Function that triggers descriptors discovery for characteristic.
/// - returns: `Single` that emits `next` with array of `Descriptor` instances, once they're discovered.
///
/// Observable can ends with following errors:
/// * `BluetoothError.descriptorsDiscoveryFailed`
/// * `BluetoothError.peripheralDisconnected`
/// * `BluetoothError.destroyed`
/// * `BluetoothError.bluetoothUnsupported`
/// * `BluetoothError.bluetoothUnauthorized`
/// * `BluetoothError.bluetoothPoweredOff`
/// * `BluetoothError.bluetoothInUnknownState`
/// * `BluetoothError.bluetoothResetting`
public func discoverDescriptors() -> Single<[Descriptor]> {
return service.peripheral.discoverDescriptors(for: self)
}
/// Function that allow to observe writes that happened for characteristic.
/// - Returns: `Observable` that emits `next` with `Characteristic` instance every time when write has happened.
/// It's **infinite** stream, so `.complete` is never called.
///
/// Observable can ends with following errors:
/// * `BluetoothError.characteristicWriteFailed`
/// * `BluetoothError.peripheralDisconnected`
/// * `BluetoothError.destroyed`
/// * `BluetoothError.bluetoothUnsupported`
/// * `BluetoothError.bluetoothUnauthorized`
/// * `BluetoothError.bluetoothPoweredOff`
/// * `BluetoothError.bluetoothInUnknownState`
/// * `BluetoothError.bluetoothResetting`
public func observeWrite() -> Observable<Characteristic> {
return service.peripheral.observeWrite(for: self)
}
/// Function that allows to know the exact time, when isNotyfing value has changed on a characteristic.
///
/// - returns: `Observable` emitting `Characteristic` when isNoytfing value has changed.
///
/// Observable can ends with following errors:
/// * `BluetoothError.characteristicSetNotifyValueFailed`
/// * `BluetoothError.peripheralDisconnected`
/// * `BluetoothError.destroyed`
/// * `BluetoothError.bluetoothUnsupported`
/// * `BluetoothError.bluetoothUnauthorized`
/// * `BluetoothError.bluetoothPoweredOff`
/// * `BluetoothError.bluetoothInUnknownState`
/// * `BluetoothError.bluetoothResetting`
public func observeNotifyValue() -> Observable<Characteristic> {
return service.peripheral.observeNotifyValue(for: self)
}
/// Function that triggers write of data to characteristic. Write is called after subscribtion to `Observable` is made.
/// Behavior of this function strongly depends on [CBCharacteristicWriteType](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBPeripheral_Class/#//apple_ref/swift/enum/c:@E@CBCharacteristicWriteType), so be sure to check this out before usage of the method.
/// - parameter data: `Data` that'll be written to the `Characteristic`
/// - parameter type: Type of write operation. Possible values: `.withResponse`, `.withoutResponse`
/// - returns: `Single` whose emission depends on `CBCharacteristicWriteType` passed to the function call.
/// Behavior is following:
///
/// - `withResponse` - `Observable` emits `next` with `Characteristic` instance write was confirmed without any errors.
/// If any problem has happened, errors are emitted.
/// - `withoutResponse` - `Observable` emits `next` with `Characteristic` instance once write was called.
/// Result of this call is not checked, so as a user you are not sure
/// if everything completed successfully. Errors are not emitted
///
/// Observable can ends with following errors:
/// * `BluetoothError.characteristicWriteFailed`
/// * `BluetoothError.peripheralDisconnected`
/// * `BluetoothError.destroyed`
/// * `BluetoothError.bluetoothUnsupported`
/// * `BluetoothError.bluetoothUnauthorized`
/// * `BluetoothError.bluetoothPoweredOff`
/// * `BluetoothError.bluetoothInUnknownState`
/// * `BluetoothError.bluetoothResetting`
public func writeValue(_ data: Data, type: CBCharacteristicWriteType) -> Single<Characteristic> {
return service.peripheral.writeValue(data, for: self, type: type)
}
/// Function that allow to observe value updates for `Characteristic` instance.
/// - Returns: `Observable` that emits `Next` with `Characteristic` instance every time when value has changed.
/// It's **infinite** stream, so `.complete` is never called.
///
/// Observable can ends with following errors:
/// * `BluetoothError.characteristicReadFailed`
/// * `BluetoothError.peripheralDisconnected`
/// * `BluetoothError.destroyed`
/// * `BluetoothError.bluetoothUnsupported`
/// * `BluetoothError.bluetoothUnauthorized`
/// * `BluetoothError.bluetoothPoweredOff`
/// * `BluetoothError.bluetoothInUnknownState`
/// * `BluetoothError.bluetoothResetting`
public func observeValueUpdate() -> Observable<Characteristic> {
return service.peripheral.observeValueUpdate(for: self)
}
/// Function that triggers read of current value of the `Characteristic` instance.
/// Read is called after subscription to `Observable` is made.
/// - Returns: `Single` which emits `next` with given characteristic when value is ready to read.
///
/// Observable can ends with following errors:
/// * `BluetoothError.characteristicReadFailed`
/// * `BluetoothError.peripheralDisconnected`
/// * `BluetoothError.destroyed`
/// * `BluetoothError.bluetoothUnsupported`
/// * `BluetoothError.bluetoothUnauthorized`
/// * `BluetoothError.bluetoothPoweredOff`
/// * `BluetoothError.bluetoothInUnknownState`
/// * `BluetoothError.bluetoothResetting`
public func readValue() -> Single<Characteristic> {
return service.peripheral.readValue(for: self)
}
/// Setup characteristic notification in order to receive callbacks when given characteristic has been changed.
/// Returned observable will emit `Characteristic` on every notification change.
/// It is possible to setup more observables for the same characteristic and the lifecycle of the notification will be shared among them.
///
/// Notification is automaticaly unregistered once this observable is unsubscribed
///
/// - returns: `Observable` emitting `next` with `Characteristic` when given characteristic has been changed.
///
/// This is **infinite** stream of values.
///
/// Observable can ends with following errors:
/// * `BluetoothError.characteristicReadFailed`
/// * `BluetoothError.peripheralDisconnected`
/// * `BluetoothError.destroyed`
/// * `BluetoothError.bluetoothUnsupported`
/// * `BluetoothError.bluetoothUnauthorized`
/// * `BluetoothError.bluetoothPoweredOff`
/// * `BluetoothError.bluetoothInUnknownState`
/// * `BluetoothError.bluetoothResetting`
public func observeValueUpdateAndSetNotification() -> Observable<Characteristic> {
return service.peripheral.observeValueUpdateAndSetNotification(for: self)
}
}
extension Characteristic: CustomStringConvertible {
public var description: String {
return "\(type(of: self)) \(uuid)"
}
}
extension Characteristic: Equatable {}
extension Characteristic: UUIDIdentifiable {}
/// Compare two characteristics. Characteristics are the same when their UUIDs are the same.
///
/// - parameter lhs: First characteristic to compare
/// - parameter rhs: Second characteristic to compare
/// - returns: True if both characteristics are the same.
public func == (lhs: Characteristic, rhs: Characteristic) -> Bool {
return lhs.characteristic == rhs.characteristic
}
extension CBCharacteristic {
/// Unwrap the parent service or throw if the service is nil
func unwrapService() throws -> CBService {
guard let cbService = service as CBService? else {
throw BluetoothError.serviceDeallocated
}
return cbService
}
}
| apache-2.0 | 04e8e3b3008d17f7f6bf1e9ef5585c6a | 46.822967 | 292 | 0.716358 | 5.336359 | false | false | false | false |
PrajeetShrestha/ioshubgsheetwrite | ioshubSheets/LoginController.swift | 1 | 1854 | //
// LoginController.swift
// ioshubSheets
//
// Created by Prajeet Shrestha on 8/12/16.
// Copyright © 2016 eeposit. All rights reserved.
//
import UIKit
import GoogleAPIClient
import GTMOAuth2
class LoginController: UIViewController {
private let service = GlobalGTLService.sharedInstance.service
override func viewDidLoad() {
}
@IBAction func login(sender: AnyObject) {
self.presentViewController(createAuthController(), animated: true
, completion: nil)
}
private func createAuthController() -> GTMOAuth2ViewControllerTouch {
let scopeString = kScopes.joinWithSeparator(" ")
return GTMOAuth2ViewControllerTouch(
scope: scopeString,
clientID: kClientID,
clientSecret: nil,
keychainItemName: kKeychainItemName,
delegate: self,
finishedSelector: #selector(viewController(_:finishedWithAuth:error:))
)
}
func viewController(vc : UIViewController,
finishedWithAuth authResult : GTMOAuth2Authentication, error : NSError?) {
if let error = error {
service.authorizer = nil
showAlert("Authentication Error", message: error.localizedDescription, controller: self)
return
}
service.authorizer = authResult
dismissViewControllerAnimated(true, completion: {
//Navigate to second view controller
if let authorizer = self.service.authorizer,
canAuth = authorizer.canAuthorize where canAuth {
//Navigation Code here
let controller = self.storyboard?.instantiateViewControllerWithIdentifier("tabBarController")
self.showViewController(controller!, sender: nil)
}
})
}
}
| apache-2.0 | 7dc93004d2b9e2ad4837088269de2ad2 | 30.948276 | 109 | 0.634107 | 5.45 | false | false | false | false |
TransitionKit/Union | Union/Presenter.swift | 1 | 3773 | //
// Presenter.swift
// Union
//
// Created by Hirohisa Kawasaki on 10/7/15.
// Copyright © 2015 Hirohisa Kawasaki. All rights reserved.
//
import UIKit
public class Presenter: NSObject {
let before = AnimationManager()
let present = AnimationManager()
var duration: NSTimeInterval {
return before.duration + present.duration
}
func animate(transitionContext: UIViewControllerContextTransitioning) {
setup(transitionContext)
start(transitionContext)
}
public class func animate() -> UIViewControllerAnimatedTransitioning {
return Presenter()
}
}
extension Presenter: UIViewControllerAnimatedTransitioning {
public func animateTransition(transitionContext: UIViewControllerContextTransitioning) {
animate(transitionContext)
}
public func transitionDuration(transitionContext: UIViewControllerContextTransitioning?) -> NSTimeInterval {
return duration
}
}
extension Presenter {
func setup(transitionContext: UIViewControllerContextTransitioning) {
let fromViewController = transitionContext.viewControllerForKey(UITransitionContextFromViewControllerKey)
let toViewController = transitionContext.viewControllerForKey(UITransitionContextToViewControllerKey)
if let fromViewController = fromViewController, let toViewController = toViewController {
_setup(fromViewController: fromViewController, toViewController: toViewController)
}
}
func start(transitionContext: UIViewControllerContextTransitioning) {
before.completion = { [unowned self] in
self.startTransition(transitionContext)
}
before.start()
}
func startTransition(transitionContext: UIViewControllerContextTransitioning) {
guard let containerView = transitionContext.containerView() else {
transitionContext.completeTransition(true)
return
}
let fromViewController = transitionContext.viewControllerForKey(UITransitionContextFromViewControllerKey)
let toViewController = transitionContext.viewControllerForKey(UITransitionContextToViewControllerKey)
if let toView = toViewController?.view, let fromView = fromViewController?.view {
switch transitionContext.presentationStyle() {
case .None:
containerView.insertSubview(toView, aboveSubview: fromView)
default:
// context.containerView() is UIPresentationController.view
if !fromView.isDescendantOfView(containerView) {
containerView.insertSubview(toView, aboveSubview: fromView)
}
break
}
}
present.completion = {
switch transitionContext.presentationStyle() {
case .None:
fromViewController?.view?.removeFromSuperview()
default:
break
}
transitionContext.completeTransition(true)
}
present.start()
}
private func _setup(fromViewController fromViewController: UIViewController, toViewController: UIViewController) {
if let delegate = fromViewController as? Delegate {
before.animations = delegate.animationsBeforeTransition(from: fromViewController, to: toViewController)
}
// present
let fromAnimations: [Animation] = (fromViewController as? Delegate)?.animationsDuringTransition(from: fromViewController, to: toViewController) ?? []
let toAnimations: [Animation] = (toViewController as? Delegate)?.animationsDuringTransition(from: fromViewController, to: toViewController) ?? []
present.animations = fromAnimations + toAnimations
}
} | mit | 72c6f260c02a2a97910e0814ce990711 | 34.933333 | 157 | 0.695917 | 6.629174 | false | false | false | false |
ello/ello-ios | Specs/Model/ExperienceUpdateSpec.swift | 1 | 1022 | ////
/// ExperienceUpdateSpec.swift
//
@testable import Ello
import Quick
import Nimble
class ExperienceUpdateSpec: QuickSpec {
override func spec() {
describe("ExperienceUpdate") {
it("should update post comment counts") {
let post1 = Post.stub(["id": "post1", "commentsCount": 1])
let post2 = Post.stub(["id": "post2", "commentsCount": 1])
let comment = ElloComment.stub([
"parentPost": post1,
"loadedFromPost": post2
])
ElloLinkedStore.shared.setObject(post1, forKey: post1.id, type: .postsType)
ContentChange.updateCommentCount(comment, delta: 1)
expect(post1.commentsCount) == 2
expect(post2.commentsCount) == 2
let storedPost = ElloLinkedStore.shared.getObject(post1.id, type: .postsType)
as! Post
expect(storedPost.commentsCount) == 2
}
}
}
}
| mit | 14cfbc539c557cb4f298e69d6375f780 | 33.066667 | 93 | 0.545988 | 4.522124 | false | false | false | false |
raymondshadow/SwiftDemo | SwiftApp/StudyNote/StudyNote/RxSwift/custom/model/SNStuInfoModel.swift | 1 | 1288 | //
// SNStuInfoModel.swift
// StudyNote
//
// Created by 邬勇鹏 on 2018/9/21.
// Copyright © 2018年 Raymond. All rights reserved.
//
import UIKit
class SNStuInfoModel: NSObject {
@objc dynamic var baseInfo: SNStuBaseInfoModel = SNStuBaseInfoModel()
@objc dynamic var scoreInfo: SNStuScoreInfoModel = SNStuScoreInfoModel()
}
class SNStuBaseInfoModel: NSObject {
@objc dynamic var id: Int
@objc dynamic var name: String
@objc dynamic var age: Int
@objc dynamic var address: String
override init() {
self.id = 0
self.name = ""
self.age = 0
self.address = ""
}
convenience init(id: Int, name: String, age: Int, address: String) {
self.init()
self.id = id
self.name = name
self.age = age
self.address = address
}
}
class SNStuScoreInfoModel: NSObject {
@objc dynamic var math: Int = 0
@objc dynamic var english: Int = 0
@objc dynamic var china: Int = 0
override init() {
super.init()
}
convenience init(math: Int, english: Int, china: Int) {
self.init()
self.math = math
self.english = english
self.china = china
}
}
| apache-2.0 | 7ed2dfb382e4e8878b42bd7a59409cf4 | 18.984375 | 76 | 0.57154 | 4.099359 | false | false | false | false |
iMetalk/TCZDemo | RealmTest-swift-/Pods/RealmSwift/RealmSwift/Sync.swift | 5 | 29955 | ////////////////////////////////////////////////////////////////////////////
//
// Copyright 2016 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 Realm
import Realm.Private
import Foundation
/**
An object representing a Realm Object Server user.
- see: `RLMSyncUser`
*/
public typealias SyncUser = RLMSyncUser
/**
An immutable data object representing information retrieved from the Realm Object
Server about a particular user.
- see: `RLMSyncUserInfo`
*/
public typealias SyncUserInfo = RLMSyncUserInfo
/**
A singleton which configures and manages the Realm Object Server synchronization-related
functionality.
- see: `RLMSyncManager`
*/
public typealias SyncManager = RLMSyncManager
extension SyncManager {
/// The sole instance of the singleton.
public static var shared: SyncManager {
return __shared()
}
}
/**
A session object which represents communication between the client and server for a specific
Realm.
- see: `RLMSyncSession`
*/
public typealias SyncSession = RLMSyncSession
/**
A closure type for a closure which can be set on the `SyncManager` to allow errors to be reported
to the application.
- see: `RLMSyncErrorReportingBlock`
*/
public typealias ErrorReportingBlock = RLMSyncErrorReportingBlock
/**
A closure type for a closure which is used by certain APIs to asynchronously return a `SyncUser`
object to the application.
- see: `RLMUserCompletionBlock`
*/
public typealias UserCompletionBlock = RLMUserCompletionBlock
/**
An error associated with the SDK's synchronization functionality. All errors reported by
an error handler registered on the `SyncManager` are of this type.
- see: `RLMSyncError`
*/
public typealias SyncError = RLMSyncError
/**
An error associated with network requests made to the authentication server. This type of error
may be returned in the callback block to `SyncUser.logIn()` upon certain types of failed login
attempts (for example, if the request is malformed or if the server is experiencing an issue).
- see: `RLMSyncAuthError`
*/
public typealias SyncAuthError = RLMSyncAuthError
/**
An error associated with retrieving or modifying user permissions to access a synchronized Realm.
- see: `RLMSyncPermissionError`
*/
public typealias SyncPermissionError = RLMSyncPermissionError
/**
An enum which can be used to specify the level of logging.
- see: `RLMSyncLogLevel`
*/
public typealias SyncLogLevel = RLMSyncLogLevel
/**
An enum representing the different states a sync management object can take.
- see: `RLMSyncManagementObjectStatus`
*/
public typealias SyncManagementObjectStatus = RLMSyncManagementObjectStatus
/**
A data type whose values represent different authentication providers that can be used with
the Realm Object Server.
- see: `RLMIdentityProvider`
*/
public typealias Provider = RLMIdentityProvider
public extension SyncError {
/// Given a client reset error, extract and return the recovery file path and the reset closure.
public func clientResetInfo() -> (String, () -> Void)? {
if code == SyncError.clientResetError,
let recoveryPath = userInfo[kRLMSyncPathOfRealmBackupCopyKey] as? String,
let block = _nsError.__rlmSync_clientResetBlock() {
return (recoveryPath, block)
}
return nil
}
/// Given a permission denied error, extract and return the reset closure.
public func deleteRealmUserInfo() -> (() -> Void)? {
return _nsError.__rlmSync_deleteRealmBlock()
}
}
/**
A `SyncConfiguration` represents configuration parameters for Realms intended to sync with
a Realm Object Server.
*/
public struct SyncConfiguration {
/// The `SyncUser` who owns the Realm that this configuration should open.
public let user: SyncUser
/**
The URL of the Realm on the Realm Object Server that this configuration should open.
- warning: The URL must be absolute (e.g. `realms://example.com/~/foo`), and cannot end with
`.realm`, `.realm.lock` or `.realm.management`.
*/
public let realmURL: URL
/**
A policy that determines what should happen when all references to Realms opened by this
configuration go out of scope.
*/
internal let stopPolicy: RLMSyncStopPolicy
/**
Whether the SSL certificate of the Realm Object Server should be validated.
*/
public let enableSSLValidation: Bool
internal init(config: RLMSyncConfiguration) {
self.user = config.user
self.realmURL = config.realmURL
self.stopPolicy = config.stopPolicy
self.enableSSLValidation = config.enableSSLValidation
}
func asConfig() -> RLMSyncConfiguration {
let config = RLMSyncConfiguration(user: user, realmURL: realmURL)
config.stopPolicy = stopPolicy
config.enableSSLValidation = enableSSLValidation
return config
}
/**
Initialize a sync configuration with a user and a Realm URL.
Additional settings can be optionally specified. Descriptions of these
settings follow.
`enableSSLValidation` is true by default. It can be disabled for debugging
purposes.
- warning: The URL must be absolute (e.g. `realms://example.com/~/foo`), and cannot end with
`.realm`, `.realm.lock` or `.realm.management`.
- warning: NEVER disable SSL validation for a system running in production.
*/
public init(user: SyncUser, realmURL: URL, enableSSLValidation: Bool = true) {
self.user = user
self.realmURL = realmURL
self.stopPolicy = .afterChangesUploaded
self.enableSSLValidation = enableSSLValidation
}
}
/// A `SyncCredentials` represents data that uniquely identifies a Realm Object Server user.
public struct SyncCredentials {
public typealias Token = String
internal var token: Token
internal var provider: Provider
internal var userInfo: [String: Any]
/**
Initialize new credentials using a custom token, authentication provider, and user information
dictionary. In most cases, the convenience initializers should be used instead.
*/
public init(customToken token: Token, provider: Provider, userInfo: [String: Any] = [:]) {
self.token = token
self.provider = provider
self.userInfo = userInfo
}
internal init(_ credentials: RLMSyncCredentials) {
self.token = credentials.token
self.provider = credentials.provider
self.userInfo = credentials.userInfo
}
/// Initialize new credentials using a Facebook account token.
public static func facebook(token: Token) -> SyncCredentials {
return SyncCredentials(RLMSyncCredentials(facebookToken: token))
}
/// Initialize new credentials using a Google account token.
public static func google(token: Token) -> SyncCredentials {
return SyncCredentials(RLMSyncCredentials(googleToken: token))
}
/// Initialize new credentials using a CloudKit account token.
public static func cloudKit(token: Token) -> SyncCredentials {
return SyncCredentials(RLMSyncCredentials(cloudKitToken: token))
}
/// Initialize new credentials using a Realm Object Server username and password.
public static func usernamePassword(username: String,
password: String,
register: Bool = false) -> SyncCredentials {
return SyncCredentials(RLMSyncCredentials(username: username, password: password, register: register))
}
/// Initialize new credentials using a Realm Object Server access token.
public static func accessToken(_ accessToken: String, identity: String) -> SyncCredentials {
return SyncCredentials(RLMSyncCredentials(accessToken: accessToken, identity: identity))
}
}
extension RLMSyncCredentials {
internal convenience init(_ credentials: SyncCredentials) {
self.init(customToken: credentials.token, provider: credentials.provider, userInfo: credentials.userInfo)
}
}
extension SyncUser {
/**
Given credentials and a server URL, log in a user and asynchronously return a `SyncUser`
object which can be used to open `Realm`s and retrieve `SyncSession`s.
*/
public static func logIn(with credentials: SyncCredentials,
server authServerURL: URL,
timeout: TimeInterval = 30,
onCompletion completion: @escaping UserCompletionBlock) {
return SyncUser.__logIn(with: RLMSyncCredentials(credentials),
authServerURL: authServerURL,
timeout: timeout,
onCompletion: completion)
}
/// A dictionary of all valid, logged-in user identities corresponding to their `SyncUser` objects.
public static var all: [String: SyncUser] {
return __allUsers()
}
/**
The logged-in user. `nil` if none exists. Only use this property if your application expects
no more than one logged-in user at any given time.
- warning: Throws an Objective-C exception if more than one logged-in user exists.
*/
public static var current: SyncUser? {
return __current()
}
/**
Returns an instance of the Management Realm owned by the user.
This Realm can be used to control access permissions for Realms managed by the user.
This includes granting other users access to Realms.
*/
public func managementRealm() throws -> Realm {
var config = Realm.Configuration.fromRLMRealmConfiguration(.managementConfiguration(for: self))
guard let permissionChangeClass = NSClassFromString("RealmSwift.SyncPermissionChange") as? Object.Type else {
fatalError("Internal error: could not build `SyncPermissionChange` metaclass from string.")
}
config.objectTypes = [permissionChangeClass,
SyncPermissionOffer.self,
SyncPermissionOfferResponse.self]
return try Realm(configuration: config)
}
/**
Returns an instance of the Permission Realm owned by the user.
This read-only Realm contains `SyncPermission` objects reflecting the
synchronized Realms and permission details this user has access to.
*/
@available(*, deprecated, message: "Use SyncUser.retrievePermissions()")
public func permissionRealm() throws -> Realm {
var config = Realm.Configuration.fromRLMRealmConfiguration(.permissionConfiguration(for: self))
config.objectTypes = [SyncPermission.self]
return try Realm(configuration: config)
}
}
/**
A value which represents a permission granted to a user to interact
with a Realm. These values are passed into APIs on `SyncUser`, and
returned from `SyncPermissionResults`.
- see: `RLMSyncPermissionValue`
*/
public typealias SyncPermissionValue = RLMSyncPermissionValue
/**
An enumeration describing possible access levels.
- see: `RLMSyncAccessLevel`
*/
public typealias SyncAccessLevel = RLMSyncAccessLevel
/**
A collection of `SyncPermissionValue`s that represent the permissions
that have been configured on all the Realms that some user is allowed
to administer.
- see: `RLMSyncPermissionResults`
*/
public typealias SyncPermissionResults = RLMSyncPermissionResults
#if swift(>=3.1)
extension SyncPermissionResults: RandomAccessCollection {
public subscript(index: Int) -> SyncPermissionValue {
return object(at: index)
}
public func index(after i: Int) -> Int {
return i + 1
}
public var startIndex: Int {
return 0
}
public var endIndex: Int {
return count
}
}
#else
extension SyncPermissionResults {
/// Return the first permission value in the results, or `nil` if
/// the results are empty.
public var first: SyncPermissionValue? {
return count > 0 ? object(at: 0) : nil
}
/// Return the last permission value in the results, or `nil` if
/// the results are empty.
public var last: SyncPermissionValue? {
return count > 0 ? object(at: count - 1) : nil
}
}
extension SyncPermissionResults: Sequence {
public struct Iterator: IteratorProtocol {
private let iteratorBase: NSFastEnumerationIterator
fileprivate init(results: SyncPermissionResults) {
iteratorBase = NSFastEnumerationIterator(results)
}
public func next() -> SyncPermissionValue? {
return iteratorBase.next() as! SyncPermissionValue?
}
}
public func makeIterator() -> SyncPermissionResults.Iterator {
return Iterator(results: self)
}
}
#endif
/**
This model is used to reflect permissions.
It should be used in conjunction with a `SyncUser`'s Permission Realm.
You can only read this Realm. Use the objects in Management Realm to
make request for modifications of permissions.
See https://realm.io/docs/realm-object-server/#permissions for general
documentation.
*/
@available(*, deprecated, message: "Use `SyncPermissionValue`")
public final class SyncPermission: Object {
/// The date this object was last modified.
@objc public dynamic var updatedAt = Date()
/// The ID of the affected user by the permission.
@objc public dynamic var userId = ""
/// The path to the realm.
@objc public dynamic var path = ""
/// Whether the affected user is allowed to read from the Realm.
@objc public dynamic var mayRead = false
/// Whether the affected user is allowed to write to the Realm.
@objc public dynamic var mayWrite = false
/// Whether the affected user is allowed to manage the access rights for others.
@objc public dynamic var mayManage = false
/// :nodoc:
override public class func shouldIncludeInDefaultSchema() -> Bool {
return false
}
/// :nodoc:
override public class func _realmObjectName() -> String? {
return "Permission"
}
}
/**
This model is used for requesting changes to a Realm's permissions.
It should be used in conjunction with a `SyncUser`'s Management Realm.
See https://realm.io/docs/realm-object-server/#permissions for general
documentation.
*/
@available(*, deprecated, message: "Use `SyncUser.applyPermission()` and `SyncUser.revokePermission()`")
public final class SyncPermissionChange: Object {
/// The globally unique ID string of this permission change object.
@objc public dynamic var id = UUID().uuidString
/// The date this object was initially created.
@objc public dynamic var createdAt = Date()
/// The date this object was last modified.
@objc public dynamic var updatedAt = Date()
/// The status code of the object that was processed by Realm Object Server.
public let statusCode = RealmOptional<Int>()
/// An error or informational message, typically written to by the Realm Object Server.
@objc public dynamic var statusMessage: String?
/// Sync management object status.
public var status: SyncManagementObjectStatus {
return SyncManagementObjectStatus(statusCode: statusCode)
}
/// The remote URL to the realm.
@objc public dynamic var realmUrl = "*"
/// The identity of a user affected by this permission change.
@objc public dynamic var userId = "*"
/// Define read access. Set to `true` or `false` to update this value. Leave unset
/// to preserve the existing setting.
public let mayRead = RealmOptional<Bool>()
/// Define write access. Set to `true` or `false` to update this value. Leave unset
/// to preserve the existing setting.
public let mayWrite = RealmOptional<Bool>()
/// Define management access. Set to `true` or `false` to update this value. Leave
/// unset to preserve the existing setting.
public let mayManage = RealmOptional<Bool>()
/**
Construct a permission change object used to change the access permissions for a user on a Realm.
- parameter realmURL: The Realm URL whose permissions settings should be changed.
Use `*` to change the permissions of all Realms managed by the Management Realm's `SyncUser`.
- parameter userID: The user or users who should be granted these permission changes.
Use `*` to change the permissions for all users.
- parameter mayRead: Define read access. Set to `true` or `false` to update this value.
Leave unset to preserve the existing setting.
- parameter mayWrite: Define write access. Set to `true` or `false` to update this value.
Leave unset to preserve the existing setting.
- parameter mayManage: Define management access. Set to `true` or `false` to update this value.
Leave unset to preserve the existing setting.
*/
public convenience init(realmURL: String, userID: String, mayRead: Bool?, mayWrite: Bool?, mayManage: Bool?) {
self.init()
self.realmUrl = realmURL
self.userId = userID
self.mayRead.value = mayRead
self.mayWrite.value = mayWrite
self.mayManage.value = mayManage
}
/// :nodoc:
override public class func primaryKey() -> String? {
return "id"
}
/// :nodoc:
override public class func shouldIncludeInDefaultSchema() -> Bool {
return false
}
/// :nodoc:
override public class func _realmObjectName() -> String? {
return "PermissionChange"
}
}
/**
This model is used for offering permission changes to other users.
It should be used in conjunction with a `SyncUser`'s Management Realm.
See https://realm.io/docs/realm-object-server/#permissions for general
documentation.
*/
public final class SyncPermissionOffer: Object {
/// The globally unique ID string of this permission offer object.
@objc public dynamic var id = UUID().uuidString
/// The date this object was initially created.
@objc public dynamic var createdAt = Date()
/// The date this object was last modified.
@objc public dynamic var updatedAt = Date()
/// The status code of the object that was processed by Realm Object Server.
public let statusCode = RealmOptional<Int>()
/// An error or informational message, typically written to by the Realm Object Server.
@objc public dynamic var statusMessage: String?
/// Sync management object status.
public var status: SyncManagementObjectStatus {
return SyncManagementObjectStatus(statusCode: statusCode)
}
/// A token which uniquely identifies this offer. Generated by the server.
@objc public dynamic var token: String?
/// The remote URL to the realm.
@objc public dynamic var realmUrl = ""
/// Whether this offer allows the receiver to read from the Realm.
@objc public dynamic var mayRead = false
/// Whether this offer allows the receiver to write to the Realm.
@objc public dynamic var mayWrite = false
/// Whether this offer allows the receiver to manage the access rights for others.
@objc public dynamic var mayManage = false
/// When this token will expire and become invalid.
@objc public dynamic var expiresAt: Date?
/**
Construct a permission offer object used to offer permission changes to other users.
- parameter realmURL: The URL to the Realm on which to apply these permission changes
to, once the offer is accepted.
- parameter expiresAt: When this token will expire and become invalid.
Pass `nil` if this offer should not expire.
- parameter mayRead: Grant or revoke read access.
- parameter mayWrite: Grant or revoked read-write access.
- parameter mayManage: Grant or revoke administrative access.
*/
public convenience init(realmURL: String, expiresAt: Date?, mayRead: Bool, mayWrite: Bool, mayManage: Bool) {
self.init()
self.realmUrl = realmURL
self.expiresAt = expiresAt
self.mayRead = mayRead
self.mayWrite = mayWrite
self.mayManage = mayManage
}
/// :nodoc:
override public class func indexedProperties() -> [String] {
return ["token"]
}
/// :nodoc:
override public class func primaryKey() -> String? {
return "id"
}
/// :nodoc:
override public class func shouldIncludeInDefaultSchema() -> Bool {
return false
}
/// :nodoc:
override public class func _realmObjectName() -> String? {
return "PermissionOffer"
}
}
/**
This model is used to apply permission changes defined in the permission offer
object represented by the specified token, which was created by another user's
`SyncPermissionOffer` object.
It should be used in conjunction with a `SyncUser`'s Management Realm.
See https://realm.io/docs/realm-object-server/#permissions for general
documentation.
*/
public final class SyncPermissionOfferResponse: Object {
/// The globally unique ID string of this permission offer response object.
@objc public dynamic var id = UUID().uuidString
/// The date this object was initially created.
@objc public dynamic var createdAt = Date()
/// The date this object was last modified.
@objc public dynamic var updatedAt = Date()
/// The status code of the object that was processed by Realm Object Server.
public let statusCode = RealmOptional<Int>()
/// An error or informational message, typically written to by the Realm Object Server.
@objc public dynamic var statusMessage: String?
/// Sync management object status.
public var status: SyncManagementObjectStatus {
return SyncManagementObjectStatus(statusCode: statusCode)
}
/// The received token which uniquely identifies another user's `SyncPermissionOffer`.
@objc public dynamic var token = ""
/// The remote URL to the realm on which these permission changes were applied.
@objc public dynamic var realmUrl: String?
/**
Construct a permission offer response object used to apply permission changes
defined in the permission offer object represented by the specified token,
which was created by another user's `SyncPermissionOffer` object.
- parameter token: The received token which uniquely identifies another user's
`SyncPermissionOffer`.
*/
public convenience init(token: String) {
self.init()
self.token = token
}
/// :nodoc:
override public class func primaryKey() -> String? {
return "id"
}
/// :nodoc:
override public class func shouldIncludeInDefaultSchema() -> Bool {
return false
}
/// :nodoc:
override public class func _realmObjectName() -> String? {
return "PermissionOfferResponse"
}
}
fileprivate extension SyncManagementObjectStatus {
fileprivate init(statusCode: RealmOptional<Int>) {
guard let statusCode = statusCode.value else {
self = .notProcessed
return
}
if statusCode == 0 {
self = .success
} else {
self = .error
}
}
}
public extension SyncSession {
/**
The transfer direction (upload or download) tracked by a given progress notification block.
Progress notification blocks can be registered on sessions if your app wishes to be informed
how many bytes have been uploaded or downloaded, for example to show progress indicator UIs.
*/
public enum ProgressDirection {
/// For monitoring upload progress.
case upload
/// For monitoring download progress.
case download
}
/**
The desired behavior of a progress notification block.
Progress notification blocks can be registered on sessions if your app wishes to be informed
how many bytes have been uploaded or downloaded, for example to show progress indicator UIs.
*/
public enum ProgressMode {
/**
The block will be called forever, or until it is unregistered by calling
`ProgressNotificationToken.stop()`.
Notifications will always report the latest number of transferred bytes, and the
most up-to-date number of total transferrable bytes.
*/
case reportIndefinitely
/**
The block will, upon registration, store the total number of bytes
to be transferred. When invoked, it will always report the most up-to-date number
of transferrable bytes out of that original number of transferrable bytes.
When the number of transferred bytes reaches or exceeds the
number of transferrable bytes, the block will be unregistered.
*/
case forCurrentlyOutstandingWork
}
/**
A token corresponding to a progress notification block.
Call `stop()` on the token to stop notifications. If the notification block has already
been automatically stopped, calling `stop()` does nothing. `stop()` should be called
before the token is destroyed.
*/
public typealias ProgressNotificationToken = RLMProgressNotificationToken
/**
A struct encapsulating progress information, as well as useful helper methods.
*/
public struct Progress {
/// The number of bytes that have been transferred.
public let transferredBytes: Int
/**
The total number of transferrable bytes (bytes that have been transferred,
plus bytes pending transfer).
If the notification block is tracking downloads, this number represents the size of the
changesets generated by all other clients using the Realm.
If the notification block is tracking uploads, this number represents the size of the
changesets representing the local changes on this client.
*/
public let transferrableBytes: Int
/// The fraction of bytes transferred out of all transferrable bytes. If this value is 1,
/// no bytes are waiting to be transferred (either all bytes have already been transferred,
/// or there are no bytes to be transferred in the first place).
public var fractionTransferred: Double {
if transferrableBytes == 0 {
return 1
}
let percentage = Double(transferredBytes) / Double(transferrableBytes)
return percentage > 1 ? 1 : percentage
}
/// Whether all pending bytes have already been transferred.
public var isTransferComplete: Bool {
return transferredBytes >= transferrableBytes
}
fileprivate init(transferred: UInt, transferrable: UInt) {
transferredBytes = Int(transferred)
transferrableBytes = Int(transferrable)
}
}
/**
Register a progress notification block.
If the session has already received progress information from the
synchronization subsystem, the block will be called immediately. Otherwise, it
will be called as soon as progress information becomes available.
Multiple blocks can be registered with the same session at once. Each block
will be invoked on a side queue devoted to progress notifications.
The token returned by this method must be retained as long as progress
notifications are desired, and the `stop()` method should be called on it
when notifications are no longer needed and before the token is destroyed.
If no token is returned, the notification block will never be called again.
There are a number of reasons this might be true. If the session has previously
experienced a fatal error it will not accept progress notification blocks. If
the block was configured in the `forCurrentlyOutstandingWork` mode but there
is no additional progress to report (for example, the number of transferrable bytes
and transferred bytes are equal), the block will not be called again.
- parameter direction: The transfer direction (upload or download) to track in this progress notification block.
- parameter mode: The desired behavior of this progress notification block.
- parameter block: The block to invoke when notifications are available.
- returns: A token which must be held for as long as you want notifications to be delivered.
- see: `ProgressDirection`, `Progress`, `ProgressNotificationToken`
*/
public func addProgressNotification(for direction: ProgressDirection,
mode: ProgressMode,
block: @escaping (Progress) -> Void) -> ProgressNotificationToken? {
return __addProgressNotification(for: (direction == .upload ? .upload : .download),
mode: (mode == .reportIndefinitely
? .reportIndefinitely
: .forCurrentlyOutstandingWork)) { transferred, transferrable in
block(Progress(transferred: transferred, transferrable: transferrable))
}
}
}
| mit | 1b1ea9361b13ce5441de5f00e9c57faa | 36.397004 | 121 | 0.68199 | 5.179837 | false | false | false | false |
manavgabhawala/swift | test/SILGen/retaining_globals.swift | 2 | 2824 | // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -import-objc-header %S/Inputs/globals.h -emit-silgen %s | %FileCheck %s
// REQUIRES: objc_interop
// This test makes sure loading from globals properly retains/releases loads from globals.
// NSString was the only real problem, as the compiler treats NSString globals specially.
// The rest of these are just hedges against future changes.
// From header:
// globalString: __strong NSString*
// globalObject: __strong NSObject*
// globalID: __strong id
// globalArray: __strong NSArray*
// globalConstArray: __strong NSArray *const
func main() {
Globals.sharedInstance() // Initialize globals (dispatch_once)
// CHECK: global_addr @globalConstArray : $*Optional<NSArray>
// CHECK: global_addr @globalArray : $*Optional<NSArray>
// CHECK: global_addr @globalId : $*Optional<AnyObject>
// CHECK: global_addr @globalObject : $*Optional<NSObject>
// CHECK: global_addr @globalString : $*NSString
// CHECK: [[globalString:%.*]] = load [copy] {{%.*}} : $*NSString
// CHECK: [[bridgeStringFunc:%.*]] = function_ref @{{.*}} : $@convention(method) (@owned Optional<NSString>, @thin String.Type) -> @owned String
// CHECK: [[wrappedString:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[globalString]] : $NSString
// CHECK: [[stringMetaType:%.*]] = metatype $@thin String.Type
// CHECK: [[bridgedString:%.*]] = apply [[bridgeStringFunc]]([[wrappedString]], [[stringMetaType]]) : $@convention(method) (@owned Optional<NSString>, @thin String.Type) -> @owned String
let string = globalString // Problematic case, wasn't being retained
// CHECK: [[load_1:%.*]] = load [copy] {{%.*}} : $*Optional<NSObject>
let object = globalObject
// CHECK: [[load_2:%.*]] = load [copy] {{%.*}} : $*Optional<AnyObject>
let id = globalId
// CHECK: [[load_3:%.*]] = load [copy] {{%.*}} : $*Optional<NSArray>
let arr = globalArray
// CHECK: [[load_4:%.*]] = load [copy] {{%.*}} : $*Optional<NSArray>
let constArr = globalConstArray
// Make sure there's no more copies
// CHECK-NOT: load [copy]
print(string as Any)
print(object as Any)
print(id as Any)
print(arr as Any)
print(constArr as Any)
// CHECK: [[PRINT_FUN:%.*]] = function_ref @_TFs5printFTGSaP{{.*}} : $@convention(thin) (@owned Array<Any>, @owned String, @owned String) -> ()
// CHECK: apply [[PRINT_FUN]]({{.*}})
// CHECK: destroy_value [[load_4]]
// CHECK: destroy_value [[load_3]]
// CHECK: destroy_value [[load_2]]
// CHECK: destroy_value [[load_1]]
// CHECK: destroy_value [[bridgedString]]
// Make sure there's no more destroys
// CHECK-NOT: destroy_value
// CHECK: } // end sil function '_TF17retaining_globals4mainFT_T_'
}
main()
main() // Used to crash here, due to use-after-free.
main()
main()
main()
main()
| apache-2.0 | 8b26b61acfe06419799410df9c236530 | 37.162162 | 188 | 0.651912 | 3.725594 | false | false | false | false |
Elm-Tree-Island/Shower | Shower/Carthage/Checkouts/ReactiveCocoa/ReactiveCocoaTests/UIKit/UIScrollViewSpec.swift | 5 | 3876 | import ReactiveSwift
import ReactiveCocoa
import UIKit
import Quick
import Nimble
import enum Result.NoError
private final class UIScrollViewDelegateForZooming: NSObject, UIScrollViewDelegate {
func viewForZooming(in scrollView: UIScrollView) -> UIView? {
return scrollView.subviews.first!
}
}
class UIScrollViewSpec: QuickSpec {
override func spec() {
var scrollView: UIScrollView!
weak var _scrollView: UIScrollView?
beforeEach {
scrollView = UIScrollView(frame: .zero)
_scrollView = scrollView
}
afterEach {
scrollView = nil
expect(_scrollView).to(beNil())
}
it("should accept changes from bindings to its content inset value") {
scrollView.contentInset = .zero
let (pipeSignal, observer) = Signal<UIEdgeInsets, NoError>.pipe()
scrollView.reactive.contentInset <~ SignalProducer(pipeSignal)
observer.send(value: UIEdgeInsets(top: 1, left: 2, bottom: 3, right: 4))
expect(scrollView.contentInset) == UIEdgeInsets(top: 1, left: 2, bottom: 3, right: 4)
observer.send(value: .zero)
expect(scrollView.contentInset) == UIEdgeInsets.zero
}
it("should accept changes from bindings to its scroll indicator insets value") {
scrollView.scrollIndicatorInsets = .zero
let (pipeSignal, observer) = Signal<UIEdgeInsets, NoError>.pipe()
scrollView.reactive.scrollIndicatorInsets <~ SignalProducer(pipeSignal)
observer.send(value: UIEdgeInsets(top: 1, left: 2, bottom: 3, right: 4))
expect(scrollView.scrollIndicatorInsets) == UIEdgeInsets(top: 1, left: 2, bottom: 3, right: 4)
observer.send(value: .zero)
expect(scrollView.scrollIndicatorInsets) == UIEdgeInsets.zero
}
it("should accept changes from bindings to its scroll enabled state") {
scrollView.isScrollEnabled = true
let (pipeSignal, observer) = Signal<Bool, NoError>.pipe()
scrollView.reactive.isScrollEnabled <~ SignalProducer(pipeSignal)
observer.send(value: true)
expect(scrollView.isScrollEnabled) == true
observer.send(value: false)
expect(scrollView.isScrollEnabled) == false
}
it("should accept changes from bindings to its zoom scale value") {
let contentView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
scrollView.addSubview(contentView)
let delegate = UIScrollViewDelegateForZooming()
scrollView.delegate = delegate
scrollView.minimumZoomScale = 1
scrollView.maximumZoomScale = 5
scrollView.zoomScale = 1
let (pipeSignal, observer) = Signal<CGFloat, NoError>.pipe()
scrollView.reactive.zoomScale <~ SignalProducer(pipeSignal)
observer.send(value: 3)
expect(scrollView.zoomScale) == 3
observer.send(value: 1)
expect(scrollView.zoomScale) == 1
}
it("should accept changes from bindings to its minimum zoom scale value") {
scrollView.minimumZoomScale = 0
let (pipeSignal, observer) = Signal<CGFloat, NoError>.pipe()
scrollView.reactive.minimumZoomScale <~ SignalProducer(pipeSignal)
observer.send(value: 42)
expect(scrollView.minimumZoomScale) == 42
observer.send(value: 0)
expect(scrollView.minimumZoomScale) == 0
}
it("should accept changes from bindings to its maximum zoom scale value") {
scrollView.maximumZoomScale = 0
let (pipeSignal, observer) = Signal<CGFloat, NoError>.pipe()
scrollView.reactive.maximumZoomScale <~ SignalProducer(pipeSignal)
observer.send(value: 42)
expect(scrollView.maximumZoomScale) == 42
observer.send(value: 0)
expect(scrollView.maximumZoomScale) == 0
}
it("should accept changes from bindings to its scrolls to top state") {
scrollView.scrollsToTop = true
let (pipeSignal, observer) = Signal<Bool, NoError>.pipe()
scrollView.reactive.scrollsToTop <~ SignalProducer(pipeSignal)
observer.send(value: true)
expect(scrollView.scrollsToTop) == true
observer.send(value: false)
expect(scrollView.scrollsToTop) == false
}
}
}
| gpl-3.0 | d83efe30cea3570f19a5aa118e112ab4 | 30.258065 | 97 | 0.736068 | 4.071429 | false | false | false | false |
leizh007/HiPDA | HiPDA/HiPDA/General/Categories/String+Emoji.swift | 1 | 3101 | //
// String+Emoji.swift
// HiPDA
//
// Created by leizh007 on 2017/6/15.
// Copyright © 2017年 HiPDA. All rights reserved.
//
import Foundation
// https://stackoverflow.com/questions/30757193/find-out-if-character-in-string-is-emoji
extension UnicodeScalar {
var isEmoji: Bool {
switch value {
case 0x1F600...0x1F64F, // Emoticons
0x1F300...0x1F5FF, // Misc Symbols and Pictographs
0x1F680...0x1F6FF, // Transport and Map
0x2600...0x26FF, // Misc symbols
0x2700...0x27BF, // Dingbats
0xFE00...0xFE0F, // Variation Selectors
0x1F900...0x1F9FF, // Supplemental Symbols and Pictographs
65024...65039, // Variation selector
8400...8447: // Combining Diacritical Marks for Symbols
return true
default: return false
}
}
var isZeroWidthJoiner: Bool {
return value == 8205
}
}
extension String {
var glyphCount: Int {
let richText = NSAttributedString(string: self)
let line = CTLineCreateWithAttributedString(richText)
return CTLineGetGlyphCount(line)
}
var isSingleEmoji: Bool {
return glyphCount == 1 && containsEmoji
}
var containsEmoji: Bool {
return unicodeScalars.contains { $0.isEmoji }
}
var containsOnlyEmoji: Bool {
return !isEmpty
&& !unicodeScalars.contains(where: {
!$0.isEmoji
&& !$0.isZeroWidthJoiner
})
}
// The next tricks are mostly to demonstrate how tricky it can be to determine emoji's
// If anyone has suggestions how to improve this, please let me know
var emojiString: String {
return emojiScalars.map { String($0) }.reduce("", +)
}
var emojis: [String] {
var scalars: [[UnicodeScalar]] = []
var currentScalarSet: [UnicodeScalar] = []
var previousScalar: UnicodeScalar?
for scalar in emojiScalars {
if let prev = previousScalar, !prev.isZeroWidthJoiner && !scalar.isZeroWidthJoiner {
scalars.append(currentScalarSet)
currentScalarSet = []
}
currentScalarSet.append(scalar)
previousScalar = scalar
}
scalars.append(currentScalarSet)
return scalars.map { $0.map{ String($0) } .reduce("", +) }
}
fileprivate var emojiScalars: [UnicodeScalar] {
var chars: [UnicodeScalar] = []
var previous: UnicodeScalar?
for cur in unicodeScalars {
if let previous = previous, previous.isZeroWidthJoiner && cur.isEmoji {
chars.append(previous)
chars.append(cur)
} else if cur.isEmoji {
chars.append(cur)
}
previous = cur
}
return chars
}
}
| mit | dc0627b64a4c09ccc325c64d43f5b134 | 25.93913 | 96 | 0.54164 | 4.901899 | false | false | false | false |
davejlin/treehouse | swift/swift3/RestaurantReviews/RestaurantReviews/YelpSearchController.swift | 1 | 7349 | //
// YelpSearchController.swift
// RestaurantReviews
//
// Created by Pasan Premaratne on 5/9/17.
// Copyright © 2017 Treehouse. All rights reserved.
//
import UIKit
import MapKit
class YelpSearchController: UIViewController {
// MARK: - Properties
let searchController = UISearchController(searchResultsController: nil)
@IBOutlet weak var tableView: UITableView!
@IBOutlet weak var mapView: MKMapView!
let dataSource = YelpSearchResultsDataSource()
lazy var locationManager: LocationManager = {
return LocationManager(delegate: self, permissionsDelegate: nil)
}()
lazy var client: YelpClient = {
let yelpAccount = YelpAccount.loadFromKeychain()
let oauthToken = yelpAccount!.accessToken
return YelpClient(oauthToken: oauthToken)
}()
var coordinate: Coordinate? {
didSet {
if let coordinate = coordinate {
showNearbyRestaurants(at: coordinate)
}
}
}
let queue = OperationQueue()
var isAuthorized: Bool {
let isAuthorizedWithYelpToken = YelpAccount.isAuthorized
let isAuthorizedForLocation = LocationManager.isAuthorized
return isAuthorizedWithYelpToken && isAuthorizedForLocation
}
override func viewDidLoad() {
super.viewDidLoad()
setupSearchBar()
setupTableView()
}
override func viewDidAppear(_ animated: Bool) {
if isAuthorized {
locationManager.requestLocation()
} else {
checkPermissions()
}
}
// MARK: - Table View
func setupTableView() {
self.tableView.dataSource = dataSource
self.tableView.delegate = self
}
func showNearbyRestaurants(at coordinate: Coordinate) {
client.search(withTerm: "", at: coordinate) { [weak self] result in
switch result {
case .success(let businesses):
self?.dataSource.update(with: businesses)
self?.tableView.reloadData()
let annotations: [MKPointAnnotation] = businesses.map { business in
let point = MKPointAnnotation()
point.coordinate = CLLocationCoordinate2D(latitude: business.location.latitude, longitude: business.location.longitude)
point.title = business.name
point.subtitle = business.isClosed ? "Closed" : "Open"
return point
}
self?.mapView.addAnnotations(annotations)
case .failure(let error):
print(error)
}
}
}
// MARK: - Search
func setupSearchBar() {
self.navigationItem.titleView = searchController.searchBar
searchController.dimsBackgroundDuringPresentation = false
searchController.hidesNavigationBarDuringPresentation = false
searchController.searchResultsUpdater = self
}
// MARK: - Permissions
/// Checks (1) if the user is authenticated against the Yelp API and has an OAuth
/// token and (2) if the user has authorized location access for whenInUse tracking.
func checkPermissions() {
let isAuthorizedWithToken = YelpAccount.isAuthorized
let isAuthorizedForLocation = LocationManager.isAuthorized
let permissionsController = PermissionsController(isAuthorizedForLocation: isAuthorizedForLocation, isAuthorizedWithToken: isAuthorizedWithToken)
present(permissionsController, animated: true, completion: nil)
}
}
// MARK: - UITableViewDelegate
extension YelpSearchController: UITableViewDelegate {
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
let business = dataSource.object(at: indexPath)
let detailsOperation = YelpBusinessDetailsOperation(business: business, client: self.client)
let reviewsOperation = YelpBusinessReviewsOperation(business: business, client: client)
reviewsOperation.addDependency(detailsOperation)
reviewsOperation.completionBlock = {
DispatchQueue.main.async {
self.dataSource.update(business, at: indexPath)
self.performSegue(withIdentifier: "showBusiness", sender: nil)
}
}
queue.addOperation(detailsOperation)
queue.addOperation(reviewsOperation)
}
}
// MARK: - Search Results
extension YelpSearchController: UISearchResultsUpdating {
func updateSearchResults(for searchController: UISearchController) {
guard let searchTerm = searchController.searchBar.text, let coordinate = coordinate else { return }
if !searchTerm.isEmpty {
client.search(withTerm: searchTerm, at: coordinate) { [weak self] result in
switch result {
case .success(let businesses):
self?.dataSource.update(with: businesses)
self?.tableView.reloadData()
self?.mapView.removeAnnotations(self!.mapView.annotations)
let annotations: [MKPointAnnotation] = businesses.map { business in
let point = MKPointAnnotation()
point.coordinate = CLLocationCoordinate2D(latitude: business.location.latitude, longitude: business.location.longitude)
point.title = business.name
point.subtitle = business.isClosed ? "Closed" : "Open"
return point
}
self?.mapView.addAnnotations(annotations)
case .failure(let error):
print(error)
}
}
}
}
}
// MARK: - Navigation
extension YelpSearchController {
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
if segue.identifier == "showBusiness" {
if let indexPath = tableView.indexPathForSelectedRow {
let business = dataSource.object(at: indexPath)
let detailController = segue.destination as! YelpBusinessDetailController
detailController.business = business
detailController.dataSource.updateData(business.reviews)
}
}
}
}
// MARK: - Location Manager Delegate
extension YelpSearchController: LocationManagerDelegate {
func obtainedCoordinates(_ coordinate: Coordinate) {
self.coordinate = coordinate
adjustMap(with: coordinate)
}
func failedWithError(_ error: LocationError) {
print(error)
}
}
// MARK: - MapKit
extension YelpSearchController {
func adjustMap(with coordinate: Coordinate) {
let coordinate2D = CLLocationCoordinate2D(latitude: coordinate.latitude, longitude: coordinate.longitude)
let span = MKCoordinateRegionMakeWithDistance(coordinate2D, 2500, 2500).span
let region = MKCoordinateRegion(center: coordinate2D, span: span)
mapView.setRegion(region, animated: true)
}
}
| unlicense | 7b77658e5563a628f9b4c93cd71449db | 32.552511 | 153 | 0.617039 | 5.902008 | false | false | false | false |
gottsohn/ios-swift-boiler | IOSSwiftBoilerTests/WebViewControllerTests.swift | 1 | 2422 | //
// WebViewControllerTests.swift
// IOSSwiftBoiler
//
// Created by Godson Ukpere on 3/17/16.
// Copyright © 2016 Godson Ukpere. All rights reserved.
//
import XCTest
@testable import IOSSwiftBoiler
class WebViewControllerTests: XCTestCase {
var webViewController:WebViewController!
var timer:NSTimer!
var asyncExpectation:XCTestExpectation!
override func setUp() {
super.setUp()
webViewController = UIStoryboard(name: "Main", bundle: nil).instantiateViewControllerWithIdentifier(Const.ID_WEB_VIEW_CONTROLLER) as! WebViewController
}
override func tearDown() {
// Put teardown code here. This method is called after the invocation of each test method in the class.
webViewController = nil
super.tearDown()
}
func testViews() {
XCTAssertNil(webViewController.webView)
XCTAssertNil(webViewController.progressView)
_ = webViewController.view
XCTAssertNotNil(webViewController.webView)
XCTAssertNotNil(webViewController.progressView)
}
func testWebViewNoLoad() {
XCTAssertNil(webViewController.url)
XCTAssertNil(webViewController.labelText)
_ = webViewController.view
XCTAssertEqual(webViewController.progressView.progress, 0.0)
}
func testWebViewLoad() {
asyncExpectation = expectationWithDescription("server responded")
XCTAssertNil(webViewController.url)
XCTAssertNil(webViewController.labelText)
webViewController.url = "http://blog.godson.com.ng"
_ = webViewController.view
timer = NSTimer.scheduledTimerWithTimeInterval(10, target: self, selector: #selector(WebViewControllerTests.checkProgress), userInfo: nil, repeats: false)
waitForExpectationsWithTimeout(15, handler: nil)
}
func checkProgress() {
XCTAssertNotNil(webViewController.progressView)
XCTAssert(webViewController.progressView.hidden, "Progress View should be hidden")
XCTAssertEqual(webViewController.progressView.progress, 1.0)
timer.invalidate()
asyncExpectation.fulfill()
}
func testPerformanceExample() {
// This is an example of a performance test case.
self.measureBlock {
// Put the code you want to measure the time of here.
}
}
}
| mit | 272046dca3435f0c36bec7c5f30295a1 | 31.28 | 162 | 0.677406 | 5.391982 | false | true | false | false |
salesforce-ux/design-system-ios | Demo-Swift/slds-sample-app/MainListViewController.swift | 1 | 5475 | // Copyright (c) 2015-present, salesforce.com, inc. All rights reserved
// Licensed under BSD 3-Clause - see LICENSE.txt or git.io/sfdc-license
import UIKit
class MainListViewController: UITableViewController {
var footerHeight : CGFloat = 200.0
var tableData : [(name:String, cell:UITableViewCell.Type, controller:UIViewController.Type)] {
return [("DemoCell", DemoCell.self, DemoViewController.self),
("LibraryCell", LibraryCell.self, LibraryListViewController.self),
("AboutCell", AboutCell.self, UIViewController.self)]
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override var preferredStatusBarStyle: UIStatusBarStyle {
return .lightContent
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override func viewDidLoad() {
for item in self.tableData {
self.tableView.register(item.cell, forCellReuseIdentifier: item.name)
}
self.view.backgroundColor = UIColor.sldsBackgroundColor(.colorBackgroundRowSelected)
self.tableView.separatorStyle = .none
self.navigationController?.navigationBar.isTranslucent = false
self.navigationController?.navigationBar.tintColor = UIColor.sldsTextColor(.colorTextButtonBrand)
self.navigationController?.navigationBar.barTintColor = UIColor.sldsFill(.brandActive)
self.navigationController?.navigationBar.backIndicatorImage = UIImage.sldsUtilityIcon(.chevronleft, withSize:SLDSSquareIconUtilityMedium)
self.navigationController?.navigationBar.backIndicatorTransitionMaskImage = UIImage.sldsUtilityIcon(.chevronleft,
withSize: SLDSSquareIconUtilityMedium).withAlignmentRectInsets(UIEdgeInsetsMake(0, 0, -1, 0))
self.navigationController?.navigationBar.titleTextAttributes = [NSForegroundColorAttributeName: UIColor.white,
NSFontAttributeName: UIFont.sldsFont(.regular, with: .medium)]
self.title = "Lightning Design System"
self.tableView.alwaysBounceVertical = false
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
let rowHeight = (self.view.frame.height - tableView.contentInset.top) / CGFloat(tableData.count)
if indexPath.row < tableData.count - 1 {
return rowHeight + 70
}
return rowHeight - 140
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override func numberOfSections(in tableView: UITableView) -> Int {
return 1
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return tableData.count
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: tableData[indexPath.row].name)
return cell!
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override func tableView(_ tableView: UITableView, willSelectRowAt indexPath: IndexPath) -> IndexPath? {
if indexPath.row == tableData.count - 1 {
return nil
}
return indexPath
}
//––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
let controllerClass = tableData[indexPath.row].controller
let controller = controllerClass.init()
self.navigationController?.show(controller, sender: self)
}
}
| bsd-3-clause | 2cc3ee2ffa709db8e8426e21e5e79445 | 43.03125 | 201 | 0.54625 | 6.752396 | false | false | false | false |
kzaher/RxSwift | RxCocoa/macOS/NSTextField+Rx.swift | 7 | 2690 | //
// NSTextField+Rx.swift
// RxCocoa
//
// Created by Krunoslav Zaher on 5/17/15.
// Copyright © 2015 Krunoslav Zaher. All rights reserved.
//
#if os(macOS)
import Cocoa
import RxSwift
/// Delegate proxy for `NSTextField`.
///
/// For more information take a look at `DelegateProxyType`.
open class RxTextFieldDelegateProxy
: DelegateProxy<NSTextField, NSTextFieldDelegate>
, DelegateProxyType
, NSTextFieldDelegate {
/// Typed parent object.
public weak private(set) var textField: NSTextField?
/// Initializes `RxTextFieldDelegateProxy`
///
/// - parameter textField: Parent object for delegate proxy.
init(textField: NSTextField) {
self.textField = textField
super.init(parentObject: textField, delegateProxy: RxTextFieldDelegateProxy.self)
}
public static func registerKnownImplementations() {
self.register { RxTextFieldDelegateProxy(textField: $0) }
}
fileprivate let textSubject = PublishSubject<String?>()
// MARK: Delegate methods
open func controlTextDidChange(_ notification: Notification) {
let textField: NSTextField = castOrFatalError(notification.object)
let nextValue = textField.stringValue
self.textSubject.on(.next(nextValue))
_forwardToDelegate?.controlTextDidChange?(notification)
}
// MARK: Delegate proxy methods
/// For more information take a look at `DelegateProxyType`.
open class func currentDelegate(for object: ParentObject) -> NSTextFieldDelegate? {
object.delegate
}
/// For more information take a look at `DelegateProxyType`.
open class func setCurrentDelegate(_ delegate: NSTextFieldDelegate?, to object: ParentObject) {
object.delegate = delegate
}
}
extension Reactive where Base: NSTextField {
/// Reactive wrapper for `delegate`.
///
/// For more information take a look at `DelegateProxyType` protocol documentation.
public var delegate: DelegateProxy<NSTextField, NSTextFieldDelegate> {
RxTextFieldDelegateProxy.proxy(for: self.base)
}
/// Reactive wrapper for `text` property.
public var text: ControlProperty<String?> {
let delegate = RxTextFieldDelegateProxy.proxy(for: self.base)
let source = Observable.deferred { [weak textField = self.base] in
delegate.textSubject.startWith(textField?.stringValue)
}.take(until: self.deallocated)
let observer = Binder(self.base) { (control, value: String?) in
control.stringValue = value ?? ""
}
return ControlProperty(values: source, valueSink: observer.asObserver())
}
}
#endif
| mit | 69b85eef87e2320ebf8595a7f281c4f7 | 29.908046 | 99 | 0.686872 | 5.141491 | false | false | false | false |
meetkei/KxUI | KxUI/View/Button/KUUnderlineLabelButton.swift | 1 | 1959 | //
// Copyright (c) 2016 Keun young Kim <[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
@IBDesignable open class KUUnderlineLabelButton: UIButton {
open override func prepareForInterfaceBuilder() {
setupView()
}
open override func awakeFromNib() {
super.awakeFromNib()
setupView()
}
open override func layoutSubviews() {
super.layoutSubviews()
setupView()
}
func setupView() {
if let _ = title(for: .normal), let label = titleLabel {
var frame = label.frame
frame.origin.y = frame.maxY
frame.size.height = 0.5
let view = UIView(frame: frame)
view.backgroundColor = titleColor(for: .normal)
view.isUserInteractionEnabled = false
addSubview(view)
}
}
}
| mit | 3aed961a1f13f0e06efe72a93ee59ca9 | 33.368421 | 81 | 0.665646 | 4.697842 | false | false | false | false |
mrdepth/EVEUniverse | Legacy/Neocom/Neocom/ZKillboardInteractor.swift | 2 | 972 | //
// ZKillboardInteractor.swift
// Neocom
//
// Created by Artem Shimanski on 11/15/18.
// Copyright © 2018 Artem Shimanski. All rights reserved.
//
import Foundation
import Futures
import CloudData
class ZKillboardInteractor: TreeInteractor {
typealias Presenter = ZKillboardPresenter
typealias Content = Void
weak var presenter: Presenter?
required init(presenter: Presenter) {
self.presenter = presenter
}
var api = Services.api.current
func load(cachePolicy: URLRequest.CachePolicy) -> Future<Content> {
return .init(())
}
private var didChangeAccountObserver: NotificationObserver?
func configure() {
didChangeAccountObserver = NotificationCenter.default.addNotificationObserver(forName: .didChangeAccount, object: nil, queue: .main) { [weak self] _ in
_ = self?.presenter?.reload(cachePolicy: .useProtocolCachePolicy).then(on: .main) { presentation in
self?.presenter?.view?.present(presentation, animated: true)
}
}
}
}
| lgpl-2.1 | a06c5dc6821ae8a0eb91abe4ab1ef244 | 25.972222 | 153 | 0.745623 | 4.029046 | false | false | false | false |
RedRoma/Lexis | Code/Lexis/WordViewController+Sharing.swift | 1 | 4687 | //
// WordViewController+Sharing.swift
// Lexis
//
// Created by Wellington Moreno on 9/24/16.
// Copyright © 2016 RedRoma, Inc. All rights reserved.
//
import AromaSwiftClient
import Foundation
import LexisDatabase
import Archeota
import UIKit
/** Determines the size of the card created and shared. */
private let shareSize = CGSize(width: 500, height: 500)
extension WordViewController
{
var isPhone: Bool
{
return UIDevice.current.userInterfaceIdiom == UIUserInterfaceIdiom.phone
}
var isPad: Bool
{
return UIDevice.current.userInterfaceIdiom == UIUserInterfaceIdiom.pad
}
func share(word: LexisWord, in view: UIView, expanded: Bool = true)
{
LOG.info("Sharing word: \(word)")
AromaClient.beginMessage(withTitle: "Sharing Word")
.addBody("Word:").addLine()
.addBody("\(word)")
.withPriority(.medium)
.send()
guard let shareViewController = self.storyboard?.instantiateViewController(withIdentifier: "SimpleShareViewController") as? SimpleShareViewController
else
{
LOG.warn("Could not instantiate ShareViewController")
return
}
shareViewController.word = word
shareViewController.view.frame = CGRect(origin: CGPoint.zero, size: shareSize)
shareViewController.view.setNeedsDisplay()
shareViewController.view.layoutIfNeeded()
guard let image = shareViewController.view.screenshot() else { return }
guard let controller = self.createShareController(word: word, andImage: image, expanded: expanded) else { return }
if self.isPhone
{
self.navigationController?.present(controller, animated: true, completion: nil)
}
else if self.isPad
{
// Change Rect to position Popover
controller.modalPresentationStyle = .popover
guard let popover = controller.popoverPresentationController else { return }
popover.permittedArrowDirections = .any
popover.sourceView = view
self.navigationController?.present(controller, animated: true, completion: nil)
}
}
private func createShareController(word: LexisWord, andImage image: UIImage, expanded: Bool) -> UIActivityViewController?
{
let text: String
if expanded
{
text = word.forms.map() { return $0.capitalizingFirstCharacter() }.joined(separator: ", ")
}
else
{
text = (word.forms.first?.capitalizingFirstCharacter()) ?? ""
}
// let's add a String and an NSURL
let activityViewController = UIActivityViewController(
activityItems: [text, image],
applicationActivities: nil)
activityViewController.completionWithItemsHandler = { (activity, success, items, error) in
let activity = activity?.rawValue ?? ""
if success
{
AromaClient.beginMessage(withTitle:"Lexis Shared")
.withPriority(.high)
.addBody("Word:").addLine()
.addBody(word.description).addLine(2)
.addBody("To Activity: ").addLine()
.addBody("\(activity)")
.send()
}
else if let error = error
{
AromaClient.beginMessage(withTitle:"Lexis Share Failed")
.withPriority(.high)
.addBody("Word:").addLine()
.addBody(word.description).addLine(3)
.addBody("\(error)")
.send()
}
else
{
AromaClient.beginMessage(withTitle:"Lexis Share Canceled")
.withPriority(.low)
.addBody("Word:").addLine()
.addBody(word.description).addLine(3)
.addBody("\(error)")
.send()
}
}
return activityViewController
}
}
fileprivate extension UIView
{
func screenshot() -> UIImage?
{
UIGraphicsBeginImageContextWithOptions(self.frame.size, self.isOpaque, 0.0)
guard let context = UIGraphicsGetCurrentContext() else { return nil }
layer.render(in: context)
let image = UIGraphicsGetImageFromCurrentImageContext()
UIGraphicsEndImageContext()
return image
}
}
| apache-2.0 | bb0f44c91cc779831d23d07779dc9836 | 30.662162 | 157 | 0.567222 | 5.673123 | false | false | false | false |
hooman/swift | test/SourceKit/CursorInfo/cursor_some_type.swift | 4 | 3793 | public protocol Proto {
associatedtype Assoc
func method() -> Assoc
}
public class Base {}
public class Derived: Base, Proto {
public func method() -> Int {}
}
public struct S {
public func foo<T>(x: T) -> some Base & Proto {
return Derived()
}
}
func test(value: S) {
let _ = value.foo(x: 12)
}
// RUN: %sourcekitd-test -req=cursor -pos=13:15 %s -- %s -module-name Test | %FileCheck %s -check-prefix=DECLSITE
// DECLSITE: source.lang.swift.decl.function.method.instance (13:15-13:27)
// DECLSITE-NEXT: foo(x:)
// DECLSITE-NEXT: s:4Test1SV3foo1xQrx_tlF
// DECLSITE-NEXT: source.lang.swift
// DECLSITE-NEXT: <T> (S) -> (T) -> some Base & Proto
// DECLSITE-NEXT: $s1xQrx_tcluD
// DECLSITE-NEXT: <Declaration>public func foo<T>(x: <Type usr=[[T_USR:.*]]>T</Type>) -> some <Type usr=[[Base_USR:.*]]>Base</Type> & <Type usr=[[Proto_USR:.*]]>Proto</Type></Declaration>
// DECLSITE-NEXT: <decl.function.method.instance><syntaxtype.keyword>public</syntaxtype.keyword> <syntaxtype.keyword>func</syntaxtype.keyword> <decl.name>foo</decl.name><<decl.generic_type_param usr=[[T_USR]]><decl.generic_type_param.name>T</decl.generic_type_param.name></decl.generic_type_param>>(<decl.var.parameter><decl.var.parameter.argument_label>x</decl.var.parameter.argument_label>: <decl.var.parameter.type><ref.generic_type_param usr=[[T_USR]]>T</ref.generic_type_param></decl.var.parameter.type></decl.var.parameter>) -> <decl.function.returntype><syntaxtype.keyword>some</syntaxtype.keyword> <ref.class usr=[[Base_USR]]>Base</ref.class> & <ref.protocol usr=[[Proto_USR]]>Proto</ref.protocol></decl.function.returntype></decl.function.method.instance>
// RUN: %sourcekitd-test -req=cursor -pos=13:43 %s -- %s -module-name Test | %FileCheck %s -check-prefix=PROTO_AFTER_SOME
// PROTO_AFTER_SOME: source.lang.swift.ref.protocol (1:17-1:22)
// PROTO_AFTER_SOME-NEXT: Proto
// PROTO_AFTER_SOME-NEXT: s:4Test5ProtoP
// PROTO_AFTER_SOME-NEXT: source.lang.swift
// PROTO_AFTER_SOME-NEXT: Proto.Protocol
// PROTO_AFTER_SOME-NEXT: $s4Test5Proto_pmD
// PROTO_AFTER_SOME-NEXT: <Declaration>public protocol Proto</Declaration>
// PROTO_AFTER_SOME-NEXT: <decl.protocol><syntaxtype.keyword>public</syntaxtype.keyword> <syntaxtype.keyword>protocol</syntaxtype.keyword> <decl.name>Proto</decl.name></decl.protocol>
// RUN: %sourcekitd-test -req=cursor -pos=19:17 %s -- %s -module-name Test | %FileCheck %s -check-prefix=USESITE
// USESITE: source.lang.swift.ref.function.method.instance (13:15-13:27)
// USESITE-NEXT: foo(x:)
// USESITE-NEXT: s:4Test1SV3foo1xQrx_tlF
// USESITE-NEXT: source.lang.swift
// USESITE-NEXT: <T> (S) -> (T) -> some Base & Proto
// USESITE-NEXT: $s1xQrx_tcluD
// USESITE-NEXT: <Container>$s4Test1SVD</Container>
// USESITE-NEXT: <Declaration>public func foo<T>(x: <Type usr="s:4Test1SV3foo1xQrx_tlFQO1Txmfp">T</Type>) -> some <Type usr=[[Base_USR:.*]]>Base</Type> & <Type usr=[[Proto_USR:.*]]>Proto</Type></Declaration>
// USESITE-NEXT: <decl.function.method.instance><syntaxtype.keyword>public</syntaxtype.keyword> <syntaxtype.keyword>func</syntaxtype.keyword> <decl.name>foo</decl.name><<decl.generic_type_param usr="s:4Test1SV3foo1xQrx_tlFQO1Txmfp"><decl.generic_type_param.name>T</decl.generic_type_param.name></decl.generic_type_param>>(<decl.var.parameter><decl.var.parameter.argument_label>x</decl.var.parameter.argument_label>: <decl.var.parameter.type><ref.generic_type_param usr="s:4Test1SV3foo1xQrx_tlFQO1Txmfp">T</ref.generic_type_param></decl.var.parameter.type></decl.var.parameter>) -> <decl.function.returntype><syntaxtype.keyword>some</syntaxtype.keyword> <ref.class usr=[[Base_USR]]>Base</ref.class> & <ref.protocol usr=[[Proto_USR]]>Proto</ref.protocol></decl.function.returntype></decl.function.method.instance>
| apache-2.0 | 2946920a674758d4237c1a160539320a | 73.372549 | 824 | 0.723438 | 3.012708 | false | true | false | false |
swipe-org/swipe | core/SwipePage.swift | 2 | 28798 | //
// SwipePage.swift
// Swipe
//
// Created by satoshi on 6/3/15.
// Copyright (c) 2015 Satoshi Nakajima. All rights reserved.
//
#if os(OSX)
import Cocoa
import AVFoundation
#else
import UIKit
import AVFoundation
import MediaPlayer
#endif
extension UIResponder {
private weak static var _currentFirstResponder: UIResponder? = nil
public class func currentFirstResponder() -> UIResponder? {
UIResponder._currentFirstResponder = nil
UIApplication.shared.sendAction(#selector(UIResponder.findFirstResponder(sender:)), to: nil, from: nil, for: nil)
return UIResponder._currentFirstResponder
}
@objc internal func findFirstResponder(sender: Any) {
UIResponder._currentFirstResponder = self
}
}
private func MyLog(_ text:String, level:Int = 0) {
let s_verbosLevel = 0
if level <= s_verbosLevel {
print(text)
}
}
protocol SwipePageDelegate: NSObjectProtocol {
func dimension(_ page:SwipePage) -> CGSize
func scale(_ page:SwipePage) -> CGSize
func prototypeWith(_ name:String?) -> [String:Any]?
func pageTemplateWith(_ name:String?) -> SwipePageTemplate?
func pathWith(_ name:String?) -> Any?
#if !os(OSX) // REVIEW
func speak(_ utterance:AVSpeechUtterance)
func stopSpeaking()
#endif
func currentPageIndex() -> Int
func parseMarkdown(_ markdowns:[String]) -> NSAttributedString
func baseURL() -> URL?
func voice(_ k:String?) -> [String:Any]
func languageIdentifier() -> String?
func tapped()
}
extension Notification.Name {
static let SwipePageDidStartPlaying = Notification.Name("SwipePageDidStartPlaying")
static let SwipePageDidFinishPlaying = Notification.Name("SwipePageDidFinishPlaying")
static let SwipePageShouldStartAutoPlay = Notification.Name("SwipePageShouldStartAutoPlay")
static let SwipePageShouldPauseAutoPlay = Notification.Name("SwipePageShouldPauseAutoPlay")
}
class SwipePage: SwipeView, SwipeElementDelegate {
// Debugging
static var objectCount = 0
var accessCount = 0
var completionCount = 0
// Public properties
let index:Int
var pageTemplate:SwipePageTemplate?
weak var delegate:SwipePageDelegate!
// Public Lazy Properties
lazy var fixed:Bool = {
let ret = (self.transition != "scroll")
//NSLog("SWPage fixed = \(self.transition) \(ret), \(self.index)")
return self.transition != "scroll"
}()
lazy var replace:Bool = {
return self.transition == "replace"
}()
// Private properties
private var fSeeking = false
private var fEntered = false
private var cPlaying = 0
private var cDebug = 0
private var fPausing = false
private var offsetPaused:CGFloat?
// Private lazy properties
// Private properties allocated in loadView (we need to clean up in unloadView)
#if !os(OSX)
private var utterance:AVSpeechUtterance?
#endif
private var viewVideo:UIView? // Special layer to host auto-play video layers
private var viewAnimation:UIView?
private var aniLayer:CALayer?
private var audioPlayer:AVAudioPlayer?
init(index:Int, info:[String:Any], delegate:SwipePageDelegate) {
self.index = index
self.delegate = delegate
self.pageTemplate = delegate.pageTemplateWith(info["template"] as? String)
if self.pageTemplate == nil {
self.pageTemplate = delegate.pageTemplateWith(info["scene"] as? String)
if self.pageTemplate != nil {
MyLog("SwPage DEPRECATED 'scene'; use 'template'")
}
}
super.init(info: SwipeParser.inheritProperties(info, baseObject: pageTemplate?.pageTemplateInfo))
SwipePage.objectCount += 1
}
func unloadView() {
#if !os(tvOS)
NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillShowNotification, object: nil)
NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillHideNotification, object: nil)
#endif
SwipeTimer.cancelAll()
if let view = self.view {
MyLog("SWPage unloading @\(index)", level: 2)
view.removeFromSuperview()
for c in children {
if let element = c as? SwipeElement {
element.clear() // PARANOIA (extra effort to clean up everything)
}
}
children.removeAll()
self.view = nil
self.viewVideo = nil
self.viewAnimation = nil
#if !os(OSX)
self.utterance = nil
#endif
self.audioPlayer = nil
}
}
deinit {
MyLog("SWPage deinit \(index) \(accessCount) \(completionCount)", level: 1)
if self.autoplay {
NotificationCenter.default.post(name: .SwipePageShouldPauseAutoPlay, object: self)
}
SwipePage.objectCount -= 1
}
static func checkMemoryLeak() {
//assert(SwipePage.objectCount == 0)
if SwipePage.objectCount > 0 {
NSLog("SWPage memory leak detected ###")
}
}
// Private lazy properties
private lazy var backgroundColor:CGColor = {
if let value = self.info["bc"] {
return SwipeParser.parseColor(value)
}
return UIColor.white.cgColor
}()
private lazy var transition:String = {
if let value = self.info["transition"] as? String {
return value
}
return (self.animation == "scroll") ? "replace": "scroll" // default
}()
private lazy var fps:Int = {
if let value = self.info["fps"] as? Int {
return value
}
return 60 // default
}()
private lazy var animation:String = {
if let value = self.info["play"] as? String {
return value
}
if let value = self.info["animation"] as? String {
NSLog("SWPage DEPRECATED 'animation'; use 'play'")
return value
}
return "auto" // default
}()
private lazy var autoplay:Bool = {
return self.animation == "auto" || self.animation == "always"
}()
private lazy var always:Bool = {
return self.animation == "always"
}()
private lazy var scroll:Bool = {
return self.animation == "scroll"
}()
private lazy var vibrate:Bool = {
if let value = self.info["vibrate"] as? Bool {
return value
}
return false
}()
private lazy var duration:CGFloat = {
if let value = self.info["duration"] as? CGFloat {
return value
}
return 0.2
}()
private lazy var fRepeat:Bool = {
if let value = self.info["repeat"] as? Bool {
return value
}
return false
}()
private lazy var rewind:Bool = {
if let value = self.info["rewind"] as? Bool {
return value
}
return false
}()
func setTimeOffsetWhileDragging(_ offset:CGFloat) {
if self.scroll {
fEntered = false // stops the element animation
CATransaction.begin()
CATransaction.setDisableActions(true)
assert(self.viewAnimation != nil, "must have self.viewAnimation")
assert(self.viewVideo != nil, "must have viewVideo")
self.aniLayer?.timeOffset = CFTimeInterval(offset)
for c in children {
if let element = c as? SwipeElement {
element.setTimeOffsetTo(offset)
}
}
CATransaction.commit()
}
}
func willLeave(_ fAdvancing:Bool) {
MyLog("SWPage willLeave @\(index) \(fAdvancing)", level: 2)
#if !os(OSX)
if let _ = self.utterance {
delegate.stopSpeaking()
prepareUtterance() // recreate a new utterance to avoid reusing itt
}
#endif
}
func pause(_ fForceRewind:Bool) {
fPausing = true
if let player = self.audioPlayer {
player.stop()
}
NotificationCenter.default.post(name: .SwipePageShouldPauseAutoPlay, object: self)
// auto rewind
if self.rewind || fForceRewind {
prepareToPlay()
}
}
func didLeave(_ fGoingBack:Bool) {
fEntered = false
self.pause(fGoingBack)
MyLog("SWPage didLeave @\(index) \(fGoingBack)", level: 2)
}
func willEnter(_ fForward:Bool) {
MyLog("SWPage willEnter @\(index) \(fForward)", level: 2)
if self.autoplay && fForward || self.always {
prepareToPlay()
}
if fForward && self.scroll {
playAudio()
}
}
private func playAudio() {
if let player = audioPlayer {
player.currentTime = 0.0
player.play()
}
#if !os(OSX)
if let utterance = self.utterance {
delegate.speak(utterance)
}
if self.vibrate {
AudioServicesPlayAlertSound(SystemSoundID(kSystemSoundID_Vibrate))
}
#endif
}
func didEnter(_ fForward:Bool) {
fEntered = true
accessCount += 1
if fForward && self.autoplay || self.always || self.fRepeat {
autoPlay(false)
} else if self.hasRepeatElement() {
autoPlay(true)
}
MyLog("SWPage didEnter @\(index) \(fForward)", level: 2)
}
func prepare() {
if scroll {
prepareToPlay(index > self.delegate.currentPageIndex())
} else {
if index < self.delegate.currentPageIndex() {
prepareToPlay(rewind)
}
}
}
private func prepareToPlay(_ fForward:Bool = true) {
CATransaction.begin()
CATransaction.setDisableActions(true)
self.aniLayer?.timeOffset = fForward ? 0.0 : 1.0
for c in children {
if let element = c as? SwipeElement {
element.setTimeOffsetTo(fForward ? 0.0 : 1.0)
}
}
CATransaction.commit()
self.offsetPaused = nil
}
func play() {
// REVIEW: Remove this block once we detect the end of speech
if let _ = self.utterance {
delegate.stopSpeaking()
prepareUtterance() // recreate a new utterance to avoid reusing it
}
self.autoPlay(false)
}
private func autoPlay(_ fElementRepeat:Bool) {
fPausing = false
if !fElementRepeat {
playAudio()
NotificationCenter.default.post(name: .SwipePageShouldStartAutoPlay, object: self)
}
assert(self.viewAnimation != nil, "must have self.viewAnimation")
assert(self.viewVideo != nil, "must have viewVideo")
if let offset = self.offsetPaused {
timerTick(offset, fElementRepeat: fElementRepeat)
} else {
timerTick(0.0, fElementRepeat: fElementRepeat)
}
self.cDebug += 1
self.cPlaying += 1
self.didStartPlayingInternal()
}
private func timerTick(_ offset:CGFloat, fElementRepeat:Bool) {
var fElementRepeatNext = fElementRepeat
// NOTE: We don't want to add [unowned self] because the timer will fire anyway.
// During the shutdown sequence, the loop will stop when didLeave was called.
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + Double(Int64(1000 * NSEC_PER_MSEC / UInt64(self.fps))) / Double(NSEC_PER_SEC), execute: {
() -> Void in
var offsetForNextTick:CGFloat?
if self.fEntered && !self.fPausing {
var nextOffset = offset + 1.0 / self.duration / CGFloat(self.fps)
if nextOffset < 1.0 {
offsetForNextTick = nextOffset
} else {
nextOffset = 1.0
if self.fRepeat {
self.playAudio()
offsetForNextTick = 0.0
} else if self.hasRepeatElement() {
offsetForNextTick = 0.0
fElementRepeatNext = true
}
}
CATransaction.begin()
CATransaction.setDisableActions(true)
if !fElementRepeatNext {
self.aniLayer?.timeOffset = CFTimeInterval(nextOffset)
}
for c in self.children {
if let element = c as? SwipeElement {
element.setTimeOffsetTo(nextOffset, fAutoPlay: true)
}
}
CATransaction.commit()
}
if let value = offsetForNextTick {
self.timerTick(value, fElementRepeat: fElementRepeatNext)
} else {
self.offsetPaused = self.fPausing ? offset : nil
self.cPlaying -= 1
self.cDebug -= 1
self.didFinishPlayingInternal()
}
})
}
// Returns the list of URLs of required resouces for this element (including children)
lazy var resourceURLs:[URL:String] = {
var urls = [URL:String]()
let baseURL = self.delegate.baseURL()
for key in ["audio"] {
if let src = self.info[key] as? String,
let url = URL.url(src, baseURL: baseURL) {
urls[url] = ""
}
}
if let elementsInfo = self.info["elements"] as? [[String:Any]] {
let scaleDummy = CGSize(width: 0.1, height: 0.1)
for e in elementsInfo {
let element = SwipeElement(info: e, scale:scaleDummy, parent:self, delegate:self)
for (url, prefix) in element.resourceURLs {
urls[url as URL] = prefix
}
}
}
if let pageTemplate = self.pageTemplate {
for (url, prefix) in pageTemplate.resourceURLs {
urls[url as URL] = prefix
}
}
return urls
}()
lazy var prefetcher:SwipePrefetcher = {
return SwipePrefetcher(urls:self.resourceURLs)
}()
func loadView(_ callback:(()->(Void))?) -> UIView {
MyLog("SWPage loading @\(index)", level: 2)
assert(self.view == nil, "loadView self.view must be nil")
let view = InternalView(wrapper: self, frame: CGRect(x: 0.0, y: 0.0, width: 100.0, height: 100.0))
view.clipsToBounds = true
self.view = view
let viewVideo = UIView(frame: view.bounds)
self.viewVideo = viewVideo
let viewAnimation = UIView(frame: view.bounds)
self.viewAnimation = viewAnimation
#if os(OSX)
let layer = view.makeBackingLayer()
let aniLayer = viewAnimation.makeBackingLayer()
#else
let layer = view.layer
let aniLayer = viewAnimation.layer
#endif
self.aniLayer = aniLayer
let dimension = delegate.dimension(self)
var transform = CATransform3DIdentity
transform.m34 = -1 / dimension.width // default eyePosition is canvas width
if let eyePosition = info["eyePosition"] as? CGFloat {
transform.m34 = -1 / (dimension.width * eyePosition)
}
aniLayer.sublayerTransform = transform
viewVideo.layer.sublayerTransform = transform
view.addSubview(viewVideo)
view.addSubview(viewAnimation)
//view.tag = 100 + index // for debugging only
layer.backgroundColor = self.backgroundColor
if animation != "never" {
aniLayer.speed = 0 // to manually specify the media timing
aniLayer.beginTime = 0 // to manually specify the media timing
aniLayer.fillMode = CAMediaTimingFillMode.forwards
}
#if os(OSX)
viewAnimation.autoresizingMask = [.ViewWidthSizable, .ViewHeightSizable]
#else
viewVideo.autoresizingMask = [.flexibleWidth, .flexibleHeight]
viewAnimation.autoresizingMask = [.flexibleWidth, .flexibleHeight]
#endif
//viewAnimation.backgroundColor = UIColor(red: 0.0, green: 1.0, blue: 0.0, alpha: 0.2)
self.prefetcher.start { (completed:Bool, _:[URL], _:[NSError]) -> Void in
if completed {
if self.view != nil {
// NOTE: We are intentionally ignoring fetch errors (of network resources) here.
if let eventsInfo = self.info["events"] as? [String:Any] {
self.eventHandler.parse(eventsInfo)
}
self.loadSubviews()
callback?()
}
}
}
setupGestureRecognizers()
#if !os(tvOS)
NotificationCenter.default.addObserver(self, selector: #selector(SwipePage.keyboardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(SwipePage.keyboardWillHide(notification:)), name: UIResponder.keyboardWillHideNotification, object: nil)
#endif
if let actions = eventHandler.actionsFor("load") {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) {
self.execute(self, actions: actions)
}
}
return view
}
#if !os(tvOS)
@objc func keyboardWillShow(notification: Notification) {
if let info = notification.userInfo {
if let kbFrame = info[UIResponder.keyboardFrameBeginUserInfoKey] as? CGRect {
if let fr = findFirstResponder() {
let frFrame = fr.view!.frame
let myFrame = self.view!.frame
//let duration = info[UIKeyboardAnimationDurationUserInfoKey] as! NSNumber as NSTimeInterval
//UIView.animateWithDuration(0.25, delay: 0.25, options: UIViewAnimationOptions.CurveEaseInOut, animations: {
self.view!.frame = CGRect(x: 0, y: myFrame.origin.y - max(0, (frFrame.origin.y + frFrame.size.height) - (myFrame.size.height - kbFrame.size.height)), width: myFrame.size.height, height: myFrame.size.height)
// }, completion: nil)
}
}
}
}
@objc func keyboardWillHide(notification: Notification) {
if let _ = notification.userInfo {
if findFirstResponder() != nil {
let myFrame = self.view!.frame
//let duration = info[UIKeyboardAnimationDurationUserInfoKey] as! NSNumber as NSTimeInterval
//UIView.animateWithDuration(0.25, delay: 0.25, options: UIViewAnimationOptions.CurveEaseInOut, animations: {
self.view!.frame = CGRect(x: 0, y: 0, width: myFrame.size.height, height: myFrame.size.height)
// }, completion: nil)
}
}
}
#endif
private func loadSubviews() {
let scale = delegate.scale(self)
let dimension = delegate.dimension(self)
if let value = self.info["audio"] as? String,
let url = URL.url(value, baseURL: self.delegate.baseURL()),
let urlLocal = self.prefetcher.map(url) {
do {
audioPlayer = try AVAudioPlayer(contentsOf: urlLocal)
audioPlayer?.prepareToPlay()
} catch let error as NSError {
NSLog("SWPage audio error \(error)")
}
}
prepareUtterance()
if let elementsInfo = self.info["elements"] as? [[String:Any]] {
for e in elementsInfo {
let element = SwipeElement(info: e, scale:scale, parent:self, delegate:self)
if let subview = element.loadView(dimension) {
if (self.autoplay || !self.scroll) && element.isVideoElement() {
// HACK: video element can not be played normally if it is added to the animation layer, which has the speed property zero.
self.viewVideo!.addSubview(subview)
} else {
self.viewAnimation!.addSubview(subview)
}
children.append(element)
}
} // for e in elementsInfo
}
}
private func prepareUtterance() {
// REVIEW: Disabled for OSX for now
#if !os(OSX)
if let speech = self.info["speech"] as? [String:Any],
let text = parseText(self, info: speech, key: "text") {
let voice = self.delegate.voice(speech["voice"] as? String)
let utterance = AVSpeechUtterance(string: text)
// BCP-47 code
if let lang = voice["lang"] as? String {
// HACK: Work-around an iOS9 bug
// http://stackoverflow.com/questions/30794082/how-do-we-solve-an-axspeechassetdownloader-error-on-ios
// https://forums.developer.apple.com/thread/19079?q=AVSpeechSynthesisVoice
let voices = AVSpeechSynthesisVoice.speechVoices()
var theVoice:AVSpeechSynthesisVoice?
for voice in voices {
//NSLog("SWPage lang=\(voice.language)")
if lang == voice.language {
theVoice = voice
break;
}
}
if let voice = theVoice {
utterance.voice = voice
} else {
NSLog("SWPage Voice for \(lang) is not available (iOS9 bug)")
}
// utterance.voice = AVSpeechSynthesisVoice(language: lang)
}
if let pitch = voice["pitch"] as? Float {
if pitch >= 0.5 && pitch < 2.0 {
utterance.pitchMultiplier = pitch
}
}
if let rate = voice["rate"] as? Float {
if rate >= 0.0 && rate <= 1.0 {
utterance.rate = AVSpeechUtteranceMinimumSpeechRate + (AVSpeechUtteranceDefaultSpeechRate - AVSpeechUtteranceMinimumSpeechRate) * rate
} else if rate > 1.0 && rate <= 2.0 {
utterance.rate = AVSpeechUtteranceDefaultSpeechRate + (AVSpeechUtteranceMaximumSpeechRate - AVSpeechUtteranceDefaultSpeechRate) * (rate - 1.0)
}
}
self.utterance = utterance
}
#endif
}
// <SwipeElementDelegate> method
func addedResourceURLs(_ urls:[URL:String], callback:@escaping () -> Void) {
self.prefetcher.append(urls) { (completed:Bool, _:[URL], _:[NSError]) -> Void in
if completed {
callback()
}
}
}
func prototypeWith(_ name:String?) -> [String:Any]? {
return delegate.prototypeWith(name)
}
// <SwipeElementDelegate> method
func pathWith(_ name:String?) -> Any? {
return delegate.pathWith(name)
}
// <SwipeElementDelegate> method
func shouldRepeat(_ element:SwipeElement) -> Bool {
return fEntered && self.fRepeat
}
// <SwipeElementDelegate> method
func onAction(_ element:SwipeElement) {
if let action = element.action {
MyLog("SWPage onAction \(action)", level: 2)
if action == "play" {
//prepareToPlay()
//autoPlay()
play()
}
}
}
// <SwipeElementDelegate> method
func didStartPlaying(_ element:SwipeElement) {
didStartPlayingInternal()
}
// <SwipeElementDelegate> method
func didFinishPlaying(_ element:SwipeElement, completed:Bool) {
if completed {
completionCount += 1
}
didFinishPlayingInternal()
}
// <SwipeElementDelegate> method
func baseURL() -> URL? {
return delegate.baseURL()
}
// <SwipeElementDelegate> method
func pageIndex() -> Int {
return index
}
// <SwipeElementDelegate> method
func localizedStringForKey(_ key:String) -> String? {
if let strings = self.info["strings"] as? [String:Any],
let texts = strings[key] as? [String:Any] {
return SwipeParser.localizedString(texts, langId: delegate.languageIdentifier())
}
return nil
}
// <SwipeElementDelegate> method
func languageIdentifier() -> String? {
return delegate.languageIdentifier()
}
func parseText(_ originator: SwipeNode, info:[String:Any], key:String) -> String? {
guard let value = info[key] else {
return nil
}
if let text = value as? String {
return text
}
if let ref = value as? [String:Any],
let key = ref["ref"] as? String,
let text = localizedStringForKey(key) {
return text
}
return nil
}
private func didStartPlayingInternal() {
cPlaying += 1
if cPlaying==1 {
//NSLog("SWPage didStartPlaying @\(index)")
NotificationCenter.default.post(name: .SwipePageDidStartPlaying, object: self)
}
}
private func didFinishPlayingInternal() {
assert(cPlaying > 0, "didFinishPlaying going negative! @\(index)")
cPlaying -= 1
if cPlaying == 0 {
NotificationCenter.default.post(name: .SwipePageDidFinishPlaying, object: self)
}
}
#if !os(OSX)
func speak(_ utterance:AVSpeechUtterance) {
delegate.speak(utterance)
}
#endif
func parseMarkdown(_ element:SwipeElement, markdowns:[String]) -> NSAttributedString {
return self.delegate.parseMarkdown(markdowns)
}
func map(_ url:URL) -> URL? {
return self.prefetcher.map(url)
}
func isPlaying() -> Bool {
let fPlaying = cPlaying > 0
//assert(fPlaying == self.isPlayingOld())
return fPlaying
}
/*
private func isPlayingOld() -> Bool {
for element in elements {
if element.isPlaying() {
return true
}
}
return false
}
*/
func hasRepeatElement() -> Bool {
for c in children {
if let element = c as? SwipeElement {
if element.isRepeatElement() {
return true
}
}
}
return false
}
// SwipeView
override func tapped() {
self.delegate.tapped()
}
// SwipeNode
override func getValue(_ originator: SwipeNode, info: [String:Any]) -> Any? {
var name = "*"
if let val = info["id"] as? String {
name = val
}
// first try own page property
if (name == "*" || self.name.caseInsensitiveCompare(name) == .orderedSame) {
if let attribute = info["property"] as? String {
return getPropertyValue(originator, property: attribute)
} else if let attributeInfo = info["property"] as? [String:Any] {
return getPropertiesValue(originator, info: attributeInfo)
}
}
for c in children {
if let e = c as? SwipeElement {
if name == "*" || e.name.caseInsensitiveCompare(name) == .orderedSame {
if let attribute = info["property"] as? String {
return e.getPropertyValue(originator, property: attribute)
} else if let attributeInfo = info["property"] as? [String:Any] {
return e.getPropertiesValue(originator, info: attributeInfo)
}
}
}
}
return nil
}
override func updateElement(_ originator: SwipeNode, name: String, up: Bool, info: [String:Any]) -> Bool {
// Find named element and update
for c in children {
if let e = c as? SwipeElement {
if e.name.caseInsensitiveCompare(name) == .orderedSame {
e.update(originator, info: info)
return true
}
}
}
return false
}
override func appendList(_ originator: SwipeNode, name: String, up: Bool, info: [String : Any]) -> Bool {
// Find named element and update
for c in children {
if let e = c as? SwipeElement {
if e.name.caseInsensitiveCompare(name) == .orderedSame {
e.appendList(originator, info: info)
return true
}
}
}
return false
}
}
| mit | fa3c304ddc458adfe9a983174bd332b8 | 33.447368 | 230 | 0.563199 | 4.904292 | false | false | false | false |
dymx101/BallDown | BallDown/Extension/SKNodeExtension.swift | 1 | 631 | //
// SKNodeExtension.swift
// BallDown
//
// Copyright (c) 2015 ones. All rights reserved.
//
import Foundation
import SpriteKit
extension SKNode {
var bind: AnyObject? {
get {
return self.userData?.objectForKey("@bind")
}
set {
if newValue == nil {
self.userData?.removeObjectForKey("@bind")
}
else {
if self.userData == nil {
self.userData = NSMutableDictionary()
}
self.userData!.setValue(newValue, forKey: "@bind")
}
}
}
} | mit | 151b05098d6531b3d2d103cf3d80e65d | 19.387097 | 66 | 0.478605 | 4.891473 | false | false | false | false |
firebase/quickstart-ios | database/DatabaseExampleSwiftUI/DatabaseExample/Shared/Models/UserViewModel.swift | 1 | 2150 | //
// Copyright (c) 2021 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.
//
import SwiftUI
import FirebaseAuth
class UserViewModel: ObservableObject {
@AppStorage("isSignedIn") var isSignedIn = false
@Published var email = ""
@Published var password = ""
@Published var alert = false
@Published var alertMessage = ""
private func showAlertMessage(message: String) {
alertMessage = message
alert.toggle()
}
func login() {
// check if all fields are inputted correctly
if email.isEmpty || password.isEmpty {
showAlertMessage(message: "Neither email nor password can be empty.")
return
}
// sign in with email and password
Auth.auth().signIn(withEmail: email, password: password) { result, err in
if let err = err {
self.alertMessage = err.localizedDescription
self.alert.toggle()
} else {
self.isSignedIn = true
}
}
}
func signUp() {
// check if all fields are inputted correctly
if email.isEmpty || password.isEmpty {
showAlertMessage(message: "Neither email nor password can be empty.")
return
}
// sign up with email and password
Auth.auth().createUser(withEmail: email, password: password) { result, err in
if let err = err {
self.alertMessage = err.localizedDescription
self.alert.toggle()
} else {
self.login()
}
}
}
func logout() {
do {
try Auth.auth().signOut()
isSignedIn = false
email = ""
password = ""
} catch {
print("Error signing out.")
}
}
}
let user = UserViewModel()
| apache-2.0 | 20b71fac76f689ee828550dc06df042d | 26.564103 | 81 | 0.652093 | 4.282869 | false | false | false | false |
mobgeek/swift | Swift em 4 Semanas/Playgrounds/Semana 3/5-Inicialização.playground/Contents.swift | 2 | 3737 | // Playground - noun: a place where you can play
import UIKit
// Initializers
struct CelsiusTeste {
var temperatura:Double = 35.0
//Uma outra opção seria usar o init() para inicializar temperatura. O resultado seria o mesmo.
// init() {
//
// temperatura = 35.0
//
// }
}
var c = CelsiusTeste()
println("A temperatura padrão é \(c.temperatura)")
//Customizando inicialização - Parâmetros de Inicialização
struct Celsius {
var temperaturaEmCelsius: Double = 0.0
init(deFahrenheit fahrenheit: Double) {
temperaturaEmCelsius = (fahrenheit - 32) / 1.8
}
init(deKelvin kelvin: Double) {
temperaturaEmCelsius = kelvin - 273.15
}
}
//Não esquecer que definindo pontoDeEbulição e pontoDoCongelamento como constantes, todas as propriedades são consideradas constantes, por se tratar de uma estrutura (Tipo Valor)
let pontoDeEbulição = Celsius(deFahrenheit: 212.0)
let pontoDeCongelamento = Celsius(deKelvin: 273.15)
//Quando nomes externos para os parâmetros dos initializers não são informados, Swift irá considerar o nome como local e externo
struct Cor {
let vermelho, verde, azul: Double
init(vermelho: Double, verde: Double, azul: Double) {
self.vermelho = vermelho
self.verde = verde
self.azul = azul
}
init(branco: Double) {
vermelho = branco
verde = branco
azul = branco
}
}
let magenta = Cor(vermelho: 1.0, verde: 0.0, azul: 1.0)
let meioCinza = Cor(branco: 0.5)
//let verdão = Cor(0.0, 1.0, 0.0) //erro, nomes externos não foram informados
//Ignorando o Nome Externo
struct Celsius2 {
var temperaturaEmCelsius: Double = 0.0
//Basta usar o _ antes do parâmetro para não precisar usar mais nome externo
init(_ celsius: Double) {
temperaturaEmCelsius = celsius
}
}
let temperaturaDoCorpo = Celsius2(37.0) //nome externo foi ignorado
//Customizando inciaialização - Propriedades Opcionais
class PerguntaEnquete {
var texto: String
var resposta: String? //inicializada com nil, logo, não é preciso usá-la em algum init
init(texto: String) {
self.texto = texto
}
func pergunta() {
println(texto)
}
}
let perguntaGeek = PerguntaEnquete(texto: "Você se considera um Geek?")
perguntaGeek.pergunta()
perguntaGeek.resposta = "Hm. Acho que sim :-)"
perguntaGeek.resposta! //Lembrando que é preciso forçar o desempacotamento (F.U.)
//Propriedades Constantes:
//mudando a propriedade texto da classe PerguntaEnquete de variável para constante, ela poderá ter seu valor alterado apenas dentro de algum initializer
//Inicializadores Padrão
//Relembrando: Em Estruturas, ao fornecer ou não valores padrão para todas as propriedades, Swift fornece um Incializador de Membro.
//Agora, tanto Classes e Estruturas, ao terem todas as suas propriedades inicializadas com algum valor padrão, Swift fornecerá um Inicializador Padrão para elas. E nas Estruturas além de ter o Inicializador Padrão, terá o de Membro.
//Em Classes
class ListaDeCompras {
var nome: String?
var quantidade = 1
var comprado = false
}
var item = ListaDeCompras() //Inicializador Padrão
// Em estruturas
struct Resolução {
var largura = 0.0
var altura = 0.0
}
var fullHD1 = Resolução(largura: 1920, altura: 1080) //Inicializador de Membro
var novaResolução = Resolução() //Inicializador Padrão
| mit | 97bd94b70d533c2aa0c4d378e36dbb28 | 19.9375 | 232 | 0.654817 | 3.479698 | false | false | false | false |
DylanModesitt/Picryption_iOS | Picryption/AppDelegate.swift | 1 | 4771 | //
// AppDelegate.swift
// Picryption
//
// Created by Dylan Modesitt on 4/21/17.
// Copyright © 2017 Modesitt Systems. All rights reserved.
//
import UIKit
import CoreData
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
func applicationWillResignActive(_ application: UIApplication) {
// Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
// Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game.
}
func applicationDidEnterBackground(_ application: UIApplication) {
// Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
// If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}
func applicationWillEnterForeground(_ application: UIApplication) {
// Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
}
func applicationDidBecomeActive(_ application: UIApplication) {
// Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}
func applicationWillTerminate(_ application: UIApplication) {
// Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
// Saves changes in the application's managed object context before the application terminates.
if #available(iOS 10.0, *) {
self.saveContext()
} else {
// Fallback on earlier versions
}
}
// MARK: - Core Data stack
@available(iOS 10.0, *)
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: "Picryption")
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
@available(iOS 10.0, *)
func saveContext () {
let context = persistentContainer.viewContext
if context.hasChanges {
do {
try context.save()
} catch {
// Replace this implementation with code to handle the error appropriately.
// fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
let nserror = error as NSError
fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
}
}
}
}
| mit | 29e8f9d893d748453a32cf014fd64d0b | 47.181818 | 285 | 0.678197 | 5.733173 | false | false | false | false |
rlasante/Swift-Trip-Tracker | LocationTracker/TripManager.swift | 1 | 4691 | //
// LocationManager.swift
// LocationTracker
//
// Created by Ryan LaSante on 11/1/15.
// Copyright © 2015 rlasante. All rights reserved.
//
import UIKit
import CoreData
import CoreLocation
import ReactiveCocoa
class TripManager: NSObject, CLLocationManagerDelegate {
static let sharedInstance = TripManager()
private let (speedSignal, speedObserver) = Signal<CLLocationSpeed, NoError>.pipe()
private let (tripSignal, tripObserver) = Signal<Trip, NoError>.pipe()
var trips = [Trip]()
var currentTrip: Trip?
private lazy var locationManager: CLLocationManager = {
let manager = CLLocationManager()
manager.delegate = self
manager.desiredAccuracy = kCLLocationAccuracyBest
manager.requestWhenInUseAuthorization()
return manager
}()
private lazy var managedObjectContext: NSManagedObjectContext = {
let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
return appDelegate.managedObjectContext
}()
private func saveContext() {
let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
appDelegate.saveContext()
}
private override init() {
super.init()
loadSavedTrips()
tripSignal.observeNext {[weak self] (trip) -> () in
self?.trips.append(trip)
self?.saveTrip(trip)
}
}
func startTracking() {
guard CLLocationManager.locationServicesEnabled() else {
return
}
currentTrip = Trip()
locationManager.startUpdatingLocation()
}
func stopTracking() {
guard CLLocationManager.locationServicesEnabled() else {
return
}
locationManager.stopUpdatingLocation()
if let trip = currentTrip where !trip.locations.isEmpty {
tripObserver.sendNext(trip)
}
currentTrip = nil
speedObserver.sendNext(0)
}
func currentSpeedSignal() -> Signal<CLLocationSpeed, NoError> {
// Returns the signal that sends the current speed in meters per second
return speedSignal
}
func completedTripSignal() -> Signal<Trip, NoError> {
return tripSignal
}
private func loadSavedTrips() {
let fetchRequest = NSFetchRequest(entityName: "Trip")
do {
let results = try self.managedObjectContext.executeFetchRequest(fetchRequest)
let tripObjects = results as! [NSManagedObject]
for tripObject in tripObjects {
trips.append(Trip(object: tripObject))
}
} catch let error as NSError {
print("Unable to fetch \(error). \(error.userInfo)")
}
}
private func saveTrip(trip: Trip) {
let tripEntity = NSEntityDescription.entityForName("Trip", inManagedObjectContext: self.managedObjectContext)
let tripObject = NSManagedObject(entity: tripEntity!, insertIntoManagedObjectContext: self.managedObjectContext)
let locations = getLocationEntities(trip)
if locations.count > 0 {
tripObject.setValue(Set(locations), forKey: "locations")
}
self.saveContext()
}
private func getLocationEntities(trip: Trip) -> [NSManagedObject] {
var managedLocations = [NSManagedObject]()
for location in trip.locations {
let locationEntity = NSEntityDescription.entityForName("Location", inManagedObjectContext: self.managedObjectContext)
let locationObject = NSManagedObject(entity: locationEntity!,
insertIntoManagedObjectContext: self.managedObjectContext)
locationObject.setValue(NSNumber(double: location.altitude), forKey: "altitude")
locationObject.setValue(NSNumber(double: location.course), forKey: "course")
locationObject.setValue(NSNumber(double: location.coordinate.latitude), forKey: "lat")
locationObject.setValue(NSNumber(double: location.coordinate.longitude), forKey: "long")
locationObject.setValue(NSNumber(double: location.horizontalAccuracy), forKey: "horizontalAccuracy")
locationObject.setValue(NSNumber(double: location.verticalAccuracy), forKey: "verticalAccuracy")
locationObject.setValue(NSNumber(double: location.speed), forKey: "speed")
locationObject.setValue(location.timestamp, forKey: "timestamp")
managedLocations.append(locationObject)
}
return managedLocations
}
func locationManager(manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
if let trip = currentTrip {
let trimmedLocations = locations.filter { (location) -> Bool in
let tripBeforeLocation = trip.createdAt.compare(location.timestamp) == .OrderedAscending
return tripBeforeLocation && location.horizontalAccuracy < 50.0
}
trip.addLocations(trimmedLocations)
if !trimmedLocations.isEmpty {
speedObserver.sendNext(trimmedLocations.last!.speed)
}
}
}
}
| mit | a33dbd9e8de8b523c05017e8ac15fa6b | 33.485294 | 123 | 0.726652 | 5.048439 | false | false | false | false |
joe22499/JKCalendar | Sources/JKCalendarScrollView.swift | 1 | 6964 | //
// JKCalendarScrollView.swift
//
// Copyright © 2017 Joe Ciou. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
import UIKit
public class JKCalendarScrollView: UIScrollView {
public let calendar: JKCalendar = JKCalendar(frame: CGRect.zero)
public weak var nativeDelegate: UIScrollViewDelegate?
public var startsCollapsed: Bool = false
private var first = true
private var rotating = false
override public init(frame: CGRect) {
super.init(frame: frame)
setup()
}
required public init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
setup()
}
func setup() {
super.delegate = self
calendar.interactionObject = self
NotificationCenter.default.addObserver(self, selector: #selector(rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
}
override open func layoutSubviews() {
super.layoutSubviews()
layoutSubviewsHandler()
}
func layoutSubviewsHandler() {
if first || rotating{
var calendarSize: CGSize!
let footerHeight = calendar.delegate?.heightOfFooterView?(in: calendar) ?? 0
if frame.width > frame.height {
let height = ((calendar.isTopViewDisplayed ? calendar.topView.frame.height: 0) + calendar.weekView.frame.height + frame.width * 0.35 + footerHeight).rounded()
calendarSize = CGSize(width: frame.width,
height: height)
} else {
let height = ((calendar.isTopViewDisplayed ? calendar.topView.frame.height: 0) + calendar.weekView.frame.height + frame.width * 0.65 + footerHeight).rounded()
calendarSize = CGSize(width: frame.width,
height: height)
}
calendar.frame = CGRect(x: 0,
y: frame.origin.y,
width: calendarSize.width,
height: calendarSize.height)
contentInset = UIEdgeInsets(top: calendarSize.height,
left: 0,
bottom: 0,
right: 0)
scrollIndicatorInsets = UIEdgeInsets(top: calendarSize.height,
left: 0,
bottom: 0,
right: 0)
contentOffset = CGPoint(x: 0, y: -calendarSize.height)
rotating = false
if first {
superview?.insertSubview(calendar, aboveSubview: self)
first = false
}
}
}
@objc
func rotated() {
if !first {
rotating = true
layoutSubviewsHandler()
}
}
}
extension JKCalendarScrollView: UIScrollViewDelegate {
public func scrollViewDidScroll(_ scrollView: UIScrollView) {
var value = calendar.frame.height + contentOffset.y
if value > calendar.collapsedMaximum {
value = calendar.collapsedMaximum
} else if value < 0 {
value = 0
}
calendar.collapsedValue = value
nativeDelegate?.scrollViewDidScroll?(scrollView)
}
public func scrollViewDidZoom(_ scrollView: UIScrollView) {
nativeDelegate?.scrollViewDidZoom?(scrollView)
}
public func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
nativeDelegate?.scrollViewWillBeginDragging?(scrollView)
}
public func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
let value = (targetContentOffset.pointee.y + calendar.bounds.height) / calendar.collapsedMaximum
if value < 1 {
targetContentOffset.pointee.y = (value > 0.5 ? calendar.collapsedMaximum : 0) - calendar.bounds.height
}
nativeDelegate?.scrollViewWillEndDragging?(scrollView, withVelocity: velocity, targetContentOffset: targetContentOffset)
}
public func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
nativeDelegate?.scrollViewDidEndDragging?(scrollView, willDecelerate: decelerate)
}
public func scrollViewWillBeginDecelerating(_ scrollView: UIScrollView) {
nativeDelegate?.scrollViewWillBeginDecelerating?(scrollView)
}
public func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
nativeDelegate?.scrollViewDidEndDecelerating?(scrollView)
}
public func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
nativeDelegate?.scrollViewDidEndScrollingAnimation?(scrollView)
}
public func viewForZooming(in scrollView: UIScrollView) -> UIView? {
return nativeDelegate?.viewForZooming?(in: scrollView)
}
public func scrollViewWillBeginZooming(_ scrollView: UIScrollView, with view: UIView?) {
nativeDelegate?.scrollViewWillBeginZooming?(scrollView, with: view)
}
public func scrollViewDidEndZooming(_ scrollView: UIScrollView, with view: UIView?, atScale scale: CGFloat) {
nativeDelegate?.scrollViewDidEndZooming?(scrollView, with: view, atScale: scale)
}
public func scrollViewShouldScrollToTop(_ scrollView: UIScrollView) -> Bool {
return nativeDelegate?.scrollViewShouldScrollToTop?(scrollView) != nil ? nativeDelegate!.scrollViewShouldScrollToTop!(scrollView): true
}
public func scrollViewDidScrollToTop(_ scrollView: UIScrollView) {
nativeDelegate?.scrollViewDidScrollToTop?(scrollView)
}
}
| mit | f8afad54f25e7f66abeb93a1f634d21c | 38.788571 | 174 | 0.633491 | 5.735585 | false | false | false | false |
bjarkehs/Rex | Source/UIKit/UIBarButtonItem.swift | 1 | 1168 | //
// UIBarButtonItem.swift
// Rex
//
// Created by Bjarke Hesthaven Søndergaard on 24/07/15.
// Copyright (c) 2015 Neil Pankey. All rights reserved.
//
import ReactiveCocoa
import UIKit
extension UIBarButtonItem {
/// Exposes a property that binds an action to bar button item. The action is set as
/// a target of the button. When property changes occur the previous action is
/// overwritten. This also binds the enabled state of the action to the `rex_enabled`
/// property on the button.
public var rex_action: MutableProperty<CocoaAction> {
return associatedObject(self, key: &actionKey) { [weak self] _ in
let initial = CocoaAction.rex_disabled
let property = MutableProperty(initial)
property.producer.start(Observer(next: { next in
self?.target = next
self?.action = CocoaAction.selector
}))
if let strongSelf = self {
strongSelf.rex_enabled <~ property.producer.flatMap(.Latest) { $0.rex_enabledProducer }
}
return property
}
}
}
private var actionKey: UInt8 = 0
| mit | de1914a70d1846b882f8f828fe6253a2 | 31.416667 | 103 | 0.62982 | 4.540856 | false | false | false | false |
ioscreator/ioscreator | IOSSendEmailTutorial/IOSSendEmailTutorial/ViewController.swift | 1 | 1902 | //
// ViewController.swift
// IOSSendEmailTutorial
//
// Created by Arthur Knopper on 08/02/2020.
// Copyright © 2020 Arthur Knopper. All rights reserved.
//
import UIKit
import MessageUI
class ViewController: UIViewController, MFMailComposeViewControllerDelegate, UITextFieldDelegate, UITextViewDelegate {
@IBOutlet weak var subject: UITextField!
@IBOutlet weak var body: UITextView!
@IBAction func sendMail(_ sender: Any) {
let picker = MFMailComposeViewController()
picker.mailComposeDelegate = self
if let subjectText = subject.text {
picker.setSubject(subjectText)
}
picker.setMessageBody(body.text, isHTML: true)
present(picker, animated: true, completion: nil)
}
override func viewDidLoad() {
super.viewDidLoad()
subject.delegate = self
body.delegate = self
if !MFMailComposeViewController.canSendMail() {
print("Mail services are not available")
return
}
}
// MFMailComposeViewControllerDelegate
// 1
func mailComposeController(_ controller: MFMailComposeViewController, didFinishWith result: MFMailComposeResult, error: Error?) {
dismiss(animated: true, completion: nil)
}
// UITextFieldDelegate
// 2
func textFieldShouldReturn(_ textField: UITextField) -> Bool {
textField.resignFirstResponder()
return true
}
// UITextViewDelegate
// 3
func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
body.text = textView.text
if text == "\n" {
textView.resignFirstResponder()
return false
}
return true
}
}
| mit | e839e79ffa2b1b78905a191745ef3432 | 25.041096 | 133 | 0.607575 | 5.849231 | false | false | false | false |
studyYF/YueShiJia | YueShiJia/YueShiJia/Classes/Home/Models/YFSpecialGoodsItem.swift | 1 | 3890 | //
// YFAdvetiseItem.swift
// YueShiJia
//
// Created by YangFan on 2017/5/12.
// Copyright © 2017年 YangFan. All rights reserved.
//
import UIKit
class YFSpecialGoodsItem: NSObject {
var special_sum: Int?
var special_share_url: String?
var special_image: String?
var news_special: [News_Special]?
var special_tis: String?
var special_id: String?
var special_title: String?
var special_stitle: String?
init(dict: [String: Any]) {
special_sum = dict["special_sum"] as? Int
special_share_url = dict["special_share_url"] as? String
special_image = dict["special_image"] as? String
special_id = dict["special_id"] as? String
special_title = dict["special_title"] as? String
special_stitle = dict["special_stitle"] as? String
if let array = dict["news_special"] as? NSArray {
news_special = [News_Special]()
for good in array {
news_special?.append(News_Special(dict: good as! [String : Any]))
}
}
}
}
class News_Special: NSObject {
var object_font: String?
var special_type: Int?
var goods_list: [Goods_List]?
init(dict: [String: Any]) {
object_font = dict["object_font"] as? String
special_type = dict["special_type"] as? Int
if let array = dict["goods_list"] as? NSArray {
goods_list = [Goods_List]()
for good in array {
goods_list?.append(Goods_List(dict: good as! [String : Any]))
}
}
}
}
class Goods_List: NSObject {
var is_presell: String?
var sole_flag: Bool?
var is_fcode: String?
var if_favorites: Int?
var is_own_shop: String?
var goods_jingle: String?
var goods_marketprice: String?
var group_flag: Bool?
var specif_set: String?
var goods_image: String?
var goods_name: String?
var goods_salenum: String?
var store_id: String?
var evaluation_good_star: String?
var goods_image_long: String?
var store_name: String?
var store_logo: String?
var tag_print: String?
var evaluation_count: String?
var goods_custom: String?
var goods_image_url: String?
var xianshi_flag: Bool?
var goods_price: String?
var goods_id: String?
var have_gift: String?
var is_virtual: String?
init(dict: [String: Any]) {
is_presell = dict[""] as? String
sole_flag = dict["sole_flag"] as? Bool
is_fcode = dict["is_fcode"] as? String
if_favorites = dict["if_favorites"] as? Int
is_own_shop = dict["is_own_shop"] as? String
goods_jingle = dict["goods_jingle"] as? String
goods_marketprice = dict["goods_marketprice"] as? String
group_flag = dict["group_flag"] as? Bool
specif_set = dict["specif_set"] as? String
goods_image = dict["goods_image"] as? String
goods_name = dict["goods_name"] as? String
goods_salenum = dict["goods_salenum"] as? String
store_id = dict["store_id"] as? String
evaluation_good_star = dict["evaluation_good_star"] as? String
goods_image_long = dict["goods_image_long"] as? String
store_name = dict["store_name"] as? String
store_logo = dict["store_logo"] as? String
tag_print = dict["tag_print"] as? String
evaluation_count = dict["evaluation_count"] as? String
goods_custom = dict["goods_custom"] as? String
goods_image_url = dict["goods_image_url"] as? String
xianshi_flag = dict["xianshi_flag"] as? Bool
goods_price = dict["goods_price"] as? String
goods_id = dict["goods_id"] as? String
have_gift = dict["have_gift"] as? String
is_virtual = dict["is_virtual"] as? String
}
}
| apache-2.0 | cac4bad764122fd68012a3c2ec9a5e84 | 20.837079 | 81 | 0.585799 | 3.656632 | false | false | false | false |
bitboylabs/selluv-ios | selluv-ios/selluv-ios/Classes/Base/Model/Etc/AlbumModel.swift | 1 | 2705 | //
// AlbumModel.swift
// bitboylabs-ios-base
//
// Created by 조백근 on 2016. 10. 18..
// Copyright © 2016년 BitBoy Labs. All rights reserved.
//
import RealmSwift
class AlbumModel: NSObject {
let realm = try! Realm()
var albums: [[String: String]]
let onGetData: Foundation.Notification = Foundation.Notification(name: NSNotification.Name(rawValue: "onGetData"), object: nil)
override init() {
self.albums = []
super.init()
}
func getAlbums(_ term: String){
NotificationCenter.default.post(onGetData)
}
func perseRealm<T: Album>(_ collection: Results<T>) -> [[String: String]] {
var returnAlbums: [[String : String]] = []
for i in 0 ..< collection.count {
returnAlbums.append(parseRealmToDict(collection[i]))
}
returnAlbums = returnAlbums.reversed()
return returnAlbums
}
func contains(_ collectionId: String) -> Bool {
var flag: Bool = false
for i in 0 ..< self.albums.count {
if(self.albums[i]["collectionId"] == collectionId) {
flag = true
}
}
return flag
}
func save(_ newAlbum: [String: String]) {
}
func destroy(_ collectionId: String) {
}
func addRealm<T: Album>(_ model: T, selectedAlbum: [String: String]) {
model.id = selectedAlbum["collectionId"]!
model.collectionName = selectedAlbum["collectionName"]!
model.imageUrl = selectedAlbum["imageUrl"]!
model.artistName = selectedAlbum["artistName"]!
try! realm.write {
realm.add(model, update: true)
self.getAlbums("")
}
}
func removeRealm<T: Album>(_ model: T) {
try! realm.write {
realm.delete(model)
self.getAlbums("")
}
}
func deleteError(_ collectionId: String) {
print("Error: \(collectionId) not found")
}
func parseRealmToDict<T: Album>(_ model: T) -> [String: String] {
return [
"collectionId": String(describing: model["id"]!),
"collectionName": String(describing: model["collectionName"]!),
"artistName": String(describing: model["artistName"]!),
"imageUrl": String(describing: model["imageUrl"]!)
]
}
func setModelProp(_ model: [String: String]) -> [String: String] {
return [
"collectionId": String(model["collectionId"]!),
"collectionName": String(model["collectionName"]!),
"artistName": String(model["artistName"]!),
"imageUrl": String(model["imageUrl"]!)
]
}
}
| mit | b53882ef0dfd6407fdf2b8f274ec16b8 | 28.626374 | 131 | 0.563798 | 4.531092 | false | false | false | false |
endpress/PopNetwork | PopNetwork/Source/Client.swift | 1 | 1376 | //
// SessionHttpClient.swift
// PopNetwork
//
// Created by apple on 12/7/16.
// Copyright © 2016 zsc. All rights reserved.
//
import Foundation
/// the client protocol used to sent request and handle data
protocol Client {
func send<T: PopRequest>(popRequest: T, dataHandler: @escaping DataHandler)
}
/// a session client use session to sent request
protocol SessionClient: Client {
var session: URLSession { get }
var sessionDelegate: SessionDelegate { get }
}
extension SessionClient {
var session: URLSession {
return SessionSingleton.default
}
var sessionDelegate: SessionDelegate {
return SessionDelegate.default
}
func send<T: PopRequest>(popRequest: T, dataHandler: @escaping DataHandler) {
let parameterEncoder = ParameterEncoder()
let encodeError = PopError.error(reason: "ParameterEncoder encode function failed")
guard let request = parameterEncoder.encode(popRequest: popRequest) else {
return dataHandler(Result.Faliure(error: encodeError))
}
let task = session.dataTask(with: request)
sessionDelegate[task] = Response(dataHandler: dataHandler)
task.resume()
}
}
struct SessionSingleton {
static let `default` = URLSession(configuration: .default, delegate: SessionDelegate.default, delegateQueue: nil)
}
| apache-2.0 | 0761fbc462543743200f5561ca711f4e | 27.061224 | 117 | 0.694545 | 4.508197 | false | false | false | false |
STShenZhaoliang/iOS-GuidesAndSampleCode | 精通Swift设计模式/Chapter 22/SportsStore/SportsStore/ProductDataStore.swift | 4 | 3803 | import Foundation
final class ProductDataStore {
var callback:((Product) -> Void)?;
private var networkQ:dispatch_queue_t
private var uiQ:dispatch_queue_t;
lazy var products:[Product] = self.loadData();
init() {
networkQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
uiQ = dispatch_get_main_queue();
}
private func loadData() -> [Product] {
var products = [Product]();
for product in productData {
var p:Product = LowStockIncreaseDecorator(product: product);
if (p.category == "Soccer") {
p = SoccerDecreaseDecorator(product: p);
}
dispatch_async(self.networkQ, {() in
StockServerFactory.getStockServer().getStockLevel(p.name,
callback: { name, stockLevel in
p.stockLevel = stockLevel;
dispatch_async(self.uiQ, {() in
if (self.callback != nil) {
self.callback!(p);
}
})
});
});
products.append(p);
}
return products;
}
private var productData:[Product] = [
ProductComposite(name: "Running Pack",
description: "Complete Running Outfit", category: "Running",
stockLevel: 10, products:
Product.createProduct("Shirt", description: "Running Shirt",
category: "Running", price: 42, stockLevel: 10),
Product.createProduct("Shorts", description: "Running Shorts",
category: "Running", price: 30, stockLevel: 10),
Product.createProduct("Shoes", description: "Running Shoes",
category: "Running", price: 120, stockLevel: 10),
ProductComposite(name: "Headgear", description: "Hat, etc",
category: "Running", stockLevel: 10, products:
Product.createProduct("Hat", description: "Running Hat",
category: "Running", price: 10, stockLevel: 10),
Product.createProduct("Sunglasses", description: "Glasses",
category: "Running", price: 10, stockLevel: 10))
),
Product.createProduct("Kayak", description:"A boat for one person",
category:"Watersports", price:275.0, stockLevel:0),
Product.createProduct("Lifejacket",
description:"Protective and fashionable",
category:"Watersports", price:48.95, stockLevel:0),
Product.createProduct("Soccer Ball",
description:"FIFA-approved size and weight",
category:"Soccer", price:19.5, stockLevel:0),
Product.createProduct("Corner Flags",
description:"Give your playing field a professional touch",
category:"Soccer", price:34.95, stockLevel:0),
Product.createProduct("Stadium",
description:"Flat-packed 35,000-seat stadium",
category:"Soccer", price:79500.0, stockLevel:0),
Product.createProduct("Thinking Cap",
description:"Improve your brain efficiency",
category:"Chess", price:16.0, stockLevel:0),
Product.createProduct("Unsteady Chair",
description:"Secretly give your opponent a disadvantage",
category: "Chess", price: 29.95, stockLevel:0),
Product.createProduct("Human Chess Board",
description:"A fun game for the family",
category:"Chess", price:75.0, stockLevel:0),
Product.createProduct("Bling-Bling King",
description:"Gold-plated, diamond-studded King",
category:"Chess", price:1200.0, stockLevel:0)];
}
| mit | f878b14cf57d23741eed55353c73202e | 44.27381 | 84 | 0.567447 | 4.838422 | false | false | false | false |
tsc000/SCCycleScrollView | SCCycleScrollView/SCCycleScrollView/CustomCell/CustomCollectionViewCell.swift | 1 | 1131 | //
// CustomCollectionViewCell.swift
// SCCycleScrollView
//
// Created by tongshichao on 2018/11/28.
// Copyright © 2018 童世超. All rights reserved.
//
import UIKit
class CustomCollectionViewCell: UICollectionViewCell {
override init(frame: CGRect) {
super.init(frame: frame)
initial()
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
private func initial() {
imageView.frame = CGRect(x: 5, y: 5, width: self.frame.width - 10, height: self.frame.height - 10)
titleLabel.center = imageView.center
}
private lazy var titleLabel: UILabel! = {
let titleLabel = UILabel()
titleLabel.text = "自定义ell"
titleLabel.textAlignment = .left
contentView.addSubview(titleLabel)
titleLabel.sizeToFit()
return titleLabel
}()
private lazy var imageView: UIImageView! = {
let imageView = UIImageView()
imageView.backgroundColor = UIColor.orange
contentView.addSubview(imageView)
return imageView
}()
}
| mit | 6d6f6edbcf3684592a02822c746762a5 | 25.619048 | 106 | 0.635063 | 4.563265 | false | false | false | false |
snazzware/Mergel | HexMatch/HexMap/HexCell.swift | 2 | 9324 | //
// HexCell.swift
// HexMatch
//
// Created by Josh McKee on 1/12/16.
// Copyright © 2016 Josh McKee. All rights reserved.
//
import Foundation
enum HexCellDirection {
case north, south, northEast, northWest, southEast, southWest
static let allDirections = [north, south, northEast, northWest, southEast, southWest]
}
enum MergeStyle : String {
case Liner = "Liner"
case Cluster = "Cluster"
}
class HexCell : NSObject, NSCoding {
//var x: Int
//var y: Int
var position: HCPosition
var isVoid = false
var mergeStyle: MergeStyle = .Cluster
var hexMap: HexMap
var _hexPiece: HexPiece?
var hexPiece: HexPiece? {
get {
return self._hexPiece
}
set {
// unlink any existing piece
if (self._hexPiece != nil) {
self._hexPiece!.hexCell = nil
}
// update value
self._hexPiece = newValue
// link to new piece
if (self._hexPiece != nil) {
self._hexPiece!.hexCell = self
// map is no longer blank
self.hexMap.isBlank = false
}
}
}
init(_ map: HexMap, _ x: Int, _ y: Int) {
self.position = HCPosition(x, y)
self.hexMap = map
}
func getCellByDirection(_ direction: HexCellDirection) -> HexCell? {
switch direction {
case HexCellDirection.north:
return self.north
case HexCellDirection.south:
return self.south
case HexCellDirection.southEast:
return self.southEast
case HexCellDirection.southWest:
return self.southWest
case HexCellDirection.northEast:
return self.northEast
case HexCellDirection.northWest:
return self.northWest
}
}
var north:HexCell? {
get {
return self.hexMap.cell(self.position.north)
}
}
var northEast:HexCell? {
get {
return self.hexMap.cell(self.position.northEast)
}
}
var northWest:HexCell? {
get {
return self.hexMap.cell(self.position.northWest)
}
}
var south:HexCell? {
get {
return self.hexMap.cell(self.position.south)
}
}
var southEast:HexCell? {
get {
return self.hexMap.cell(self.position.southEast)
}
}
var southWest:HexCell? {
get {
return self.hexMap.cell(self.position.southWest)
}
}
override var description: String {
return "HexCell \(self.position)"
}
/**
Determines if this cell will accept a given HexPiece
- Parameters:
- hexPiece: The piece to be tested
- Returns: True if this cell will accept the piece, false otherwise
*/
func willAccept(_ hexPiece: HexPiece) -> Bool {
return self.isOpen()
}
func isOpen() -> Bool {
return (!self.isVoid && self.hexPiece == nil)
}
/**
Recursively checks for valid merges in every direction for a given HexPiece, skipping cells which have already
been checked as part of the current recursion.
*/
func getClusterMerges(_ hexPiece: HexPiece, _ visitedCells: [HexCell]) -> [HexPiece] {
var merges: [HexPiece] = Array()
var localVisitedCells = visitedCells
for direction in HexCellDirection.allDirections {
let targetCell = self.getCellByDirection(direction)
if (targetCell != nil && !localVisitedCells.contains(targetCell!)) {
localVisitedCells.append(targetCell!)
if (targetCell != nil && targetCell!.hexPiece != nil && targetCell!.hexPiece!.canMergeWithPiece(hexPiece) && hexPiece.canMergeWithPiece(targetCell!.hexPiece!)) {
merges.append(targetCell!.hexPiece!)
merges += targetCell!.getClusterMerges(hexPiece, localVisitedCells)
}
}
}
return merges
}
/**
Iterates over each direction from this cell, looking for runs of pieces which canMergeWithPiece(hexPiece) is true.
If a merge is detected, the function recurses to detect further matches with the incremented value piece.
- Parameters:
- hexPiece: The piece to be tested
- Returns: Set of HexPieces which would be merged (if any), or empty if none
*/
func getWouldMergeWith(_ hexPiece: HexPiece) -> [HexPiece] {
var merges: [HexPiece] = Array()
// Number of same pieces we found searching all directions
var samePieceCount = 0
let firstValue = hexPiece.getMinMergeValue()
let lastValue = hexPiece.getMaxMergeValue()
var neighborValues: [Int] = Array()
// Get values of all of our neighbors, for iteration, where value is between our piece's firstValue and lastValue
for direction in HexCellDirection.allDirections {
let targetCell = self.getCellByDirection(direction)
if (targetCell != nil && targetCell!.hexPiece != nil && !neighborValues.contains(targetCell!.hexPiece!.value) && (firstValue <= targetCell!.hexPiece!.value && lastValue >= targetCell!.hexPiece!.value)) {
neighborValues.append(targetCell!.hexPiece!.value)
}
}
// Sort ascending
neighborValues = neighborValues.sorted { $0 < $1 }
// Get last (largest) value
var value = neighborValues.popLast()
// Loop over possible values for the piece being placed, starting with highest, until we find a merge
while (samePieceCount<2 && value != nil) {
merges.removeAll()
samePieceCount = 0
hexPiece.value = value!
switch (self.mergeStyle) {
case .Liner:
// Iterate over all directions, following each direction as long as there is a matching piece value
for direction in HexCellDirection.allDirections {
var targetCell = self.getCellByDirection(direction)
while (targetCell != nil && targetCell!.hexPiece != nil && targetCell!.hexPiece!.canMergeWithPiece(hexPiece) && hexPiece.canMergeWithPiece(targetCell!.hexPiece!)) {
merges.append(targetCell!.hexPiece!)
samePieceCount += 1
targetCell = targetCell!.getCellByDirection(direction)
}
}
break
case .Cluster:
var visitedCells: [HexCell] = Array()
// Prevent visiting self
visitedCells.append(self)
// Recurse and find merges
merges += self.getClusterMerges(hexPiece, visitedCells)
samePieceCount = merges.count
break
}
value = neighborValues.popLast()
}
// If we didn't get at least two of the same piece, clear our merge array
if (samePieceCount < 2) {
merges.removeAll()
} else {
// If we DID get at least two, recurse with the new piece
if (hexPiece.value<HexMapHelper.instance.maxPieceValue) {
if (hexPiece is WildcardHexPiece) { // create a copy if we're dealing with a wildcard
let mergedPiece = HexPiece()
mergedPiece.value = hexPiece.value+1
merges += self.getWouldMergeWith(mergedPiece)
} else { // try next merge with updated value
hexPiece.updateValueForMergeTest()
merges += self.getWouldMergeWith(hexPiece)
hexPiece.rollbackValueForMergeTest()
}
}
}
return merges
}
required convenience init?(coder decoder: NSCoder) {
let x = decoder.decodeInteger(forKey: "x")
let y = decoder.decodeInteger(forKey: "y")
let hexMap = (decoder.decodeObject(forKey: "hexMap") as? HexMap)!
self.init(hexMap, x, y)
self.isVoid = decoder.decodeBool(forKey: "isVoid")
self.mergeStyle = MergeStyle(rawValue: (decoder.decodeObject(forKey: "mergeStyle") as! String))!
self.hexPiece = (decoder.decodeObject(forKey: "hexPiece") as? HexPiece)
}
func encode(with coder: NSCoder) {
coder.encode(self.position.x, forKey: "x")
coder.encode(self.position.y, forKey: "y")
coder.encode(self.hexMap, forKey: "hexMap")
coder.encode(self.isVoid, forKey: "isVoid")
coder.encode(self.mergeStyle.rawValue, forKey: "mergeStyle")
coder.encode(self.hexPiece, forKey: "hexPiece")
}
}
| mit | e8f672eb34006c830f722334a745155c | 32.901818 | 215 | 0.551217 | 5.179444 | false | false | false | false |
grpc/grpc-swift | Sources/GRPC/ClientCalls/LazyEventLoopPromise.swift | 1 | 3420 | /*
* Copyright 2020, gRPC Authors All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import NIOConcurrencyHelpers
import NIOCore
extension EventLoop {
internal func makeLazyPromise<Value>(of: Value.Type = Value.self) -> LazyEventLoopPromise<Value> {
return LazyEventLoopPromise(on: self)
}
}
/// A `LazyEventLoopPromise` is similar to an `EventLoopPromise` except that the underlying
/// `EventLoopPromise` promise is only created if it is required. That is, when the future result
/// has been requested and the promise has not yet been completed.
///
/// Note that all methods **must** be called from its `eventLoop`.
internal struct LazyEventLoopPromise<Value> {
private enum State {
// No future has been requested, no result has been delivered.
case idle
// No future has been requested, but this result have been delivered.
case resolvedResult(Result<Value, Error>)
// A future has been request; the promise may or may not contain a result.
case unresolvedPromise(EventLoopPromise<Value>)
// A future was requested, it's also been resolved.
case resolvedFuture(EventLoopFuture<Value>)
}
private var state: State
private let eventLoop: EventLoop
fileprivate init(on eventLoop: EventLoop) {
self.state = .idle
self.eventLoop = eventLoop
}
/// Get the future result of this promise.
internal mutating func getFutureResult() -> EventLoopFuture<Value> {
self.eventLoop.preconditionInEventLoop()
switch self.state {
case .idle:
let promise = self.eventLoop.makePromise(of: Value.self)
self.state = .unresolvedPromise(promise)
return promise.futureResult
case let .resolvedResult(result):
let future: EventLoopFuture<Value>
switch result {
case let .success(value):
future = self.eventLoop.makeSucceededFuture(value)
case let .failure(error):
future = self.eventLoop.makeFailedFuture(error)
}
self.state = .resolvedFuture(future)
return future
case let .unresolvedPromise(promise):
return promise.futureResult
case let .resolvedFuture(future):
return future
}
}
/// Succeed the promise with the given value.
internal mutating func succeed(_ value: Value) {
self.completeWith(.success(value))
}
/// Fail the promise with the given error.
internal mutating func fail(_ error: Error) {
self.completeWith(.failure(error))
}
/// Complete the promise with the given result.
internal mutating func completeWith(_ result: Result<Value, Error>) {
self.eventLoop.preconditionInEventLoop()
switch self.state {
case .idle:
self.state = .resolvedResult(result)
case let .unresolvedPromise(promise):
promise.completeWith(result)
self.state = .resolvedFuture(promise.futureResult)
case .resolvedResult, .resolvedFuture:
()
}
}
}
| apache-2.0 | 6622841b3496ba70e1866551547aaa38 | 30.666667 | 100 | 0.711404 | 4.494087 | false | false | false | false |
Subsets and Splits