khawajafarooq

public class CGRectUtility {
    
    // MARK: Geometry Methods
    public class func GMCenteredRectWithinRect(rect: CGRect, containerRect: CGRect) -> CGRect
    {
        var r: CGRect = rect
        
        r.origin.y = containerRect.size.height / 2 - (r.size.height / 2)
        r.origin.x = containerRect.size.width / 2 - (r.size.width / 2)
        

khawajafarooq

import Foundation

extension Double {
    
    mutating func round(to places: Int) -> Double {
        let divisor = pow(10.0, Double(places))
        return Darwin.round(self * divisor) / divisor
    }
}

khawajafarooq

import Foundation

extension UIViewController {
    
    func hideKeyboardWhenTappedAround() {
        
        let tap: UITapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(UIViewController.dismissKeyboard))
        view.addGestureRecognizer(tap)
    }
    

khawajafarooq

import Foundation

extension String {
    
    /* Get length of string */
    var length: Int {
        return self.characters.count
    }
    
    /* Trim leading or trailing white spaces */

khawajafarooq

class TimerTestViewController: UIViewController {
  
        override func viewDidLoad() {
                super.viewDidLoad()

                Timer.scheduledTimer(timeInterval: interval, target: self,
                                     selector: #selector(ViewController.methodToRepeat(timer:)),
                                     userInfo: nil, repeats: true)
        }

khawajafarooq

func selectionSort<T: Comparable>(_ a:[T]) -> [T] {
    guard array.count > 1 else { return array }
    
    var array = a
    for i in 0..<array.count {
        
        if let min = Array(array[i..<array.count]).min() {
            if let idx = array.index(of: min) {
                array.swapAt(i, idx)
            }

khawajafarooq

/*
https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
The sieve of Eratosthenes is one of the most efficient way to find all prime numbers up to any given limit. 
It's a simple and ancient algorithm that is know for it's performance. Here is a swift flavor of this algorithm.
*/
func sieveOfEratosthenes(number n: UInt) -> [UInt] {
    
    var list = Array(2...n)
    
    list = list.filter {

khawajafarooq

struct Address {
    let unitNumber: String
    let buildingNumebr: String
}

struct Residance {
    var numberOfRooms: Int
    var address: Address
}

khawajafarooq

enum Direction {
    case up
    case down
    case left
    case right
}

struct Position {
    var x: Int
    var y: Int

khawajafarooq

class Machine {
    let model: String
    var make: String

    init(model: String, make: String) {
        self.model = model
        self.make = make
    }
}