Esempio n. 1
0
        static void InitField(StringBuilder initer, FieldWrap field)
        {
            int level = SEM_LEVEL + 1;

            if (field.IsRaw || field.IsEnum || field.IsClass)
            {
                initer.Space(SEM_LEVEL);
                initer.AppendLine($"{field.Name} = {ReadValue(field)};");
            }
            else if (field.OriginalType == Setting.LIST)
            {
                initer.Space(SEM_LEVEL).AppendLine($"for (int n = {ARG_DATASTREAM}.GetArrayLength(); n-- > 0;)");
                initer.Space(SEM_LEVEL).AppendLine("{");
                {
                    FieldWrap item = field.GetItemDefine();
                    initer.Space(level).AppendLine($"var v = {ReadValue(item)};");
                    initer.Space(level).AppendLine($"{field.Name}.Add(v);");
                }
                initer.Space(SEM_LEVEL).AppendLine("}");
            }
            else if (field.OriginalType == Setting.DICT)
            {
                initer.Space(SEM_LEVEL).AppendLine($"for (int n = {ARG_DATASTREAM}.GetMapLength(); n-- > 0;)");
                initer.Space(SEM_LEVEL).AppendLine("{");
                {
                    FieldWrap key   = field.GetKeyDefine();
                    FieldWrap value = field.GetValueDefine();
                    initer.Space(level).AppendLine($"var k = {ReadValue(key)};");
                    initer.Space(level).AppendLine($"{field.Name}[k] = {ReadValue(value)};");
                }
                initer.Space(SEM_LEVEL).AppendLine("}");
            }
        }
Esempio n. 2
0
 static string ReadValue(FieldWrap field)
 {
     if (field.IsRaw)
     {
         return($"{ARG_DATASTREAM}.Get{field.FullName.FirstCharUpper()}()");
     }
     else if (field.IsEnum)
     {
         return($"({Util.CorrectFullType(field.FullName)}){ARG_DATASTREAM}.GetInt()");
     }
     else if (field.IsClass)
     {
         ClassWrap info     = ClassWrap.Get(field.FullName);
         string    fullType = Util.CorrectFullType(field.FullName);
         if (info.IsDynamic())
         {
             return($"({fullType}){ARG_DATASTREAM}.GetObject({ARG_DATASTREAM}.GetString())");
         }
         else
         {
             return($"new {fullType}({ARG_DATASTREAM})");
         }
     }
     else
     {
         Util.Error("不支持集合嵌套类型:" + field.FullName);
     }
     return(null);
 }
Esempio n. 3
0
 static string GetDefineName(FieldWrap field)
 {
     if (field.IsRaw)
     {
         return($"o.Get{Util.FirstCharUpper(field.FullName)}()");
     }
     else if (field.IsEnum)
     {
         return($"<{CorrectNamespace(field.FullName)}>o.GetInt()");
     }
     else if (field.IsClass)
     {
         var    cls       = ClassWrap.Classes[field.FullName];
         string parseName = GetDynamicName(cls);
         return($"o.Get{parseName}()");
     }
     else if (field.OriginalType == Setting.LIST)
     {
         return($"o.Get{Util.FirstCharUpper(field.OriginalType)}('{GetDefineName(field.Types[1])}')");
     }
     else if (field.OriginalType == Setting.DICT)
     {
         return($"o.Get{Util.FirstCharUpper(field.OriginalType)}('{GetDefineName(field.Types[1])}', '{GetDefineName(field.Types[2])}')");
     }
     else
     {
         return("unknow:" + field.FullName);
     }
 }
Esempio n. 4
0
        public FClass(FClass host, FieldWrap define, XmlElement value) : base(host, define)
        {
            _fullType = define.FullName;

            ClassWrap info = ClassWrap.Get(define.FullName);

            Load(info, value);
        }
