private EntityDeclaration GenerateProperty(
MemberWrapper mw,
ICodeGeneratorProxy targetCodeBehind,
string masterWrapperVariableName)
{
var property = (IProperty)mw.Member;
if (mw.ImplementationDetails.ImplementExplicitly)
{
return
(targetCodeBehind.CreateProperty(
modifier:
string.Empty,
returnTypeFullName:
property.ReturnType.GetOriginalFullNameWithGlobal(),
propertyName:
property.IsIndexer
? string.Format(
"{0}.this [{1} {2}]",
mw.ImplementationDetails.ExplicitInterfaceImplementationType
.GetOriginalFullNameWithGlobal(),
property.Parameters.First().Type.GetOriginalFullNameWithGlobal(),
property.Parameters.First().Name
)
:
mw.ImplementationDetails.ExplicitInterfaceImplementationType
.GetOriginalFullNameWithGlobal() +
"." + property.Name,
getterMethodBody:
GetPropertyGetterStatement(mw, masterWrapperVariableName),
setterMethodBody:
GetPropertySetterStatement(mw, masterWrapperVariableName)));
}
else
{
return
(targetCodeBehind.CreateProperty(
modifier:
property.GetModifiersString(
overrideModifiers:
mw.ImplementationDetails.ImplementInTargetAsAbstract
? "abstract" : null),
returnTypeFullName:
property.ReturnType.GetOriginalFullNameWithGlobal(),
propertyName:
property.IsIndexer
? string.Format(
"this [{0} {1}]",
property.Parameters.First().Type.GetOriginalFullNameWithGlobal(),
property.Parameters.First().Name
)
: property.Name,
getterMethodBody:
GetPropertyGetterStatement(mw, masterWrapperVariableName),
setterMethodBody:
GetPropertySetterStatement(mw, masterWrapperVariableName)));
}
}
/// <summary>
/// Create code similar to:
/// <code>
/// <![CDATA[
/// public System.Func<int,string> ProtectedVirtualMethodFunc { get; set; }
///
/// public System.Func<string> PublicVirtualPropertyGetFunc { get; set; }
/// public System.Action<string> PublicVirtualPropertySetFunc { get; set; }
///
/// ]]></code>
/// </summary>
/// <param name="manager"></param>
/// <param name="wrapperClass"></param>
private void CreateVirtualMemberFunctions(
pMixinGeneratorPipelineState manager, ICodeGeneratorProxy wrapperClass)
{
var membersThatNeedVirtualFuncs =
manager.CurrentMixinMembers.Select(x => x.Member)
.DistinctMembers()
.Where(
member => member.IsVirtual ||
member.IsOverride ||
member.IsOverridable);
foreach (var member in membersThatNeedVirtualFuncs)
{
if (member is IMethod)
{
var propertyReturnType =
(member as IMethod).ReturnType.Kind == TypeKind.Void
? "global::System.Action"
: String.Format("global::System.Func<{0}>",
string.Join(",",
(member as IMethod).Parameters.Select(x => x.Type.GetOriginalFullNameWithGlobal())
.Union(member.ReturnType.GetFullTypeName())));
wrapperClass.CreateProperty(
"public",
propertyReturnType,
this.GenerateVirtualMethodFuncName(member),
"get;",
"set;");
}
else if (member is IProperty)
{
//Get
if ((member as IProperty).CanGet && !(member as IProperty).Getter.IsPrivate)
{
wrapperClass.CreateProperty(
"public",
"global::System.Func<" + member.ReturnType.GetOriginalFullNameWithGlobal() + ">",
GenerateVirtualMethodFuncName(member) + "Get",
"get;",
"set;");
}
//Set
if ((member as IProperty).CanSet && !(member as IProperty).Setter.IsPrivate)
{
wrapperClass.CreateProperty(
"public",
"global::System.Action<" + member.ReturnType.GetOriginalFullNameWithGlobal() + ">",
GenerateVirtualMethodFuncName(member) + "Set",
"get;",
"set;");
}
}
}
}
private EntityDeclaration GenerateField(
IField field,
ICodeGeneratorProxy targetCodeBehind,
string masterWrapperVariableName)
{
return
(targetCodeBehind.CreateProperty(
modifier:
field.GetModifiersString(),
returnTypeFullName:
field.ReturnType.GetOriginalFullNameWithGlobal(),
propertyName:
field.Name,
getterMethodBody:
string.Format(
"get{{ return {0}.{1}; }}",
masterWrapperVariableName,
field.Name),
setterMethodBody:
(field.IsConst || field.IsReadOnly)
? string.Empty
: string.Format(
"set{{ {0}.{1} = value; }}",
masterWrapperVariableName,
field.Name)));
}
public void CreateMembers(IEnumerable <MemberWrapper> memberWrappers)
{
foreach (var mw in memberWrappers)
{
#region Process Methods
if (mw.Member is IMethod)
{
CodeGeneratorProxy.CreateMethod(
modifier:
string.Empty, //no modifier for interface member
returnTypeFullName:
mw.Member.ReturnType.GetOriginalFullNameWithGlobal(),
methodName:
mw.ImplementationDetails.RequirementsInterfaceImplementationName,
parameters:
(mw.Member as IMethod).Parameters.ToKeyValuePair(),
methodBody:
string.Empty,
constraingClause:
(mw.Member as IMethod).GetGenericMethodConstraints(Compilation));
}
#endregion
#region Process Properties
else if (mw.Member is IProperty)
{
CodeGeneratorProxy.CreateProperty(
modifier:
string.Empty, //no modifier for interface member
returnTypeFullName:
mw.Member.ReturnType.GetOriginalFullNameWithGlobal(),
propertyName:
mw.ImplementationDetails.RequirementsInterfaceImplementationName,
getterMethodBody:
(mw.Member as IProperty).CanGet ? "get;" : "",
setterMethodBody:
(mw.Member as IProperty).CanSet ? "set;" : "");
}
#endregion
}
}
/// <summary>
/// Wrap every non-private member in current pMixin with special
/// handling for static and virtual members
/// </summary>
/// <param name="manager"></param>
/// <param name="wrapperClass"></param>
private void ProcessMembers(pMixinGeneratorPipelineState manager, ICodeGeneratorProxy wrapperClass)
{
var proxyMemberHelper =
new MasterWrapperCodeGeneratorProxyMemberHelper(wrapperClass,
manager.BaseState.Context.TypeResolver.Compilation);
//Static Members
proxyMemberHelper.CreateMembers(
manager.CurrentMixinMembers
.Select(x => x.Member)
.DistinctMembers()
.Where(member => member.IsStatic),
generateMemberModifier: member => "internal static",
baseObjectIdentifierFunc:
member =>
manager.CurrentpMixinAttribute.Mixin.IsStaticOrSealed()
? manager.CurrentpMixinAttribute.Mixin.GetOriginalFullNameWithGlobal()
: manager.CurrentMixinAbstractMembersWrapperClass.Name
);
//Regular Members
proxyMemberHelper.CreateMembers(
manager.CurrentMixinMembers
.Select(x => x.Member)
.DistinctMembers()
.Where(
member => !member.IsStatic &&
!(member.IsAbstract && member.IsProtected) &&
!member.IsOverride &&
!member.IsOverridable &&
!member.IsVirtual),
generateMemberModifier: member => "internal",
baseObjectIdentifierFunc: member => MixinInstanceDataMemberName);
//Protected Abstract Members
proxyMemberHelper.CreateMembers(
manager.CurrentMixinMembers
.Select(x => x.Member)
.DistinctMembers()
.Where(member => (member.IsAbstract || member.IsOverride) && member.IsProtected),
generateMemberModifier: member => "internal",
baseObjectIdentifierFunc: member => MixinInstanceDataMemberName,
baseObjectMemberNameFunc: member =>
GenerateAbstractMixinMembersWrapperClass.GetProtectedMemberWrapperMemberName(member));
//Virtual Members
foreach (
var member in
manager.CurrentMixinMembers
.Select(x => x.Member)
.DistinctMembers()
.Where(member => member.IsVirtual ||
(member.IsOverride ||
member.IsOverridable &&
!member.IsProtected)))
{
#region Virtual Method
if (member is IMethod)
{
//Virtual methods call to the Virtual Method Func
wrapperClass.CreateMethod(
"internal",
member.ReturnType.GetOriginalFullNameWithGlobal(),
member.Name,
(member as IMethod).Parameters.ToKeyValuePair(),
string.Format("{0} {1}({2});",
(member as IMethod).GetReturnString(),
GenerateVirtualMethodFuncName(member),
string.Join(",",
(member as IMethod).Parameters.Select(x => x.Name))),
(member as IMethod).GetGenericMethodConstraints(
manager.BaseState.Context.TypeResolver.Compilation));
}
#endregion
#region Virtual Property
else if (member is IProperty)
{
wrapperClass.CreateProperty(
"internal",
member.ReturnType.GetOriginalFullNameWithGlobal(),
member.Name,
(member as IProperty).CanGet && !(member as IProperty).Getter.IsPrivate
? string.Format("get{{ return {0}(); }}",
GenerateVirtualMethodFuncName(member) + "Get")
: "",
(member as IProperty).CanSet && !(member as IProperty).Setter.IsPrivate
? string.Format("set {{{0}(value); }}",
GenerateVirtualMethodFuncName(member) + "Set")
: ""
);
}
#endregion
}
}
