Merge pull request #60 from LimeChain/feature/map

Feature/map

Author: Daniel-K-Ivanov

README.md

@@ -24,6 +24,7 @@ The following table shows the status of the types and their arrays:
 | `Bool` | ✅| ✅|
 | `Hash` |✅ | :heavy_minus_sign: |
 | `String` | ✅|✅ | 
+| `Map` |✅| :heavy_minus_sign: | 
 
 The following table shows the status of the fixed width numbers:
 
@@ -37,7 +38,6 @@ The following table shows the status of the fixed width numbers:
 
 - **Compact Int** - [Documentation](https://substrate.dev/docs/en/knowledgebase/advanced/codec#compactgeneral-integers)
 
-
 ## **Getting Started**  
 *You can find more information on AssemblyScript and how to get started with it in the AssemblyScript docs -> [https://www.assemblyscript.org/introduction.html](https://www.assemblyscript.org/introduction.html)*
 
@@ -61,6 +61,10 @@ Every type has а **toU8a** function. It encodes type value into an array of byt
 import { Bool, Byte, ScaleString, Hash, CompactInt } from "as-scale-codec"
 import { Int8, Int16, Int32, Int64 } from "as-scale-codec"
 import { UInt8, UInt16, UInt32, UInt64, UInt128 } from "as-scale-codec"
+// ScaleMap
+const scaleMap = new ScaleMap<Int32, Bool>();
+scaleMap.set(new Int32(1), new Bool(false));
+scaleMap.toU8a() // => [4, 1, 0, 0, 0, 0];
 
 // Bool
 const scaleBool = new Bool(true);
@@ -117,7 +121,7 @@ scaleUInt128.toU8a() // => [0x13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 Every type has a **static** function **fromU8a**. It decodes an array of bytes to the desired type
 
 ```jsx
-import { Bool, Byte, ScaleString, Hash, CompactInt } from "as-scale-codec"
+import { ScaleMap, Bool, Byte, ScaleString, Hash, CompactInt } from "as-scale-codec"
 import { Int8, Int16, Int32, Int64 } from "as-scale-codec"
 import { UInt8, UInt16, UInt32, UInt64, UInt128 } from "as-scale-codec"
 
@@ -134,6 +138,10 @@ Byte.fromU8a([0x04, 0x61]); // => new ScaleString('a')
 Hash.fromU8a([0xff, 0x00, 0xab]); 
 // => [0xff, 0x00, 0xab, 0x00, ... 0x00] (32 bytes long)
 
+ScaleMap<Int32, Bool>.fromU8a([4, 1, 0, 0, 0, 0]);
+// => const scaleMap = new ScaleMap<Int32, Bool>()
+// => scaleMap.set(new Int32(1), new Bool(false))
+
 // Compact Int
 CompactInt.fromU8a([0x04]); // => new CompactInt(1)
 
@@ -256,6 +264,13 @@ const hashBytes: u8[] = [0xff, 0x00, 0xab];
 BytesReader.decodeInto<Hash>(hashBytes);
 // new Hash([0xff, 0x00, 0xab])
 
+const mapBytes: u8[] = [2, 1, 0, 1, 0, 0, 0, 3, 0, 3, 0, 0, 0];
+// Read ScaleMap
+BytesReader.decodeInto<ScaleMap<UInt16, UInt32>>(mapBytes);
+// => const scaleMap = new ScaleMap<UInt16, UInt32>();
+// => scaleMap.set(new UInt16(1), new UInt32(1))
+// => scaleMap.set(new UInt16(3), new UInt32(3))
+
 const cmpBytes: u8[] = [169, 2];
 // Read CompactInt
 BytesReader.decodeInto<CompactInt>(cmpBytes);

assembly/AbstractInt.ts

@@ -12,31 +12,41 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { Codec } from "./interfaces/Codec";
+import { UnwrappableCodec } from "./interfaces/UnwrappableCodec";
 import { Bytes } from "./utils/Bytes";
 
 /** Representation for a Int value in the system. */
-export abstract class AbstractInt<T extends number> implements Codec {
+export abstract class AbstractInt<T extends number> implements UnwrappableCodec<T> {
 
     protected bitLength: i32;
     private _value: T;
-    
-    get value(): T{
-        return this._value;
-    }
 
     constructor (value: T, bitLength: i32) {
         this._value = value;
         this.bitLength = bitLength;
     }
 
+    /**
+     * @description Returns the inner native value
+     */
+    public unwrap(): T{
+        return this._value;
+    }
+
     /** Encodes the value as u8[] as per the SCALE codec specification */
     public toU8a (): u8[] {
         let bytesEncoded = new Array<u8>(this.bitLength);
-        Bytes.putUint<T>(bytesEncoded, this.value, this.bitLength);
+        Bytes.putUint<T>(bytesEncoded, this.unwrap(), this.bitLength);
         return bytesEncoded;
     }
 
+    public eq(other: AbstractInt<T>): bool{
+        return this.unwrap() == other.unwrap();
+    }
+    public notEq(other: AbstractInt<T>): bool{
+        return this.unwrap() != other.unwrap();
+    }
+
     /**
      * @description Non-static constructor method used to populate defined properties of the model
      * @param bytes SCALE encoded bytes
@@ -51,7 +61,7 @@ export abstract class AbstractInt<T extends number> implements Codec {
      * @description Returns the string representation of the value
      */
     toString (): string {
-        return this.value.toString();
+        return this.unwrap().toString();
     }
     /**
      * @description The length of Uint8Array when the value is encoded

assembly/Arrays/AbstractArray.ts

@@ -13,19 +13,35 @@
 // limitations under the License.
 
 import { Codec } from "../interfaces/Codec";
+import { DecodedData } from "../interfaces/DecodedData";
+import { UnwrappableCodec } from "../interfaces/UnwrappableCodec";
+import { ArrayUtils } from "../utils/Arrays";
 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> implements Codec{
+export abstract class AbstractArray<ScaleType extends Codec, NativeType> implements UnwrappableCodec<Array<NativeType>>{
 
     public values: Array<NativeType>;
     constructor(input: NativeType[] = []) {
         this.values = new Array<NativeType>(input.length);
         Bytes.copy<NativeType>(input, this.values);
     }
+    
+    /**
+     * @description Returns the inner native value
+     */
+    public unwrap(): Array<NativeType>{
+        return this.values;
+    }
 
+    public eq(other: AbstractArray<ScaleType, NativeType>): bool{
+        return ArrayUtils.areArraysEqual(this.values, other.values);
+    };
+    
+    public notEq(other: AbstractArray<ScaleType, NativeType>): bool{
+        return !ArrayUtils.areArraysEqual(this.values, other.values);
+    };
+    
     /**
     * @description  Encodes values of all elements in u8[] successively as per the SCALE codec specification
     */

assembly/Arrays/BoolArray.ts

@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { BytesReader, CompactInt } from "..";
+import { DecodedData } from "../interfaces/DecodedData";
 import { Bool } from "./../Bool";
-import { AbstractArray } from "./AbstractArray"
+import { AbstractArray } from "./AbstractArray";
 
-import { DecodedData } from "../interfaces/DecodedData";
-import { ArrayUtils } from "../utils/Arrays";
-import { BytesReader, CompactInt } from "..";
 
 // @ts-ignore
 export class BoolArray extends AbstractArray<Bool, bool> {
@@ -29,7 +28,7 @@ export class BoolArray extends AbstractArray<Bool, bool> {
         const scaleBool = Bool.fromU8a([value[0]]);
 
         return new DecodedData<bool>(
-            scaleBool.value,
+            scaleBool.unwrap(),
             scaleBool.encodedLength()
         )
     }
@@ -40,7 +39,7 @@ export class BoolArray extends AbstractArray<Bool, bool> {
     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
@@ -50,9 +49,9 @@ export class BoolArray extends AbstractArray<Bool, bool> {
         const bytesReader = new BytesReader(bytes.slice(index));
         const data = bytesReader.readInto<CompactInt>();
 
-        for(let i: i32 = 0; i < data.value - index; i++){
+        for(let i: i32 = 0; i < data.unwrap() - index; i++){
             const element = bytesReader.readInto<Bool>();
-            this.values.push(element.value);
+            this.values.push(element.unwrap());
         }
     }
     /**
@@ -64,11 +63,11 @@ export class BoolArray extends AbstractArray<Bool, bool> {
 
     @inline @operator('==')
     static eq(a: BoolArray, b: BoolArray): bool {
-        return ArrayUtils.areEqual(a, b);
+        return a.eq(b);
     }
 
     @inline @operator('!=')
     static notEq(a: BoolArray, b: BoolArray): bool {
-        return !ArrayUtils.areEqual(a, b);
+        return a.notEq(b);
     }
 }

assembly/Arrays/ByteArray.ts

@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { BytesReader } from "..";
 import { Byte } from "../Byte";
 import { CompactInt } from "../Int";
-import { AbstractArray } from "./AbstractArray";
 import { DecodedData } from "../interfaces/DecodedData";
-import { ArrayUtils } from "../utils/Arrays";
-import { BytesReader } from "..";
+import { AbstractArray } from "./AbstractArray";
 
 // @ts-ignore
 export class ByteArray extends AbstractArray<Byte, u8> {
@@ -45,7 +44,7 @@ export class ByteArray extends AbstractArray<Byte, u8> {
         const scaleByte = Byte.fromU8a([value[0]]);
 
         return new DecodedData<u8>(
-            scaleByte.value,
+            scaleByte.unwrap(),
             scaleByte.encodedLength()
         )
     }
@@ -66,9 +65,9 @@ export class ByteArray extends AbstractArray<Byte, u8> {
         const bytesReader = new BytesReader(bytes.slice(index));
         const data = bytesReader.readInto<CompactInt>();
 
-        for(let i: i32 = 0; i < data.value; i++){
+        for(let i: i32 = 0; i < data.unwrap(); i++){
             const element: Byte = bytesReader.readInto<Byte>();
-            this.values.push(element.value);
+            this.values.push(element.unwrap());
         }
     }
     /**
@@ -80,13 +79,12 @@ export class ByteArray extends AbstractArray<Byte, u8> {
 
     @inline @operator('==')
     static eq(a: ByteArray, b: ByteArray): bool {
-        return ArrayUtils.areEqual(a, b);
+        return a.eq(b);
     }
 
     @inline @operator('!=')
     static notEq(a: ByteArray, b: ByteArray): bool {
-        return !ArrayUtils.areEqual(a, b);
+        return a.notEq(b);
     }
-    
 }
 

assembly/Arrays/IntArray.ts

@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { BytesReader } from "..";
 import { CompactInt } from "../Int/CompactInt";
+import { DecodedData } from "../interfaces/DecodedData";
 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> {
@@ -29,7 +28,7 @@ export class IntArray extends AbstractArray<CompactInt, i64> {
         const compactInt = CompactInt.fromU8a(value);
 
         return new DecodedData<u64>(
-            compactInt.value,
+            compactInt.unwrap(),
             compactInt.encodedLength()
         )
     }
@@ -54,9 +53,9 @@ export class IntArray extends AbstractArray<CompactInt, i64> {
         const bytesReader = new BytesReader(bytes.slice(index));
         const data = bytesReader.readInto<CompactInt>();
 
-        for(let i: i32 = 0; i < data.value; i++){
+        for(let i: i32 = 0; i < data.unwrap(); i++){
             const element: CompactInt = bytesReader.readInto<CompactInt>();
-            this.values.push(element.value);
+            this.values.push(element.unwrap());
         }
     }
     /**
@@ -68,12 +67,12 @@ export class IntArray extends AbstractArray<CompactInt, i64> {
 
     @inline @operator('==')
     static eq(a: IntArray, b: IntArray): bool {
-        return ArrayUtils.areEqual(a, b);
+        return a.eq(b);
     }
 
     @inline @operator('!=')
     static notEq(a: IntArray, b: IntArray): bool {
-        return !ArrayUtils.areEqual(a, b);
+        return a.notEq(b);
     }
 }
 

assembly/Arrays/StringArray.ts

@@ -12,13 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { BytesReader, CompactInt } from "..";
+import { DecodedData } from "../interfaces/DecodedData";
+import { ScaleString } from "../ScaleString";
 import { Bytes } from "../utils/Bytes";
 import { AbstractArray } from "./AbstractArray";
-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>{
@@ -31,7 +30,7 @@ export class StringArray extends AbstractArray<ScaleString, string>{
         const encodedStringLength = i32(stringLength.decBytes + stringLength.value);
 
         return new DecodedData<string>(
-            ScaleString.fromU8a(value.slice(0, encodedStringLength)).valueStr,
+            ScaleString.fromU8a(value.slice(0, encodedStringLength)).toString(),
             encodedStringLength
         )
     }
@@ -57,9 +56,9 @@ export class StringArray extends AbstractArray<ScaleString, string>{
         const bytesReader = new BytesReader(bytes.slice(index));
         const data = bytesReader.readInto<CompactInt>();
 
-        for(let i: i32 = 0; i < data.value; i++){
+        for(let i: i32 = 0; i < data.unwrap(); i++){
             const element: ScaleString = bytesReader.readInto<ScaleString>();
-            this.values.push(element.valueStr);
+            this.values.push(element.toString());
         }
     }
 
@@ -70,14 +69,13 @@ export class StringArray extends AbstractArray<ScaleString, string>{
         return AbstractArray.fromU8a<StringArray>(input);
     }
 
-
     @inline @operator('==')
     static eq(a: StringArray, b: StringArray): bool {
-        return ArrayUtils.areEqual(a, b);
+        return a.eq(b);
     }
 
     @inline @operator('!=')
     static notEq(a: StringArray, b: StringArray): bool {
-        return !ArrayUtils.areEqual(a, b);
+        return a.notEq(b);
     }
 }