Esempio n. 5
0
        static void ReadFunc(StringBuilder reader, FieldWrap field)
        {
            int    level = SEM_LEVEL + 1;
            string type  = Util.CorrectFullType(field.FullName);

            if (field.IsRaw)
            {
                reader.Space(level).AppendLine($"case \"{field.Name}\": {field.Name} = Read{type.FirstCharUpper()}(_2); break;");
            }
            else if (field.IsEnum)
            {
                reader.Space(level).AppendLine($"case \"{field.Name}\": {field.Name} = ({type})ReadInt(_2); break;");
            }
            else if (field.IsClass)
            {
                if (field.IsDynamic)
                {
                    string ns = type.Substring(0, type.LastIndexOf('.'));
                    reader.Space(level).AppendLine($"case \"{field.Name}\": {field.Name} = ReadDynamicObject<{type}>(_2, \"{ns}\"); break;");
                }
                else
                {
                    reader.Space(level).AppendLine($"case \"{field.Name}\": {field.Name} = ReadObject<{type}>(_2, \"{type}\"); break;");
                }
            }
            else if (field.IsContainer)
            {
                var level0 = level + 1;
                reader.Space(level).AppendLine($"case \"{field.Name}\":");
                if (field.OriginalType == Setting.LIST)
                {
                    var item = field.GetItemDefine();
                    reader.Space(level0).AppendLine($"var {field.Name}s = GetChilds(_2);");
                    reader.Space(level0).AppendLine($"for (int i = 0; i < {field.Name}s.Count; i++)");
                    reader.Space(level0).AppendLine($"{{");
                    reader.Space(level0 + 1).AppendLine($"var _3 = {field.Name}s[i];");
                    reader.Space(level0 + 1).AppendLine($"{field.Name}.Add({ReadList(item)});");
                    reader.Space(level0).AppendLine($"}}");
                    reader.Space(level0).AppendLine($"break;");
                }
                else if (field.OriginalType == Setting.DICT)
                {
                    var key   = field.GetKeyDefine();
                    var value = field.GetValueDefine();
                    reader.Space(level0).AppendLine($"var {field.Name}s = GetChilds(_2);");
                    reader.Space(level0).AppendLine($"for (int i = 0; i < {field.Name}s.Count; i++)");
                    reader.Space(level0).AppendLine($"{{");
                    reader.Space(level0 + 1).AppendLine($"var _3 = {field.Name}s[i];");
                    reader.Space(level0 + 1).AppendLine($"var key = {ReadDict(key, Setting.KEY)};");
                    reader.Space(level0 + 1).AppendLine($"var value = {ReadDict(value, Setting.VALUE)};");
                    reader.Space(level0 + 1).AppendLine($"{field.Name}.Add(key, value);");
                    reader.Space(level0).AppendLine($"}}");
                    reader.Space(level0).AppendLine($"break;");
                }
            }
        }
Esempio n. 6
0
        public FInt(FClass host, FieldWrap define, XmlElement value) : base(host, define)
        {
            string v = value.InnerText;
            int    r;

            if (!int.TryParse(v, out r))
            {
                Util.Error("{0}非int类型或者数值溢出", v);
                Value = -1;
            }
            Value = r;
        }
Esempio n. 7
0
        public FLong(FClass host, FieldWrap define, XmlElement xml) : base(host, define)
        {
            string v = xml.InnerText;
            long   r;

            if (!long.TryParse(v, out r))
            {
                Util.Error("{0}非long类型或者数值溢出", v);
                Value = -1;
            }
            Value = r;
        }
Esempio n. 8
0
        public FFloat(FClass host, FieldWrap define, XmlElement xml) : base(host, define)
        {
            string v = xml.InnerText;
            float  r;

            if (!float.TryParse(v, out r))
            {
                Util.Error("{0}非float类型或者数值溢出", v);
                Value = -1;
            }
            Value = r;
        }
Esempio n. 9
0
 public static void AddIndex(FieldWrap index, Data data)
 {
     if (_indexs.ContainsKey(index))
     {
         _indexs[index].Add(data);
     }
     else
     {
         _indexs.Add(index, new HashSet <Data>()
         {
             data
         });
     }
 }
Esempio n. 10
0
        public override void GetList(FList data, FieldWrap define)
        {
            FieldWrap item = define.GetItemDefine();

            while (!IsSectionEnd())
            {
                var d = Data.Create(data.Host, item, this);
                if (data.IsRoot)//数据表List
                {
                    Program.AddLastData(d);
                }
                data.Values.Add(d);
            }
        }
