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()); }
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); } }