         return findKey(identifier, index: readIndex(index.offset[keyIndex]))
     }
     
-    func readIndex(offset: Int) -> Index {
+    public func readIndex(offset: Int) -> Index {
         if let index = indexCache[offset] { return index }
         let indexData = readIndexData(offset)
         indexData.flip()
         return indexData.getIndexedFileV1Index()
     }
     
-    func readIndexData(offset: Int) -> ByteBuffer {
+    public func readIndexData(offset: Int) -> ByteBuffer {
         return IndexedFileV1.readData(mappedBuffer, offset: offset, length: 984, pageSize: header.pageSize)
     }
     

    }

    public struct Header: Printable { // 1024
        var fileType: UInt32 = 0
        var pageSize: Int = 0
        var fileSize: Int = 0
        var fileVersion: UInt32 = 0
        var firstFreePageOffset: Int = 0
        var lastFreePageOffset: Int = 0
        var numberOfFreePages: Int = 0
        var rootIndexOffset: Int = 0
        
        public var description: String { return "File Type: \(fileType)\nPage Size: \(pageSize)" }
    }
    
    struct Index: Printable { // 984
        struct Key: Printable {
            let value: UInt32 = 0
            let offset: Int = 0
            let length: Int = 0
            
            var description: String { return "\(value):\(offset):\(length)" }
        }
        
        var offset: Array<Int> // 62
        var count: Int
        var key: Array<Key> // 61
        
        var isLeaf: Bool { return offset[0] == 0 }
        var description: String { return "\(offset):\(count):\(key)" }
    }
}

        return nil
    }
    
    public func findKey(identifier: UInt32, index: Index) -> Index.Key? {
        var keyIndex = 0
        while keyIndex < index.count && identifier > index.key[keyIndex].value { keyIndex++ }
        if index.key[keyIndex].value == identifier { return index.key[keyIndex] }