Esempio n. 11
0
        public FEnum(FClass host, FieldWrap define, ImportExcel excel) : base(host, define)
        {
            EnumWrap info = EnumWrap.Enums[define.OriginalType];
            string   name = excel.GetEnum();

            EnumName = info.GetEnumName(name);
            EnumName = EnumName.IsEmpty() ? name : EnumName;
            Value    = info.GetEnumValue(EnumName);

            if (!info.ContainItem(name))
            {
                excel.Error($"未定义枚举(名称/别名){define.FullName}.{name}   !");
            }
        }
Esempio n. 12
0
 public Checker(FieldWrap define, string rules)
 {
     _define = define;
     _rules  = rules;
     string[] nodes = rules.Split(Setting.CheckSplit, System.StringSplitOptions.RemoveEmptyEntries);
     _ruleTable = new RuleInfo[nodes.Length];
     for (int i = 0; i < nodes.Length; i++)
     {
         _ruleTable[i] = new RuleInfo()
         {
             _rule = nodes[i]
         }
     }
     ;
 }
Esempio n. 13
0
 static void Field(FieldWrap field)
 {
     Comment(field.Desc, MEM_LEVEL);
     builder.Space(MEM_LEVEL);
     if (field.IsRaw || field.IsEnum || field.IsClass)
     {
         builder.AppendLine($"{FEILD_MODIFIERS} {Util.CorrectFullType(field.FullName)} {field.Name};");
     }
     else if (field.OriginalType == Setting.LIST)
     {
         builder.AppendLine($"{FEILD_MODIFIERS} List<{Util.CorrectFullType(field.Types[1])}> {field.Name} = new List<{Util.CorrectFullType(field.Types[1])}>();");
     }
     else if (field.OriginalType == Setting.DICT)
     {
         builder.AppendLine($"{FEILD_MODIFIERS} Dictionary<{field.Types[1]}, {Util.CorrectFullType(field.Types[2])}> {field.Name} = new Dictionary<{field.Types[1]}, {Util.CorrectFullType(field.Types[2])}>();");
     }
 }
Esempio n. 14
0
        public FBool(FClass host, FieldWrap define, XmlElement xml) : base(host, define)
        {
            string v = xml.InnerText;

            if (v.Equals("true", StringComparison.CurrentCultureIgnoreCase))
            {
                Value = true;
            }
            else if (v.Equals("false", StringComparison.CurrentCultureIgnoreCase))
            {
                Value = false;
            }
            else
            {
                Util.Error("{0}非bool类型", v);
                Value = false;
            }
        }
Esempio n. 15
0
 static string GetType(FieldWrap field)
 {
     if (field.IsRaw || field.IsEnum || field.IsClass)
     {
         return(GetRawType(field.OriginalType));
     }
     else if (field.OriginalType == Setting.LIST)
     {
         return($"{GetRawType(field.Types[1])}[]");
     }
     else if (field.OriginalType == Setting.DICT)
     {
         return($"Map<{GetRawType(field.Types[1])}, {GetRawType(field.Types[2])}>");
     }
     else
     {
         return("unknow");
     }
 }
Esempio n. 16
0
        public override void GetDict(FDict data, FieldWrap define)
        {
            FieldWrap key   = define.GetKeyDefine();
            FieldWrap value = define.GetValueDefine();

            while (!IsSectionEnd())
            {
                var dk = Data.Create(data.Host, key, this);
                var dv = Data.Create(data.Host, value, this);
                if (!data.Values.ContainsKey(dk))
                {
                    data.Values.Add(dk, dv);
                }
                else
                {
                    Error($"字段:{define.Name} Key:{dk} 重复");
                }
            }
        }
Esempio n. 17
0
        static string ReadDict(FieldWrap field, string node)
        {
            var type = Util.CorrectFullType(field.FullName);

            if (field.IsRaw)
            {
                return($"Read{type.FirstCharUpper()}(GetOnlyChild(_3, \"{node}\"))");
            }
            else if (field.IsEnum)
            {
                return($"({type})ReadInt(GetOnlyChild(_3, \"{node}\"))");
            }
            else if (field.IsClass)
            {
                return($"ReadObject<{type}>(GetOnlyChild(_3, \"{node}\"), \"{type}\")");
            }
            else
            {
                Util.LogError($"集合中类型仅支持基础类型,Enum,Class!");
                return("<集合中类型仅支持基础类型,Enum,Class!>");
            }
        }
