VM: Support for conversion between strings and char arrays

Author: Relfos

Phantasma.Tests/VMTests.cs

@@ -286,6 +286,25 @@ public void ArrayObjects()
             }
         }
 
+        [TestMethod]
+        public void StringUnicodeArrays()
+        {
+            var original = "Hello Phantasma";
+
+            var obj = VMObject.FromObject(original);
+            Assert.IsTrue(obj.Type == VMType.String);
+
+            var temp = VMObject.CastTo(obj, VMType.Struct);
+            Assert.IsTrue(temp.Type == VMType.Struct);
+
+            var elements = temp.GetChildren();
+            Assert.IsTrue(elements.Count == original.Length);
+
+            var result = temp.AsString();
+
+            Assert.IsTrue(original == result);
+        }
+
         public struct TestStruct : ISerializable
         {
             public string Name;

Phantasma.VM/VMObject.cs

@@ -190,15 +190,37 @@ public string AsString()
                         return "Interop:" + Data.GetType().Name;
                     }
                 case VMType.Struct:
-                    using (var stream = new MemoryStream())
+                    VMType arrayType = GetArrayType(); 
+                    if (arrayType == VMType.Number) // convert array of unicode numbers into a string
+                    {                        
+                        var children = GetChildren();
+                        var sb = new StringBuilder();
+
+                        for (int i = 0; i < children.Count; i++)
+                        {
+                            var key = VMObject.FromObject(i);
+                            var val = children[key];
+
+                            var ch = (char)((uint)val.AsNumber());
+
+                            sb.Append(ch);
+                        }
+
+                        return sb.ToString();
+                    }
+                    else
                     {
-                        using (var writer = new BinaryWriter(stream))
+                        using (var stream = new MemoryStream())
                         {
-                            SerializeData(writer);
+                            using (var writer = new BinaryWriter(stream))
+                            {
+                                SerializeData(writer);
+                            }
+                            return Convert.ToBase64String(stream.ToArray());
                         }
-                        return Convert.ToBase64String(stream.ToArray());
                     }
 
+
                 case VMType.Bool:
                     return ((bool)Data) ? "true" : "false";
 
@@ -211,6 +233,46 @@ public string AsString()
             }
         }
 
+        // this method checks if the VMObject is an array by checking the following rules
+        // a) must be a struct 
+        // b) all keys of the struct must be numeric indexes from 0 to count-1
+        // c) all element values must have same type
+        public VMType GetArrayType()
+        {
+            if (this.Type != VMType.Struct)
+            {
+                return VMType.None;
+            }
+
+            var children = GetChildren();
+
+            VMType result = VMType.None;
+
+            for (int i=0; i<children.Count; i++)
+            {
+                var key = VMObject.FromObject(i);
+
+                if (!children.ContainsKey(key))
+                {
+                    return VMType.None;
+                }
+
+                var val = children[key];
+
+                if (result == VMType.None)
+                {
+                    result = val.Type;
+                }
+                else
+                if (val.Type != result)
+                {
+                    return VMType.None;
+                }                
+            }
+
+            return result;
+        }
+
         public byte[] AsByteArray()
         {
             switch (this.Type)
@@ -937,6 +999,14 @@ public static VMObject CastTo(VMObject srcObj, VMType type)
                 case VMType.Struct:
                     switch (srcObj.Type)
                     {
+                        // this allow casting a string into char array (represented as unicode numbers)
+                        case VMType.String:
+                            {
+                                var str = srcObj.AsString();
+                                var chars = str.ToCharArray().Select(x => new BigInteger((uint)x)).ToArray();
+                                return VMObject.FromArray(chars);
+                            }
+
                         case VMType.Object: return CastViaReflection(srcObj.Data, 0);
 
                         default: throw new Exception($"invalid cast: {srcObj.Type} to {type}");