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