0001    import Echo
0002    import Foundation
0003    
0004    #if os(Linux)
0005    import Glibc
0006    #else
0007    import Darwin
0008    #endif
0009    
0010    public enum EncodingType
Data.swift:4
    static var encodingType: EncodingType { get }
Data.swift:9
    public static var encodingType: EncodingType { {
0011        case UTF8
Data.swift:10
        return .UTF8
Vaquita.swift:17
        case UTF8:
Vaquita.swift:26
        case UTF8:
0012    
0013        var typeForEncoding: Any.Type {
0014    
0015            let type: Any.Type
0016            switch self {
0017            case UTF8:
0018                type = UInt8.self
0019            }
0020    
0021            return type
0022        }
0023    
0024        var encoding
Data.swift:43
            encoding: UInt8.encodingType.encoding,: UInt {
0025            switch self {
0026            case UTF8:
0027                return NSUTF8StringEncoding
0028            }
0029        }
0030    }
0031    
0032    public enum FileError
Vaquita.swift:58
            throw FileError.OpenFailed
Vaquita.swift:96
            throw FileError.OpenFailed: ErrorType {
0033        case ReadFailed
0034        case WriteFailed
0035        case OpenFailed
Vaquita.swift:58
            throw FileError.OpenFailed
Vaquita.swift:96
            throw FileError.OpenFailed
0036    }
0037    
0038    public class Vaquita {
0039    
0040        static let fileQueue
Vaquita.swift:45
        dispatch_async(fileQueue) {
Vaquita.swift:83
        dispatch_async(fileQueue) { = dispatch_queue_create("com.vaquita.file", 
0041                                                     DISPATCH_QUEUE_SERIAL)
0042        
0043        public class func readFile(path path: String, 
0044                                   handler: (data: Data?, error: ErrorType?) -> ()) {
0045            dispatch_async(fileQueue) {
0046                do {
0047                    let data = try self.readFileSync(path: path)
0048                    handler(data: data, error: nil)
0049                } catch {
0050                    handler(data: nil, error: error)
0051                }
0052            }
0053        }
0054    
0055        public class func readFileSync
Vaquita.swift:47
                let data = try self.readFileSync(path: path)(path path: String) throws -> Data {
0056            let fileptr = fopen(path, "rb")
0057            if fileptr == nil {
0058                throw FileError.OpenFailed
0059            }
0060            fseek(fileptr, , SEEK_END)
0061            let fileLength = ftell(fileptr)
0062            rewind(fileptr)
0063    
0064            var buffer: UnsafeMutablePointer<UInt8> = 
0065                UnsafeMutablePointer.alloc(fileLength)
0066            fread(buffer, fileLength, , fileptr)
0067            fclose(fileptr)
0068    
0069            var data = [UInt8]()
0070            for _ in  ..< fileLength {
0071                
0072                data.append(buffer.memory)
0073                buffer = buffer.successor()
0074            }
0075    
0076            buffer.destroy()
0077    
0078            return Data(bytes: data)
0079        }
0080    
0081        public class func writeData(data: Data, toFilePath path: String, 
0082            handler: (error: ErrorType?) -> ()) {
0083            dispatch_async(fileQueue) {
0084                do {
0085                    try self.writeDataSync(data, toFilePath: path)
0086                    handler(error: nil)
0087                } catch {
0088                    handler(error: error)
0089                }
0090            }
0091        }
0092    
0093        public class func writeDataSync
Vaquita.swift:85
                try self.writeDataSync(data, toFilePath: path)(data: Data, toFilePath path: String) throws {
0094            let fileptr = fopen(path, "w")
0095            if fileptr == nil {
0096                throw FileError.OpenFailed
0097            }
0098            let string = try data.toString()
0099            fwrite(string, , data.size, fileptr)
0100            fclose(fileptr)
0101        }
0102    }
0103