List

Esiur/Data/Codec.cs

@@ -338,20 +338,11 @@ public static class Codec
     };
 
 
-
+    internal static (TransmissionTypeIdentifier identifier, byte[])
-    /// <summary>
+        ComposeInternal(object valueOrSource, Warehouse warehouse, DistributedConnection connection)
-    /// Compose a variable
-    /// </summary>
-    /// <param name="value">Value to compose.</param>
-    /// <param name="connection">DistributedConnection is required to check locality.</param>
-    /// <param name="prependType">If True, prepend the DataType at the beginning of the output.</param>
-    /// <returns>Array of bytes in the network byte order.</returns>
-    public static byte[] Compose(object valueOrSource, Warehouse warehouse, DistributedConnection connection)//, bool prependType = true)
     {
-
-
         if (valueOrSource == null)
-            return TransmissionType.Compose(TransmissionTypeIdentifier.Null, null);
+            return (TransmissionTypeIdentifier.Null, null);
 
         var type = valueOrSource.GetType();
 
@@ -377,11 +368,8 @@ public static class Codec
         if (valueOrSource is IUserType)
             valueOrSource = ((IUserType)valueOrSource).Get();
 
-        //if (valueOrSource is Func<DistributedConnection, object>)
-        //    valueOrSource = (valueOrSource as Func<DistributedConnection, object>)(connection);
-
         if (valueOrSource == null)
-            return TransmissionType.Compose(TransmissionTypeIdentifier.Null, null);
+            return (TransmissionTypeIdentifier.Null, null);
 
 
         type = valueOrSource.GetType();
@@ -390,19 +378,19 @@ public static class Codec
         if (Composers.ContainsKey(type))
         {
             var (hdr, data) = Composers[type](valueOrSource, warehouse, connection);
-            return TransmissionType.Compose(hdr, data);
+            return (hdr, data);
         }
         else
         {
             if (Codec.ImplementsInterface(type, typeof(IResource)))
             {
                 var (hdr, data) = DataSerializer.ResourceComposer(valueOrSource, warehouse, connection);
-                return TransmissionType.Compose(hdr, data);
+                return (hdr, data);
             }
             else if (Codec.ImplementsInterface(type, typeof(IRecord)))
             {
                 var (hdr, data) = DataSerializer.RecordComposer(valueOrSource, warehouse, connection);
-                return TransmissionType.Compose(hdr, data);
+                return (hdr, data);
             }
             else if (type.IsGenericType)
             {
@@ -415,7 +403,7 @@ public static class Codec
                     //if (Composers.ContainsKey(args[0]))
                     //{
                     var (hdr, data) = DataSerializer.TypedListComposer((IEnumerable)valueOrSource, args[0], warehouse, connection);
-                    return TransmissionType.Compose(hdr, data);
+                    return (hdr, data);
                     //}
                 }
                 else if (genericType == typeof(Map<,>))
@@ -423,7 +411,7 @@ public static class Codec
                     var args = type.GetGenericArguments();
 
                     var (hdr, data) = DataSerializer.TypedMapComposer(valueOrSource, args[0], args[1], warehouse, connection);
-                    return TransmissionType.Compose(hdr, data);
+                    return (hdr, data);
 
                 }
                 else if (genericType == typeof(Dictionary<,>))
@@ -431,7 +419,7 @@ public static class Codec
                     var args = type.GetGenericArguments();
 
                     var (hdr, data) = DataSerializer.TypedDictionaryComposer(valueOrSource, args[0], args[1], warehouse, connection);
-                    return TransmissionType.Compose(hdr, data);
+                    return (hdr, data);
 
                 }
 
@@ -444,7 +432,7 @@ public static class Codec
                   )
                 {
                     var (hdr, data) = DataSerializer.TupleComposer(valueOrSource, warehouse, connection);
-                    return TransmissionType.Compose(hdr, data);
+                    return (hdr, data);
                 }
             }
             else if (type.IsArray)
