예제 #1
0
        public void WritePropertyInitializer(ClassField field, int indent = 3)
        {
            SetIndent(indent);

            string init;

            if (field.DefaultValue != null)
            {
                init = field.DefaultValue;
            }
            else if (field is RecordField && typeof(Subrecord).IsAssignableFrom(field.Type))
            {
                init = String.Format("new {0}(\"{1}\")", field.TypeString, (field as RecordField).Tag);
            }
            else if (field.Type == typeof(string))
            {
                init = "\"\"";
            }
            else if (field.Type != typeof(byte[]))
            {
                init = String.Format("new {0}()", field.TypeString);
            }
            else
            {
                init = String.Format("new byte[{0}]", field.byteCount);
            }

            WriteLine("{0} = {1};", field.Name, init);

            ClearIndent();
        }
예제 #2
0
        public void WriteWriteXMLCommand(ClassField field, int indent = 3)
        {
            SetIndent(indent);

            if (field.implementWriteXML)
            {
                WriteLine("ele.TryPathTo(\"{0}\", true, out subEle);", field.XMLPath);
                if (field.Type.GetInterface("IEnumerable`1") != null && field.Type.IsConstructedGenericType)
                {
                    if (field.isSorted && field.Type.GenericTypeArguments[0].GetInterface("IComparable`1") != null)
                    {
                        WriteLine("{0}.Sort();", field.Name);
                    }

                    WriteLine("foreach (var temp in {0})", field.Name);
                    WriteLine("{");
                    PushIndent("\t");

                    if (field.Type.GenericTypeArguments[0] == typeof(Single))
                    {
                        WriteLine("subEle.Add(new XElement(\"{0}\", temp.ToString(\"G15\"));", field.XMLSubName);
                    }
                    else if (field.Type.GenericTypeArguments[0].GetInterface("IESPSerializable") != null)
                    {
                        WriteLine("XElement e = new XElement(\"{0}\");", field.XMLSubName);
                        WriteLine("temp.WriteXML(e, master);");
                        WriteLine("subEle.Add(e);");
                    }
                    else
                    {
                        WriteLine("subEle.Add(new XElement(\"{0}\", temp));", field.XMLSubName);
                    }

                    PopIndent();
                    WriteLine("}");
                }
                else if (field.Type == typeof(byte[]))
                {
                    WriteLine("subEle.Value = {0}.ToHex();", field.Name);
                }
                else if (field.Type == typeof(Single))
                {
                    WriteLine("subEle.Value = {0}.ToString(\"G15\");", field.Name);
                }
                else if (field.Type.GetInterface("IESPSerializable") != null)
                {
                    WriteLine("{0}.WriteXML(subEle, master);", field.Name);
                }
                else
                {
                    WriteLine("subEle.Value = {0}.ToString();", field.Name);
                }
            }
            else
            {
                WriteLine("Write{0}XML(ele, master);", field.Name);
            }

            ClearIndent();
        }
예제 #3
0
        public void WriteCopyConstructorAssignment(ClassField field, int indent = 3)
        {
            SetIndent(indent);

            if (field.Type.GetInterface("IEnumerable`1") != null && field.Type.IsConstructedGenericType)
            {
                WriteLine("if (copyObject.{0} != null)", field.Name);
                PushIndent("\t");
                WriteLine("foreach(var temp in copyObject.{0})", field.Name);
                PushIndent("\t");
                WriteLine("{0}.Add({1});", field.Name, field.Type.GenericTypeArguments[0].GetCloneText("temp"));
                PopIndent();
                PopIndent();
            }
            else if (field.Type == typeof(object))
            {
                WriteLine("{0} = copyObject.{0};", field.Name);
            }
            else if (!field.Type.IsValueType)
            {
                WriteLine("if (copyObject.{0} != null)", field.Name);
                PushIndent("\t");
                WriteLine("{0} = {1};", field.Name, field.Type.GetCloneText(string.Format("copyObject.{0}", field.Name)));
            }
            else
            {
                WriteLine("{0} = {1};", field.Name, field.Type.GetCloneText(string.Format("copyObject.{0}", field.Name)));
            }

            ClearIndent();
        }