Esempio n. 18
0
        public FDict(FClass host, FieldWrap define, XmlElement data) : base(host, define)
        {
            _key   = define.GetKeyDefine();
            _value = define.GetValueDefine();

            XmlNodeList dict = data.ChildNodes;

            for (int i = 0; i < dict.Count; i++)
            {
                XmlNode    pair  = dict[i];
                XmlElement key   = pair[Setting.KEY];
                XmlElement value = pair[Setting.VALUE];
                var        dk    = Data.Create(host, _key, key);
                var        dv    = Data.Create(host, _value, value);
                if (!Values.ContainsKey(dk))
                {
                    Values.Add(dk, dv);
                }
                else
                {
                    Util.Error("字段:{0} Key:{1} 重复", define.Name, dk);
                }
            }
        }
Esempio n. 19
0
        /// <summary>
        /// 数据结构定义
        /// </summary>
        private static void GenDataStruct()
        {
            StringBuilder builder = new StringBuilder();

            builder.AppendLine("local Stream = require(\"Common.DataStream\")");
            builder.AppendLine("local GetOrCreate = Util.GetOrCreate");
            builder.AppendLine();
            builder.AppendLine("local meta");

            var cit = ClassWrap.Classes.GetEnumerator();

            while (cit.MoveNext())
            {
                var cls      = cit.Current.Value;
                var fullType = Util.CorrectFullType(cls.FullName);
                builder.AppendLine("meta= {}");
                builder.AppendLine("meta.__index = meta");
                builder.AppendFormat("meta.__cname = '{0}'\n", fullType);

                //--常量字段
                for (int j = 0; j < cls.Consts.Count; j++)
                {
                    ConstWrap constant = cls.Consts[j];
                    if (!Util.MatchGroups(constant.Group))
                    {
                        continue;
                    }

                    string value = constant.Value;
                    switch (constant.FullName)
                    {
                    case Setting.BOOL:
                        value = value.ToLower();
                        break;

                    case Setting.STRING:
                        value = string.Format("'{0}'", value);
                        break;

                    default:
                        if (EnumWrap.IsEnum(constant.FullName))
                        {
                            value = EnumWrap.Enums[constant.FullName].GetValue(constant.Value);
                        }
                        break;
                    }
                    builder.AppendFormat("meta.{0} = {1}\n", constant.Name, value);
                }

                builder.AppendFormat("GetOrCreate('{0}.{1}')['{2}'] = meta\n", Setting.ModuleName, cls.Namespace, cls.Name);
                string funcName = fullType.Replace(".", "");
                if (cls.IsDynamic())
                {
                    builder.AppendFormat("function Stream:Get{0}Maker()\n", funcName);
                    builder.Space().AppendFormat("return self['Get' .. self:GetString():gsub('%.', '')](self)\n");
                    builder.AppendFormat("end\n");
                }
                builder.AppendFormat("function Stream:Get{0}()\n", funcName);
                if (!cls.Inherit.IsEmpty())
                {
                    builder.Space().AppendFormat("local o = self:Get{0}()\n", Util.CorrectFullType(cls.Inherit).Replace(".", ""));
                }
                else
                {
                    builder.Space().AppendFormat("local o = {{}}\n");
                }
                builder.Space().AppendFormat("setmetatable(o, {0})\n", fullType);

                //--普通字段
                for (int j = 0; j < cls.Fields.Count; j++)
                {
                    FieldWrap field = cls.Fields[j];
                    if (!Util.MatchGroups(field.Group))
                    {
                        continue;
                    }

                    if (field.IsRaw)
                    {
                        builder.Space().AppendFormat("o.{0} = self:Get{1}()\n", field.Name, field.OriginalType.FirstCharUpper());
                    }
                    else if (field.IsEnum)
                    {
                        builder.Space().AppendFormat("o.{0} = self:GetInt()\n", field.Name);
                    }
                    else if (field.IsClass)
                    {
                        if (field.IsDynamic)
                        {
                            builder.Space().AppendFormat("o.{0} = self:Get{1}Maker()\n", field.Name, Util.CorrectFullType(field.OriginalType).Replace(".", ""));
                        }
                        else
                        {
                            builder.Space().AppendFormat("o.{0} = self:Get{1}()\n", field.Name, Util.CorrectFullType(field.OriginalType).Replace(".", ""));
                        }
                    }
                    else if (field.IsContainer)
                    {
                        if (field.OriginalType == Setting.LIST)
                        {
                            var    item  = field.GetItemDefine();
                            string index = Util.CorrectFullType(item.OriginalType).Replace(".", "").FirstCharUpper();
                            if (item.IsClass && item.IsDynamic)
                            {
                                index += "Maker";
                            }
                            builder.Space().AppendFormat("o.{0} = self:GetList('{1}')\n", field.Name, index);
                        }
                        else if (field.OriginalType == Setting.DICT)
                        {
                            var    k   = field.GetKeyDefine();
                            string key = k.OriginalType.FirstCharUpper();
                            if (k.IsEnum)
                            {
                                key = "Int";
                            }
                            var    v     = field.GetValueDefine();
                            string value = Util.CorrectFullType(v.OriginalType).Replace(".", "").FirstCharUpper();
                            if (v.IsClass && v.IsDynamic)
                            {
                                value += "Maker";
                            }
                            else if (v.IsEnum)
                            {
                                value = "Int";
                            }
                            builder.Space().AppendFormat("o.{0} = self:GetDict('{1}', '{2}')\n", field.Name, key, value);
                        }
                    }
                }
                builder.Space().AppendFormat("return o\n");
                builder.AppendFormat("end\n");
            }

            var eit = EnumWrap.Enums.GetEnumerator();

            while (eit.MoveNext())
            {
                EnumWrap en = eit.Current.Value;
                builder.AppendFormat("GetOrCreate('{0}.{1}')['{2}'] = {{\n", Setting.ModuleName, en.Namespace, en.Name);
                foreach (var item in en.Values)
                {
                    builder.Space().AppendFormat("{0} = {1},\n", item.Key, item.Value);
                }
                builder.AppendLine("}");
            }
            builder.AppendLine("return Stream");
            string path = Path.Combine(Setting.LuaDir, DATA_STRUCT + ".lua");

            Util.SaveFile(path, builder.ToString());
        }
