Calculating 64bit checksum of a part of file in Swift - objective-c

Question

I'm trying to port the code for calculating OpenSubtitles hash and I'm using the Objective-C example as reference (http://trac.opensubtitles.org/projects/opensubtitles/wiki/HashSourceCodes#Objective-C). The formula for the hash is file size + 64bit checksum of the first 64k of the file + 64bit checksum of the last 64k of the file.
I'm having trouble with the bit of code that calculates the checksums. This is the important part of the code in Objective-C:
const NSUInteger CHUNK_SIZE=65536;
NSData *fileDataBegin, *fileDataEnd;
uint64_t hash=0;
fileDataBegin = [handle readDataOfLength:(NSUInteger)CHUNK_SIZE];
[handle seekToEndOfFile];
unsigned long long fileSize = [handle offsetInFile];
uint64_t * data_bytes= (uint64_t*)[fileDataBegin bytes];
for( int i=0; i< CHUNK_SIZE/sizeof(uint64_t); i++ )
hash+=data_bytes[i];
I tried converting most of the code ti Swift by just rewriting it in a similar fashion. I'm having trouble with coming up with the replacement code for this little bit:
uint64_t * data_bytes= (uint64_t*)[fileDataBegin bytes];
for( int i=0; i< CHUNK_SIZE/sizeof(uint64_t); i++ )
hash+=data_bytes[i];
Any help would be great.

Answer 1

uint64_t * data_bytes= (uint64_t*)[fileDataBegin bytes];
can be translated as
let data_bytes = UnsafeBufferPointer<UInt64>(
start: UnsafePointer(fileDataBegin.bytes),
count: fileDataBegin.length/sizeof(UInt64)
)
which has the additional advantage that data_bytes is not just
a pointer, but also stores the number of elements. An
UnsafeBufferPointer can be treated almost like a Swift Array.
Therefore
for( int i=0; i< CHUNK_SIZE/sizeof(uint64_t); i++ )
hash+=data_bytes[i];
can be written simply as
var hash : UInt64 = 0
// ...
hash = reduce(data_bytes, hash) { $0 &+ $1 }
using
/// Return the result of repeatedly calling `combine` with an
/// accumulated value initialized to `initial` and each element of
/// `sequence`, in turn.
func reduce<S : SequenceType, U>(sequence: S, initial: U, combine: (U, S.Generator.Element) -> U) -> U
and the "overflow operator" &+:
Unlike arithmetic operators in C, arithmetic operators in Swift do not
overflow by default. Overflow behavior is trapped and reported as an
error. To opt in to overflow behavior, use Swift’s second set of
arithmetic operators that overflow by default, such as the overflow
addition operator (&+). All of these overflow operators begin with an
ampersand (&).