@@ -454,23 +442,35 @@ public static class Codec
                 //if (Composers.ContainsKey(elementType))
                 //{
                 var (hdr, data) = DataSerializer.TypedListComposer((IEnumerable)valueOrSource, elementType, warehouse, connection);
-                return TransmissionType.Compose(hdr, data);
+                return (hdr, data);
 
                 //}
             }
             else if (type.IsEnum)
             {
                 var (hdr, data) = DataSerializer.EnumComposer(valueOrSource, warehouse, connection);
-                return TransmissionType.Compose(hdr, data);
+                return (hdr, data);
             }
 
         }
 
-        return TransmissionType.Compose(TransmissionTypeIdentifier.Null, null);
+        return (TransmissionTypeIdentifier.Null, null);
 
     }
 
 
+    /// <summary>
+    /// Compose a variable
+    /// </summary>
+    /// <param name="value">Value to compose.</param>
+    /// <param name="connection">DistributedConnection is required to check locality.</param>
+    /// <param name="prependType">If True, prepend the DataType at the beginning of the output.</param>
+    /// <returns>Array of bytes in the network byte order.</returns>
+    public static byte[] Compose(object valueOrSource, Warehouse warehouse, DistributedConnection connection)//, bool prependType = true)
+    {
+        var (hdr, data) = ComposeInternal(valueOrSource, warehouse, connection);
+        return TransmissionType.Compose(hdr, data);
+    }
 
     public static bool IsAnonymous(Type type)
     {

Esiur/Data/DataConverter.cs

@@ -105,9 +105,12 @@ public static class DC // Data Converter
                     {
                         return Convert.ChangeType(value, destinationType);
                     }
+
                 }
-                catch
+                catch (Exception ex)
                 {
+
+                    throw ex;
                     return null;
                 }
             }

Esiur/Data/DataDeserializer.cs

@@ -1,14 +1,15 @@
 using Esiur.Core;
+using Esiur.Data;
+using Esiur.Misc;
 using Esiur.Net.IIP;
 using Esiur.Resource;
+using Esiur.Resource.Template;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using System;
 using System.Collections.Generic;
-using System.Text;
+using System.ComponentModel.DataAnnotations;
-using Esiur.Data;
-using Esiur.Resource.Template;
 using System.Linq;
-using Esiur.Misc;
+using System.Text;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Esiur.Data;
 