예제 #4
0
        public void WriteParamsConstructorAssignment(ClassField field, int indent = 3)
        {
            SetIndent(indent);

            WriteLine("this.{0} = {0};", field.Name);

            ClearIndent();
        }
예제 #5
0
        public void WritePropertyDeclaration(ClassField field, int indent = 2)
        {
            SetIndent(indent);

            if (field.isReadOnly)
            {
                WriteLine("public {0} {1} {{ get; protected set; }}", field.TypeString, field.Name);
            }
            else
            {
                WriteLine("public {0} {1} {{ get; set; }}", field.TypeString, field.Name);
            }

            ClearIndent();
        }
예제 #6
0
        public void WriteCompareCommand(ClassField field, int indent = 4)
        {
            SetIndent(indent);

            if (field.Type == typeof(byte[]))
            {
                WriteLine("result = {0}.GetHashCode().CompareTo(other.{0}.GetHashCode());", field.Name);
            }
            else
            {
                WriteLine("result = {0}.CompareTo(other.{0});", field.Name);
            }

            ClearIndent();
        }
예제 #7
0
        public void WriteReadXMLCommand(ClassField field, int indent = 3)
        {
            SetIndent(indent);

            if (field.implementReadXML)
            {
                WriteLine("if (ele.TryPathTo(\"{0}\", false, out subEle))", field.XMLPath);
                PushIndent("\t");
                if (field.Type.GetInterface("IEnumerable`1") != null && field.Type.IsConstructedGenericType)
                {
                    WriteLine("foreach (XElement e in subEle.Elements())");
                    WriteLine("{");
                    PushIndent("\t");

                    if (field.Type.GenericTypeArguments[0].IsEnum)
                    {
                        WriteLine("{0}.Add(e.ToEnum<{1}>());", field.Name, field.Type.GenericTypeArguments[0].FriendlyName());
                    }
                    else if (field.Type.GenericTypeArguments[0] == typeof(string))
                    {
                        WriteLine("{0}.Add(e.Value);", field.Name);
                    }
                    else if (field.Type.GenericTypeArguments[0].GetInterface("IESPSerializable") != null)
                    {
                        WriteLine("var temp = new {0}();", field.Type.GenericTypeArguments[0].FriendlyName());
                        WriteLine("temp.ReadXML(e, master);");
                        WriteLine("{0}.Add(temp);", field.Name);
                    }
                    else
                    {
                        WriteLine("{0}.Add(e.To{1}());", field.Name, field.Type.GenericTypeArguments[0].FriendlyName());
                    }

                    PopIndent();
                    WriteLine("}");
                }
                else if (field.Type.IsEnum)
                {
                    WriteLine("{0} = subEle.ToEnum<{1}>();", field.Name, field.TypeString);
                }
                else if (field.Type == typeof(byte[]))
                {
                    WriteLine("{0} = subEle.ToBytes();", field.Name, field.TypeString);
                }
                else if (field.Type == typeof(string))
                {
                    WriteLine("{0} = subEle.Value;", field.Name);
                }
                else if (field.Type.GetInterface("IESPSerializable") != null)
                {
                    WriteLine("{0}.ReadXML(subEle, master);", field.Name);
                }
                else
                {
                    WriteLine("{0} = subEle.To{1}();", field.Name, field.TypeString);
                }
            }
            else
            {
                WriteLine("Read{0}XML(ele, master);", field.Name);
            }

            ClearIndent();
        }
