2839 c = c.getComponentType();
2840 }
2841 String baseName = c.getPackageName();
2842 if (baseName != null && !baseName.isEmpty()) {
2843 name = baseName.replace('.', '/') + "/" + name;
2844 }
2845 } else {
2846 name = name.substring(1);
2847 }
2848 return name;
2849 }
2850
2851 /**
2852 * Atomic operations support.
2853 */
2854 private static class Atomic {
2855 // initialize Unsafe machinery here, since we need to call Class.class instance method
2856 // and have to avoid calling it in the static initializer of the Class class...
2857 private static final Unsafe unsafe = Unsafe.getUnsafe();
2858 // offset of Class.reflectionData instance field
2859 private static final long reflectionDataOffset;
2860 // offset of Class.annotationType instance field
2861 private static final long annotationTypeOffset;
2862 // offset of Class.annotationData instance field
2863 private static final long annotationDataOffset;
2864
2865 static {
2866 Field[] fields = Class.class.getDeclaredFields0(false); // bypass caches
2867 reflectionDataOffset = objectFieldOffset(fields, "reflectionData");
2868 annotationTypeOffset = objectFieldOffset(fields, "annotationType");
2869 annotationDataOffset = objectFieldOffset(fields, "annotationData");
2870 }
2871
2872 private static long objectFieldOffset(Field[] fields, String fieldName) {
2873 Field field = searchFields(fields, fieldName);
2874 if (field == null) {
2875 throw new Error("No " + fieldName + " field found in java.lang.Class");
2876 }
2877 return unsafe.objectFieldOffset(field);
2878 }
2879
2880 static <T> boolean casReflectionData(Class<?> clazz,
2881 SoftReference<ReflectionData<T>> oldData,
2882 SoftReference<ReflectionData<T>> newData) {
2883 return unsafe.compareAndSetObject(clazz, reflectionDataOffset, oldData, newData);
2884 }
2885
2886 static <T> boolean casAnnotationType(Class<?> clazz,
2887 AnnotationType oldType,
2888 AnnotationType newType) {
2889 return unsafe.compareAndSetObject(clazz, annotationTypeOffset, oldType, newType);
2890 }
2891
2892 static <T> boolean casAnnotationData(Class<?> clazz,
2893 AnnotationData oldData,
2894 AnnotationData newData) {
2895 return unsafe.compareAndSetObject(clazz, annotationDataOffset, oldData, newData);
2896 }
2897 }
2898
|
2839 c = c.getComponentType();
2840 }
2841 String baseName = c.getPackageName();
2842 if (baseName != null && !baseName.isEmpty()) {
2843 name = baseName.replace('.', '/') + "/" + name;
2844 }
2845 } else {
2846 name = name.substring(1);
2847 }
2848 return name;
2849 }
2850
2851 /**
2852 * Atomic operations support.
2853 */
2854 private static class Atomic {
2855 // initialize Unsafe machinery here, since we need to call Class.class instance method
2856 // and have to avoid calling it in the static initializer of the Class class...
2857 private static final Unsafe unsafe = Unsafe.getUnsafe();
2858 // offset of Class.reflectionData instance field
2859 private static final long reflectionDataOffset
2860 = unsafe.objectFieldOffset(Class.class, "reflectionData");
2861 // offset of Class.annotationType instance field
2862 private static final long annotationTypeOffset
2863 = unsafe.objectFieldOffset(Class.class, "annotationType");
2864 // offset of Class.annotationData instance field
2865 private static final long annotationDataOffset
2866 = unsafe.objectFieldOffset(Class.class, "annotationData");
2867
2868 static <T> boolean casReflectionData(Class<?> clazz,
2869 SoftReference<ReflectionData<T>> oldData,
2870 SoftReference<ReflectionData<T>> newData) {
2871 return unsafe.compareAndSetObject(clazz, reflectionDataOffset, oldData, newData);
2872 }
2873
2874 static <T> boolean casAnnotationType(Class<?> clazz,
2875 AnnotationType oldType,
2876 AnnotationType newType) {
2877 return unsafe.compareAndSetObject(clazz, annotationTypeOffset, oldType, newType);
2878 }
2879
2880 static <T> boolean casAnnotationData(Class<?> clazz,
2881 AnnotationData oldData,
2882 AnnotationData newData) {
2883 return unsafe.compareAndSetObject(clazz, annotationDataOffset, oldData, newData);
2884 }
2885 }
2886
|