@@ -676,8 +677,20 @@ public static class DataDeserializer
     {
         var rt = new List<object>();
 
+        //TransmissionTypeIdentifier? previous = null;
+        //byte[]? previousUUID = null;
+
+        TransmissionType? previous = null;
+
         while (length > 0)
         {
+            var (longLen, dataType) = TransmissionType.Parse(data, offset, (uint)data.Length);
+
+            if (dataType.Value.Identifier == TransmissionTypeIdentifier.Same)
+            {
+                // Add UUID
+            }
+
             var (cs, reply) = Codec.ParseSync(data, offset, warehouse);
 
             rt.Add(reply);

Esiur/Data/DataSerializer.cs

@@ -320,8 +320,33 @@ public static class DataSerializer
 
         var rt = new List<byte>();
 
+        TransmissionTypeIdentifier? previous = null;
+        byte[]? previousUUID = null;
+
         foreach (var i in value)
+        {
+            var (hdr, data) = Codec.ComposeInternal(i, warehouse, connection);
+            if (previous == null)
+                previous = hdr;
+            else if (hdr == previous)
+            {
+                if (hdr == TransmissionTypeIdentifier.Record)
+                {
+                    var newUUID = data.Take(16).ToArray();
+                    // check same uuid
+                    if (newUUID.SequenceEqual(previousUUID))
+                        rt.AddRange(TransmissionType.Compose(TransmissionTypeIdentifier.Same,
+                            data.Skip(16).ToArray()));
+                    else
+                        rt.AddRange(TransmissionType.Compose(hdr, data));
+
+                    previous = hdr;
+                    previousUUID = newUUID;
+                }
+            }
+                
             rt.AddRange(Codec.Compose(i, warehouse, connection));
+        }
 
         return rt.ToArray();
     }

Esiur/Data/Map.cs

@@ -22,17 +22,18 @@ SOFTWARE.
 
 */
 
+using Esiur.Core;
+using Esiur.Data;
+using Esiur.Misc;
+using Esiur.Net.IIP;
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Dynamic;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
-using Esiur.Data;
-using Esiur.Misc;
-using Esiur.Core;
-using System.Reflection;
-using System.Dynamic;
 
 namespace Esiur.Data;
 
@@ -54,69 +55,70 @@ namespace Esiur.Data;
 public interface IMap
 {
     public void Add(object key, object value);
-    public void Remove(object key);
+    //public void Remove(object key);
-    public void Clear();
+    //public void Clear();
-    public bool ContainsKey(object key);
+    //public bool ContainsKey(object key);
     public object[] Serialize();
 }
 
-public class Map<KT, VT> : IEnumerable<KeyValuePair<KT, VT>>, IMap
+public class Map<KT, VT> : Dictionary<KT, VT>, IMap // IEnumerable<KeyValuePair<KT, VT>>
 {
 
-    private Dictionary<KT, VT> dic = new Dictionary<KT, VT>();
+    //private Dictionary<KT, VT> dic = new Dictionary<KT, VT>();
     private object syncRoot = new object();
 
-    // Change map types
+    //public static implicit operator Map<KT, VT>(Dictionary<KT, VT> dictionary)
+    //                                => new Map<KT, VT>() { dic = dictionary };
+
+    //public static implicit operator Dictionary<KT, VT>(Map<KT, VT> map)
+    //                            => map.ToDictionary();
+
+    //Change map types
     public Map<NewKeyType, NewValueType> Select<NewKeyType, NewValueType>
                                         (Func<KeyValuePair<KT, VT>, KeyValuePair<NewKeyType, NewValueType>> selector)
     {
         var rt = new Map<NewKeyType, NewValueType>();
-        foreach(var kv in dic)
+        foreach (var kv in this)
         {
             var nt = selector(kv);
-            rt.dic.Add(nt.Key, nt.Value);
+            rt.Add(nt.Key, nt.Value);
         }
 
         return rt;
     }
 
-    public bool ContainsKey(KT key)
+    //public bool ContainsKey(KT key)
-    {
+    //{
-        return dic.ContainsKey(key);
+    //    return dic.ContainsKey(key);
-    }
+    //}
 
     public override string ToString()
     {
         var rt = "";
-        foreach (var kv in dic)
+        foreach (var kv in this)
             rt += kv.Key + ": " + kv.Value.ToString() + " \r\n";
 
         return rt.TrimEnd('\r', '\n');
     }
 
-    public Map(Map<KT,VT> source)
+    //public Map(Map<KT,VT> source)
-    {
+    //{
-        dic = source.dic;
+    //    dic = source.dic;
-    }
+    //}
     public Map()
     {
 
     }
 
-    public static Map<KT,VT> FromMap(Map<KT,VT> source, Type destinationType)
+    //public static Map<KT,VT> FromMap(Map<KT,VT> source, Type destinationType)
-    {
-        var rt = Activator.CreateInstance(destinationType) as Map<KT, VT>;
-        rt.dic = source.dic;
-        return rt;
-    }
-
-    //public static T FromStructure<T>(Map<KT, VT> source) where T : Map<KT, VT>
     //{
-    //    var rt = Activator.CreateInstance<T>();
+    //    var rt = Activator.CreateInstance(destinationType) as Map<KT, VT>;
     //    rt.dic = source.dic;
     //    return rt;
     //}
 
+
+
    // public static explicit operator Map<string, object>(ExpandoObject obj) => FromDynamic(obj);
 
     public static Map<string, object> FromDynamic(ExpandoObject obj)
@@ -127,10 +129,10 @@ public class Map<KT, VT> : IEnumerable<KeyValuePair<KT, VT>>, IMap
         return rt;
     }
 
-    public static Map<KT, VT> FromDictionary(Dictionary<KT, VT> dictionary)
+    //public static Map<KT, VT> FromDictionary(Dictionary<KT, VT> dictionary)
-        => new Map<KT, VT>() { dic = dictionary };
+    //    => new Map<KT, VT>() { dic = dictionary };
 
-    public Dictionary<KT, VT> ToDictionary() => dic;
+    //public Dictionary<KT, VT> ToDictionary() => dic;
 
     public static Map<string,object> FromObject(object obj)
     {
@@ -169,68 +171,65 @@ public class Map<KT, VT> : IEnumerable<KeyValuePair<KT, VT>>, IMap
         //    //  return null;
     }
 
-    public IEnumerator<KeyValuePair<KT, VT>> GetEnumerator()
+    //public IEnumerator<KeyValuePair<KT, VT>> GetEnumerator()
-    {
+    //{
-        return dic.GetEnumerator();
+    //    return dic.GetEnumerator();
-    }
+    //}
 
-    IEnumerator IEnumerable.GetEnumerator()
+    //IEnumerator IEnumerable.GetEnumerator()
-    {
+    //{
-        return dic.GetEnumerator();
+    //    return dic.GetEnumerator();
-    }
+    //}
 
-    public int Length
+    //public int Length
-    {
+    //{
-        get { return dic.Count; }
+    //    get { return dic.Count; }
-    }
+    //}
 
-    public KeyValuePair<KT, VT> At(int index)
+    //public KeyValuePair<KT, VT> At(int index)
-    {
+    //{
-        return dic.ElementAt(index);
+    //    return dic.ElementAt(index);
-    }
+    //}
 
     public object SyncRoot
     {
         get { return syncRoot; }
     }
 
-    public KT[] GetKeys() => dic.Keys.ToArray();//GetKeys()
+    //public KT[] GetKeys() => dic.Keys.ToArray();
-                                                    //{
-                                                    //  return dic.Keys.ToArray();
-                                                    //}
 
-    public void Add(KT key, VT value)
+    //public void Add(KT key, VT value)
-    {
+    //{
-        if (dic.ContainsKey(key))
+    //    if (dic.ContainsKey(key))
-            dic[key] = value;
+    //        dic[key] = value;
-        else
+    //    else
-            dic.Add(key, value);
+    //        dic.Add(key, value);
-     }
+    // }
 
     public void Add(object key, object value)
     {
-        Add((KT)key, (VT)value);
+        base.Add((KT)key, (VT)value);
     }
 
-    public void Remove(object key)
+    //public void Remove(object key)
-    {
+    //{
-        Remove((KT)key);
+    //    Remove((KT)key);
-    }
+    //}
 
-    public void Clear()
+    //public void Clear()
-    {
+    //{
-        dic.Clear();
+    //    dic.Clear();
-    }
+    //}
 
-    public bool ContainsKey(object key)
+    //public bool ContainsKey(object key)
-    {
+    //{
-        return ContainsKey((KT)key);
+    //    return ContainsKey((KT)key);
-    }
+    //}
 
     public object[] Serialize()
     {
         var rt = new List<object>();
-        foreach(var kv in dic)
+        foreach(var kv in this)
         {
             rt.Add(kv.Key);
             rt.Add(kv.Value);
@@ -239,22 +238,22 @@ public class Map<KT, VT> : IEnumerable<KeyValuePair<KT, VT>>, IMap
         return rt.ToArray();
     }
 
-    public VT this[KT index]
+    //public VT this[KT index]
-    {
+    //{
-        get
+    //    get
-        {
+    //    {
-            if (dic.ContainsKey(index))
+    //        if (dic.ContainsKey(index))
-                return dic[index];
+    //            return dic[index];
-            else
+    //        else
-                return default;
+    //            return default;
-        }
+    //    }
-        set
+    //    set
-        {
+    //    {
-            if (dic.ContainsKey(index))
+    //        if (dic.ContainsKey(index))
-                dic[index] = value;
+    //            dic[index] = value;
-            else
+    //        else
-                dic.Add(index, value);
+    //            dic.Add(index, value);
-        }
+    //    }
-    }
+    //}
 
 }

Esiur/Data/RepresentationType.cs

@@ -76,6 +76,46 @@ namespace Esiur.Data
                     RepresentationTypeIdentifier.TypedResource
           };
 