예제 #8
0
        public void WriteWriteBinaryCommand(ClassField field, string writerName = "writer", int indent = 3)
        {
            SetIndent(indent);

            if (field.implementWriteData)
            {
                if (field.Type.GetInterface("IEnumerable`1") != null && field.Type.IsConstructedGenericType)
                {
                    if (field.hasListCount)
                    {
                        WriteLine("{0}.Write(({1}){2}.Count);", writerName, Utility.GetFriendlyName(field.listCountType), field.Name);
                    }

                    if (field.isSorted && field.Type.GenericTypeArguments[0].GetInterface("IComparable`1") != null)
                    {
                        WriteLine("{0}.Sort();", field.Name);
                    }

                    WriteLine("foreach (var temp in {0})", field.Name);
                    WriteLine("{");
                    PushIndent("\t");

                    if (field.Type.GenericTypeArguments[0].IsEnum)
                    {
                        WriteLine("{0}.Write(({1})temp);", writerName, Utility.GetFriendlyName(Enum.GetUnderlyingType(field.Type.GenericTypeArguments[0])));
                    }
                    else if (field.Type.GenericTypeArguments[0].GetInterface("IESPSerializable") != null)
                    {
                        WriteLine("temp.WriteBinary({0});", writerName);
                    }
                    else
                    {
                        WriteLine("{0}.Write(temp);", writerName);
                    }

                    PopIndent();
                    WriteLine("}");
                }
                else if (field.Type.IsEnum)
                {
                    WriteLine("{0}.Write(({1}){2});", writerName, Utility.GetFriendlyName(Enum.GetUnderlyingType(field.Type)), field.Name);
                }
                else if (field.Type == typeof(byte[]))
                {
                    WriteLine("if ({0} == null)", field.Name);
                    WriteLine("\t{0}.Write(new byte[{1}]);", writerName, field.byteCount);
                    WriteLine("else");
                    WriteLine("{0}.Write({1});", writerName, field.Name);
                }
                else if (field.Type.GetInterface("IESPSerializable") != null)
                {
                    WriteLine("{0}.WriteBinary({1});", field.Name, writerName);
                }
                else
                {
                    WriteLine("{0}.Write({1});", writerName, field.Name);
                }
            }
            else
            {
                WriteLine("Write{0}Binary({1});", field.Name, writerName);
            }

            ClearIndent();
        }
예제 #9
0
        public void WriteReadBinaryCommand(ClassField field, string readerName = "reader", int indent = 5)
        {
            SetIndent(indent);

            if (field.implementReadData)
            {
                if (field.Type.GetInterface("IEnumerable`1") != null && field.Type.IsConstructedGenericType)
                {
                    if (field.hasListCount)
                    {
                        WriteLine("{0} {1}Count = {2}.Read{0}();", Utility.GetFriendlyName(field.listCountType), field.Name, readerName);
                        WriteLine("");
                        WriteLine("for (int i = 0; i < {0}Count; i++)", field.Name);
                    }
                    else if (field.listItemSize > 0)
                    {
                        WriteLine("for (int i = 0; i < size/{0}; i++)", field.listItemSize);
                    }
                    else
                    {
                        throw new Exception();
                    }

                    WriteLine("{");
                    PushIndent("\t");
                    if (field.Type.GenericTypeArguments[0].IsEnum)
                    {
                        WriteLine("{0}.Add({1}.ReadEnum<{2}>());", field.Name, readerName, field.Type.GenericTypeArguments[0].FriendlyName());
                    }
                    else if (field.Type.GenericTypeArguments[0] == typeof(byte[]))
                    {
                        WriteLine("{0}.Add({1}.ReadBytes({2}));", field.Name, readerName, field.byteCount);
                    }
                    else if (field.Type.GenericTypeArguments[0].GetInterface("IESPSerializable") != null)
                    {
                        WriteLine("var temp = new {0}();", field.Type.GenericTypeArguments[0].FriendlyName());
                        WriteLine("temp.ReadBinary({0});", readerName);
                        WriteLine("{0}.Add(temp);", field.Name);
                    }
                    else
                    {
                        WriteLine("{0}.Add({1}.Read{2}());", field.Name, readerName, field.Type.GenericTypeArguments[0].FriendlyName());
                    }
                    PopIndent();
                    WriteLine("}");
                }
                else if (field.Type == typeof(byte[]))
                {
                    WriteLine("{0} = {1}.ReadBytes({2});", field.Name, readerName, field.byteCount);
                }
                else if (field.Type.IsEnum)
                {
                    WriteLine("{0} = {1}.ReadEnum<{2}>();", field.Name, readerName, field.TypeString);
                }
                else if (field.Type.GetInterface("IESPSerializable") != null)
                {
                    WriteLine("{0}.ReadBinary({1});", field.Name, readerName);
                }
                else
                {
                    WriteLine("{0} = {1}.Read{2}();", field.Name, readerName, field.TypeString);
                }
            }
            else
            {
                WriteLine("Read{0}Binary({1});", field.Name, readerName);
            }

            ClearIndent();
        }