esiur/esiur-dotnet
2
0
Fork 0
mirror of https://github.com/esiur/esiur-dotnet.git synced 2025-09-13 12:43:17 +00:00
Code Issues Projects Releases Wiki Activity

List

Browse Source
This commit is contained in:
ahmed
2025-08-31 17:02:51 +03:00
parent eee5c7c036
commit 608441c0eb
7 changed files with 212 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
Esiur/Data/Codec.cs
View File

@@ -338,20 +338,11 @@ public static class Codec
};
/// <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)
internal static (TransmissionTypeIdentifier identifier, byte[])
ComposeInternal(object valueOrSource, Warehouse warehouse, DistributedConnection connection)
{
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,24 +442,36 @@ 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 (hdr, data);
}
}
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);
}
}
return TransmissionType.Compose(TransmissionTypeIdentifier.Null, null);
}
public static bool IsAnonymous(Type type)
{
// Detect anonymous types

5
Esiur/Data/DataConverter.cs
View File

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

23
Esiur/Data/DataDeserializer.cs
View File

@@ -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 Esiur.Data;
using Esiur.Resource.Template;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Esiur.Misc;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Text;
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);

25
Esiur/Data/DataSerializer.cs
View File

@@ -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();
}

181
Esiur/Data/Map.cs
View File

@@ -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 Clear();
public bool ContainsKey(object key);
//public void Remove(object key);
//public void Clear();
//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();
//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)
{
return dic.ContainsKey(key);
}
//public bool ContainsKey(KT 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)
{
dic = source.dic;
}
//public Map(Map<KT,VT> source)
//{
// dic = source.dic;
//}
public Map()
{
}
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>
//public static Map<KT,VT> FromMap(Map<KT,VT> source, Type destinationType)
//{
// 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)
=> new Map<KT, VT>() { dic = dictionary };
//public static Map<KT, VT> FromDictionary(Dictionary<KT, VT> 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()
{
return dic.GetEnumerator();
}
//public IEnumerator<KeyValuePair<KT, VT>> GetEnumerator()
//{
// return dic.GetEnumerator();
//}
IEnumerator IEnumerable.GetEnumerator()
{
return dic.GetEnumerator();
}
//IEnumerator IEnumerable.GetEnumerator()
//{
// return dic.GetEnumerator();
//}
public int Length
{
get { return dic.Count; }
}
//public int Length
//{
// get { return dic.Count; }
//}
public KeyValuePair<KT, VT> At(int index)
{
return dic.ElementAt(index);
}
//public KeyValuePair<KT, VT> At(int index)
//{
// return dic.ElementAt(index);
//}
public object SyncRoot
{
get { return syncRoot; }
}
public KT[] GetKeys() => dic.Keys.ToArray();//GetKeys()
//{
// return dic.Keys.ToArray();
//}
//public KT[] GetKeys() => dic.Keys.ToArray();
public void Add(KT key, VT value)
{
if (dic.ContainsKey(key))
dic[key] = value;
else
dic.Add(key, value);
}
//public void Add(KT key, VT value)
//{
// if (dic.ContainsKey(key))
// dic[key] = value;
// else
// 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)
{
Remove((KT)key);
}
//public void Remove(object key)
//{
// Remove((KT)key);
//}
public void Clear()
{
dic.Clear();
}
//public void Clear()
//{
// dic.Clear();
//}
public bool ContainsKey(object key)
{
return ContainsKey((KT)key);
}
//public bool ContainsKey(object 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]
{
get
{
if (dic.ContainsKey(index))
return dic[index];
else
return default;
}
set
{
if (dic.ContainsKey(index))
dic[index] = value;
else
dic.Add(index, value);
}
}
//public VT this[KT index]
//{
// get
// {
// if (dic.ContainsKey(index))
// return dic[index];
// else
// return default;
// }
// set
// {
// if (dic.ContainsKey(index))
// dic[index] = value;
// else
// dic.Add(index, value);
// }
//}
}

40
Esiur/Data/RepresentationType.cs
View File

@@ -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))

4
Esiur/Data/TransmissionType.cs
View File

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