deukpack 1.0.1 → 1.0.3

package/dist/csharp/DeukPackSerializer.cs

@@ -0,0 +1,256 @@
+/**
+ * DeukPackSerializer — 직렬화 헬퍼. DpProtocolLibrary 모듈화.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace DeukPack.Protocol
+{
+    /// <summary>
+    /// DeukPack serialization helper - modularized to reduce code duplication
+    /// Recursive serialization support for nested structures
+    /// </summary>
+    public static class DeukPackSerializer
+    {
+        /// <summary>
+        /// Write a value recursively based on its type
+        /// </summary>
+        public static void WriteValue(DpProtocol oprot, DpWireType type, object value)
+        {
+            if (value == null)
+                return;
+
+            switch (type)
+            {
+                case DpWireType.Bool:
+                    oprot.WriteBool((bool)value);
+                    break;
+                case DpWireType.Byte:
+                    oprot.WriteByte((byte)value);
+                    break;
+                case DpWireType.I16:
+                    oprot.WriteI16(value is short s16 ? s16 : Convert.ToInt16(value));
+                    break;
+                case DpWireType.I32:
+                    oprot.WriteI32(value is int i32 ? i32 : Convert.ToInt32(value));
+                    break;
+                case DpWireType.I64:
+                    oprot.WriteI64(value is long i64 ? i64 : Convert.ToInt64(value));
+                    break;
+                case DpWireType.Double:
+                    oprot.WriteDouble((double)value);
+                    break;
+                case DpWireType.String:
+                    if (value is byte[] bytes)
+                        oprot.WriteBinary(bytes);
+                    else
+                        oprot.WriteString((string)value);
+                    break;
+                case DpWireType.Struct:
+                    if (value is IDpSerializable serializable)
+                        serializable.Write(oprot);
+                    break;
+                default:
+                    if (value is IDpSerializable serializableValue)
+                        serializableValue.Write(oprot);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Read a value recursively based on its type
+        /// </summary>
+        public static object ReadValue(DpProtocol iprot, DpWireType type, Type targetType = null)
+        {
+            switch (type)
+            {
+                case DpWireType.Bool:
+                    return iprot.ReadBool();
+                case DpWireType.Byte:
+                    return iprot.ReadByte();
+                case DpWireType.I16:
+                {
+                    short v = iprot.ReadI16();
+                    return (targetType != null && targetType.IsEnum) ? Enum.ToObject(targetType, v) : (object)v;
+                }
+                case DpWireType.I32:
+                {
+                    int v = iprot.ReadI32();
+                    return (targetType != null && targetType.IsEnum) ? Enum.ToObject(targetType, v) : (object)v;
+                }
+                case DpWireType.I64:
+                {
+                    long v = iprot.ReadI64();
+                    return (targetType != null && targetType.IsEnum) ? Enum.ToObject(targetType, v) : (object)v;
+                }
+                case DpWireType.Double:
+                    return iprot.ReadDouble();
+                case DpWireType.String:
+                    if (targetType == typeof(string))
+                        return iprot.ReadString();
+                    return iprot.ReadBinary();
+                case DpWireType.Struct:
+                    if (targetType != null)
+                    {
+                        var instance = Activator.CreateInstance(targetType);
+                        if (instance is IDpSerializable serializable)
+                        {
+                            serializable.Read(iprot);
+                            return instance;
+                        }
+                    }
+                    return null;
+                default:
+                    if (targetType != null)
+                    {
+                        var instance = Activator.CreateInstance(targetType);
+                        if (instance is IDpSerializable serializable)
+                        {
+                            serializable.Read(iprot);
+                            return instance;
+                        }
+                    }
+                    return null;
+            }
+        }
+
+        /// <summary>
+        /// Write a list recursively
+        /// </summary>
+        public static void WriteList<T>(DpProtocol oprot, DpWireType elementType, IEnumerable<T> list)
+        {
+            var count = list is ICollection<T> collection ? collection.Count : list.Count();
+            oprot.WriteListBegin(new DpList { ElementType = elementType, Count = count });
+            foreach (var item in list)
+            {
+                WriteValue(oprot, elementType, item);
+            }
+            oprot.WriteListEnd();
+        }
+
+        /// <summary>
+        /// Read a list recursively
+        /// </summary>
+        public static List<T> ReadList<T>(DpProtocol iprot, DpWireType elementType, Func<DpProtocol, T> reader = null)
+        {
+            var listInfo = iprot.ReadListBegin();
+            var list = new List<T>(listInfo.Count);
+            for (int i = 0; i < listInfo.Count; i++)
+            {
+                if (reader != null)
+                {
+                    list.Add(reader(iprot));
+                }
+                else
+                {
+                    var value = ReadValue(iprot, elementType, typeof(T));
+                    if (value is T item)
+                    {
+                        list.Add(item);
+                    }
+                }
+            }
+            iprot.ReadListEnd();
+            return list;
+        }
+
+        /// <summary>
+        /// Write a set recursively
+        /// </summary>
+        public static void WriteSet<T>(DpProtocol oprot, DpWireType elementType, IEnumerable<T> set)
+        {
+            var count = set is ICollection<T> collection ? collection.Count : set.Count();
+            oprot.WriteSetBegin(new DpSet { ElementType = elementType, Count = count });
+            foreach (var item in set)
+            {
+                WriteValue(oprot, elementType, item);
+            }
+            oprot.WriteSetEnd();
+        }
+
+        /// <summary>
+        /// Read a set recursively
+        /// </summary>
+        public static HashSet<T> ReadSet<T>(DpProtocol iprot, DpWireType elementType, Func<DpProtocol, T> reader = null)
+        {
+            var setInfo = iprot.ReadSetBegin();
+            var set = new HashSet<T>();
+            for (int i = 0; i < setInfo.Count; i++)
+            {
+                if (reader != null)
+                {
+                    set.Add(reader(iprot));
+                }
+                else
+                {
+                    var value = ReadValue(iprot, elementType, typeof(T));
+                    if (value is T item)
+                    {
+                        set.Add(item);
+                    }
+                }
+            }
+            iprot.ReadSetEnd();
+            return set;
+        }
+
+        /// <summary>
+        /// Write a map recursively
+        /// </summary>
+        public static void WriteMap<TKey, TValue>(DpProtocol oprot, DpWireType keyType, DpWireType valueType, IDictionary<TKey, TValue> map)
+        {
+            oprot.WriteMapBegin(new DpDict { KeyType = keyType, ValueType = valueType, Count = map.Count });
+            foreach (var kvp in map)
+            {
+                WriteValue(oprot, keyType, kvp.Key);
+                WriteValue(oprot, valueType, kvp.Value);
+            }
+            oprot.WriteMapEnd();
+        }
+
+        /// <summary>
+        /// Read a map recursively
+        /// </summary>
+        public static Dictionary<TKey, TValue> ReadMap<TKey, TValue>(
+            DpProtocol iprot,
+            DpWireType keyType,
+            DpWireType valueType,
+            Func<DpProtocol, TKey> keyReader = null,
+            Func<DpProtocol, TValue> valueReader = null)
+        {
+            var mapInfo = iprot.ReadMapBegin();
+            var map = new Dictionary<TKey, TValue>(mapInfo.Count);
+            for (int i = 0; i < mapInfo.Count; i++)
+            {
+                TKey key;
+                if (keyReader != null)
+                {
+                    key = keyReader(iprot);
+                }
+                else
+                {
+                    var keyValue = ReadValue(iprot, keyType, typeof(TKey));
+                    key = keyValue is TKey k ? k : default(TKey);
+                }
+
+                TValue value;
+                if (valueReader != null)
+                {
+                    value = valueReader(iprot);
+                }
+                else
+                {
+                    var valueObj = ReadValue(iprot, valueType, typeof(TValue));
+                    value = valueObj is TValue v ? v : default(TValue);
+                }
+
+                map[key] = value;
+            }
+            iprot.ReadMapEnd();
+            return map;
+        }
+    }
+}

package/dist/csharp/DeukPackThriftCompat.cs

@@ -0,0 +1,147 @@
+/**
+ * DeukPack.Protocol compatibility: T* and Thrift* type names for existing generated code and add-in.
+ * New code should use Dp* types (DpProtocol, DpWireType, DpRecord, DpColumn, DpSchema, etc.).
+ * See docs/DEUKPACK_CORE_VS_APACHE_AND_OTHERS.md §5.
+ */
+
+using System;
+
+namespace DeukPack.Protocol
+{
+#pragma warning disable CS0618 // Type or member is obsolete
+
+    [Obsolete("Use DpWireType")]
+    public enum TType
+    {
+        Stop = 0, Void = 1, Bool = 2, Byte = 3, Double = 4,
+        I16 = 6, I32 = 8, I64 = 10, String = 11, Struct = 12, Map = 13, Set = 14, List = 15
+    }
+
+    [Obsolete("Use DpProtocol")]
+    public interface TProtocol : DpProtocol { }
+
+    [Obsolete("Use DpRecord")]
+    public struct TStruct
+    {
+        public string Name;
+        public TStruct(string name) { Name = name; }
+        public static implicit operator TStruct(DpRecord r) => new TStruct(r.Name);
+        public static implicit operator DpRecord(TStruct t) => new DpRecord(t.Name);
+    }
+
+    [Obsolete("Use DpColumn")]
+    public struct TField
+    {
+        public string Name;
+        public TType Type;
+        public short ID;
+        public TField(string name, TType type, short id) { Name = name; Type = type; ID = id; }
+        public static implicit operator TField(DpColumn c) => new TField(c.Name, (TType)(int)c.Type, c.ID);
+        public static implicit operator DpColumn(TField t) => new DpColumn(t.Name, (DpWireType)(int)t.Type, t.ID);
+    }
+
+    [Obsolete("Use DpList")]
+    public struct TList
+    {
+        public TType ElementType;
+        public int Count;
+        public static implicit operator TList(DpList l) => new TList { ElementType = (TType)(int)l.ElementType, Count = l.Count };
+        public static implicit operator DpList(TList t) => new DpList { ElementType = (DpWireType)(int)t.ElementType, Count = t.Count };
+    }
+
+    [Obsolete("Use DpSet")]
+    public struct TSet
+    {
+        public TType ElementType;
+        public int Count;
+        public static implicit operator TSet(DpSet s) => new TSet { ElementType = (TType)(int)s.ElementType, Count = s.Count };
+        public static implicit operator DpSet(TSet t) => new DpSet { ElementType = (DpWireType)(int)t.ElementType, Count = t.Count };
+    }
+
+    [Obsolete("Use DpDict")]
+    public struct TMap
+    {
+        public TType KeyType;
+        public TType ValueType;
+        public int Count;
+        public static implicit operator TMap(DpDict d) => new TMap { KeyType = (TType)(int)d.KeyType, ValueType = (TType)(int)d.ValueType, Count = d.Count };
+        public static implicit operator DpDict(TMap t) => new DpDict { KeyType = (DpWireType)(int)t.KeyType, ValueType = (DpWireType)(int)t.ValueType, Count = t.Count };
+    }
+
+    [Obsolete("Use DpProtocolUtil")]
+    public static class TProtocolUtil
+    {
+        public static void Skip(TProtocol prot, TType type) => DpProtocolUtil.Skip(prot, (DpWireType)(int)type);
+    }
+
+    [Obsolete("Use DpSchemaType")]
+    public enum ThriftType
+    {
+        Bool, Byte, I16, I32, I64, Double, String, Binary, Struct, Enum, List, Set, Map
+    }
+
+    [Obsolete("Use DpDefinitionKind")]
+    public enum ThriftSchemaType
+    {
+        Struct, Enum, Typedef, Constant
+    }
+
+    [Obsolete("Use DpFieldSchema")]
+    public class ThriftFieldSchema
+    {
+        public int Id { get; set; }
+        public int Order { get; set; }
+        public string Name { get; set; }
+        public ThriftType Type { get; set; }
+        public string TypeName { get; set; }
+        public bool Required { get; set; }
+        public object DefaultValue { get; set; }
+        public string DocComment { get; set; }
+        public System.Collections.Generic.Dictionary<string, string> Annotations { get; set; }
+        public DpFieldSchema ToDpFieldSchema() => new DpFieldSchema
+        {
+            Id = Id, Order = Order, Name = Name, Type = (DpSchemaType)(int)Type, TypeName = TypeName,
+            Required = Required, DefaultValue = DefaultValue, DocComment = DocComment, Annotations = Annotations
+        };
+    }
+
+    [Obsolete("Use DpSchema")]
+    public class ThriftSchema
+    {
+        public string Name { get; set; }
+        public ThriftSchemaType Type { get; set; }
+        public System.Collections.Generic.Dictionary<int, ThriftFieldSchema> Fields { get; set; }
+        public string DocComment { get; set; }
+        public System.Collections.Generic.Dictionary<string, string> Annotations { get; set; }
+        public DpSchema ToDpSchema()
+        {
+            var fs = new System.Collections.Generic.Dictionary<int, DpFieldSchema>();
+            if (Fields != null)
+                foreach (var kv in Fields)
+                    fs[kv.Key] = kv.Value.ToDpFieldSchema();
+            return new DpSchema
+            {
+                Name = Name,
+                Type = (DpDefinitionKind)(int)Type,
+                Fields = fs,
+                DocComment = DocComment,
+                Annotations = Annotations
+            };
+        }
+    }
+
+    [Obsolete("Use DpTypeNames")]
+    public static class ThriftProtocolTypeNames
+    {
+        public static string ToProtocolName(TType t) => DpTypeNames.ToProtocolName((DpWireType)(int)t);
+        public static DpWireType FromProtocolName(string dt) => DpTypeNames.FromProtocolName(dt);
+        public static bool IsContainerType(TType t) => DpTypeNames.IsContainerType((DpWireType)(int)t);
+        public static DpWireType FromSchemaTypeName(string name) => DpTypeNames.FromSchemaTypeName(name);
+        public static string StripOuterGeneric(string typeName) => DpTypeNames.StripOuterGeneric(typeName);
+        public static string SchemaFieldToDataType(ThriftFieldSchema f) => f == null ? "string" : DpTypeNames.SchemaFieldToDataType(f.ToDpFieldSchema());
+    }
+
+    // TExcelProtocol moved to DeukPack.ExcelProtocol DLL (DpExcelCompat.cs)
+
+#pragma warning restore CS0618
+}