@@ -13,34 +13,36 @@
  * file.
  */
 
 #include "config.h"
 
-#import "OFData+CryptoHashing.h"
+#import "OFData+CryptographicHashing.h"
 #import "OFString.h"
-#import "OFCryptoHash.h"
+#import "OFCryptographicHash.h"
 #import "OFMD5Hash.h"
 #import "OFRIPEMD160Hash.h"
 #import "OFSHA1Hash.h"
 #import "OFSHA224Hash.h"
 #import "OFSHA256Hash.h"
 #import "OFSHA384Hash.h"
 #import "OFSHA512Hash.h"
 
-int _OFData_CryptoHashing_reference;
+int _OFData_CryptographicHashing_reference;
 
-@implementation OFData (CryptoHashing)
-- (OFString *)of_cryptoHashWithClass: (Class <OFCryptoHash>)class OF_DIRECT
+@implementation OFData (CryptographicHashing)
+static OFString *
+stringByHashing(Class <OFCryptographicHash> class, OFData *self)
 {
 	void *pool = objc_autoreleasePoolPush();
-	id <OFCryptoHash> hash =
-	    [class cryptoHashWithAllowsSwappableMemory: true];
+	id <OFCryptographicHash> hash =
+	    [class hashWithAllowsSwappableMemory: true];
 	size_t digestSize = [class digestSize];
 	const unsigned char *digest;
 	char cString[digestSize * 2];
 
-	[hash updateWithBuffer: _items length: _count * _itemSize];
+	[hash updateWithBuffer: self->_items
+			length: self->_count * self->_itemSize];
 	digest = hash.digest;
 
 	for (size_t i = 0; i < digestSize; i++) {
 		uint8_t high, low;
 
@@ -58,38 +60,38 @@
 				    length: digestSize * 2];
 }
 
 - (OFString *)stringByMD5Hashing
 {
-	return [self of_cryptoHashWithClass: [OFMD5Hash class]];
+	return stringByHashing([OFMD5Hash class], self);
 }
 
 - (OFString *)stringByRIPEMD160Hashing
 {
-	return [self of_cryptoHashWithClass: [OFRIPEMD160Hash class]];
+	return stringByHashing([OFRIPEMD160Hash class], self);
 }
 
 - (OFString *)stringBySHA1Hashing
 {
-	return [self of_cryptoHashWithClass: [OFSHA1Hash class]];
+	return stringByHashing([OFSHA1Hash class], self);
 }
 
 - (OFString *)stringBySHA224Hashing
 {
-	return [self of_cryptoHashWithClass: [OFSHA224Hash class]];
+	return stringByHashing([OFSHA224Hash class], self);
 }
 
 - (OFString *)stringBySHA256Hashing
 {
-	return [self of_cryptoHashWithClass: [OFSHA256Hash class]];
+	return stringByHashing([OFSHA256Hash class], self);
 }
 
 - (OFString *)stringBySHA384Hashing
 {
-	return [self of_cryptoHashWithClass: [OFSHA384Hash class]];
+	return stringByHashing([OFSHA384Hash class], self);
 }
 
 - (OFString *)stringBySHA512Hashing
 {
-	return [self of_cryptoHashWithClass: [OFSHA512Hash class]];
+	return stringByHashing([OFSHA512Hash class], self);
 }
 @end