FileLib (Swift)

FileLib.swift

/*
 The MIT License (MIT)

 Copyright (c) 2015 Tom Hancocks

 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.

 This a library API for file access in Swift. The aim of the library is to decouple
 from Foundation and the legacy aspects and concepts that were driven by Objective-C.
*/

import Darwin


/// A file structure is simply a wrapper around the path, and optional data.
struct File {
  let path: String
  private var handle: UnsafeMutablePointer<FILE>?
  private let internalMode: Mode
  private let internalEndian: Endian

  /// The position within the file that is currently open
  var pos: Int {
    get {
      guard let handle = handle else { return 0 }
      return ftell(handle)
    }
    set {
      guard let handle = handle else { return }
      fseek(handle, pos, SEEK_SET)
    }
  }

  /// Initialise the receiver to represent the file located at the specified path string
  init(_ path: String, mode: Mode = .Read, endian: Endian = .Default) {
    self.path = path
    self.internalMode = mode
    self.internalEndian = endian
  }

  /// Initialise the receiver to represent the file located at the specified path structure
  init(_ path: Path, mode: Mode = .Read, endian: Endian = .Default) {
    self.path = path.absolutePath.stringRepresentation
    self.internalMode = mode
    self.internalEndian = endian
  }

  /// Initialise the receiver using an exist file
  init(_ file: File, newMode mode: Mode = .Read) {
    self.path = file.path
    self.internalMode = mode
    self.internalEndian = file.internalEndian
  }
}


/// The file can be used in various modes which influence the type of operations that
/// can be preformed.
extension File {
  enum Mode {
    case Read
    case Write
    case Append

    var code: String {
      switch self {
      case .Read: return "r"
      case .Write: return "w"
      case .Append: return "r+"
      }
    }
  }
}


/// Files can be written or read with a regard to endianness. These values simply
/// denote the type of endianness
extension File {
  enum Endian {
    case Default
    case Little
    case Big
  }
}


/// Opening files should be done only for the required amount of time. This extension
/// provides a safe way for this to occur, and ensures the file is closed after work
/// has been completed.
extension File {

  /// Open the file represented by the receiver. The file will be available for access
  /// with in the provided block.
  func open(accessInBlock block: (File) -> Void) -> File {
    if let openFile = acquireNewFileHandle(internalMode) {
      block(openFile)
      openFile.close()
    }
    return self
  }

  /// Close the receivers file handle
  func close() {
    guard let handle = handle else { return }
    fclose(handle)
  }

}


/// Extension for handling the opening and closing of files
extension File {

  /// Test to see if there is a valid file handle associated with the receiver
  private var hasFileHandle: Bool { return handle != nil }

  /// Acquire a lock on the file. If this is the first lock then a file
  /// handle will be created. Returns true on sucessfully acquiring a
  /// lock.
  private func acquireNewFileHandle(mode: File.Mode = .Read) -> File? {
    var newFile = File(self, newMode: mode)
    newFile.handle = fopen(path, newFile.internalMode.code)
    if let handle = newFile.handle where handle == UnsafeMutablePointer<FILE>() { return nil }
    return newFile
  }

}


/// Extension for requesting information about the various File properties
extension File {

  /// Get the size of the file contents in bytes. This is *not* the size of the file
  /// on disk!
  var size: Int {
    if let openFile = acquireNewFileHandle() {
      guard let handle = openFile.handle else { return 0 }
      let pos = ftell(handle)
      fseek(handle, 0, SEEK_END)
      let endPos = ftell(handle)
      fseek(handle, pos, SEEK_SET)
      openFile.close()
      return endPos
    }
    return 0
  }

  /// Is the position in the file currently at the end?
  var eof: Bool {
    return pos >= size
  }

}


/// Extension for reading the contents of the file as a/series of strings
extension File {

  /// If the size is specified as 0 then the entire contents of the file will
  /// be read, otherwise a string of that size will be read from the current
  /// file location.
  func readString(size: Int = 0) -> String {
    guard let handle = handle where hasFileHandle else { fatalError() }

    let readSize = size > 0 ? size : self.size
    let data = UnsafeMutablePointer<Void>.alloc(sizeof(UInt8) * Int(readSize))

    let n = fread(data, sizeof(UInt8), Int(readSize), handle)
    assert(n == readSize, "Read \(n) bytes from the file, but expected to read \(size) bytes")

    if let s = String.fromCString(UnsafePointer<Int8>(data)) {
      return s
    }

    fatalError()
  }

