Added fromBytes (dcodeIO#43)

* Added fromBytes. Also add entries for fromBytes/toBytes to README.

* Name the anon functions in toBytes to match previous. Put doc entries in order.

Author: CyDragon80

README.md

@@ -127,6 +127,18 @@ assumed to use 32 bits.
 | unsigned        | *boolean*       | Whether unsigned or not, defaults to `false` for signed 
 | **@returns**    | *!Long*         | The corresponding Long value 
 
+#### Long.fromBytes(arrBytes, offset=, unsigned=, le=)
+
+Returns a Long representing the 64 bit integer that comes by concatenating the given bytes.
+
+|Parameter      |Type           |Description  
+|---------------|---------------|-------------
+|arrBytes       |*!Array.<number>*|Byte representation in an array of at least offset+8 bytes
+|offset         |*number*       |The starting index from which to read 8 elements of the array, defaults to zero
+|unsigned       |*boolean*      |Whether unsigned or not, defaults to `false` for signed 
+|le             |*boolean*      |Whether little or big endian, defaults to big endian 
+|**@returns**   |*!Long*        |The corresponding Long value 
+
 #### Long.fromInt(value, unsigned=)
 
 Returns a Long representing the given 32 bit integer value.
@@ -451,6 +463,15 @@ Returns the difference of this and the specified Long.
 | subtrahend      | *!Long | number | string* | Subtrahend 
 | **@returns**    | *!Long*         | Difference 
 
+#### Long#toBytes(le=)
+
+Converts this Long to its byte representation.
+
+|Parameter      |Type           |Description  
+|---------------|---------------|-------------
+|le             |*boolean*      |Whether little or big endian, defaults to big endian 
+|**@returns**   |*!Array.<number>*|Byte representation
+
 #### Long#toInt()
 
 Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
@@ -502,6 +523,8 @@ Returns the bitwise XOR of this Long and the given one.
 | other           | *!Long | number | string* | Other Long 
 | **@returns**    | *!Long*         | 
 
+
+
 Downloads
 ---------
 * [Distributions](https://github.com/dcodeIO/long.js/tree/master/dist)

dist/long.js

@@ -1163,15 +1163,15 @@
      * @param {boolean=} le Whether little or big endian, defaults to big endian
      * @returns {!Array.<number>} Byte representation
      */
-    LongPrototype.toBytes = function(le) {
+    LongPrototype.toBytes = function toBytes(le) {
         return le ? this.toBytesLE() : this.toBytesBE();
-    }
+    };
 
     /**
      * Converts this Long to its little endian byte representation.
      * @returns {!Array.<number>} Little endian byte representation
      */
-    LongPrototype.toBytesLE = function() {
+    LongPrototype.toBytesLE = function toBytesLE() {
         var hi = this.high,
             lo = this.low;
         return [
@@ -1184,13 +1184,13 @@
             (hi >>> 16) & 0xff,
             (hi >>> 24) & 0xff
         ];
-    }
+    };
 
     /**
      * Converts this Long to its big endian byte representation.
      * @returns {!Array.<number>} Big endian byte representation
      */
-    LongPrototype.toBytesBE = function() {
+    LongPrototype.toBytesBE = function toBytesBE() {
         var hi = this.high,
             lo = this.low;
         return [
@@ -1203,7 +1203,51 @@
             (lo >>>  8) & 0xff,
              lo         & 0xff
         ];
+    };
+
+    /**
+     * @param {!Array.<number>} arrBytes
+     * @param {number=} offset
+     * @param {boolean=} unsigned
+     * @param {boolean=} le
+     * @returns {!Long}
+     * @inner
+     */
+    function fromBytes(arrBytes, offset, unsigned, le) {
+        if (typeof(offset)!=='number') offset=0;
+        if (le) {
+            var lo = arrBytes[offset++];
+            lo |= (arrBytes[offset++] << 8);
+            lo |= (arrBytes[offset++] << 16);
+            lo |= (arrBytes[offset++] << 24);
+            var hi = arrBytes[offset++];
+            hi |= (arrBytes[offset++] << 8);
+            hi |= (arrBytes[offset++] << 16);
+            hi |= (arrBytes[offset] << 24);
+        }
+        else {
+            var hi = (arrBytes[offset++] << 24);
+            hi |= (arrBytes[offset++] << 16);
+            hi |= (arrBytes[offset++] << 8);
+            hi |= arrBytes[offset++];
+            var lo = (arrBytes[offset++] << 24);
+            lo |= (arrBytes[offset++] << 16);
+            lo |= (arrBytes[offset++] << 8);
+            lo |= arrBytes[offset];
+        }
+        return Long.fromBits(lo, hi, unsigned);
     }
 
+    /**
+     * Returns a Long representing the 64 bit integer that comes by concatenating the given bytes.
+     * @function
+     * @param {!Array.<number>} arrBytes Byte representation in an array of at least offset+8 bytes
+     * @param {number=} offset The starting index from which to read 8 elements of the array, defaults to zero
+     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
+     * @param {boolean=} le Whether little or big endian, defaults to big endian
+     * @returns {!Long} The corresponding Long value
+     */
+    Long.fromBytes = fromBytes;
+
     return Long;
 });