From 7b02207537d35bfa1714bf8beafc921f717d100a Mon Sep 17 00:00:00 2001
From: 单军华
Date: Wed, 11 Jul 2018 10:47:42 +0800
Subject: [PATCH] 首次上传
---
screendisplay/Pods/YYCategories/YYCategories/Foundation/NSData+YYAdd.m | 642 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 642 insertions(+), 0 deletions(-)
diff --git a/screendisplay/Pods/YYCategories/YYCategories/Foundation/NSData+YYAdd.m b/screendisplay/Pods/YYCategories/YYCategories/Foundation/NSData+YYAdd.m
new file mode 100755
index 0000000..26c7f0e
--- /dev/null
+++ b/screendisplay/Pods/YYCategories/YYCategories/Foundation/NSData+YYAdd.m
@@ -0,0 +1,642 @@
+//
+// NSData+YYAdd.m
+// YYCategories <https://github.com/ibireme/YYCategories>
+//
+// Created by ibireme on 13/4/4.
+// Copyright (c) 2015 ibireme.
+//
+// This source code is licensed under the MIT-style license found in the
+// LICENSE file in the root directory of this source tree.
+//
+
+#import "NSData+YYAdd.h"
+#import "YYCategoriesMacro.h"
+#include <CommonCrypto/CommonCrypto.h>
+#include <zlib.h>
+
+YYSYNTH_DUMMY_CLASS(NSData_YYAdd)
+
+
+@implementation NSData (YYAdd)
+
+- (NSString *)md2String {
+ unsigned char result[CC_MD2_DIGEST_LENGTH];
+ CC_MD2(self.bytes, (CC_LONG)self.length, result);
+ return [NSString stringWithFormat:
+ @"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+ result[0], result[1], result[2], result[3],
+ result[4], result[5], result[6], result[7],
+ result[8], result[9], result[10], result[11],
+ result[12], result[13], result[14], result[15]
+ ];
+}
+
+- (NSData *)md2Data {
+ unsigned char result[CC_MD2_DIGEST_LENGTH];
+ CC_MD2(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_MD2_DIGEST_LENGTH];
+}
+
+- (NSString *)md4String {
+ unsigned char result[CC_MD4_DIGEST_LENGTH];
+ CC_MD4(self.bytes, (CC_LONG)self.length, result);
+ return [NSString stringWithFormat:
+ @"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+ result[0], result[1], result[2], result[3],
+ result[4], result[5], result[6], result[7],
+ result[8], result[9], result[10], result[11],
+ result[12], result[13], result[14], result[15]
+ ];
+}
+
+- (NSData *)md4Data {
+ unsigned char result[CC_MD4_DIGEST_LENGTH];
+ CC_MD4(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_MD4_DIGEST_LENGTH];
+}
+
+- (NSString *)md5String {
+ unsigned char result[CC_MD5_DIGEST_LENGTH];
+ CC_MD5(self.bytes, (CC_LONG)self.length, result);
+ return [NSString stringWithFormat:
+ @"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+ result[0], result[1], result[2], result[3],
+ result[4], result[5], result[6], result[7],
+ result[8], result[9], result[10], result[11],
+ result[12], result[13], result[14], result[15]
+ ];
+}
+
+- (NSData *)md5Data {
+ unsigned char result[CC_MD5_DIGEST_LENGTH];
+ CC_MD5(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_MD5_DIGEST_LENGTH];
+}
+
+- (NSString *)sha1String {
+ unsigned char result[CC_SHA1_DIGEST_LENGTH];
+ CC_SHA1(self.bytes, (CC_LONG)self.length, result);
+ NSMutableString *hash = [NSMutableString
+ stringWithCapacity:CC_SHA1_DIGEST_LENGTH * 2];
+ for (int i = 0; i < CC_SHA1_DIGEST_LENGTH; i++) {
+ [hash appendFormat:@"%02x", result[i]];
+ }
+ return hash;
+}
+
+- (NSData *)sha1Data {
+ unsigned char result[CC_SHA1_DIGEST_LENGTH];
+ CC_SHA1(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_SHA1_DIGEST_LENGTH];
+}
+
+- (NSString *)sha224String {
+ unsigned char result[CC_SHA224_DIGEST_LENGTH];
+ CC_SHA224(self.bytes, (CC_LONG)self.length, result);
+ NSMutableString *hash = [NSMutableString
+ stringWithCapacity:CC_SHA224_DIGEST_LENGTH * 2];
+ for (int i = 0; i < CC_SHA224_DIGEST_LENGTH; i++) {
+ [hash appendFormat:@"%02x", result[i]];
+ }
+ return hash;
+}
+
+- (NSData *)sha224Data {
+ unsigned char result[CC_SHA224_DIGEST_LENGTH];
+ CC_SHA224(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_SHA224_DIGEST_LENGTH];
+}
+
+- (NSString *)sha256String {
+ unsigned char result[CC_SHA256_DIGEST_LENGTH];
+ CC_SHA256(self.bytes, (CC_LONG)self.length, result);
+ NSMutableString *hash = [NSMutableString
+ stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
+ for (int i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
+ [hash appendFormat:@"%02x", result[i]];
+ }
+ return hash;
+}
+
+- (NSData *)sha256Data {
+ unsigned char result[CC_SHA256_DIGEST_LENGTH];
+ CC_SHA256(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_SHA256_DIGEST_LENGTH];
+}
+
+- (NSString *)sha384String {
+ unsigned char result[CC_SHA384_DIGEST_LENGTH];
+ CC_SHA384(self.bytes, (CC_LONG)self.length, result);
+ NSMutableString *hash = [NSMutableString
+ stringWithCapacity:CC_SHA384_DIGEST_LENGTH * 2];
+ for (int i = 0; i < CC_SHA384_DIGEST_LENGTH; i++) {
+ [hash appendFormat:@"%02x", result[i]];
+ }
+ return hash;
+}
+
+- (NSData *)sha384Data {
+ unsigned char result[CC_SHA384_DIGEST_LENGTH];
+ CC_SHA384(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_SHA384_DIGEST_LENGTH];
+}
+
+- (NSString *)sha512String {
+ unsigned char result[CC_SHA512_DIGEST_LENGTH];
+ CC_SHA512(self.bytes, (CC_LONG)self.length, result);
+ NSMutableString *hash = [NSMutableString
+ stringWithCapacity:CC_SHA512_DIGEST_LENGTH * 2];
+ for (int i = 0; i < CC_SHA512_DIGEST_LENGTH; i++) {
+ [hash appendFormat:@"%02x", result[i]];
+ }
+ return hash;
+}
+
+- (NSData *)sha512Data {
+ unsigned char result[CC_SHA512_DIGEST_LENGTH];
+ CC_SHA512(self.bytes, (CC_LONG)self.length, result);
+ return [NSData dataWithBytes:result length:CC_SHA512_DIGEST_LENGTH];
+}
+
+- (NSString *)hmacStringUsingAlg:(CCHmacAlgorithm)alg withKey:(NSString *)key {
+ size_t size;
+ switch (alg) {
+ case kCCHmacAlgMD5: size = CC_MD5_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA1: size = CC_SHA1_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA224: size = CC_SHA224_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA256: size = CC_SHA256_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA384: size = CC_SHA384_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA512: size = CC_SHA512_DIGEST_LENGTH; break;
+ default: return nil;
+ }
+ unsigned char result[size];
+ const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding];
+ CCHmac(alg, cKey, strlen(cKey), self.bytes, self.length, result);
+ NSMutableString *hash = [NSMutableString stringWithCapacity:size * 2];
+ for (int i = 0; i < size; i++) {
+ [hash appendFormat:@"%02x", result[i]];
+ }
+ return hash;
+}
+
+- (NSData *)hmacDataUsingAlg:(CCHmacAlgorithm)alg withKey:(NSData *)key {
+ size_t size;
+ switch (alg) {
+ case kCCHmacAlgMD5: size = CC_MD5_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA1: size = CC_SHA1_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA224: size = CC_SHA224_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA256: size = CC_SHA256_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA384: size = CC_SHA384_DIGEST_LENGTH; break;
+ case kCCHmacAlgSHA512: size = CC_SHA512_DIGEST_LENGTH; break;
+ default: return nil;
+ }
+ unsigned char result[size];
+ CCHmac(alg, [key bytes], key.length, self.bytes, self.length, result);
+ return [NSData dataWithBytes:result length:size];
+}
+
+- (NSString *)hmacMD5StringWithKey:(NSString *)key {
+ return [self hmacStringUsingAlg:kCCHmacAlgMD5 withKey:key];
+}
+
+- (NSData *)hmacMD5DataWithKey:(NSData *)key {
+ return [self hmacDataUsingAlg:kCCHmacAlgMD5 withKey:key];
+}
+
+- (NSString *)hmacSHA1StringWithKey:(NSString *)key {
+ return [self hmacStringUsingAlg:kCCHmacAlgSHA1 withKey:key];
+}
+
+- (NSData *)hmacSHA1DataWithKey:(NSData *)key {
+ return [self hmacDataUsingAlg:kCCHmacAlgSHA1 withKey:key];
+}
+
+- (NSString *)hmacSHA224StringWithKey:(NSString *)key {
+ return [self hmacStringUsingAlg:kCCHmacAlgSHA224 withKey:key];
+}
+
+- (NSData *)hmacSHA224DataWithKey:(NSData *)key {
+ return [self hmacDataUsingAlg:kCCHmacAlgSHA224 withKey:key];
+}
+
+- (NSString *)hmacSHA256StringWithKey:(NSString *)key {
+ return [self hmacStringUsingAlg:kCCHmacAlgSHA256 withKey:key];
+}
+
+- (NSData *)hmacSHA256DataWithKey:(NSData *)key {
+ return [self hmacDataUsingAlg:kCCHmacAlgSHA256 withKey:key];
+}
+
+- (NSString *)hmacSHA384StringWithKey:(NSString *)key {
+ return [self hmacStringUsingAlg:kCCHmacAlgSHA384 withKey:key];
+}
+
+- (NSData *)hmacSHA384DataWithKey:(NSData *)key {
+ return [self hmacDataUsingAlg:kCCHmacAlgSHA384 withKey:key];
+}
+
+- (NSString *)hmacSHA512StringWithKey:(NSString *)key {
+ return [self hmacStringUsingAlg:kCCHmacAlgSHA512 withKey:key];
+}
+
+- (NSData *)hmacSHA512DataWithKey:(NSData *)key {
+ return [self hmacDataUsingAlg:kCCHmacAlgSHA512 withKey:key];
+}
+
+- (NSString *)crc32String {
+ uLong result = crc32(0, self.bytes, (uInt)self.length);
+ return [NSString stringWithFormat:@"%08x", (uint32_t)result];
+}
+
+- (uint32_t)crc32 {
+ uLong result = crc32(0, self.bytes, (uInt)self.length);
+ return (uint32_t)result;
+}
+
+- (NSData *)aes256EncryptWithKey:(NSData *)key iv:(NSData *)iv {
+ if (key.length != 16 && key.length != 24 && key.length != 32) {
+ return nil;
+ }
+ if (iv.length != 16 && iv.length != 0) {
+ return nil;
+ }
+
+ NSData *result = nil;
+ size_t bufferSize = self.length + kCCBlockSizeAES128;
+ void *buffer = malloc(bufferSize);
+ if (!buffer) return nil;
+ size_t encryptedSize = 0;
+ CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt,
+ kCCAlgorithmAES128,
+ kCCOptionPKCS7Padding,
+ key.bytes,
+ key.length,
+ iv.bytes,
+ self.bytes,
+ self.length,
+ buffer,
+ bufferSize,
+ &encryptedSize);
+ if (cryptStatus == kCCSuccess) {
+ result = [[NSData alloc]initWithBytes:buffer length:encryptedSize];
+ free(buffer);
+ return result;
+ } else {
+ free(buffer);
+ return nil;
+ }
+}
+
+- (NSData *)aes256DecryptWithkey:(NSData *)key iv:(NSData *)iv {
+ if (key.length != 16 && key.length != 24 && key.length != 32) {
+ return nil;
+ }
+ if (iv.length != 16 && iv.length != 0) {
+ return nil;
+ }
+
+ NSData *result = nil;
+ size_t bufferSize = self.length + kCCBlockSizeAES128;
+ void *buffer = malloc(bufferSize);
+ if (!buffer) return nil;
+ size_t encryptedSize = 0;
+ CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt,
+ kCCAlgorithmAES128,
+ kCCOptionPKCS7Padding,
+ key.bytes,
+ key.length,
+ iv.bytes,
+ self.bytes,
+ self.length,
+ buffer,
+ bufferSize,
+ &encryptedSize);
+ if (cryptStatus == kCCSuccess) {
+ result = [[NSData alloc]initWithBytes:buffer length:encryptedSize];
+ free(buffer);
+ return result;
+ } else {
+ free(buffer);
+ return nil;
+ }
+}
+
+- (NSString *)utf8String {
+ if (self.length > 0) {
+ return [[NSString alloc] initWithData:self encoding:NSUTF8StringEncoding];
+ }
+ return @"";
+}
+
+- (NSString *)hexString {
+ NSUInteger length = self.length;
+ NSMutableString *result = [NSMutableString stringWithCapacity:length * 2];
+ const unsigned char *byte = self.bytes;
+ for (int i = 0; i < length; i++, byte++) {
+ [result appendFormat:@"%02X", *byte];
+ }
+ return result;
+}
+
++ (NSData *)dataWithHexString:(NSString *)hexStr {
+ hexStr = [hexStr stringByReplacingOccurrencesOfString:@" " withString:@""];
+ hexStr = [hexStr lowercaseString];
+ NSUInteger len = hexStr.length;
+ if (!len) return nil;
+ unichar *buf = malloc(sizeof(unichar) * len);
+ if (!buf) return nil;
+ [hexStr getCharacters:buf range:NSMakeRange(0, len)];
+
+ NSMutableData *result = [NSMutableData data];
+ unsigned char bytes;
+ char str[3] = { '\0', '\0', '\0' };
+ int i;
+ for (i = 0; i < len / 2; i++) {
+ str[0] = buf[i * 2];
+ str[1] = buf[i * 2 + 1];
+ bytes = strtol(str, NULL, 16);
+ [result appendBytes:&bytes length:1];
+ }
+ free(buf);
+ return result;
+}
+
+static const char base64EncodingTable[64]
+= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const short base64DecodingTable[256] = {
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -2, -1, -1, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, -2, -2, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, -2, -2, -2,
+ -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, -2,
+ -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
+ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2
+};
+
+- (NSString *)base64EncodedString {
+ NSUInteger length = self.length;
+ if (length == 0)
+ return @"";
+
+ NSUInteger out_length = ((length + 2) / 3) * 4;
+ uint8_t *output = malloc(((out_length + 2) / 3) * 4);
+ if (output == NULL)
+ return nil;
+
+ const char *input = self.bytes;
+ NSInteger i, value;
+ for (i = 0; i < length; i += 3) {
+ value = 0;
+ for (NSInteger j = i; j < i + 3; j++) {
+ value <<= 8;
+ if (j < length) {
+ value |= (0xFF & input[j]);
+ }
+ }
+ NSInteger index = (i / 3) * 4;
+ output[index + 0] = base64EncodingTable[(value >> 18) & 0x3F];
+ output[index + 1] = base64EncodingTable[(value >> 12) & 0x3F];
+ output[index + 2] = ((i + 1) < length)
+ ? base64EncodingTable[(value >> 6) & 0x3F]
+ : '=';
+ output[index + 3] = ((i + 2) < length)
+ ? base64EncodingTable[(value >> 0) & 0x3F]
+ : '=';
+ }
+
+ NSString *base64 = [[NSString alloc] initWithBytes:output
+ length:out_length
+ encoding:NSASCIIStringEncoding];
+ free(output);
+ return base64;
+}
+
++ (NSData *)dataWithBase64EncodedString:(NSString *)base64EncodedString {
+ NSInteger length = base64EncodedString.length;
+ const char *string = [base64EncodedString cStringUsingEncoding:NSASCIIStringEncoding];
+ if (string == NULL)
+ return nil;
+
+ while (length > 0 && string[length - 1] == '=')
+ length--;
+
+ NSInteger outputLength = length * 3 / 4;
+ NSMutableData *data = [NSMutableData dataWithLength:outputLength];
+ if (data == nil)
+ return nil;
+ if (length == 0)
+ return data;
+
+ uint8_t *output = data.mutableBytes;
+ NSInteger inputPoint = 0;
+ NSInteger outputPoint = 0;
+ while (inputPoint < length) {
+ char i0 = string[inputPoint++];
+ char i1 = string[inputPoint++];
+ char i2 = inputPoint < length ? string[inputPoint++] : 'A';
+ char i3 = inputPoint < length ? string[inputPoint++] : 'A';
+
+ output[outputPoint++] = (base64DecodingTable[i0] << 2)
+ | (base64DecodingTable[i1] >> 4);
+ if (outputPoint < outputLength) {
+ output[outputPoint++] = ((base64DecodingTable[i1] & 0xf) << 4)
+ | (base64DecodingTable[i2] >> 2);
+ }
+ if (outputPoint < outputLength) {
+ output[outputPoint++] = ((base64DecodingTable[i2] & 0x3) << 6)
+ | base64DecodingTable[i3];
+ }
+ }
+
+ return data;
+}
+
+- (id)jsonValueDecoded {
+ NSError *error = nil;
+ id value = [NSJSONSerialization JSONObjectWithData:self options:kNilOptions error:&error];
+ if (error) {
+ NSLog(@"jsonValueDecoded error:%@", error);
+ }
+ return value;
+}
+
+- (NSData *)gzipInflate {
+ if ([self length] == 0) return self;
+
+ unsigned full_length = (unsigned)[self length];
+ unsigned half_length = (unsigned)[self length] / 2;
+
+ NSMutableData *decompressed = [NSMutableData
+ dataWithLength:full_length + half_length];
+ BOOL done = NO;
+ int status;
+
+ z_stream strm;
+ strm.next_in = (Bytef *)[self bytes];
+ strm.avail_in = (unsigned)[self length];
+ strm.total_out = 0;
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+
+ if (inflateInit2(&strm, (15 + 32)) != Z_OK) return nil;
+ while (!done) {
+ // Make sure we have enough room and reset the lengths.
+ if (strm.total_out >= [decompressed length])
+ [decompressed increaseLengthBy:half_length];
+ strm.next_out = [decompressed mutableBytes] + strm.total_out;
+ strm.avail_out = (uInt)([decompressed length] - strm.total_out);
+
+ // Inflate another chunk.
+ status = inflate(&strm, Z_SYNC_FLUSH);
+ if (status == Z_STREAM_END) done = YES;
+ else if (status != Z_OK) break;
+ }
+ if (inflateEnd(&strm) != Z_OK) return nil;
+
+ // Set real length.
+ if (done) {
+ [decompressed setLength:strm.total_out];
+ return [NSData dataWithData:decompressed];
+ } else return nil;
+}
+
+- (NSData *)gzipDeflate {
+ if ([self length] == 0) return self;
+
+ z_stream strm;
+
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.total_out = 0;
+ strm.next_in = (Bytef *)[self bytes];
+ strm.avail_in = (uInt)[self length];
+
+ // Compresssion Levels:
+ // Z_NO_COMPRESSION
+ // Z_BEST_SPEED
+ // Z_BEST_COMPRESSION
+ // Z_DEFAULT_COMPRESSION
+
+ if (deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, (15 + 16),
+ 8, Z_DEFAULT_STRATEGY) != Z_OK)
+ return nil;
+
+ // 16K chunks for expansion
+ NSMutableData *compressed = [NSMutableData dataWithLength:16384];
+
+ do {
+ if (strm.total_out >= [compressed length])
+ [compressed increaseLengthBy:16384];
+
+ strm.next_out = [compressed mutableBytes] + strm.total_out;
+ strm.avail_out = (uInt)([compressed length] - strm.total_out);
+
+ deflate(&strm, Z_FINISH);
+ }
+ while (strm.avail_out == 0);
+
+ deflateEnd(&strm);
+
+ [compressed setLength:strm.total_out];
+ return [NSData dataWithData:compressed];
+}
+
+- (NSData *)zlibInflate {
+ if ([self length] == 0) return self;
+
+ NSUInteger full_length = [self length];
+ NSUInteger half_length = [self length] / 2;
+
+ NSMutableData *decompressed = [NSMutableData
+ dataWithLength:full_length + half_length];
+ BOOL done = NO;
+ int status;
+
+ z_stream strm;
+ strm.next_in = (Bytef *)[self bytes];
+ strm.avail_in = (uInt)full_length;
+ strm.total_out = 0;
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+
+ if (inflateInit(&strm) != Z_OK) return nil;
+
+ while (!done) {
+ // Make sure we have enough room and reset the lengths.
+ if (strm.total_out >= [decompressed length])
+ [decompressed increaseLengthBy:half_length];
+ strm.next_out = [decompressed mutableBytes] + strm.total_out;
+ strm.avail_out = (uInt)([decompressed length] - strm.total_out);
+
+ // Inflate another chunk.
+ status = inflate(&strm, Z_SYNC_FLUSH);
+ if (status == Z_STREAM_END) done = YES;
+ else if (status != Z_OK) break;
+ }
+ if (inflateEnd(&strm) != Z_OK) return nil;
+
+ // Set real length.
+ if (done) {
+ [decompressed setLength:strm.total_out];
+ return [NSData dataWithData:decompressed];
+ } else return nil;
+}
+
+- (NSData *)zlibDeflate {
+ if ([self length] == 0) return self;
+
+ z_stream strm;
+
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.total_out = 0;
+ strm.next_in = (Bytef *)[self bytes];
+ strm.avail_in = (uInt)[self length];
+
+ // Compresssion Levels:
+ // Z_NO_COMPRESSION
+ // Z_BEST_SPEED
+ // Z_BEST_COMPRESSION
+ // Z_DEFAULT_COMPRESSION
+
+ if (deflateInit(&strm, Z_DEFAULT_COMPRESSION) != Z_OK) return nil;
+
+ // 16K chuncks for expansion
+ NSMutableData *compressed = [NSMutableData dataWithLength:16384];
+
+ do {
+ if (strm.total_out >= [compressed length])
+ [compressed increaseLengthBy:16384];
+
+ strm.next_out = [compressed mutableBytes] + strm.total_out;
+ strm.avail_out = (uInt)([compressed length] - strm.total_out);
+
+ deflate(&strm, Z_FINISH);
+ }
+ while (strm.avail_out == 0);
+
+ deflateEnd(&strm);
+
+ [compressed setLength:strm.total_out];
+ return [NSData dataWithData:compressed];
+}
+
++ (NSData *)dataNamed:(NSString *)name {
+ NSString *path = [[NSBundle mainBundle] pathForResource:name ofType:@""];
+ if (!path) return nil;
+ NSData *data = [NSData dataWithContentsOfFile:path];
+ return data;
+}
+
+@end
--
Gitblit v1.8.0