  /// Read a single line of text from the file
  func readLine() -> String {
    guard let handle = handle where hasFileHandle else { fatalError() }

    let prevPos = pos

    var count = 0
    let data = UnsafeMutablePointer<Void>.alloc(sizeof(UInt8))
    while true {
      let n = fread(data, sizeof(UInt8), 1, handle)
      count++
      if n == 0 { break }
      if String.fromCString(UnsafePointer<Int8>(data)) == "\n" { break }
    }

    fseek(handle, prevPos, SEEK_SET)
    let line = readString(count - 1)
    fseek(handle, prevPos + count, SEEK_SET)

    return line
  }

}

/// Extension for reading binary file contents
extension File {

  private func readBytesAsUInt64(count: Int = 2, endian: Endian = .Default) -> UInt64 {
    if endian == .Default { return readBytesAsUInt64(count, endian: internalEndian) }

    var value = UInt64(0)
    count.iterate { idx in
      let byte = self.readUInt8()

      if endian == .Big { value |= UInt64(UInt64(byte) << UInt64((count - idx - 1) * 8)) }
      else { value |= UInt64(UInt64(byte) << UInt64(idx * 8)) }
    }
    
    return value
  }

  /// Read an array of bytes
  func readBytes(count: Int = 1) -> [UInt8] {
    return [UInt8](count: count, repeatedValue: 0).map { _ -> UInt8 in
      return self.readUInt8()
    }
  }

  /// Read a single unsigned byte from the current location in the file
  func readUInt8() -> UInt8 {
    guard let handle = handle where hasFileHandle else { fatalError() }
    let rawData = UnsafeMutablePointer<Void>.alloc(sizeof(UInt8))
    fread(rawData, sizeof(UInt8), 1, handle)
    let data = UnsafePointer<UInt8>(rawData)
    return data[0]
  }

  /// Read a single signed byte from the current location in the file
  func readInt8() -> Int8 {
    return Int8(readUInt8())
  }

  /// Read a single unsigned short from the current location in the file.
  /// The endianness is assumed to be little unless specified otherwise
  func readUInt16(endian: Endian = .Default) -> UInt16 {
    return UInt16(readBytesAsUInt64(sizeof(UInt16), endian: endian))
  }

  /// Read a single signed short from the current location in the file.
  /// The endianness is assumed to be little unless specified otherwise
  func readInt16(endian: Endian = .Default) -> Int16 {
    return Int16(readUInt16(endian))
  }

  /// Read a single unsigned long from the current location in the file.
  func readUInt32(endian: Endian = .Default) -> UInt32 {
    return UInt32(readBytesAsUInt64(sizeof(UInt32), endian: endian))
  }

  /// Read a single signed long from the current location in the file.
  func readInt32(endian: Endian = .Default) -> Int32 {
    return Int32(readUInt32(endian))
  }

}


/// Extension for writing text file contents
extension File {

  /// Write a single chunk of text to the current position in the file.
  func print(text: String, newline: Bool = false) {
    guard let handle = handle else { return }
    let outText = newline ? "\(text)\n" : "\(text)"
    fwrite(String.convertToVoidPointer(outText), sizeof(UInt8), outText.characters.count, handle)
  }

}

FruitNames.txt

Apple
Banana
Orange
Pear
Grapes
Strawberry
Peach
Melon

HelperExtensions.swift

/*
The MIT License (MIT)

Copyright (c) 2015 Tom Hancocks

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.

This a library API for file access in Swift. The aim of the library is to decouple
from Foundation and the legacy aspects and concepts that were driven by Objective-C.
*/

extension Int {
  func iterate(block: (Int)->Void) {
    for i in 0..<self { block(i) }
  }
}

extension String {
  static func convertToVoidPointer(ptr: UnsafePointer<CChar>) -> UnsafePointer<Void> {
    return UnsafePointer<Void>(ptr)
  }
}

Path.swift

/*
The MIT License (MIT)

Copyright (c) 2015 Tom Hancocks

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.

This a library API for file access in Swift. The aim of the library is to decouple
from Foundation and the legacy aspects and concepts that were driven by Objective-C.
*/

import Darwin

// MARK:- Abstract Path Specification

