AOC2018/Sources/AOC2018/tools.swift

//
// Tools used for mundane stuff
//

import Foundation

// Global function
func XCTAssertEqual(test: String, withExpression isTrue: Bool) {
    if (isTrue) {
        print("Pass       ", terminator: " : ")
    } else {
        print("* F A I L *", terminator: " : ")
    }
    print(test)
}

func == <T:Equatable> (tuple1:(T,T),tuple2:(T,T)) -> Bool
{
   return (tuple1.0 == tuple2.0) && (tuple1.1 == tuple2.1)
}

struct GridPoint: Equatable, Comparable, Hashable {
    var X = 0
    var Y = 0
    var hashValue: Int {
        get {
            return X.hashValue ^ Y.hashValue
        }
    }

    static func == (lhs: GridPoint, rhs: GridPoint) -> Bool {
        return (lhs.X == rhs.X) && (lhs.Y == rhs.Y)
    }

    static func < (lhs: GridPoint, rhs: GridPoint) -> Bool {
        return lhs.Y == rhs.Y ? lhs.X < rhs.X : lhs.Y < rhs.Y
    }
}

struct Tools {
    static func readFile(fromPath path: String) -> String {
        var retVal = ""
        do {
            let data = try NSString(contentsOfFile: path, encoding: String.Encoding.ascii.rawValue)
            retVal = data as String
        }
        catch let error as NSError {
            print("Tools readFile(fromPath: \"\(path)\") error: \(error)")
        }
        return retVal
    }
    
    // Assumes THE string is 'polymer'
    static func stringIndexRange(withString str: String, fromRange range: Range<Int>) -> Range<String.Index> {
        let myrange = Range(uncheckedBounds: (lower: max(0, min(str.length, range.lowerBound)), upper: min(str.length, max(0, range.upperBound))))
        let start = str.index(str.startIndex, offsetBy: myrange.lowerBound)
        let end = str.index(start, offsetBy: myrange.upperBound - myrange.lowerBound)
        return start ..< end
    }
}

extension Character {
    var isAscii: Bool {
        return unicodeScalars.first?.isASCII == true
    }
    var ascii: UInt32? {
        return isAscii ? unicodeScalars.first?.value : nil
    }
}

extension StringProtocol {
    // var string: String { return String(self) }

    var ascii: [UInt32] {
        return compactMap { $0.ascii }
    }

    subscript(offset: Int) -> Element {
        return self[index(startIndex, offsetBy: offset)]
    }
}

extension String {

  var length: Int {
    return count
  }

  subscript (i: Int) -> String {
    return self[i ..< i + 1]
  }

  func substring(fromIndex: Int) -> String {
    return self[min(fromIndex, length) ..< length]
  }

  func substring(toIndex: Int) -> String {
    return self[0 ..< max(0, toIndex)]
  }

  subscript (r: Range<Int>) -> String {
    let range = Range(uncheckedBounds: (lower: max(0, min(length, r.lowerBound)),
                                        upper: min(length, max(0, r.upperBound))))
    let start = index(startIndex, offsetBy: range.lowerBound)
    let end = index(start, offsetBy: range.upperBound - range.lowerBound)
    return String(self[start ..< end])
  }

}