Functions

The following functions are available globally.


                    
                    
                    cnlLog(_:_:_:)

Undocumented

Declaration

Swift

public func cnlLog(_ code: EyrLogger.Message, _ level: EyrLogLevel = .debug, _ params: CVarArg ...)


                    
                    
                    cnlLog(_:_:)

Undocumented

Declaration

Swift

public func cnlLog(_ code: EyrLogger.Message, _ level: EyrLogLevel = .debug)


                    
                    
                    cnlFatalError(_:_:)

Undocumented

Declaration

Swift

public func cnlFatalError(_ code: EyrLogger.Message, _ params: CVarArg ...) -> Never


                    
                    
                    cnlFatalError(_:)

Undocumented

Declaration

Swift

public func cnlFatalError(_ code: EyrLogger.Message) -> Never


                    
                    
                    assert(_:_:_:)

Undocumented

Declaration

Swift

public func assert(_ condition: Bool, _ code: EyrLogger.Message, _ params: CVarArg ...)


                    
                    
                    assert(_:_:)

Undocumented

Declaration

Swift

public func assert(_ condition: Bool, _ code: EyrLogger.Message)


                    
                    
                    +(_:_:)

Adding String to attributed string as text

Declaration

Swift

public func + (lhs: NSAttributedString, rhs: NSAttributedString) -> NSAttributedString


                    
                    
                    runThisAfterDelay(seconds:after:)

Run сlosure after particular time period

Declaration

Swift

public func runThisAfterDelay(seconds: Double, after: @escaping () -> Void)

Parameters

`seconds`	time in double format
`after`	closure which will be executed after


                    
                    
                    runThisInMainThread(_:)

Run сlosure in the main thread, usefull for UI changes

Declaration

Swift

public func runThisInMainThread(_ block: @escaping () -> Void)

Parameters


                                block

closure to be executed in Main thread, enshure exit from retain circles


                    
                    
                    runThisInBackground(_:)

Run сlosure in the background thread, usefull for long time period tasks

Declaration

Swift

public func runThisInBackground(_ block: @escaping () -> Void)

Parameters


                                block

closure to be executed in Background thread, enshure exit from retain circles


                    
                    
                    runThisEvery(seconds:startAfterSeconds:handler:)

Run сlosure every particular time after the time period

Declaration

Swift

public  func runThisEvery(seconds: TimeInterval, startAfterSeconds: TimeInterval, handler: @escaping (CFRunLoopTimer?) -> Void) -> Timer

Parameters

`seconds`	code will be executed every this double format value of time
`startAfterSeconds`	code will be executed in loop after this time period in double format
`handler`	closure to be executed in Background thread, enshure exit from retain circles


                    
                    
                    asyncGlobal(_:_:)

Run backgoundClosure async in global queue, then completionClosure async in main queue

Declaration

Swift

public func asyncGlobal (_ backgroundClosure: @escaping () -> Void, _ completionClosure: @escaping (() -> Void) )

Parameters

`backgroundClosure`	payload closure
`completionClosure`	completion closure


                    
                    
                    asyncGlobal(_:)

Run backgoundClosure async in global queue

Declaration

Swift

public func asyncGlobal (_ backgroundClosure: @escaping () -> Void)

Parameters


                                backgroundClosure

payload closure


                    
                    
                    asyncGlobal(_:_:)

Run backgoundClosure async in global queue, then calls completionClosure async in main queue with result of backgroundClosure

Declaration

Swift

public func asyncGlobal<R> (_ backgroundClosure: @escaping () -> R, _ completionClosure: @escaping ((_ result: R) -> Void) )

Parameters

`backgroundClosure`	payload closure with result
`completionClosure`	completion closure with parameter


                    
                    
                    syncMain(_:)

Run backgoundClosure sync in main queue

Declaration

Swift

public func syncMain (_ backgroundClosure: @escaping () -> Void )

Parameters


                                backgroundClosure

<#backgroundClosure description#>


                    
                    
                    asyncMain(_:_:)

Run backgoundClosure async in main queue, then calls completionClosure

Declaration

Swift

public func asyncMain (_ backgroundClosure: @escaping () -> Void, _ completionClosure: @escaping (() -> Void) )

Parameters

`backgroundClosure`	payload closure
`completionClosure`	completion closure


                    
                    
                    asyncMain(_:)

Run backgoundClosure async in main queue

Declaration

Swift

public func asyncMain (_ backgroundClosure: @escaping () -> Void )

Parameters


                                backgroundClosure

payload closure


                    
                    
                    asyncMain(_:_:)

Run backgoundClosure async in main queue, then calls completionClosure with result of backgroundClosure

Declaration

Swift

public func asyncMain<R> (_ backgroundClosure: @escaping () -> R, _ completionClosure: @escaping ((_ result: R) -> Void) )

Parameters

`backgroundClosure`	payload closure with result
`completionClosure`	completion closure with parameter


                    
                    
                    syncCritical(_:_:)

Brackets call of closure in objc_sync_enter and objc_sync_exit calls, assotiated with object

Declaration

Swift

public func syncCritical(_ object: Any, _ closure: () -> Void)

Parameters

`object`	Object used as lock souorce
`closure`	Closure to execute while lock is active


                    
                    
                    -->(_:_:)

Executes right part with left part as an argument, returns retult of execution (not Optional)

Declaration

Swift

public func --> <T, U>(left: T, right: (T) -> U) -> U

Parameters

`left`	Source value
`right`	Closue to execute

Return Value

Result of left closure


                    
                    
                    -->(_:_:)

Executes right part with left part as an argument, returns retult of execution (Optional)

Declaration

Swift

public func --> <T, U>(left: T?, right: (T?) -> U?) -> U?

Parameters

`left`	Source value
`right`	Closue to execute

Return Value

Result of left closure


                    
                    
                    -->(_:_:)

Executes right part with left part as an argument, returns left part (not Optional)

Declaration

Swift

public func --> <T>(left: T, right: (T) -> Void) -> T

Parameters

`left`	Source value
`right`	Closue to execute

Return Value

Result of left closure


                    
                    
                    -->(_:_:)

Executes right part with left part as an argument, returns left part (Optional)

Declaration

Swift

public func --> <T>(left: T?, right: (T?) -> Void) -> T?

Parameters

`left`	Source value
`right`	Closue to execute

Return Value

Result of left closure

>=(_:_:)
Additional date comparision operators (greater or equal)
Declaration
Swift

public func >= (left: Date, right: Date) -> Bool
<=(_:_:)
Additional date comparision operators (lesser or equal)
Declaration
Swift

public func <= (left: Date, right: Date) -> Bool

~=(_:_:)
Pattern matching of strings via defined functions
Declaration
Swift

public func ~=<T> (pattern: ((T) -> Bool), value: T) -> Bool


                    
                    
                    hasPrefix(_:)

Can be used in switch-case

Declaration

Swift

public func hasPrefix(_ prefix: String) -> (_ value: String) -> Bool


                    
                    
                    hasSuffix(_:)

Can be used in switch-case

Declaration

Swift

public func hasSuffix(_ suffix: String) -> (_ value: String) -> Bool

Extenstion for Dictionary for CNLDictionary purposes


                    
                    
                    +=(_:_:)

Combines the first dictionary with the second and returns single dictionary

Declaration

Swift

public func += <KeyType, ValueType> (left: inout [KeyType: ValueType], right: [KeyType: ValueType])


                    
                    
                    -(_:_:)

Difference operator

Declaration

Swift

public func - <K, V: Equatable> (first: [K: V], second: [K: V]) -> [K: V]