protected ForkStateEntry[] GetForkStateEntries()
{
ForkStateEntry[] cachedForkStateEntries = this.cachedForkStateEntries;
if (cachedForkStateEntries != null)
{
return(cachedForkStateEntries);
}
Lock writeLock = listeners.GetWriteLock();
writeLock.Lock();
try
{
// check again: concurrent thread might have been faster
cachedForkStateEntries = this.cachedForkStateEntries;
if (cachedForkStateEntries != null)
{
return(cachedForkStateEntries);
}
IThreadLocalCleanupBean[] extensions = listeners.GetExtensions();
List <ForkStateEntry> forkStateEntries = new List <ForkStateEntry>(extensions.Length);
for (int a = 0, size = extensions.Length; a < size; a++)
{
IThreadLocalCleanupBean extension = extensions[a];
FieldInfo[] fields = ReflectUtil.GetDeclaredFieldsInHierarchy(extension.GetType());
foreach (FieldInfo field in fields)
{
Forkable forkable = AnnotationUtil.GetAnnotation <Forkable>(field, false);
if (forkable == null)
{
continue;
}
Object valueTL = field.GetValue(extension);
if (valueTL == null)
{
continue;
}
Type forkProcessorType = forkable.Processor;
IForkProcessor forkProcessor = null;
if (forkProcessorType != null && !typeof(IForkProcessor).Equals(forkProcessorType))
{
WeakReference beanContextOfExtensionR = extensionToContextMap.Get(extension);
IServiceContext beanContextOfExtension = beanContextOfExtensionR != null ? (IServiceContext)beanContextOfExtensionR.Target : null;
if (beanContextOfExtension == null)
{
beanContextOfExtension = BeanContext;
}
forkProcessor = beanContextOfExtension.RegisterBean <IForkProcessor>(forkProcessorType).Finish();
}
forkStateEntries.Add(new ForkStateEntry(extension, field.Name, valueTL, forkable.Value, forkProcessor));
}
}
cachedForkStateEntries = forkStateEntries.ToArray();
this.cachedForkStateEntries = cachedForkStateEntries;
return(cachedForkStateEntries);
}
finally
{
writeLock.Unlock();
}
}
protected PropertyInfoEntry GetPropertyEntry(Type type, SmartCopyMap <Type, PropertyInfoEntry> map, bool isOldIocMode, bool isIocMode)
{
ParamChecker.AssertParamNotNull(type, "type");
PropertyInfoEntry propertyEntry = map.Get(type);
if (propertyEntry != null)
{
return(propertyEntry);
}
Object writeLock = map.GetWriteLock();
lock (writeLock)
{
propertyEntry = map.Get(type);
if (propertyEntry != null)
{
// Concurrent thread might have been faster
return(propertyEntry);
}
HashMap <String, HashMap <Type, HashMap <String, MethodInfo> > > sortedMethods = new HashMap <String, HashMap <Type, HashMap <String, MethodInfo> > >();
MethodInfo[] methods = ReflectUtil.GetDeclaredMethodsInHierarchy(type);
foreach (MethodInfo method in methods)
{
if (method.DeclaringType.Equals(typeof(Object)))
{
continue;
}
if (method.IsStatic)
{
continue;
}
try
{
String propName = GetPropertyNameFor(method);
if (propName.Length == 0)
{
continue;
}
HashMap <Type, HashMap <String, MethodInfo> > sortedMethod = sortedMethods.Get(propName);
if (sortedMethod == null)
{
sortedMethod = HashMap <Type, HashMap <String, MethodInfo> > .Create(1);
sortedMethods.Put(propName, sortedMethod);
}
ParameterInfo[] parameterInfos = method.GetParameters();
Type propertyType;
String prefix;
if (parameterInfos.Length == 1)
{
propertyType = parameterInfos[0].ParameterType;
prefix = "set";
}
else if (parameterInfos.Length == 0)
{
propertyType = method.ReturnType;
prefix = "get";
}
else
{
throw new Exception("Method is not an accessor: " + method);
}
HashMap <String, MethodInfo> methodPerType = sortedMethod.Get(propertyType);
if (methodPerType == null)
{
methodPerType = HashMap <String, MethodInfo> .Create(2);
sortedMethod.Put(propertyType, methodPerType);
}
methodPerType.Put(prefix, method);
}
catch (Exception e)
{
throw RuntimeExceptionUtil.Mask(e, "Error occured while processing " + method);
}
}
HashMap <String, HashMap <String, MethodInfo> > filteredMethods = FilterOverriddenMethods(sortedMethods, type);
HashMap <String, IPropertyInfo> propertyMap = new HashMap <String, IPropertyInfo>(0.5f);
foreach (MapEntry <String, HashMap <String, MethodInfo> > propertyData in filteredMethods)
{
String propertyName = propertyData.Key;
HashMap <String, MethodInfo> propertyMethods = propertyData.Value;
MethodInfo getter = propertyMethods.Get("get");
MethodInfo setter = propertyMethods.Get("set");
if (isIocMode)
{
if (setter == null ||
(!setter.IsPublic && !AnnotationUtil.IsAnnotationPresent <AutowiredAttribute>(setter, false) &&
!AnnotationUtil.IsAnnotationPresent <PropertyAttribute>(setter, false)))
{
continue;
}
}
MethodPropertyInfo propertyInfo = new MethodPropertyInfo(type, propertyName, getter, setter);
propertyMap.Put(propertyInfo.Name, propertyInfo);
}
Type[] interfaces = type.GetInterfaces();
List <Type> typesToSearch = new List <Type>(interfaces);
typesToSearch.Add(type);
foreach (Type typeToSearch in typesToSearch)
{
PropertyInfo[] properties = typeToSearch.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);
foreach (PropertyInfo property in properties)
{
if (property.GetGetMethod() != null && property.GetGetMethod().GetParameters().Length != 0)
{
continue;
}
if (property.GetSetMethod() != null && property.GetSetMethod().GetParameters().Length != 1)
{
continue;
}
MethodInfo getter = null;
MethodInfo setter = null;
MethodPropertyInfo propertyInfo = (MethodPropertyInfo)propertyMap.Get(property.Name);
if (propertyInfo != null)
{
getter = propertyInfo.Getter;
setter = propertyInfo.Setter;
}
if (getter == null)
{
getter = property.GetGetMethod();
}
if (setter == null)
{
setter = property.GetSetMethod();
}
if (isIocMode && setter == null)
{
continue;
}
propertyInfo = new MethodPropertyInfo(type, property.Name, getter, setter);
propertyInfo.PutAnnotations(property);
propertyMap.Put(propertyInfo.Name, propertyInfo);
}
}
FieldInfo[] fields = ReflectUtil.GetDeclaredFieldsInHierarchy(type);
foreach (FieldInfo field in fields)
{
if (field.IsStatic)
{
continue;
}
if (isOldIocMode)
{
if (!AnnotationUtil.IsAnnotationPresent <AutowiredAttribute>(field, false) && !AnnotationUtil.IsAnnotationPresent <PropertyAttribute>(field, false))
{
continue;
}
}
String propertyName = GetPropertyNameFor(field);
IPropertyInfo existingProperty = propertyMap.Get(propertyName);
if (existingProperty != null && existingProperty.IsWritable)
{
// Ignore field injection if the already resolved (method-)property is writable
continue;
}
IPropertyInfo propertyInfo = new FieldPropertyInfo(type, propertyName, field);
propertyMap.Put(propertyInfo.Name, propertyInfo);
}
propertyEntry = new PropertyInfoEntry(propertyMap);
map.Put(type, propertyEntry);
return(propertyEntry);
}
}
protected override void Init()
{
if (EntityType == null)
{
throw new ArgumentException("No class given");
}
if (Getter == null && Setter == null)
{
throw new ArgumentException("No property methods (class is '" + EntityType + "')");
}
else if (Getter != null)
{
Type declaringClass = Getter.DeclaringType;
PropertyType = Getter.ReturnType;
ElementType = TypeInfoItemUtil.GetElementTypeUsingReflection(PropertyType, null);
String nameLower = Name.ToLowerInvariant();
FieldInfo[] fields = ReflectUtil.GetDeclaredFieldsInHierarchy(declaringClass);
FieldInfo backingField = null;
FieldInfo weakBackingField = null;
String backingFieldName = "<" + Name + ">k__BackingField";
for (int a = fields.Length; a-- > 0;)
{
FieldInfo field = fields[a];
if (field.IsStatic)
{
continue;
}
String fieldName = field.Name.ToLowerInvariant();
if (fieldName.Equals(nameLower) || field.Name.Equals(backingFieldName))
{
backingField = field;
break;
}
else if (fieldName.EndsWith(nameLower))
{
if (weakBackingField != null)
{
weakBackingField = null;
break;
}
weakBackingField = field;
}
}
if (backingField == null)
{
backingField = weakBackingField;
}
BackingField = backingField;
if (backingField != null)
{
AddModifiers(backingField);
PutAnnotations(backingField);
}
PutAnnotations(Getter);
if (Setter != null)
{
if (Setter.GetParameters().Length != 1 || !PropertyType.IsAssignableFrom(Setter.GetParameters()[0].ParameterType))
{
throw new Exception("Misfitting property methods for property '" + Name + "' on class '" + EntityType.Name + "'");
}
PutAnnotations(Setter);
}
}
else
{
Type declaringClass = Setter.DeclaringType;
FieldInfo[] fields = ReflectUtil.GetDeclaredFieldsInHierarchy(declaringClass);
for (int a = fields.Length; a-- > 0;)
{
FieldInfo field = fields[a];
if (field.IsInitOnly || field.IsStatic)
{
continue;
}
String fieldName = field.Name;
if (fieldName.EndsWith(Name))
{
if (BackingField != null)
{
BackingField = null;
break;
}
BackingField = field;
}
}
if (BackingField != null)
{
AddModifiers(BackingField);
}
PropertyType = Setter.GetParameters()[0].ParameterType;
ElementType = TypeInfoItemUtil.GetElementTypeUsingReflection(PropertyType, null);
PutAnnotations(Setter);
}
//if (Getter != null && Modifier.isNative(Getter.getModifiers()))
//{
// modifiers |= Modifier.NATIVE;
//}
//if (Setter != null && Modifier.isNative(Setter.getModifiers()))
//{
// modifiers |= Modifier.NATIVE;
//}
if (Setter != null)
{
UpdateModifiers(false, (int)Modifier.FINAL);
}
bool?getterIsPublic = Getter != null ? (bool?)(Getter.IsPublic) : null;
bool?setterIsPublic = Setter != null ? (bool?)(Setter.IsPublic) : null;
if (getterIsPublic == true || setterIsPublic == true)
{
UpdateModifiers(false, (int)Modifier.PRIVATE);
UpdateModifiers(false, (int)Modifier.PROTECTED);
UpdateModifiers(true, (int)Modifier.PUBLIC);
}
else
{
bool?GetterIsProtected = Getter != null ? (bool?)(Getter.IsFamily || Getter.IsFamilyOrAssembly) : null;
bool?SetterIsProtected = Setter != null ? (bool?)(Setter.IsFamily || Setter.IsFamilyOrAssembly) : null;
if (GetterIsProtected == true || SetterIsProtected == true)
{
UpdateModifiers(false, (int)Modifier.PRIVATE);
UpdateModifiers(false, (int)Modifier.PUBLIC);
UpdateModifiers(true, (int)Modifier.PROTECTED);
}
else
{
UpdateModifiers(false, (int)Modifier.PROTECTED);
UpdateModifiers(false, (int)Modifier.PUBLIC);
UpdateModifiers(true, (int)Modifier.PRIVATE);
}
}
RefreshDeclaringType();
base.Init();
}
