public void Add(TypeIndex item) { if (!ContainsKey(item.Name)) { Add(item.Name, item as T); } }
public Property(PropertyInfo prop) : base(prop.Name, prop.PropertyType) { if (CanRead = prop.CanRead) { Methodnames.Add(prop.GetMethod.Name); } if (CanWrite = prop.CanWrite) { Methodnames.Add(prop.SetMethod.Name); } if (prop.Name == "Item" && !TypeIndex.Equals(TypeIndex.Object) && prop.GetIndexParameters().Length > 0) { IsIndex = true; } }
public override XElement ToXml() { var xe = new XElement("Define", TypeIndex.ToXml()); if (IsStatic) { xe.Add(new XAttribute("IsStatic", IsStatic)); } if (IsExtension) { xe.Add(new XAttribute("DeclaringType", DeclaringType)); } foreach (var par in Params) { xe.Add(par.ToXml()); } return(xe); }
public Define(MethodInfo method, string name = null) : base(name ?? method.Name, method.ReturnType) { IsStatic = method.IsStatic; var pars = method.GetParameters(); foreach (var p in pars) { Params.Add(new Param(p)); } if (IsStatic && method.IsDefined(typeof(ExtensionAttribute))) { var type = TypeIndex.FromSystemType(pars[0].ParameterType); var ns = Namespace.FromString(type.Namespace); var etype = ns.GetExtype(type.Name, true); Method emethod = null; if (etype.Methods.ContainsKey(Name)) { emethod = etype.Methods[Name]; } else { emethod = new Method(Name); etype.Methods.Add(emethod); } var define = new Define { Name = Name, TypeIndex = TypeIndex.FromSystemType(method.ReturnType), IsExtension = true, DeclaringType = method.DeclaringType.FullName, }; for (int i = 1; i < pars.Length; i++) { define.Params.Add(new Param(pars[i])); } emethod.AddDefine(define); } }
public override void Desc(StreamWriter sw, int space) { var pre = GetPrefixSpace(space); string pars = string.Join(", ", Params.Select(p => p.ToString())); if (IsStatic) { sw.WriteLine($"{pre}@staticmethod"); } else if (Params.Count > 0) { pars = "self, " + pars; } else { pars = "self"; } if (Name == "__init__") { sw.Write($"{pre}def {Name}({pars}) -> {TypeIndex.Name}:"); } else if (TypeIndex.Equals(TypeIndex.None)) { sw.Write($"{pre}def {Name}({pars}):"); } else { sw.Write($"{pre}def {Name}({pars}) -> {TypeIndex.Fullname}:"); } if (IsExtension) { sw.WriteLine(); sw.WriteLine($"{pre} \"\"\"Extension from: {DeclaringType}\"\"\""); } else { sw.WriteLine("..."); } }
/// <summary> /// 获取类型索引中包含的所有类型 /// </summary> /// <param name="ti">类型索引</param> private void Import(TypeIndex ti) { //把信息存入Imports字典中,以在索引的Fullname属性中解析 switch (ti.Kind) { case TypeIndexKind.System: case TypeIndexKind.GenericParam: return; case TypeIndexKind.GenericType: foreach (var tp in ti.GenericParams) { Import(tp); } break; } if (ti.Namespace == Fullname || ti.Namespace == "typing") { return; } if (!Imports.ContainsKey(ti.Namespace)) { Imports.Add(ti.Namespace, new List <string>()); } var lst = Imports[ti.Namespace]; var name = ti.Name.Split(new char[] { '.' }, 2)[0]; if (!lst.Contains(name)) { lst.Add(name); } }
public void Add(TypeIndex item) { Add(item as T); }
public override void FromXml(XElement xe) { base.FromXml(xe); TypeIndex = Parse <TypeIndex>(xe.Element("TypeIndex")); }
public Variable(string name, System.Type type) { TypeIndex = TypeIndex.FromSystemType(type); Name = name; }
public Variable(string name) { TypeIndex = new TypeIndex("None"); Name = name; }
public Type(System.Type type) { if (type.FullName == "System.Array") { Namespace = "System"; Name = "Array"; Kind = TypeIndexKind.GenericDefinition; GenericParams.Add(new TypeIndex("T", TypeIndexKind.GenericParam)); } else { var ti = FromSystemType(type); if (string.IsNullOrEmpty(ti.Namespace)) { return; } Namespace = ti.Namespace; Name = ti.Name; Kind = ti.Kind; GenericParams = ti.GenericParams; } var ns = GetNamespace(); if (type.IsNested) { var names = Name.Split('.'); var ptype = ns.Types[names[0]]; int i = 1; for (; i < names.Length - 1; i++) { ptype = ptype.Types[names[i]]; } Owner = ptype; Name = names[i]; if (ptype.Types.ContainsKey(Name)) { if (ptype.Types[Name].Kind == TypeIndexKind.General) { ptype.Types.Remove(Name); } else { return; } } ptype.Types.Add(this); } else { if (ns.Types.ContainsKey(Name)) { if (ns.Types[Name].Kind == TypeIndexKind.General) { ns.Types.Remove(Name); } else { return; } } ns.Types.Add(this); } if (type.BaseType != null) { BaseTypes.Add(FromSystemType(type.BaseType)); } var itypes = type.GetInterfaces().ToList(); for (int i = itypes.Count - 1; i >= 0; i--) { for (int j = 0; j < i; j++) { if (itypes[i].IsAssignableFrom(itypes[j])) { itypes.RemoveAt(i); break; } } } foreach (var it in itypes) { BaseTypes.Add(FromSystemType(it)); } foreach (var field in type.GetFields()) { Fields.Add(new Field(field, _type_int)); } if (!type.IsEnum) { foreach (var field in type.GetFields()) { Fields.Add(new Field(field)); } foreach (var property in type.GetProperties()) { Properties.Add(new Property(property)); } foreach (var @event in type.GetEvents()) { Events.Add(new Event(@event)); } var inits = type.GetConstructors().Where(m => !m.IsStatic); Methods.Add(new Method(inits)); //去除基类已定义的函数 var imethodnames = type.GetInterfaces() .SelectMany(t => t.GetMethods()) .Select(m => m.Name) .Distinct(); var methodnames = Properties.SelectMany(p => p.Value.Methodnames) .Union(Events.SelectMany(e => e.Value.Methodnames)) .Union(imethodnames); if (type.BaseType != null) { var bmethodnames = type.BaseType .GetMethods() .Select(m => m.Name) .Distinct(); methodnames = methodnames.Union(bmethodnames); } var methods = type.GetMethods() .Where(m => !(m.IsStatic && m.Name.StartsWith("op_")) && !m.Name.Contains(".")) .GroupBy(m => m.Name) .Where(g => !methodnames.Contains(g.Key)); foreach (var g in methods) { Methods.Add(new Method(g)); } if (Kind == TypeIndexKind.GenericDefinition) { var bti = new TypeIndex("typing", "Generic", TypeIndexKind.GenericDefinition); foreach (var p in GenericParams) { bti.GenericParams.Add(p); } BaseTypes.Add(bti); } var prop = Properties.Select(p => p.Value).FirstOrDefault(p => p.IsIndex); if (prop != null) { var bti = new TypeIndex("typing", "Iterable", TypeIndexKind.GenericDefinition); bti.GenericParams.Add(prop.TypeIndex); BaseTypes.Add(bti); } else if (type.FullName == "System.Array") { var bti = new TypeIndex("typing", "Iterable", TypeIndexKind.GenericDefinition); bti.GenericParams.Add(new TypeIndex("T", TypeIndexKind.GenericParam)); BaseTypes.Add(bti); } if (BaseTypes.Count > 1 && BaseTypes[0].Equals(Object)) { BaseTypes.RemoveAt(0); } //去除基类已定义的事件 var eventnames = type.GetInterfaces() .SelectMany(i => i.GetEvents()) .Select(e => e.Name); if (type.BaseType != null) { eventnames = type.BaseType .GetEvents() .Select(e => e.Name) .Union(eventnames); } foreach (var name in eventnames.Distinct()) { Events.Remove(name); } //去除基类已定义的属性 var propnames = type.GetInterfaces() .SelectMany(i => i.GetProperties()) .Select(p => p.Name); if (type.BaseType != null) { propnames = type.BaseType .GetProperties() .Select(p => p.Name) .Union(propnames); } foreach (var name in propnames.Distinct()) { Properties.Remove(name); } } }