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