using System;
using System.Collections;
using AnticipatingMinds.Genesis.KnowledgeManagement;
using AnticipatingMinds.Genesis.CodeDOM;
using AnticipatingMinds.Genesis.CodeDOM.Utilities;
using AnticipatingMinds.Genesis.Effectors.Utilities;
using AnticipatingMinds.Genesis.CodeParser;
using AnticipatingMinds.Genesis.AspNetDom;
using System.Threading;
using System.Text.RegularExpressions;
namespace AnticipatingMinds.KnowledgePack.Design{
public class SingletonPatternTemplate : RuleTemplate
{
public SingletonPatternTemplate(string templateId, IDictionary templateProperties):base(templateId,templateProperties)
{
}
public override string Name
{
get
{
return ResourceManager.GetLocalizedString("SingletonPatternTemplate|Name");
}
}
public override string Description
{
get
{
return ResourceManager.GetLocalizedString("SingletonPatternTemplate|Description");
}
}
public override Rule CreateRule(string ruleId, IDictionary ruleProperties)
{
return new SingletonPatternRule(ruleId, Id, ruleProperties);
}
}
public class SingletonPatternRule : Rule
{
internal SingletonPatternRule(string id, string templateId, IDictionary ruleProperties) : base(id,templateId,ruleProperties)
{
}
public override Type[] TargetedCodeElements
{
get
{
return targetedCodeElements;
}
}
private struct DefaultNames
{
public const string InstanceDefaultName = "instance";
public const string GetInstanceDefaultName = "GetInstance";
public const string LockDefaultName = "singletonLock";
}
private string instanceDefaultName = DefaultNames.InstanceDefaultName;
private string GetInstanceDefaultName = DefaultNames.GetInstanceDefaultName;
private string padlockDefaultName = DefaultNames.LockDefaultName;
private class RuleData
{
public RuleViolationCollection violations = new RuleViolationCollection();
public CodeTypeDeclaration TypeDeclaration = null;
public bool ObjectCreateReference = false;
}
public override RuleViolation[] Analyze(object codeElement, System.Threading.ManualResetEvent cancelAnalysisEvent)
{
CodeTypeDeclaration typeDeclaration = codeElement as CodeTypeDeclaration;
if(typeDeclaration == null || typeDeclaration is AnticipatingMinds.Genesis.AspNetDom.AspNetClassDeclaration)
return emptyViolationsList;
if(typeDeclaration == null || !IsCodeElementInRuleApplicabilityScope(typeDeclaration))
return emptyViolationsList;
RuleData ruleData = new RuleData();
bool allStatic = false;
ArrayList staticFields = new ArrayList();
#region check if type is Singleton
bool isExistsCurrectTypeField = false;
bool isExistsCurrectTypeMethod = false;
#endregion
// check all member of type for static modifier
int countConstructors = 0;
bool withoutParametersConstructor = false;
foreach(CodeTypeMemberDeclaration member in CodeTypeDeclarationUtils.GetTypeMembers(typeDeclaration))
{
if(member is CodeTypeConstructorDeclaration)
{
countConstructors++;
if((member as CodeTypeConstructorDeclaration).InitializerArguments.Count == 0) withoutParametersConstructor = true;
}
if(member is CodeTypeFieldDeclaration)
{
if((member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static) != 0)
{
if((member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public) != 0)
{
allStatic = true;
staticFields.Add(member);
}
}
else
{
allStatic = false;
break;
}
}
if( member is CodeTypeFieldDeclaration
&& (member as CodeTypeFieldDeclaration).DeclarationType != null
&& (member as CodeTypeFieldDeclaration).DeclarationType.TypeInfo == typeDeclaration.TypeInfo
&& (member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static) != 0
&& (member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public) == 0
)
{
// check for instance field
isExistsCurrectTypeField = true;
}
if(member is CodeTypeMethodDeclaration
&& (member as CodeTypeMethodDeclaration).ReturnType != null
&& (member as CodeTypeMethodDeclaration).ReturnType.TypeInfo == typeDeclaration.TypeInfo
&& (member as CodeTypeMethodDeclaration).Parameters.Count == 0
&& (member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static) != 0
&& (member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public) != 0
)
{
// check for GetInstance method
isExistsCurrectTypeMethod = true;
}
}
// if in type exists method-analog GetInstance && exists field-analog instance
if(isExistsCurrectTypeField && isExistsCurrectTypeMethod) return emptyViolationsList;
bool insideOnlyStaticMember = true;
#region Check all refernce inside static member
foreach(CodeTypeFieldDeclaration field in staticFields)
{
if(field == null) continue;
foreach(CodeVariableDeclarationMember variable in field.DeclaredFields)
{
CodeExpressionCollection variableReference = CodeNamedReferenceExpressionUtils.FindReferenceTo(typeDeclaration, variable.Name);
foreach(CodeExpression variableExcepression in variableReference)
{
CodeTypeMemberDeclaration variableMember = CodeTypeMemberUtils.GetContainingTypeMember(variableExcepression);
CodeExpressionStatement variableStatement = CodeStatementUtils.GetElementStatement(variableExcepression) as CodeExpressionStatement;
if(variableStatement == null) continue;
if(variableStatement.Expression is CodeBinaryExpression
&& (variableStatement.Expression as CodeBinaryExpression).LeftOperand.Equals(variableExcepression)
)
{
if((variableMember.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static) != 0)
{
insideOnlyStaticMember = (insideOnlyStaticMember) ? true : false;
}
else
{
insideOnlyStaticMember = false;
}
}
}
}
}
#endregion
// check if exists create type object
ruleData.TypeDeclaration = typeDeclaration;
//WalkAllCompileUnits(typeDeclaration.CompileUnit,new CodeDomWalker.WalkerCallback(FindObjectCreateReference), ruleData);
// if several constructor, this type not correctable to Singleton
bool isConstructorCorrect = false;
if(countConstructors == 0
|| (countConstructors == 1 && withoutParametersConstructor))
{
isConstructorCorrect = true;
}
if(allStatic && insideOnlyStaticMember && isConstructorCorrect)
{
CreateViolation(ruleData, typeDeclaration, true);
}
if(ruleData.violations.Count != 0)
return ruleData.violations.ToArray();
else
return emptyViolationsList;
}
private static CodeDomWalker.WalkerCallbackReturn FindObjectCreateReference(CodeElement codeElement,CodeDomWalker.CallBackNotificationType notification,CodeDomWalkerContext walkerContext,object applicationData)
{
if(notification != CodeDomWalker.CallBackNotificationType.OnElement)
{
return CodeDomWalker.WalkerCallbackReturn.Next;
}
RuleData data = applicationData as RuleData;
if(codeElement is CodeObjectCreateExpression
&& (codeElement as CodeObjectCreateExpression).CreateType.TypeInfo == data.TypeDeclaration.TypeInfo
)
{
CodeTypeMemberDeclaration memberDeclaration = CodeTypeMemberUtils.GetContainingTypeMember(codeElement);
if(memberDeclaration.DeclaringType.TypeInfo != data.TypeDeclaration.TypeInfo)
{
data.ObjectCreateReference = true;
return CodeDomWalker.WalkerCallbackReturn.Cancel;
}
}
return CodeDomWalker.WalkerCallbackReturn.Next;
}
private void CreateViolation(RuleData ruleData, CodeTypeDeclaration typeDeclaration, bool isCorrectable)
{
RuleViolation violation = new RuleViolation(this, typeDeclaration);
violation.Description = ResourceManager.GetLocalizedString("SingletonPatternTemplate|Violation", typeDeclaration.FullName);
violation.Severity = RuleViolation.ViolationSeverity.Warning;
if(isCorrectable)
{
RuleViolationCorrection violationCorrection;
violationCorrection = violation.AddCorrection(ResourceManager.GetLocalizedString("SingletonPatternTemplate|Correction"), false, false);
violationCorrection.CorrectionData["CodeTypeDeclaration"] = typeDeclaration;
}
ruleData.violations.Add(violation);
}
public override void Correct(RuleViolationCorrection[] requestedCorrections, AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector, System.Threading.ManualResetEvent cancelCorrectionEvent)
{
codeEffector.BeginCodeChanges("Convert type to Singleton pattern");
foreach(RuleViolationCorrection requestedCorrection in requestedCorrections)
{
if(requestedCorrection.Violation.IsFixed)
continue;
instanceDefaultName = DefaultNames.InstanceDefaultName;
GetInstanceDefaultName = DefaultNames.GetInstanceDefaultName;
padlockDefaultName = DefaultNames.LockDefaultName;
CodeTypeDeclaration typeDeclaration = requestedCorrection.CorrectionData["CodeTypeDeclaration"] as CodeTypeDeclaration;
// check for exists fields in type(instance, GetInstance, padlock)
if(!CheckSingletionFieldsInType(typeDeclaration, ref this.instanceDefaultName))
{
continue;
}
if(!CheckSingletionFieldsInType(typeDeclaration,ref this.padlockDefaultName))
{
continue;
}
if(!CheckSingletionMethodInType(typeDeclaration))
{
continue;
}
TypeData data = new TypeData();
data.GetInstanceMethodName = this.GetInstanceDefaultName;
data.TypeDeclaration = typeDeclaration;
data.codeEffector = codeEffector;
ChangedStaticModifiers(typeDeclaration, codeEffector, data);
#region Change Reference
ChangeCurrentTypeReference(typeDeclaration, codeEffector, data);
#endregion
AddInstanceField(typeDeclaration, codeEffector);
#region Create Private contstructor
CreateEmptyPrivateConstructor(typeDeclaration, codeEffector);
#endregion
requestedCorrection.Violation.IsFixed = true;
}
try
{
codeEffector.CommitCodeChanges();
}
catch(Exception)
{
codeEffector.RollbackCodeChanges();
throw;
}
}
private bool CheckSingletionFieldsInType(CodeTypeDeclaration typeDeclaration,ref string fieldName)
{
string[] typeNames = CodeTypeDeclarationUtils.GetTypeMembersNames(typeDeclaration);
if(Array.IndexOf(typeNames, fieldName) == -1 ) return true;
else
{
SingletonRenameForm frm = new SingletonRenameForm();
frm.defaultSuggestionTextBox.Text = "";
frm.currentValueTextBox.Text = fieldName;
if(frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
fieldName = frm.defaultSuggestionTextBox.Text;
return CheckSingletionFieldsInType(typeDeclaration,ref fieldName);
}
else
{
return false;
}
}
}
private bool CheckSingletionMethodInType(CodeTypeDeclaration typeDeclaration)
{
string[] typeNames = CodeTypeDeclarationUtils.GetTypeMembersNames(typeDeclaration);
if(Array.IndexOf(typeNames, this.GetInstanceDefaultName) == -1 ) return true;
foreach(CodeTypeMemberDeclaration member in CodeTypeDeclarationUtils.GetTypeMembers(typeDeclaration))
{
if(member is CodeTypeMethodDeclaration
&& (member as CodeTypeMethodDeclaration).Name == this.GetInstanceDefaultName
&& (member as CodeTypeMethodDeclaration).Parameters.Count == 0
)
{
SingletonRenameForm frm = new SingletonRenameForm();
frm.defaultSuggestionTextBox.Text = "";
frm.currentValueTextBox.Text = this.GetInstanceDefaultName;
if(frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
this.GetInstanceDefaultName = frm.defaultSuggestionTextBox.Text;
return CheckSingletionMethodInType(typeDeclaration);
}
else
{
return false;
}
}
}
return true;
}
private void CreateEmptyPrivateConstructor(CodeTypeDeclaration typeDeclaration, AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector)
{
bool existsConstructor = false;
foreach(CodeTypeMemberDeclaration member in CodeTypeDeclarationUtils.GetTypeMembers(typeDeclaration))
{
if(member is CodeTypeConstructorDeclaration
&& (member as CodeTypeConstructorDeclaration).Parameters.Count == 0)
{
existsConstructor = true;
}
}
if(!existsConstructor)
{
CodeTypeConstructorDeclaration constructor = new CodeTypeConstructorDeclaration();
constructor.Modifiers = CodeTypeMemberDeclaration.MemberDeclarationModifiers.Private;
constructor.Parent = typeDeclaration;
CodeTypeMemberDeclarationCollection memberCollection = new CodeTypeMemberDeclarationCollection();
memberCollection.AddRange(new CodeTypeMemberDeclaration[]{constructor});
codeEffector.AddCodeElements(memberCollection, typeDeclaration, (typeDeclaration as CodeClassDeclaration).Members, 0);
codeEffector.PerformCodeChanges();
}
}
private void AddInstanceField(CodeTypeDeclaration typeDeclaration, AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector)
{
CodeTypeMemberDeclarationCollection memberCollection = new CodeTypeMemberDeclarationCollection();
#region instance field
CodeTypeFieldDeclaration instanceField = new CodeTypeFieldDeclaration();
instanceField.Modifiers = CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static;
instanceField.DeclarationType = new CodeTypeReference(typeDeclaration.Name);
CodeVariableDeclarationMember instanceMember = new CodeVariableDeclarationMember(this.instanceDefaultName, new CodeNullReferenceExpression());
instanceField.DeclaredFields.Add(instanceMember);
#endregion
#region padlock field
CodeTypeFieldDeclaration padlockField = new CodeTypeFieldDeclaration();
padlockField.Modifiers = CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static;
padlockField.Modifiers |= CodeTypeMemberDeclaration.MemberDeclarationModifiers.ReadOnly;
padlockField.DeclarationType = new CodeTypeReference("object");
CodeVariableDeclarationMember padlockMember
= new CodeVariableDeclarationMember(this.padlockDefaultName, new CodeObjectCreateExpression(new CodeTypeReference("object")));
padlockField.DeclaredFields.Add(padlockMember);
#endregion
#region GetInstance method
CodeTypeMethodDeclaration instanceMethod = new CodeTypeMethodDeclaration();
instanceMethod.Name = this.GetInstanceDefaultName;
instanceMethod.Modifiers = CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static;
instanceMethod.Modifiers |= CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public;
instanceMethod.ReturnType = new CodeTypeReference(typeDeclaration.Name);
instanceMethod.Statements = new CodeStatementBlock();
string instanceContent = String.Format(@"if({0} == null){3}lock({1}){3} if ({0}==null) {0} = new {2}(); {4}{4} return {0};", this.instanceDefaultName, this.padlockDefaultName, typeDeclaration.Name, "{", "}");
AnticipatingMinds.Genesis.CodeParser.CSharpParser instanceContentParser = new AnticipatingMinds.Genesis.CodeParser.CSharpParser(instanceContent, typeDeclaration.CompileUnit.Assembly.AssemblyFileName, typeDeclaration.CompileUnit.Assembly);
instanceMethod.Statements = instanceContentParser.ParseStatements(new ManualResetEvent(false));
#endregion
// add new members to type
memberCollection.AddRange(new CodeTypeMemberDeclaration[]{instanceField, padlockField, instanceMethod});
codeEffector.AddCodeElements(memberCollection, typeDeclaration, (typeDeclaration as CodeClassDeclaration).Members, 0);
codeEffector.PerformCodeChanges();
}
private void ChangedStaticModifiers(CodeTypeDeclaration typeDeclaration, AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector, TypeData data)
{
CodeTypeMemberDeclarationCollection accessorListAll = new CodeTypeMemberDeclarationCollection();
foreach(CodeTypeMemberDeclaration member in CodeTypeDeclarationUtils.GetTypeMembers(typeDeclaration))
{
bool changeMidifiers = false;
if(member is CodeTypeConstructorDeclaration)
{
member.Modifiers &= ~CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static;
member.Modifiers &= ~CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public;
member.Modifiers |= CodeTypeMemberDeclaration.MemberDeclarationModifiers.Private;
changeMidifiers = true;
}
else if(member is CodeTypeFieldDeclaration)
{
if((member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public) != 0)
{
member.Modifiers &= ~CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public;
member.Modifiers |= CodeTypeMemberDeclaration.MemberDeclarationModifiers.Private;
accessorListAll.AddRange(CreateAccessor(typeDeclaration, member as CodeTypeFieldDeclaration, codeEffector, data));
}
else
{
foreach(CodeVariableDeclarationMember variable in (member as CodeTypeFieldDeclaration).DeclaredFields)
data.FieldAccessors.Add(variable, member);
}
member.Modifiers &= ~CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static;
changeMidifiers = true;
}
else
{
if((member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static) != 0)
{
member.Modifiers &= ~CodeTypeMemberDeclaration.MemberDeclarationModifiers.Static;
changeMidifiers = true;
}
}
if(changeMidifiers)
codeEffector.ChangeCodeElement(member, member.GetType().GetProperty("Modifiers"), member.Modifiers);
}
if(accessorListAll.Count != 0)
{
codeEffector.AddCodeElements(accessorListAll, typeDeclaration, (typeDeclaration as CodeClassDeclaration).Members, 0);
}
codeEffector.PerformCodeChanges();
}
private class TypeData
{
public Hashtable FieldAccessors = new Hashtable();
public CodeTypeDeclaration TypeDeclaration =null;
public string GetInstanceMethodName = "";
public AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector;
}
private void ChangeCurrentTypeReference(CodeTypeDeclaration typeDeclaration, AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector, TypeData data)
{
WalkAllCompileUnits(typeDeclaration.CompileUnit,new CodeDomWalker.WalkerCallback(ReplaceStaticReference), data);
}
private static CodeDomWalker.WalkerCallbackReturn ReplaceStaticReference(CodeElement codeElement,CodeDomWalker.CallBackNotificationType notification,CodeDomWalkerContext walkerContext,object applicationData)
{
if(notification != CodeDomWalker.CallBackNotificationType.OnElement)
{
return CodeDomWalker.WalkerCallbackReturn.Next;
}
if(!(codeElement is CodeNamedReferenceExpression) && !(codeElement is CodeObjectCreateExpression))
return CodeDomWalker.WalkerCallbackReturn.Next;
TypeData data = applicationData as TypeData;
#region Prepare GetInstance invoke
CodeMethodReferenceExpression getInstance = new CodeMethodReferenceExpression();
getInstance.TargetObject = new CodeTypeReferenceExpression(CodeTypeReferenceUtils.GetShortestTypeNameReference(codeElement ,data.TypeDeclaration));
getInstance.Name = data.GetInstanceMethodName;
CodeMethodInvokeExpression getInstanceInvoke = new CodeMethodInvokeExpression();
getInstanceInvoke.MethodReferenceExpression = getInstance;
#endregion
if(codeElement is CodeFieldReferenceExpression
&& (codeElement as CodeFieldReferenceExpression).FieldInfo != null
&& (codeElement as CodeFieldReferenceExpression).FieldInfo.DeclaringTypeInfo == data.TypeDeclaration.TypeInfo
)
{
CodeFieldReferenceExpression fieldReference = codeElement as CodeFieldReferenceExpression;
#region Field Reference
foreach(CodeVariableDeclarationMember variable in data.FieldAccessors.Keys)
{
CodeNamedReferenceExpression newNamedReference = null;
if(data.FieldAccessors[variable] is CodeTypePropertyDeclaration
&& (data.FieldAccessors[variable] as CodeTypePropertyDeclaration).ReturnType.TypeInfo == fieldReference.ExpressionType
&& ((data.FieldAccessors[variable] as CodeTypePropertyDeclaration).Name == fieldReference.Name || variable.Name == fieldReference.Name)
)
{
newNamedReference = new CodePropertyReferenceExpression(getInstanceInvoke , (data.FieldAccessors[variable] as CodeTypePropertyDeclaration).Name);
}
if (data.FieldAccessors[variable] is CodeTypeFieldDeclaration
&& fieldReference.FieldInfo != null
&& (data.FieldAccessors[variable] as CodeTypeFieldDeclaration).DeclaringType.TypeInfo == fieldReference.FieldInfo.DeclaringTypeInfo
&& variable.Name == fieldReference.Name
)
{
newNamedReference = codeElement.Clone() as CodeNamedReferenceExpression;
newNamedReference.TargetObject = getInstanceInvoke;
}
if(newNamedReference != null)
{
data.codeEffector.ReplaceCodeElement(codeElement, newNamedReference);
data.codeEffector.PerformCodeChanges();
}
}
#endregion
}
// check other reference
if((codeElement is CodeMethodReferenceExpression
&& (codeElement as CodeMethodReferenceExpression).MethodInfo != null
&& (codeElement as CodeMethodReferenceExpression).MethodInfo.DeclaringTypeInfo == data.TypeDeclaration.TypeInfo
) || (codeElement is CodePropertyReferenceExpression
&& (codeElement as CodePropertyReferenceExpression).PropertyInfo != null
&& (codeElement as CodePropertyReferenceExpression).PropertyInfo.DeclaringTypeInfo == data.TypeDeclaration.TypeInfo
) || (codeElement is CodeEventReferenceExpression
&& (codeElement as CodeEventReferenceExpression).EventInfo != null
&& (codeElement as CodeEventReferenceExpression).EventInfo.DeclaringTypeInfo == data.TypeDeclaration.TypeInfo
)
)
{
#region MethodReference
CodeNamedReferenceExpression newNamedReference = codeElement.Clone() as CodeNamedReferenceExpression;
newNamedReference.TargetObject = getInstanceInvoke;
data.codeEffector.ReplaceCodeElement(codeElement, newNamedReference);
data.codeEffector.PerformCodeChanges();
#endregion
}
if( codeElement is CodeObjectCreateExpression
&& (codeElement as CodeObjectCreateExpression).CreateType.TypeInfo == data.TypeDeclaration.TypeInfo
)
{
data.codeEffector.ReplaceCodeElement(codeElement, getInstanceInvoke);
data.codeEffector.PerformCodeChanges();
}
return CodeDomWalker.WalkerCallbackReturn.Next;
}
private CodeTypeMemberDeclarationCollection CreateAccessor(CodeTypeDeclaration typeDeclaration, CodeTypeFieldDeclaration member, AnticipatingMinds.Genesis.Effectors.CodeEffector codeEffector, TypeData data)
{
CodeTypeMemberDeclarationCollection accessorList = new CodeTypeMemberDeclarationCollection();
foreach(CodeVariableDeclarationMember variable in member.DeclaredFields)
{
string propertyName;
string variableName;
CreatePropertyAndFieldNames(typeDeclaration, member, variable, out propertyName, out variableName);
if(variable.Name != variableName)
{
codeEffector.ChangeCodeElement(variable, variable.GetType().GetProperty("Name"), variableName);
codeEffector.PerformCodeChanges();
}
CodeTypePropertyDeclaration accessor = new CodeTypePropertyDeclaration(propertyName);
accessor.ReturnType = member.DeclarationType;
accessor.Modifiers = CodeTypeMemberDeclaration.MemberDeclarationModifiers.Public;
#region GetStatement
accessor.GetAccessorStatements = new CodeStatementBlock();
string getStatementContent = String.Format("return {0};", variableName);
AnticipatingMinds.Genesis.CodeParser.CSharpParser getStatementContentParser = new AnticipatingMinds.Genesis.CodeParser.CSharpParser(getStatementContent, typeDeclaration.CompileUnit.Assembly.AssemblyFileName, typeDeclaration.CompileUnit.Assembly);
accessor.GetAccessorStatements = getStatementContentParser.ParseStatements(new ManualResetEvent(false));
#endregion
#region SetStatement
if((member.Modifiers & CodeTypeMemberDeclaration.MemberDeclarationModifiers.ReadOnly) == 0)
{
accessor.SetAccessorStatements = new CodeStatementBlock();
string setStatementContent = String.Format("{0} = value;", variableName);
AnticipatingMinds.Genesis.CodeParser.CSharpParser setStatementContentParser = new AnticipatingMinds.Genesis.CodeParser.CSharpParser(setStatementContent, typeDeclaration.CompileUnit.Assembly.AssemblyFileName, typeDeclaration.CompileUnit.Assembly);
accessor.SetAccessorStatements = setStatementContentParser.ParseStatements(new ManualResetEvent(false));
}
#endregion
accessorList.Add(accessor);
data.FieldAccessors.Add(variable, accessor);
}
int indexAccessor = (typeDeclaration as CodeClassDeclaration).Members.IndexOf(member);
return accessorList;
}
// check and create right names for property and private field
private void CreatePropertyAndFieldNames(CodeTypeDeclaration typeDeclaration, CodeTypeFieldDeclaration field, CodeVariableDeclarationMember member,out string propertyName,out string fieldName)
{
string[] typeNames = CodeTypeDeclarationUtils.GetTypeMembersNames(typeDeclaration);
if(Regex.IsMatch(member.Name, "^[A-Z]") || Regex.IsMatch(member.Name, "^_"))
{
propertyName = member.Name;
fieldName = member.Name.Trim().Substring(0, 1).ToLower()+ member.Name.Substring(1);
while(Array.IndexOf(typeNames,fieldName) != -1) fieldName = "_"+fieldName;
}
else
{
propertyName = member.Name.Trim().Substring(0, 1).ToUpper()+ member.Name.Substring(1);
while(Array.IndexOf(typeNames,propertyName) != -1) propertyName = "_" + propertyName;
fieldName = member.Name;
}
}
private static RuleViolation[] emptyViolationsList = new RuleViolation[0];
private Type[] targetedCodeElements = {typeof(CodeClassDeclaration)};
private static Type[] applicableApplicabilityScopeTypes = {typeof(ClassApplicabilityScope),typeof(FileApplicabilityScope)};
public override Type[] ApplicableApplicabilityScopeTypes
{
get
{
return applicableApplicabilityScopeTypes;
}
}
#region Private Helper Functions
private void WalkAllCompileUnits(CodeAssemblyFile startUnit,CodeDomWalker.WalkerCallback callback,object applicationData)
{
CodeAssemblyFileCollection compileUnits = new CodeAssemblyFileCollection();
if(startUnit != null && startUnit.Assembly != null && startUnit.Assembly.Solution != null)
{
foreach(CodeAssembly codeAssembly in startUnit.Assembly.Solution.Assemblies)
foreach(CodeAssemblyFile assemblyFile in codeAssembly.AssemblyFiles)
compileUnits.Add(assemblyFile);
}
if(startUnit != null && startUnit.Assembly != null && startUnit.Assembly.Solution == null)
{
foreach(CodeAssemblyFile assemblyFile in startUnit.Assembly.AssemblyFiles)
if(assemblyFile is CodeCompileUnit)
compileUnits.Add(assemblyFile as CodeCompileUnit);
}
if(startUnit != null && startUnit.Assembly == null)
compileUnits.Add(startUnit);
foreach(CodeAssemblyFile compileUnit in compileUnits)
CodeDomWalker.WalkCompileUnit(compileUnit,callback,applicationData);
}
#endregion
}
}
|