public ClassDeclaration AddClass(string name, TypeAttributes attributes) { if (name == null) { throw new ArgumentNullException("name"); } if (this.Classes.Contains(name)) { throw new ArgumentException("class already existing in namespace"); } ClassDeclaration c = new ClassDeclaration(name, this); c.Attributes = attributes; this.Classes.Add(c); return(c); }
public ClassDeclaration AddClass(string name) { ClassDeclaration c = new ClassDeclaration(this.Conformer.ToCapitalized(name),this.Namespace); this.nestedClasses.Add(c); return c; }
public ClassDeclaration AddClass(string name, TypeAttributes attributes) { if (name==null) throw new ArgumentNullException("name"); if (this.Classes.Contains(name)) throw new ArgumentException("class already existing in namespace"); ClassDeclaration c = new ClassDeclaration(name,this); c.Attributes = attributes; this.Classes.Add(c); return c; }
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 GenerateDefaultConstructor(ClassDeclaration c) { ConstructorDeclaration cd = new ConstructorDeclaration(c); }
private void AddField(ClassDeclaration c, FieldInfo f) { if(c==null) throw new ArgumentNullException("c"); if (f==null) throw new ArgumentNullException("f"); FieldDeclaration fd = c.AddField(MapType(f.FieldType),f.Name); PropertyDeclaration p = c.AddProperty(fd,f.Name,true,true,false); // adding attributes if (TypeHelper.HasCustomAttribute(f,typeof(XmlAttributeAttribute))) { XmlAttributeAttribute att = (XmlAttributeAttribute)TypeHelper.GetFirstCustomAttribute(f,typeof(XmlAttributeAttribute)); AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlAttributeAttribute)); string attrName = att.AttributeName; if (att.AttributeName.Length==0) attrName = f.Name; AttributeArgument arg = attr.Arguments.Add( "AttributeName", Expr.Prim(attrName) ); } else { if (TypeHelper.HasCustomAttribute(f,typeof(XmlElementAttribute))) { AttachXmlElementAttributes(p,f); } else { AttributeDeclaration attr = p.CustomAttributes.Add(typeof(XmlElementAttribute)); attr.Arguments.Add("ElementName",Expr.Prim(f.Name)); } } }
private void AddCollectionMethods(ClassDeclaration col, ITypeDeclaration mappedType, string name, string pname) { // add method MethodDeclaration add = col.AddMethod("Add"+name); ParameterDeclaration para = add.Signature.Parameters.Add(mappedType,pname,true); add.Body.Add( Expr.This.Prop("List").Method("Add").Invoke(para) ); // add method MethodDeclaration contains = col.AddMethod("Contains"+name); contains.Signature.ReturnType = new TypeTypeDeclaration(typeof(bool)); para = contains.Signature.Parameters.Add(mappedType,pname,true); contains.Body.Return( Expr.This.Prop("List").Method("Contains").Invoke(para) ); // add method MethodDeclaration remove = col.AddMethod("Remove"+name); para = remove.Signature.Parameters.Add(mappedType,pname,true); remove.Body.Add( Expr.This.Prop("List").Method("Remove").Invoke(para) ); }
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); } }
/// <summary> /// Determines whether this StringClassDeclarationDictionary contains a specific value. /// </summary> /// <param name="value"> /// The ClassDeclaration value to locate in this StringClassDeclarationDictionary. /// </param> /// <returns> /// true if this StringClassDeclarationDictionary contains an element with the specified value; /// otherwise, false. /// </returns> public virtual bool ContainsValue(ClassDeclaration value) { return ContainsKey(value.Name); }
/// <summary> /// Adds an element with the specified key and value to this StringClassDeclarationDictionary. /// </summary> /// <param name="key"> /// The String key of the element to add. /// </param> /// <param name="value"> /// The ClassDeclaration value of the element to add. /// </param> public virtual void Add(ClassDeclaration value) { this.Dictionary.Add(value.Name, value); }