Example #1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="BaseCommand" /> class.
        /// </summary>
        /// <param name="package">The hosting package.</param>
        /// <param name="id">The id for the command.</param>
        protected BaseCommand(TyrantVSPackage package, CommandID id)
            : base(BaseCommand_Execute, id)
        {
            Package = package;

            BeforeQueryStatus += BaseCommand_BeforeQueryStatus;
        }
        internal static Dictionary<string, CodeClass2> GetClassElements(TyrantVSPackage package)
        {
            var dic_FullName_ClassElement = new Dictionary<string, CodeClass2>();
            try
            {
                foreach (Project project in package.DTE.Solution.Projects)
                {
                    foreach (ProjectItem projectItem in project.ProjectItems)
                    {
                        if (projectItem.FileCodeModel == null)
                            continue;
                        foreach (CodeElement2 codeElement in projectItem.FileCodeModel.CodeElements)
                            GetClassElements(codeElement, dic_FullName_ClassElement);
                    }
                }
            }
            catch /*(Exception e)*/
            {

            }
            return dic_FullName_ClassElement;
        }
 internal static CodeClass2 GetCodeClassFormCurrentCursor(TyrantVSPackage package)
 {
     var activeDocument = package.DTE.ActiveDocument;
     if (activeDocument != null)
     {
         var textSelection = activeDocument.Selection as TextSelection;
         if (textSelection != null)
             return textSelection.ActivePoint.CodeElement[vsCMElement.vsCMElementClass] as CodeClass2;
     }
     return null;
 }
        internal static void GenerateSerializaCode(CodeClass2 classElement, CodeFunction serializeMethod, CodeFunction deserializeMethod, Dictionary<string, CodeClass2> dic, TyrantVSPackage package/*, string serializeMethodParameterName, string deserializeMethodParameterName*/)
        {
            var memberList = new List<SerializeMember>();
            foreach (CodeElement2 member in classElement.Members)
            {
                var field = member as CodeVariable2;
                if (field != null)
                {
                    memberList.Add(new SerializeMember() { Name = field.Name, TypeRef = field.Type, Attributes = field.Attributes });
                    continue;
                }
                var property = member as CodeProperty2;
                if (property != null && property.Getter != null && property.Setter != null)
                    memberList.Add(new SerializeMember() { Name = property.Name, TypeRef = property.Type, Attributes = property.Attributes });
            }
            int iii = serializeMethod.Parameters.Count;
            string serializeMethodParameterName = serializeMethod.Parameters.Item(1).Name;
            string deserializeMethodParameterName = deserializeMethod.Parameters.Item(1).Name;
            var serializeStatementList = new List<string>();
            var deserializeStatementList = new List<string>();
            string deserializeMethodCode = string.Format("int num;{0}while ((num = source.ReadFieldHeader()) > 0){0}{1}{0}switch (num){0}{1}{0}", Environment.NewLine, "{");
            for (int i = 0; i < memberList.Count; ++i)
            {
                var mem = memberList[i];
                bool needContinue = false;
                foreach (CodeAttribute2 codeArrtibute in mem.Attributes)
                {
                    if (codeArrtibute.FullName == "Tyrant.GameCore.DoNotSerializeAttribute")
                    {
                        needContinue = true;
                        break;
                    }
                }
                if (needContinue)
                    continue;

                string serializeMethodName = "";
                string deserializeMethodName = "";
                if (mem.TypeRef.TypeKind == vsCMTypeRef.vsCMTypeRefArray)
                    GetSerializeMethodAndDeserializeMethodName(mem.TypeRef.ElementType, null, ref serializeMethodName, ref deserializeMethodName, "Array", dic, package);
                else
                {
                    if (mem.TypeRef.AsFullName.StartsWith("System.Collections.Generic.List<"))
                    {
                        string fullName = mem.TypeRef.AsFullName;
                        int first = fullName.IndexOf('<');
                        var elementName = fullName.Substring(first + 1, fullName.Length - 2 - first);
                        GetSerializeMethodAndDeserializeMethodName(null, elementName, ref serializeMethodName, ref deserializeMethodName, "List", dic, package);
                    }
                    else
                        GetSerializeMethodAndDeserializeMethodName(mem.TypeRef, null, ref serializeMethodName, ref deserializeMethodName);
                }

                serializeStatementList.Add($"Tyrant.GameCore.CommunicatorHelper.{serializeMethodName}({i + 1}, {mem.Name}, {serializeMethodParameterName});");
                deserializeStatementList.Add($"case {i + 1}:{Environment.NewLine}{mem.Name} = Tyrant.GameCore.CommunicatorHelper.{deserializeMethodName}({deserializeMethodParameterName});{Environment.NewLine}break;");
            }

            if (serializeStatementList.Count > 0)
            {
                var point = serializeMethod.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
                point.ReplaceText(serializeMethod.GetEndPoint(vsCMPart.vsCMPartBody), string.Join(Environment.NewLine, serializeStatementList), (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
            }

            if (deserializeStatementList.Count > 0)
            {
                var point = deserializeMethod.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
                point.ReplaceText(deserializeMethod.GetEndPoint(vsCMPart.vsCMPartBody), deserializeMethodCode + string.Join(Environment.NewLine, deserializeStatementList) + Environment.NewLine + "}" + Environment.NewLine + "}", (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
            }
        }
 private static void GetSerializeMethodAndDeserializeMethodName(CodeTypeRef codeTypeRef, string typeFullName, ref string serializeMethodName, ref string deserializeMethodName, string suffix = "", Dictionary<string, CodeClass2> dic = null, TyrantVSPackage package = null)
 {
     string fullName = codeTypeRef != null ? codeTypeRef.AsFullName : typeFullName;
     if (fullName == typeof(bool).FullName)
     {
         serializeMethodName = $"WriteBoolean{suffix}";
         deserializeMethodName = $"ReadBoolean{suffix}";
     }
     else if (fullName == typeof(double).FullName)
     {
         serializeMethodName = $"WriteDouble{suffix}";
         deserializeMethodName = $"ReadDouble{suffix}";
     }
     else if (fullName == typeof(sbyte).FullName)
     {
         serializeMethodName = $"WriteSByte{suffix}";
         deserializeMethodName = $"ReadSByte{suffix}";
     }
     else if (fullName == typeof(short).FullName)
     {
         serializeMethodName = $"WriteInt16{suffix}";
         deserializeMethodName = $"ReadInt16{suffix}";
     }
     else if (fullName == typeof(int).FullName)
     {
         serializeMethodName = $"WriteInt32{suffix}";
         deserializeMethodName = $"ReadInt32{suffix}";
     }
     else if (fullName == typeof(long).FullName)
     {
         serializeMethodName = $"WriteInt64{suffix}";
         deserializeMethodName = $"ReadInt64{suffix}";
     }
     else if (fullName == typeof(float).FullName)
     {
         serializeMethodName = $"WriteSingle{suffix}";
         deserializeMethodName = $"ReadSingle{suffix}";
     }
     else if (fullName == typeof(string).FullName)
     {
         serializeMethodName = $"WriteString{suffix}";
         deserializeMethodName = $"ReadString{suffix}";
     }
     else if (fullName == typeof(byte).FullName)
     {
         serializeMethodName = $"WriteByte{suffix}";
         deserializeMethodName = $"ReadByte{suffix}";
     }
     else if (fullName == typeof(char).FullName)
     {
         serializeMethodName = $"WriteChar{suffix}";
         deserializeMethodName = $"ReadChar{suffix}";
     }
     else if (fullName == typeof(ushort).FullName)
     {
         serializeMethodName = $"WriteUInt16{suffix}";
         deserializeMethodName = $"ReadUInt16{suffix}";
     }
     else if (fullName == typeof(uint).FullName)
     {
         serializeMethodName = $"WriteUInt32{suffix}";
         deserializeMethodName = $"ReadUInt32{suffix}";
     }
     else if (fullName == typeof(ulong).FullName)
     {
         serializeMethodName = $"WriteUInt64{suffix}";
         deserializeMethodName = $"ReadUInt64{suffix}";
     }
     else if (fullName == typeof(TimeSpan).FullName)
     {
         serializeMethodName = $"WriteTimeSpan{suffix}";
         deserializeMethodName = $"ReadTimeSpan{suffix}";
     }
     else if (fullName == typeof(DateTime).FullName)
     {
         serializeMethodName = $"WriteDateTime{suffix}";
         deserializeMethodName = $"ReadDateTime{suffix}";
     }
     else
     {
         bool b = false;
         if (codeTypeRef != null)
             b = IsSerializableClass(codeTypeRef.CodeType as CodeClass2) || IsMessageClass(codeTypeRef.CodeType as CodeClass2);
         else if (typeFullName != null)
         {
             if (dic == null)
                 dic = CommunicationCodeInMenuCommand.GetClassElements(package);
             CodeClass2 classElement;
             dic.TryGetValue(typeFullName, out classElement);
             b = IsSerializableClass(classElement) || IsMessageClass(classElement);
         }
         if (b)
         {
             serializeMethodName = $"WriteSerializableObject{suffix}";
             deserializeMethodName = $"ReadSerializableObject{suffix}<{fullName}>";
         }
     }
 }
 public CommunicationCodeInContextCodeWindowCommand(TyrantVSPackage package)
     : base(package, new CommandID(PackageGuids.GuidContextCodeWindowGroup, PackageIds.CmdIDContextCodeWindowCommunicationCode))
 {
 }
 public CommunicationCodeInMenuCommand(TyrantVSPackage package)
     : base(package, new CommandID(PackageGuids.GuidTyrantBaseMenu, PackageIds.CmdIDGenerateCommunicationCode))
 {
 }
        public static void Excute(CodeClass2 classElement, Dictionary<string, CodeClass2> dic, TyrantVSPackage package)
        {
            if (classElement == null)
                return;

            //var classCode = classElement.StartPoint.CreateEditPoint().GetText(classElement.GetEndPoint());
            var validBases = new List<CodeElement>();
            foreach (CodeElement baseClass in classElement.Bases)
            {
                if (!baseClass.FullName.StartsWith("Tyrant.GameCore.Message<") && baseClass.FullName != typeof(object).FullName)
                    validBases.Add(baseClass);
            }
            var validInterfaces = new List<CodeElement>();
            foreach (CodeElement implementedInterface in classElement.ImplementedInterfaces)
            {
                if (implementedInterface.FullName != "Tyrant.GameCore.ISerializable")
                {
                    validInterfaces.Add(implementedInterface);
                    break;
                }
            }

            var baseCollection = classElement.Collection;
            string name = classElement.Name;
            classElement.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint().ReplaceText(classElement.GetStartPoint(vsCMPart.vsCMPartBody), $"public partial class {name}{Environment.NewLine}{{{Environment.NewLine}", (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
            classElement = baseCollection.Item(name) as CodeClass2;
            classElement.AddImplementedInterface("Tyrant.GameCore.ISerializable");
            foreach (CodeElement baseClass in validBases)
            {
                try
                {
                    classElement.AddBase(baseClass, -1);
                }
                catch { }
            }
            foreach (CodeElement implementedInterface in validInterfaces)
            {
                try
                {
                    classElement.AddImplementedInterface(implementedInterface, -1);
                }
                catch { }
            }

            CommunicationCodeHelper.RemoveMembers(classElement);

            CodeFunction2 serializeMethod = null, deserializeMethod = null;
            try
            {
                classElement.AddFunction("Tyrant.GameCore.ISerializable.Serialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessDefault);
            }
            catch { }
            serializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Serialize") as CodeFunction2;
            try
            {
                serializeMethod.AddParameter("dest", typeof(ProtoBuf.ProtoWriter).FullName);
            }
            catch
            {
                serializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Serialize") as CodeFunction2;
            }
            try
            {
                classElement.AddFunction("Tyrant.GameCore.ISerializable.Deserialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessDefault);
            }
            catch { }
            deserializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Deserialize") as CodeFunction2;
            try
            {
                deserializeMethod.AddParameter("source", typeof(ProtoBuf.ProtoReader).FullName);
            }
            catch
            {
                deserializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Deserialize") as CodeFunction2;
            }
            CommunicationCodeHelper.GenerateSerializaCode(classElement, serializeMethod, deserializeMethod, dic, package/*, "dest", "source"*/);
        }
 public SerializableClassCodeInContextCodeWindowCommand(TyrantVSPackage package)
     : base(package, new CommandID(PackageGuids.GuidContextCodeWindow, PackageIds.CmdIDSerializableClassInContextCodeWindow))
 {
 }
        public static void Excute(CodeClass2 classElement, Dictionary<string, CodeClass2> dic, TyrantVSPackage package)
        {
            if (classElement == null)
                return;

            string callBackGenericParamaName = null;
            foreach (CodeElement baseClass in classElement.Bases)
            {
                string baseFullName = baseClass.FullName;
                if (baseFullName.StartsWith("Tyrant.GameCore.Message<"))
                {
                    Stack<int> ind = new Stack<int>();
                    int thirdGenericParama = -1, find = 0;
                    int first = baseFullName.IndexOf('<');
                    for (int i = first + 1; i < baseFullName.Length; ++i)
                    {
                        char c = baseFullName[i];
                        if (c == '<')
                            ind.Push(i);
                        else if (c == ',')
                        {
                            if (ind.Count <= 0)
                            {
                                ++find;
                                if (find == 2)
                                    thirdGenericParama = i + 1;
                            }
                        }
                        else if (c == '>')
                        {
                            if (ind.Count > 0)
                                ind.Pop();
                            else
                            {
                                if (thirdGenericParama > 0 && thirdGenericParama < baseFullName.Length)
                                    callBackGenericParamaName = baseFullName.Substring(thirdGenericParama, i - 1 - thirdGenericParama).Trim();
                                break;
                            }
                        }
                    }
                }
            }

            var validInterfaces = new List<CodeElement>();
            foreach (CodeElement implementedInterface in classElement.ImplementedInterfaces)
            {
                if (implementedInterface.FullName != "Tyrant.GameCore.ISerializable")
                {
                    validInterfaces.Add(implementedInterface);
                    break;
                }
            }

            var name = classElement.Name;
            var fullName = classElement.FullName;
            var collection = classElement.Collection;
            if (!string.IsNullOrEmpty(callBackGenericParamaName))
            {
                int first = callBackGenericParamaName.IndexOf('<');
                if (first >= 0)
                    callBackGenericParamaName = callBackGenericParamaName.Substring(0, first);
                callBackGenericParamaName = $", {callBackGenericParamaName}<TUser>";
            }
            else
                callBackGenericParamaName = "";
            classElement.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint().ReplaceText(classElement.GetStartPoint(vsCMPart.vsCMPartBody), $"public partial class {name}<TUser> : Tyrant.GameCore.Message<TUser, {name}<TUser>{callBackGenericParamaName}> where TUser : Tyrant.GameCore.IUser{Environment.NewLine}{{{Environment.NewLine}", (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
            classElement = collection.Item(name) as CodeClass2;

            foreach (CodeElement implementedInterface in validInterfaces)
            {
                try
                {
                    classElement.AddImplementedInterface(implementedInterface, -1);
                }
                catch { }
            }

            CommunicationCodeHelper.RemoveMembers(classElement);

            CodeFunction2 serializeMethod = null, deserializeMethod = null;
            try
            {
                classElement.AddFunction("Serialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessProtected);
            }
            catch { }
            serializeMethod = classElement.Members.Item("Serialize") as CodeFunction2;
            if (serializeMethod == null)
            {
                return;
            }
            serializeMethod.OverrideKind = vsCMOverrideKind.vsCMOverrideKindOverride;
            try
            {
                serializeMethod.AddParameter("dest", typeof(ProtoBuf.ProtoWriter).FullName);
            }
            catch
            {
                serializeMethod = classElement.Members.Item("Serialize") as CodeFunction2;
            }
            try
            {
                classElement.AddFunction("Deserialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessProtected);
            }
            catch { }
            deserializeMethod = classElement.Members.Item("Deserialize") as CodeFunction2;
            if (deserializeMethod == null)
            {
                return;
            }
            deserializeMethod.OverrideKind = vsCMOverrideKind.vsCMOverrideKindOverride;
            try
            {
                deserializeMethod.AddParameter("source", typeof(ProtoBuf.ProtoReader).FullName);
            }
            catch
            {
                deserializeMethod = classElement.Members.Item("Deserialize") as CodeFunction2;
            }
            CommunicationCodeHelper.GenerateSerializaCode(classElement, serializeMethod, deserializeMethod, dic, package/*, "dest", "source"*/);
        }
 public MessageInContextCodeWindowCommand(TyrantVSPackage package)
     : base(package, new CommandID(PackageGuids.GuidContextCodeWindow, PackageIds.CmdIDMessageInContextCodeWindow))
 {
 }
Example #12
0
 public DesignerCodeCommand(TyrantVSPackage package)
     : base(package, new CommandID(PackageGuids.GuidTyrantBaseMenu, PackageIds.CmdIDGenerateDesignerCode))
 {
 }