/// Outlines what a file system path should be able to describe about itself
/// or create itself from.
protocol FileSystemPath: CustomStringConvertible {

  /// Create a new path using the specified string
  static func path(string: String) -> Self

  /// Create a new path using the specified path
  static func path(path: Self) -> Self

  /// Return the string representation of the receiver
  var stringRepresentation: String { get }

  /// Return an instance of the receiver that is an absolute 
  /// representation of the path.
  var absolutePath: Self { get }

  /// Returns the directory delimiter. This value defaults to
  /// POSIX standard of '/'
  var directoryDelimiter: String { get }

}

extension FileSystemPath {
  var directoryDelimiter: String { return "/" }
  var description: String { return stringRepresentation }
}



// MARK:- Concrete Path Structure

/// Represents a basic path type that is POSIX compliant
struct Path: FileSystemPath {
  private let value: String

  /// Initialise the receiver with the specified path string
  init(_ path: String) {
    self.value = path
  }

  /// Initialise the receiver with the specified FileSystemPath
  init(_ path: Path) {
    self.value = path.value
  }
}

extension Path {

  /// Create a new path using the specified string
  static func path(string: String) -> Path {
    return Path(string)
  }

  /// Create a new path using the specified path
  static func path(path: Path) -> Path {
    return Path(path)
  }

}

extension Path {

  /// Return the string representation of the receiver
  var stringRepresentation: String {
    return value
  }

}

extension Path {

  /// Return an instance of the receiver that is an absolute
  /// representation of the path.
  var absolutePath: Path {
    return by(expandingTilde: true)
  }

}



// MARK:- Implementation Specific

extension Path {

  /// Returns a new Path instance that represents the users home 
  /// directory
  static func home() -> Path {
    return Path("~/").absolutePath
  }
}

extension Path {

  /// Returns a new instance of the receiver with the tilde at the start of the
  /// path expanded to match the users home directory.
  func by(expandingTilde f: Bool) -> Path {
    if value.hasPrefix("~/") && f {
      if let homeString = String.fromCString(getenv("HOME")) {
        let strippedPath = value[value.startIndex.advancedBy(2)..<value.endIndex]
        return Path("\(homeString)\(directoryDelimiter)\(strippedPath)")
      }
    }
    return self
  }

  /// Returns a new instance of the receiver with an additional path component
  /// added to the end of it.
  func by(appendingPathComponent rawComponent: String) -> Path {
    var component = rawComponent
    if component.hasPrefix(directoryDelimiter) {
      component = component[component.startIndex.successor()..<component.endIndex]
    }

    if value.hasSuffix(directoryDelimiter) {
      return Path("\(value)\(component)")
    }
    else {
      return Path("\(value)\(directoryDelimiter)\(component)")
    }
  }

  func by(appendingPathComponent path: Path) -> Path {
    return by(appendingPathComponent: path.stringRepresentation)
  }

}

Result

Reading names of fruit from /Users/tomhancocks/Desktop/FruitNames.txt
New fruit named: Apple
New fruit named: Banana
New fruit named: Orange
New fruit named: Pear
New fruit named: Grapes
New fruit named: Strawberry
New fruit named: Peach
New fruit named: Melon
-----------
Writing city names to /Users/tomhancocks/Desktop/Cities.txt
Adding city named: London
Adding city named: York
Adding city named: Leeds
Adding city named: Sheffield
Adding city named: Manchester
Adding city named: Newcastle
Adding city named: Edinburgh

Test.swift

/*
The MIT License (MIT)

Copyright (c) 2015 Tom Hancocks

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.

This a library API for file access in Swift. The aim of the library is to decouple
from Foundation and the legacy aspects and concepts that were driven by Objective-C.
*/

let fruitFilePath = Path("~/Desktop/FruitNames.txt").absolutePath
print("Reading names of fruit from \(fruitFilePath)")
File(fruitFilePath).open { file in
  while !file.eof {
    let fruitName = file.readLine()
    print("New fruit named: \(fruitName)")
  }
}

print("-----------")

let citiesFilePath = Path("~/Desktop/Cities.txt").absolutePath
print("Writing city names to \(citiesFilePath)")

let cities = ["London", "York", "Leeds", "Sheffield", "Manchester", "Newcastle", "Edinburgh"]
File(citiesFilePath, mode: .Write).open { file in
  for city in cities {
    print("Adding city named: \(city)")
    file.print(city, newline: true)
  }
}