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 override Attribute LookForAnnotation(MemberInfo method) { Attribute annotation = base.LookForAnnotation(method); if (annotation != null) { return(annotation); } NoProxyAttribute noProxy = AnnotationUtil.GetAnnotation <NoProxyAttribute>(method, false); if (noProxy != null) { return(noProxy); } ProcessAttribute process = AnnotationUtil.GetAnnotation <ProcessAttribute>(method, false); if (process != null) { return(process); } FindAttribute find = AnnotationUtil.GetAnnotation <FindAttribute>(method, false); if (find != null) { return(find); } MergeAttribute merge = AnnotationUtil.GetAnnotation <MergeAttribute>(method, false); if (merge != null) { return(merge); } return(AnnotationUtil.GetAnnotation <RemoveAttribute>(method, false)); }
public String GetPropertyNameFor(MethodInfo method) { PropertyAccessor propertyAccessor = AnnotationUtil.GetAnnotation <PropertyAccessor>(method, true); if (propertyAccessor != null) { return(propertyAccessor.PropertyName); } Match matcher = getSetIsPattern.Match(method.Name); if (!matcher.Success) { return(""); } int paramLength = method.GetParameters().Length; String getSetIs = matcher.Groups[1].Value; if (("get_".Equals(getSetIs) || "Get".Equals(getSetIs) || "get".Equals(getSetIs)) && (0 != paramLength || typeof(void).Equals(method.ReturnType))) { return(""); } else if (("set_".Equals(getSetIs) || "Set".Equals(getSetIs) || "set".Equals(getSetIs)) && 1 != paramLength) { return(""); } else if (("Is".Equals(getSetIs) || "is".Equals(getSetIs)) && (0 != paramLength || typeof(void).Equals(method.ReturnType))) { return(""); } String name = matcher.Groups[2].Value; return(StringConversionHelper.UpperCaseFirst(name)); }
protected void FillMethodsAnnotatedWith(Type type, IList <MethodInfo> methods, params Type[] annotations) { if (type == null || typeof(Object).Equals(type)) { return; } FillMethodsAnnotatedWith(type.BaseType, methods, annotations); MethodInfo[] allMethodsOfThisType = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic); for (int a = 0, size = allMethodsOfThisType.Length; a < size; a++) { MethodInfo currentMethod = allMethodsOfThisType[a]; for (int b = annotations.Length; b-- > 0;) { if (AnnotationUtil.GetAnnotation(annotations[b], currentMethod, false) == null) { continue; } if (currentMethod.GetParameters().Length != 0) { throw new Exception("It is not allowed to annotated methods without " + annotations[b].FullName + " having 0 arguments: " + currentMethod.ToString()); } methods.Add(currentMethod); } } }
protected Object Intercept(IInvocation invocation, String methodName, Attribute annotation, Boolean?isAsyncBegin) { if (AnnotationUtil.GetAnnotation <ProcessAttribute>(invocation.Method, false) != null) { return(InterceptApplication(invocation, annotation, isAsyncBegin)); } if (AnnotationUtil.GetAnnotation <MergeAttribute>(invocation.Method, false) != null || methodName.StartsWith("update") || methodName.StartsWith("save") || methodName.StartsWith("merge") || methodName.StartsWith("insert")) { return(InterceptMerge(invocation, annotation, isAsyncBegin)); } if (AnnotationUtil.GetAnnotation <RemoveAttribute>(invocation.Method, false) != null || methodName.StartsWith("delete") || methodName.StartsWith("remove")) { return(InterceptDelete(invocation, annotation, isAsyncBegin)); } if (AnnotationUtil.GetAnnotation <FindAttribute>(invocation.Method, false) != null || methodName.StartsWith("retrieve") || methodName.StartsWith("read") || methodName.StartsWith("find") || methodName.StartsWith("get")) { return(InterceptLoad(invocation, annotation, isAsyncBegin)); } if (methodName.Equals("close") || methodName.Equals("abort")) { // Intended blank } return(InterceptApplication(invocation, annotation, isAsyncBegin)); }
protected override Attribute LookForAnnotation(MemberInfo method) { Attribute annotation = base.LookForAnnotation(method); if (annotation != null) { return(annotation); } return(AnnotationUtil.GetAnnotation <CachedAttribute>(method, false)); }
public void PutAnnotations(ICustomAttributeProvider obj) { if (obj is MethodInfo) { MethodInfo m = (MethodInfo)obj; Type[] parameters = new Type[m.GetParameters().Length]; for (int a = m.GetParameters().Length; a-- > 0;) { parameters[a] = m.GetParameters()[a].ParameterType; } Type baseType = m.DeclaringType.BaseType; MethodInfo overriddenMethod = baseType != null?ReflectUtil.GetDeclaredMethod(true, baseType, m.ReturnType, m.Name, parameters) : null; if (overriddenMethod != null) { PutAnnotations(overriddenMethod); } } Object[] annotations = obj.GetCustomAttributes(true); foreach (Object anno in annotations) { Attribute annotation = (Attribute)anno; AttributeUsageAttribute attributeUsage = AnnotationUtil.GetAnnotation <AttributeUsageAttribute>(annotation.GetType(), true); Type type = annotation.GetType(); if (this.annotations == null) { this.annotations = new LinkedHashMap <Type, Attribute[]>(); } Attribute[] existingAttributes = this.annotations.Get(type); if (existingAttributes == null) { existingAttributes = new Attribute[0]; } Attribute[] newAttributes = new Attribute[existingAttributes.Length + 1]; Array.Copy(existingAttributes, newAttributes, existingAttributes.Length); newAttributes[existingAttributes.Length] = annotation; this.annotations.Put(type, newAttributes); } }
public virtual void AfterPropertiesSet() { if (ClasspathScanner == null) { if (Log.InfoEnabled) { Log.Info("Skipped scanning for XML transfer types. Reason: No instance of " + typeof(IClasspathScanner).FullName + " resolved"); } return; } IList <Type> rootElementClasses = ClasspathScanner.ScanClassesAnnotatedWith(typeof(DataContractAttribute), typeof(System.Xml.Serialization.XmlTypeAttribute), typeof(XmlTypeAttribute)); if (Log.InfoEnabled) { Log.Info("Found " + rootElementClasses.Count + " classes annotated as XML transfer types"); } if (Log.DebugEnabled) { List <Type> sorted = new List <Type>(rootElementClasses); sorted.Sort(delegate(Type left, Type right) { return(left.FullName.CompareTo(right.FullName)); }); for (int a = 0, size = sorted.Count; a < size; a++) { Log.Debug("Xml entity found: " + sorted[a].Namespace + "." + sorted[a].Name); } } for (int a = rootElementClasses.Count; a-- > 0;) { Type rootElementClass = rootElementClasses[a]; String name; String namespaceString; XmlTypeAttribute genericXmlType = AnnotationUtil.GetAnnotation <XmlTypeAttribute>(rootElementClass, false); if (genericXmlType != null) { name = genericXmlType.Name; namespaceString = genericXmlType.Namespace; } else { DataContractAttribute dataContract = AnnotationUtil.GetAnnotation <DataContractAttribute>(rootElementClass, false); if (dataContract != null) { name = dataContract.Name; namespaceString = dataContract.Namespace; } else { System.Xml.Serialization.XmlTypeAttribute xmlTypeAttribute = AnnotationUtil.GetAnnotation <System.Xml.Serialization.XmlTypeAttribute>(rootElementClass, false); name = xmlTypeAttribute.TypeName; namespaceString = xmlTypeAttribute.Namespace; } } if (DefaultNamespace.Equals(namespaceString)) { namespaceString = null; } if (name == null) { name = rootElementClass.Name; } XmlTypeExtendable.RegisterXmlType(rootElementClass, name, namespaceString); unregisterRunnables.Add(delegate() { XmlTypeExtendable.UnregisterXmlType(rootElementClass, name, namespaceString); }); } this.rootElementClasses = rootElementClasses; }