+        static Map<TransmissionTypeIdentifier, RepresentationTypeIdentifier> typesMap = new Map<TransmissionTypeIdentifier, RepresentationTypeIdentifier>()
+        {
+            [TransmissionTypeIdentifier.UInt8] = RepresentationTypeIdentifier.UInt8,
+            [TransmissionTypeIdentifier.Int8] = RepresentationTypeIdentifier.Int8,
+            [TransmissionTypeIdentifier.UInt16] = RepresentationTypeIdentifier.UInt16,
+            [TransmissionTypeIdentifier.Int16] = RepresentationTypeIdentifier.Int16,
+            [TransmissionTypeIdentifier.UInt32] = RepresentationTypeIdentifier.UInt32,
+            [TransmissionTypeIdentifier.Int32] = RepresentationTypeIdentifier.Int32,
+            [TransmissionTypeIdentifier.UInt64] = RepresentationTypeIdentifier.UInt64,
+            [TransmissionTypeIdentifier.Int64] = RepresentationTypeIdentifier.Int64,
+            [TransmissionTypeIdentifier.UInt128] = RepresentationTypeIdentifier.UInt128,
+            [TransmissionTypeIdentifier.Int128] = RepresentationTypeIdentifier.Int128,
+            [TransmissionTypeIdentifier.Char8] = RepresentationTypeIdentifier.Char,
+            [TransmissionTypeIdentifier.DateTime] = RepresentationTypeIdentifier.DateTime,
+            [TransmissionTypeIdentifier.Float32] = RepresentationTypeIdentifier.Float32,
+            [TransmissionTypeIdentifier.Float64] = RepresentationTypeIdentifier.Float64,
+            [TransmissionTypeIdentifier.Decimal128] = RepresentationTypeIdentifier.Decimal,
+            [TransmissionTypeIdentifier.False] = RepresentationTypeIdentifier.Bool,
+            [TransmissionTypeIdentifier.True] = RepresentationTypeIdentifier.Bool,
+            [TransmissionTypeIdentifier.Map] = RepresentationTypeIdentifier.Map,
+            [TransmissionTypeIdentifier.List] = RepresentationTypeIdentifier.List,
+            [TransmissionTypeIdentifier.RawData] = RepresentationTypeIdentifier.RawData,
+            [TransmissionTypeIdentifier.Record] = RepresentationTypeIdentifier.Record,
+            [TransmissionTypeIdentifier.String] = RepresentationTypeIdentifier.String,
+        };
+
+        public bool IsCompatible(TransmissionType tdu)
+        {
+            var tru = typesMap[tdu.Identifier];
+
+            if (tru != Identifier)
+                return false;
+
+            if (tdu.Class == TransmissionTypeClass.Typed)
+            {
+                if (tdu.Identifier == TransmissionTypeIdentifier.)
+            }
+            return true;
+        }
+
         public void SetNull(List<byte> flags)
         {
             if (refTypes.Contains(Identifier))

Esiur/Data/TransmissionType.cs

@@ -56,7 +56,9 @@ public enum TransmissionTypeIdentifier : byte
     TypedEnum = 0x84,
     TypedConstant = 0x85,
 
-    ResourceLink = 0xC0
+    ResourceLink = 0xC0,
+
+    Same = 0xFF
 }
 
 public enum TransmissionTypeClass