phucnm

'''
When reading about gzip and bzip2, I found an interesting data pattern 
that terribly breaks gzip where the compressed file is larged than the 
uncompressed file. The reason is that the input data is incompressible 
to gzip, hence gzip has to store the data as uncompressed, adding file 
header and block headers, resulting in extra bytes. On the other hand, 
bzip is still quite stable and able to achieve a good compression ratio.

The format of data from the below script is as follows:
step 1, start 0: 0 1 2 3 ... 255 

phucnm

extension Reactive where Base: NSObject {
    func cfNotification(notificationName: CFString) -> Observable<Notification> {
        let cfNotificationName = CFNotificationName(notificationName)
        let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
        CFNotificationCenterAddObserver(
            notificationCenter,
            Unmanaged.passRetained(self.base).toOpaque(),
            { (
                center: CFNotificationCenter?,
                observer: UnsafeMutableRawPointer?,

phucnm

class Analytics {
    static func track(event: AppEvent) {
        let mirror = event.mirror
        let eventName = mirror.label
        let params = mirror.params
        // Track the event effortlessly
    }
}

enum AppEvent: MirrorableEnum {

phucnm

protocol MirrorableEnum {}
extension MirrorableEnum {
    var mirror: (label: String, params: [String: Any]) {
        get {
            let reflection = Mirror(reflecting: self)
            guard reflection.displayStyle == .enum,
                let associated = reflection.children.first else {
                    return ("\(self)", [:])
            }
            let values = Mirror(reflecting: associated.value).children

phucnm

class Analytics {
    static func track(event: AppEvent) {
        switch event {
        case .livestreamStarted: break
            // Just tracking
        case .liveStreamEnded(let duration):
            let param = ["duration": duration]
            // Then track the event with associated param
        case .gameRoomCreated(let gameName, let invitedFriends):
            let param = [

phucnm

struct MyStruct: Comparable {
    var a: Int
    public static func <(lhs: MyStruct, rhs: MyStruct) -> Bool {
        return lhs.a < rhs.a
    }
}

extension ObservableType {
    
    /**

phucnm

Observable.combineLatest(observable1.asObservable(), observable2.asObservable())
    .subscribe(onNext: { [weak self] (population, state) in
        guard let _self = self else { return }
        switch state {
        case .connectedHost, .connectedParticipant:
            if population == 0 {
                _self.roomPopulationState = .waiting
            } else {
                _self.roomPopulationState = .inARoom
            }

phucnm

class PassthroughToWindowView: UIView {
    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
        var view = super.hitTest(point, with: event)
        if view != self {
            return view
        }
        
        while !(view is PassthroughWindow) {
            view = view?.superview
        }

phucnm

class PassthroughWindow: UIWindow {
    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
        let view = super.hitTest(point, with: event)
        return view == self ? nil : view
    }
}

phucnm

class PassthroughView: UIView {
    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
        let view = super.hitTest(point, with: event)
        return view == self ? nil : view
    }
}