private void AddArrayField(ClassDeclaration c, FieldInfo f) { // create a collection ClassDeclaration col = c.AddClass(conformer.ToSingular(f.Name) + "Collection"); col.Parent = new TypeTypeDeclaration(typeof(System.Collections.CollectionBase)); // add serializable attribute col.CustomAttributes.Add(typeof(SerializableAttribute)); // default constructor col.AddConstructor(); // default indexer IndexerDeclaration index = col.AddIndexer( typeof(Object) ); ParameterDeclaration pindex = index.Signature.Parameters.Add(typeof(int), "index", false); // getter index.Get.Return( Expr.This.Prop("List").Item(Expr.Arg(pindex)) ); index.Set.AddAssign( Expr.This.Prop("List").Item(Expr.Arg(pindex)), Expr.Value ); // add object method MethodDeclaration addObject = col.AddMethod("Add"); ParameterDeclaration paraObject = addObject.Signature.Parameters.Add(new TypeTypeDeclaration(typeof(Object)), "o", true); addObject.Body.Add( Expr.This.Prop("List").Method("Add").Invoke(paraObject) ); // if typed array add methods for type if (f.FieldType.GetElementType() != typeof(Object)) { AddCollectionMethods( col, MapType(f.FieldType.GetElementType()), this.conformer.ToCapitalized(f.FieldType.GetElementType().Name), "o" ); } foreach (XmlElementAttribute ea in f.GetCustomAttributes(typeof(XmlElementAttribute), true)) { string name = this.conformer.ToCapitalized(ea.ElementName); string pname = this.conformer.ToCamel(name); ITypeDeclaration mappedType = null; if (ea.Type != null) { mappedType = MapType(ea.Type); } if (mappedType == null || mappedType == f.FieldType.GetElementType()) { continue; } AddCollectionMethods(col, mappedType, name, pname); } // add field FieldDeclaration fd = c.AddField(col, f.Name); fd.InitExpression = Expr.New(col); PropertyDeclaration p = c.AddProperty(fd, f.Name, true, true, false); // setting attributes // attach xml text if (TypeHelper.HasCustomAttribute(f, typeof(XmlTextAttribute))) { AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlTextAttribute)); attr.Arguments.Add("Type", Expr.TypeOf(typeof(string))); // adding to string to collection MethodDeclaration tostring = col.AddMethod("ToString"); tostring.Signature.ReturnType = new TypeTypeDeclaration(typeof(String)); tostring.Attributes = MemberAttributes.Public | MemberAttributes.Override; VariableDeclarationStatement sw = Stm.Var(typeof(StringWriter), "sw"); sw.InitExpression = Expr.New(typeof(StringWriter)); tostring.Body.Add(sw); ForEachStatement fe = Stm.ForEach( typeof(string), "s", Expr.This.Prop("List"), false); fe.Body.Add( Expr.Var(sw).Method("Write").Invoke(fe.Local) ); tostring.Body.Add(fe); tostring.Body.Return(Expr.Var(sw).Method("ToString").Invoke()); } else if (TypeHelper.HasCustomAttribute(f, typeof(XmlArrayItemAttribute))) { // add xml array attribute AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlArrayAttribute)); attr.Arguments.Add("ElementName", Expr.Prim(f.Name)); // add array item attribute XmlArrayItemAttribute arrayItem = (XmlArrayItemAttribute)TypeHelper.GetFirstCustomAttribute(f, typeof(XmlArrayItemAttribute)); attr = p.CustomAttributes.Add(typeof(XmlArrayItemAttribute)); attr.Arguments.Add("ElementName", Expr.Prim(arrayItem.ElementName)); //MMI:attr.Arguments.Add("Type",Expr.Prim(MapType(f.FieldType.GetElementType()).Name)); attr.Arguments.Add("Type", Expr.TypeOf(MapType(f.FieldType.GetElementType()))); if (arrayItem.Type != null) { attr.Arguments.Add("DataType", Expr.Prim(arrayItem.DataType)); } attr.Arguments.Add("IsNullable", Expr.Prim(arrayItem.IsNullable)); if (this.Config.KeepNamespaces) { attr.Arguments.Add("Namespace", Expr.Prim(arrayItem.Namespace)); } } else { AttachXmlElementAttributes(p, f); } }
public ClassDeclaration AddClass(NamespaceDeclaration ns) { ClassDeclaration col = ns.AddClass(this.CollectionName); // set base class as CollectionBase col.Parent = new TypeTypeDeclaration(typeof(CollectionBase)); // default constructor col.AddConstructor(); // add indexer if (this.ItemGet || this.ItemSet) { IndexerDeclaration index = col.AddIndexer( this.Type ); ParameterDeclaration pindex = index.Signature.Parameters.Add(typeof(int), "index", false); // get body if (this.ItemGet) { index.Get.Return( (Expr.This.Prop("List").Item(Expr.Arg(pindex)).Cast(this.Type) ) ); } // set body if (this.ItemSet) { index.Set.Add( Stm.Assign( Expr.This.Prop("List").Item(Expr.Arg(pindex)), Expr.Value ) ); } } string pname = ns.Conformer.ToCamel(this.Type.Name); // add method if (this.Add) { MethodDeclaration add = col.AddMethod("Add"); ParameterDeclaration para = add.Signature.Parameters.Add(this.Type, pname, true); add.Body.Add( Expr.This.Prop("List").Method("Add").Invoke(para) ); } if (this.AddRange) { MethodDeclaration add = col.AddMethod("AddRange"); ParameterDeclaration para = add.Signature.Parameters.Add(col, pname, true); ForEachStatement fe = Stm.ForEach( this.Type, "item", Expr.Arg(para), false ); fe.Body.Add( Expr.This.Prop("List").Method("Add").Invoke(fe.Local) ); add.Body.Add(fe); } // contains method if (this.Contains) { MethodDeclaration contains = col.AddMethod("Contains"); contains.Signature.ReturnType = new TypeTypeDeclaration(typeof(bool)); ParameterDeclaration para = contains.Signature.Parameters.Add(this.Type, pname, true); contains.Body.Return( Expr.This.Prop("List").Method("Contains").Invoke(para) ); } // remove method if (this.Remove) { MethodDeclaration remove = col.AddMethod("Remove"); ParameterDeclaration para = remove.Signature.Parameters.Add(this.Type, pname, true); remove.Doc.Summary.AddText("Removes the first occurrence of a specific ParameterDeclaration from this ParameterDeclarationCollection."); remove.Body.Add( Expr.This.Prop("List").Method("Remove").Invoke(para) ); } // insert if (this.Insert) { MethodDeclaration insert = col.AddMethod("Insert"); ParameterDeclaration index = insert.Signature.Parameters.Add(typeof(int), "index", true); ParameterDeclaration para = insert.Signature.Parameters.Add(this.Type, pname, true); insert.Body.Add( Expr.This.Prop("List").Method("Insert").Invoke(index, para) ); } // indexof if (this.IndexOf) { MethodDeclaration indexof = col.AddMethod("IndexOf"); ParameterDeclaration para = indexof.Signature.Parameters.Add(this.Type, pname, true); indexof.Signature.ReturnType = new TypeTypeDeclaration(typeof(int)); indexof.Body.Return( Expr.This.Prop("List").Method("IndexOf").Invoke(para) ); } if (this.Enumerator) { // create subclass ClassDeclaration en = col.AddClass("Enumerator"); // add wrapped field FieldDeclaration wrapped = en.AddField( typeof(IEnumerator), "wrapped" ); // add IEnumerator en.Interfaces.Add(typeof(IEnumerator)); // add constructor ConstructorDeclaration cs = en.AddConstructor(); ParameterDeclaration collection = cs.Signature.Parameters.Add(col, "collection", true); cs.Body.Add( Stm.Assign( Expr.This.Field(wrapped), Expr.Arg(collection).Cast(typeof(CollectionBase)).Method("GetEnumerator").Invoke() ) ); // add current PropertyDeclaration current = en.AddProperty(this.Type, "Current"); current.Get.Return( (Expr.This.Field(wrapped).Prop("Current")).Cast(this.Type) ); // add explicit interface implementation PropertyDeclaration currentEn = en.AddProperty(typeof(Object), "Current"); currentEn.Get.Return(Expr.This.Prop(current)); currentEn.PrivateImplementationType = wrapped.Type; // add reset MethodDeclaration reset = en.AddMethod("Reset"); reset.ImplementationTypes.Add(wrapped.Type); reset.Body.Add(Expr.This.Field(wrapped).Method("Reset").Invoke()); // add movenext MethodDeclaration movenext = en.AddMethod("MoveNext"); movenext.ImplementationTypes.Add(wrapped.Type); movenext.Signature.ReturnType = new TypeTypeDeclaration(typeof(bool)); movenext.Body.Return(Expr.This.Field(wrapped).Method("MoveNext").Invoke()); // add get enuemrator MethodDeclaration geten = col.AddMethod("GetEnumerator"); geten.Attributes |= MemberAttributes.New; geten.ImplementationTypes.Add(new TypeTypeDeclaration(typeof(IEnumerable))); geten.Signature.ReturnType = en; geten.Body.Return(Expr.New(en, Expr.This)); } return(col); }
private void AddArrayField(ClassDeclaration c, FieldInfo f) { // create a collection var col = c.AddClass(this.conformer.ToCapitalized(f.Name) + "Collection"); col.Parent = new TypeTypeDeclaration(typeof(System.Collections.CollectionBase)); // default constructor col.AddConstructor(); // default indexer var index = col.AddIndexer( typeof(Object) ); var pindex = index.Signature.AddParam(typeof(int), "index", false); /* index.Get = new SnippetStatement(); * index.Get.WriteLine("return this.List[{0}];",pindex.Name); * index.Set = new SnippetStatement(); * index.Set.WriteLine("this.List[{0}]=value;",pindex.Name); */ // add object method var addObject = col.AddMethod("Add"); var paraObject = addObject.Signature.AddParam(new TypeTypeDeclaration(typeof(Object)), "o", true); addObject.Body.Add( Expr.This.Prop("List").Method("Add").Invoke(paraObject) ); // if typed array add methods for type if (f.FieldType.GetElementType() != typeof(Object)) { AddCollectionMethods( col, MapType(f.FieldType.GetElementType()), this.conformer.ToCapitalized(f.FieldType.GetElementType().Name), "o" ); } foreach (XmlElementAttribute ea in f.GetCustomAttributes(typeof(XmlElementAttribute), true)) { var name = this.conformer.ToCapitalized(ea.ElementName); var pname = this.conformer.ToCamel(name); ITypeDeclaration mappedType = null; if (ea.Type != null) { mappedType = MapType(ea.Type); } if (mappedType == null || f.FieldType.GetElementType() == (Type)mappedType) { continue; } AddCollectionMethods(col, mappedType, name, pname); } // add field var fd = c.AddField(col, f.Name); fd.InitExpression = Expr.New(col); var p = c.AddProperty(fd, true, true, false); // setting attributes AttachXmlElementAttributes(p, f); }
private void AddEnumerator(ClassDeclaration c, FieldDeclaration data, MethodDeclaration close) { c.Interfaces.Add(typeof(IEnumerable)); // create subclass ClassDeclaration en = c.AddClass("Enumerator"); // add wrapped field FieldDeclaration wrapped = en.AddField( c, "wrapped" ); ITypeDeclaration enumeratorType = new TypeTypeDeclaration(typeof(IEnumerator)); ITypeDeclaration disposableType = new TypeTypeDeclaration(typeof(IDisposable)); // add IEnumerator en.Interfaces.Add(enumeratorType); en.Interfaces.Add(disposableType); // add constructor ConstructorDeclaration cs = en.AddConstructor(); ParameterDeclaration collection = cs.Signature.Parameters.Add(c, "collection", true); cs.Body.AddAssign(Expr.This.Field(wrapped), Expr.Arg(collection)); // add current PropertyDeclaration current = en.AddProperty(data.Type, "Current"); current.Get.Return( Expr.This.Field(wrapped).Prop("Data") ); // add explicit interface implementation PropertyDeclaration currentEn = en.AddProperty(typeof(Object), "Current"); currentEn.Get.Return(Expr.This.Prop(current)); currentEn.PrivateImplementationType = enumeratorType; // add reset MethodDeclaration reset = en.AddMethod("Reset"); reset.ImplementationTypes.Add(wrapped.Type); reset.Body.Add(Stm.Throw(typeof(InvalidOperationException), Expr.Prim("Not supported"))); // add movenext MethodDeclaration movenext = en.AddMethod("MoveNext"); movenext.ImplementationTypes.Add(wrapped.Type); movenext.Signature.ReturnType = new TypeTypeDeclaration(typeof(bool)); movenext.Body.Return(Expr.This.Field(wrapped).Method("Read").Invoke()); // add dispose MethodDeclaration disposeEn = en.AddMethod("Dispose"); disposeEn.ImplementationTypes.Add(disposableType); disposeEn.Body.Add( Expr.This.Field(wrapped).Method(close).Invoke() ); disposeEn.Body.AddAssign(Expr.This.Field(wrapped), Expr.Null); // add get enuemrator MethodDeclaration geten = c.AddMethod("GetEnumerator"); geten.Signature.ReturnType = en; geten.Body.Return(Expr.New(en, Expr.This)); MethodDeclaration igeten = c.AddMethod("GetEnumerator"); igeten.PrivateImplementationType = new TypeTypeDeclaration(typeof(IEnumerable)); igeten.Signature.ReturnType = new TypeTypeDeclaration(typeof(IEnumerator)); igeten.Body.Return(Expr.This.Method("GetEnumerator").Invoke()); }
/// <summary> /// Creates the column list. /// </summary> /// <param name="table">The table.</param> /// <param name="classDecl">The class decl.</param> protected virtual void CreateColumnList(TableSchema table, ClassDeclaration classDecl) { ClassDeclaration cols = new ClassDeclaration(classDecl.Name + "Columns"); var columns = table.Columns .GroupBy(c => { return c.Name; }) .Select(g => { return g.ElementAt(0); }); foreach (ColumnSchema column in columns) { string columnName = column.IsPrimaryKey ? "ID" : column.Name; FieldDeclaration field = new FieldDeclaration(columnName, typeof(string)) .IsPublic() .InitializeTo("\"" + columnName + "\""); field.AddComment("This column is of type {0}{1}({2} in .NET) and can{3} be null.", column.SqlType.ToString().ToLower(), column.Length > 0 ? String.Format("({0})", column.Length) : "", column.DataType.Name, column.Nullable ? "" : "NOT"); cols.AddField(field); } classDecl.AddClass(cols); FieldDeclaration columnsField = new FieldDeclaration("_columns", new CodeDomTypeReference(cols.Name)).IsStatic(); columnsField.AddInitializer(new CodeDomTypeReference(cols.Name)); PropertyDeclaration columnsProperty = new PropertyDeclaration("Columns", columnsField, new CodeDomTypeReference(cols.Name)) .IsStatic().IsReadOnly(); columnsProperty.AddComment("Gets an instance of the {0} class which contains all of the column names for {1}.", cols.Name, classDecl.Name); classDecl.AddProperty(columnsProperty); }