Merge pull request #56 from LimeChain/refactor/bytereader

Refactor/bytereader

Author: Daniel-K-Ivanov

assembly/AbstractInt.ts

@@ -19,10 +19,14 @@ import { Bytes } from "./utils/Bytes";
 export abstract class AbstractInt<T extends number> implements Codec {
 
     protected bitLength: i32;
-    public readonly value: T;
+    private _value: T;
+    
+    get value(): T{
+        return this._value;
+    }
 
     constructor (value: T, bitLength: i32) {
-        this.value = value;
+        this._value = value;
         this.bitLength = bitLength;
     }
 
@@ -33,6 +37,16 @@ export abstract class AbstractInt<T extends number> implements Codec {
         return bytesEncoded;
     }
 
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    public populateFromBytes(bytes: u8[], index: i32 = 0): void {
+        assert(bytes.length - index > 0, "AbstractInt: Invalid bytes provided");
+        this._value = Bytes.toUint<T>(bytes, this.bitLength, index);
+    }
+
     /**
      * @description Returns the string representation of the value
      */

assembly/Arrays/AbstractArray.ts

@@ -16,12 +16,12 @@ import { Codec } from "../interfaces/Codec";
 import { Bytes } from "../utils/Bytes";
 import { BytesBuffer } from "../utils/BytesBuffer";
 import { DecodedData } from "../interfaces/DecodedData";
+import { CompactInt } from "..";
 
-export abstract class AbstractArray<ScaleType extends Codec, NativeType> {
+export abstract class AbstractArray<ScaleType extends Codec, NativeType> implements Codec{
 
     public values: Array<NativeType>;
-
-    constructor(input: NativeType[]) {
+    constructor(input: NativeType[] = []) {
         this.values = new Array<NativeType>(input.length);
         Bytes.copy<NativeType>(input, this.values);
     }
@@ -41,6 +41,18 @@ export abstract class AbstractArray<ScaleType extends Codec, NativeType> {
         return bytesBuffer.bytes;
     }
 
+    /**
+     * @description Returns encoded byte length of the type
+     */
+    abstract encodedLength(): i32;
+    
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    abstract populateFromBytes(bytes: u8[], index: i32): void;
+
     /**
     * @description Each child class has to provide decryption implementation for elements
     */

assembly/Arrays/BoolArray.ts

@@ -16,8 +16,8 @@ import { Bool } from "./../Bool";
 import { AbstractArray } from "./AbstractArray"
 
 import { DecodedData } from "../interfaces/DecodedData";
-import { Bytes } from "../utils/Bytes";
 import { ArrayUtils } from "../utils/Arrays";
+import { BytesReader, CompactInt } from "..";
 
 // @ts-ignore
 export class BoolArray extends AbstractArray<Bool, bool> {
@@ -33,7 +33,28 @@ export class BoolArray extends AbstractArray<Bool, bool> {
             scaleBool.encodedLength()
         )
     }
+    
+    /**
+     * @description Returns encoded byte length of the type
+     */
+    public encodedLength(): i32{
+        return (new CompactInt(this.values.length).encodedLength()) + super.values.length;
+    }
 
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    populateFromBytes(bytes: u8[], index: i32 = 0): void{
+        const bytesReader = new BytesReader(bytes.slice(index));
+        const data = bytesReader.readInto<CompactInt>();
+
+        for(let i: i32 = 0; i < data.value - index; i++){
+            const element = bytesReader.readInto<Bool>();
+            this.values.push(element.value);
+        }
+    }
     /**
     * @description Instantiates ScaleBoolArray from u8[] SCALE encoded bytes (Decode)
     */

assembly/Arrays/ByteArray.ts

@@ -17,6 +17,7 @@ import { CompactInt } from "../Int";
 import { AbstractArray } from "./AbstractArray";
 import { DecodedData } from "../interfaces/DecodedData";
 import { ArrayUtils } from "../utils/Arrays";
+import { BytesReader } from "..";
 
 // @ts-ignore
 export class ByteArray extends AbstractArray<Byte, u8> {
@@ -37,7 +38,6 @@ export class ByteArray extends AbstractArray<Byte, u8> {
 
         return result;
     }
-
     /**
     * @description BoolArray elements decryption implementation
     */
@@ -51,12 +51,26 @@ export class ByteArray extends AbstractArray<Byte, u8> {
     }
 
     /**
-     * @description The length of encoded bytes of the ByteArray
+     * @description Returns encoded byte length of the type
      */
-    public encodedLength (): i32 {
-        return (new CompactInt(super.values.length).encodedLength()) + super.values.length;
+    public encodedLength(): i32{
+        return (new CompactInt(this.values.length).encodedLength()) + super.values.length;
     }
+    
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    populateFromBytes(bytes: u8[], index: i32 = 0): void {
+        const bytesReader = new BytesReader(bytes.slice(index));
+        const data = bytesReader.readInto<CompactInt>();
 
+        for(let i: i32 = 0; i < data.value; i++){
+            const element: Byte = bytesReader.readInto<Byte>();
+            this.values.push(element.value);
+        }
+    }
     /**
     * @description Instantiates ScaleByteArray from u8[] SCALE encoded bytes (Decode)
     */

assembly/Arrays/IntArray.ts

@@ -17,6 +17,7 @@ import { AbstractArray } from "./AbstractArray";
 
 import { DecodedData } from "../interfaces/DecodedData";
 import { ArrayUtils } from "../utils/Arrays";
+import { BytesReader } from "..";
 
 // @ts-ignore
 export class IntArray extends AbstractArray<CompactInt, i64> {
@@ -33,6 +34,31 @@ export class IntArray extends AbstractArray<CompactInt, i64> {
         )
     }
 
+    /**
+     * @description Returns encoded byte length of the type
+     */
+    public encodedLength(): i32{
+        let len: i32 = new CompactInt(this.values.length).encodedLength();
+        for (let i: i32 = 0; i < this.values.length; i++){
+            const value = new CompactInt(this.values[i]);
+            len += value.encodedLength();
+        }
+        return len;
+    }
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    populateFromBytes(bytes: u8[], index: i32 = 0): void {
+        const bytesReader = new BytesReader(bytes.slice(index));
+        const data = bytesReader.readInto<CompactInt>();
+
+        for(let i: i32 = 0; i < data.value; i++){
+            const element: CompactInt = bytesReader.readInto<CompactInt>();
+            this.values.push(element.value);
+        }
+    }
     /**
     * @description Instantiates ScaleIntArray from u8[] SCALE encoded bytes (Decode)
     */

assembly/Arrays/StringArray.ts

@@ -18,6 +18,7 @@ import { ScaleString } from "../ScaleString";
 
 import { DecodedData } from "../interfaces/DecodedData";
 import { ArrayUtils } from "../utils/Arrays";
+import { BytesReader, CompactInt } from "..";
 
 // @ts-ignore
 export class StringArray extends AbstractArray<ScaleString, string>{
@@ -34,6 +35,33 @@ export class StringArray extends AbstractArray<ScaleString, string>{
             encodedStringLength
         )
     }
+    
+    /**
+     * @description Returns encoded byte length of the type
+     */
+    public encodedLength(): i32{
+        let len: i32 = new CompactInt(this.values.length).encodedLength();
+        for (let i: i32 = 0; i < this.values.length; i++){
+            const value = new ScaleString(this.values[i]);
+            len += value.encodedLength();
+        }
+        return len;
+    }
+
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    populateFromBytes(bytes: u8[], index: i32 = 0): void {
+        const bytesReader = new BytesReader(bytes.slice(index));
+        const data = bytesReader.readInto<CompactInt>();
+
+        for(let i: i32 = 0; i < data.value; i++){
+            const element: ScaleString = bytesReader.readInto<ScaleString>();
+            this.values.push(element.valueStr);
+        }
+    }
 
     /**
     * @description Instantiates ScaleStringArray from u8[] SCALE encoded bytes (Decode)

assembly/Arrays/UInt128Array.ts

@@ -17,6 +17,8 @@ import { DecodedData } from "../interfaces/DecodedData";
 import { UInt128 } from "../UInt/UInt128";
 import { u128 } from "as-bignum";
 import { ArrayUtils } from "../utils/Arrays";
+import { BytesReader, CompactInt } from "..";
+import { BIT_LENGTH } from "../utils/Bytes";
 
 // @ts-ignore
 export class UInt128Array extends AbstractArray<UInt128, u128> {
@@ -33,13 +35,34 @@ export class UInt128Array extends AbstractArray<UInt128, u128> {
         )
     }
 
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    populateFromBytes(bytes: u8[], index: i32 = 0): void {
+        const bytesReader = new BytesReader(bytes.slice(index));
+        const data = bytesReader.readInto<CompactInt>();
+        for(let i: i32 = 0; i < data.value; i++){
+            const element: UInt128 = bytesReader.readInto<UInt128>();
+            this.values.push(element.value);
+        }
+    }
+
     /**
     * @description Instantiates ScaleIntArray from u8[] SCALE encoded bytes (Decode)
     */
     static fromU8a (input: u8[]): UInt128Array {
         return AbstractArray.fromU8a<UInt128Array>(input);
     }
 
+    /**
+     * @description Returns encoded byte length of the type
+     */
+    public encodedLength(): i32{
+        return (new CompactInt(this.values.length).encodedLength()) + super.values.length * BIT_LENGTH.INT_128;
+    }
+
     @inline @operator('==')
     static eq(a: UInt128Array, b: UInt128Array): bool {
         return ArrayUtils.areEqual(a, b);

assembly/Bool.ts

@@ -17,10 +17,14 @@ import { Codec } from "./interfaces/Codec";
 /** Representation for a boolean value in the system. */
 export class Bool implements Codec {
 
-    public readonly value: bool;
+    private _value: bool;
 
-    constructor (value: bool) {
-        this.value = value;
+    get value(): bool{
+        return this._value;
+    }
+    
+    constructor (value: bool = false) {
+        this._value = value;
     }
 
     /** Encodes the value as u8[] as per the SCALE codec specification
@@ -33,6 +37,16 @@ export class Bool implements Codec {
         return bytesEncoded;
     }
 
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model.
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    public populateFromBytes(bytes: u8[], index: i32 = 0): void{
+        assert(bytes.length > 0 && (bytes[index] == 1 || bytes[index] == 0), 'Bool: Cannot decode invalid input');
+        this._value = bytes[index] == 1;
+    }
+
     /**
      * @description Returns the string representation of the value
      */
@@ -49,7 +63,7 @@ export class Bool implements Codec {
 
     /** Instantiates new Bool from u8[] SCALE encoded bytes */
     static fromU8a (value: u8[], index: i32 = 0): Bool {
-        assert(value.length > 0 && (value[index] == 1 || value[index] == 0), 'Bool: Cannot decode invalid input');
+        assert(value.length - index > 0 && (value[index] == 1 || value[index] == 0), 'Bool: Cannot decode invalid input');
 
         return new Bool(value[index] == 1);
     }

assembly/Byte.ts

@@ -17,11 +17,15 @@ import { BIT_LENGTH } from "./utils/Bytes";
 
 export class Byte implements Codec {
 
-    public readonly value: u8;
+    private _value: u8;
     protected bitLength: i32;
 
-    constructor (value: u8) {
-        this.value = value;
+    get value(): u8{
+        return this._value;
+    }
+
+    constructor (value: u8 = 0) {
+        this._value = value;
         this.bitLength = BIT_LENGTH.INT_8;
     }
 
@@ -31,6 +35,15 @@ export class Byte implements Codec {
     public toU8a (): u8[] {
         return [this.value];
     }
+    /**
+     * @description Non-static constructor method used to populate defined properties of the model
+     * @param bytes SCALE encoded bytes
+     * @param index index to start decoding the bytes from
+     */
+    public populateFromBytes(bytes: u8[], index: i32 = 0): void{
+        assert(bytes.length - index > 0, 'Bool: Cannot decode invalid input');
+        this._value = bytes[index];
+    }
 
     /**
     * @description The length of Byte when the value is encoded
@@ -40,9 +53,9 @@ export class Byte implements Codec {
     }
 
     /** Instantiates new Byte from u8[] SCALE encoded bytes */
-    static fromU8a (value: u8[]): Byte {
-        assert(value.length == 1, 'Byte: cannot decode invalid type');
-        return new Byte(value[0]);
+    static fromU8a (value: u8[], index: i32 = 0): Byte {
+        assert(value.length - index > 0, 'Byte: cannot decode invalid type');
+        return new Byte(value[index]);
     }
 
     @inline @operator('==')