Esempio n. 20
0
 public abstract void GetDict(FDict data, FieldWrap define);
Esempio n. 21
0
 public abstract void GetList(FList data, FieldWrap define);
Esempio n. 22
0
        public static Data Create(FClass host, FieldWrap define, ImportExcel excel)
        {
            string type = define.OriginalType;

            if (define.IsRaw)
            {
                switch (type)
                {
                case Setting.BOOL:
                    return(new FBool(host, define, excel));

                case Setting.INT:
                    return(new FInt(host, define, excel));

                case Setting.LONG:
                    return(new FLong(host, define, excel));

                case Setting.FLOAT:
                    return(new FFloat(host, define, excel));

                case Setting.STRING:
                    return(new FString(host, define, excel));
                }
            }
            else if (define.IsEnum)
            {
                return(new FEnum(host, define, excel));
            }
            else if (define.IsClass)
            {
                if (!define.IsDynamic)
                {
                    return(new FClass(host, define, excel));
                }

                string    dType = excel.GetString();
                ClassWrap cls   = ClassWrap.Get(define.FullName);
                dType = ClassWrap.CorrectType(cls, dType);
                ClassWrap dynamic = ClassWrap.Get(dType);
                if (dynamic == null)
                {
                    excel.Error("多态类型" + dType + "未知");
                }
                if (cls.FullName != dType && !cls.HasChild(dType))
                {
                    excel.Error(string.Format("数据类型{0}非{1}子类", dType, cls.FullName));
                }
                var define0 = new FieldWrap(define.Host, define.Name, dType, new string[] { define.FullName }, define.Group);
                return(new FClass(host, define0, excel));
            }
            else if (define.IsContainer)
            {
                if (define.OriginalType == "list")
                {
                    return(new FList(host, define, excel));
                }
                else if (define.OriginalType == "dict")
                {
                    return(new FDict(host, define, excel));
                }
            }

            Util.LogError("未知类型" + type);
            return(null);
        }
Esempio n. 23
0
 public FEnum(FClass host, FieldWrap define, XmlElement xml) : base(host, define)
 {
     Value = xml.InnerText;//Xml中枚举以int表示
 }
