0001    //
0002    //  BigUInt Data.swift
0003    //  BigInt
0004    //
0005    //  Created by Károly Lőrentey on 2016-01-04.
0006    //  Copyright © 2016 Károly Lőrentey. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    extension BigUInt {
0012        //MARK: NSData Conversion
0013    
0014        /// Initializes an integer from the bits stored inside a piece of `NSData`.
0015        /// The data is assumed to be in network (big-endian) byte order.
0016        public initBigUInt Random.swift:33         return BigUInt(NSData(bytesNoCopy: buffer, length: byteCount, freeWhenDone: false))(_ data: NSData) {
0017            // This assumes Digit is binary.
0018            precondition(Digit.width % 8 == 0)
0019    
0020            self.init()
0021    
0022            let length = data.length
0023            guard length > 0 else { return }
0024            let bytesPerDigit = Digit.width / 8
0025            var index = length / bytesPerDigit
0026            var c = bytesPerDigit - length % bytesPerDigit
0027            if c == bytesPerDigit {
0028                c = 0
0029                index -= 1
0030            }
0031            var digit: Digit = 0
0032            data.enumerateByteRangesUsingBlock { p, range, stop in
0033                let p = UnsafePointer<UInt8>(p)
0034                for i in 0 ..< range.length {
0035                    digit <<= 8
0036                    digit += Digit(p[i])
0037                    c += 1
0038                    if c == bytesPerDigit {
0039                        self[index] = digit
0040                        index -= 1
0041                        c = 0
0042                        digit = 0
0043                    }
0044                }
0045            }
0046            assert(c == 0 && digit == 0 && index == -1)
0047        }
0048    
0049        /// Return an `NSData` instance that contains the base-256 representation of this integer, in network (big-endian) byte order.
0050        @warn_unused_result
0051        public func serialize() -> NSData {
0052            // This assumes Digit is binary.
0053            precondition(Digit.width % 8 == 0)
0054    
0055            let byteCount = (self.width + 7) / 8
0056    
0057            guard byteCount > 0 else { return NSData() }
0058            
0059            var byteArray = Array<UInt8>(count: byteCount, repeatedValue: 0)
0060            var i = byteCount - 1
0061            for digit in self {
0062                var digit = digit
0063                for _ in 0 ..< Digit.width / 8 {
0064                    byteArray[i] = UInt8(digit & 0xFF)
0065                    digit >>= 8
0066                    if i == 0 {
0067                        assert(digit == 0)
0068                        break
0069                    }
0070                    i -= 1
0071                }
0072            }
0073    
0074            var result: NSData? = nil
0075            byteArray.withUnsafeBufferPointer { p in
0076                result = NSData(bytes: p.baseAddress, length: p.count)
0077            }
0078            return result!
0079        }
0080    }
0081    
0082