Esempio n. 24
0
 public NotEmptyChecker(FieldWrap define, string rule) : base(define, rule)
 {
 }
Esempio n. 25
0
        static void GenClass()
        {
            List <ClassWrap> classes = ClassWrap.GetExports();

            for (int i = 0; i < classes.Count; i++)
            {
                ClassWrap cls = classes[i];
                //命名空间
                builder.AppendLine(string.Join("\r\n", namespaces));
                builder.AppendLine($"namespace {Setting.ModuleName}.{cls.Namespace}");
                Start(0);
                {
                    //类
                    Comment(cls.Desc, TYPE_LEVEL);
                    builder.Space(TYPE_LEVEL).AppendLine(cls.Attribute);
                    if (cls.Inherit.IsEmpty())
                    {
                        builder.Space(TYPE_LEVEL).AppendLine($"public partial class {cls.Name} : {CLASS_XML_OBJECT}");
                    }
                    else
                    {
                        builder.Space(TYPE_LEVEL).AppendLine($"public partial class {cls.Name} : {Util.CorrectFullType(cls.Inherit)}");
                    }
                    Start(TYPE_LEVEL);
                    {
                        StringBuilder writer = new StringBuilder();
                        StringBuilder reader = new StringBuilder();
                        for (int j = 0; j < cls.Consts.Count; j++)
                        {
                            ConstWrap constant = cls.Consts[j];
                            if (!Util.MatchGroups(constant.Group))
                            {
                                continue;
                            }
                            Const(constant);//常量成员
                        }
                        for (int j = 0; j < cls.Fields.Count; j++)
                        {
                            FieldWrap field = cls.Fields[j];
                            if (!Util.MatchGroups(field.Group))
                            {
                                continue;
                            }

                            Field(field);             //字段成员
                            WriteFunc(writer, field); //写xml数据
                            ReadFunc(reader, field);  //读xml数据
                        }

                        //写函数
                        builder.Space(MEM_LEVEL);
                        builder.AppendLine($"public override void Write(TextWriter _1)");
                        Start(MEM_LEVEL);
                        if (!cls.Inherit.IsEmpty())
                        {
                            builder.Space(SEM_LEVEL).AppendLine("base.Write(_1);");
                        }
                        builder.Append(writer.ToString());
                        End(MEM_LEVEL);
                        //读函数
                        builder.Space(MEM_LEVEL);
                        builder.AppendLine($"public override void Read(XmlNode _1)");
                        Start(MEM_LEVEL);
                        {
                            if (!cls.Inherit.IsEmpty())
                            {
                                builder.Space(SEM_LEVEL).AppendLine("base.Read(_1);");
                            }
                            builder.Space(SEM_LEVEL).AppendLine($"foreach (System.Xml.XmlNode _2 in GetChilds (_1))");
                            builder.Space(SEM_LEVEL).AppendLine($"switch (_2.Name)");
                            Start(SEM_LEVEL);
                            builder.Append(reader.ToString());
                            End(SEM_LEVEL);
                        }
                        End(MEM_LEVEL);
                    }
                    End(TYPE_LEVEL);
                }
                End(0);
                string path = Path.Combine(Setting.XmlCodeDir, $"{Setting.ModuleName}.{cls.FullName}.cs");
                Util.SaveFile(path, builder.ToString());
                builder.Clear();
            }
        }
Esempio n. 26
0
 public RangeChecker(FieldWrap define, string rule) : base(define, rule)
 {
 }
Esempio n. 27
0
 public Data(FClass host, FieldWrap define)
 {
     _define = define;
     _host   = host;
 }
Esempio n. 28
0
 public FClass(FClass host, FieldWrap define, ImportExcel excel) : base(host, define)
 {
     _fullType = define.FullName;
     excel.GetClass(this, ClassWrap.Get(define.FullName));
 }
Esempio n. 29
0
 //_ruleTable.Length == 0表示不需要检查dict.value
 //dict检查需要在规则中添加value
 public UniqueChecker(FieldWrap define, string rule) : base(define, rule)
 {
 }
Esempio n. 30
0
 static void WriteFunc(StringBuilder writer, FieldWrap field)
 {
     writer.Space(SEM_LEVEL).AppendLine($"Write(_1, \"{field.Name}\", {field.Name});");
 }