/** * Affirms if the given code is valid. */ public static boolean isValidClassCode(int code) { if (code == EMPTY) return true; return (code%2 == 0 || code == EMPTY) && code >= UNKNOWN && code <= (MIXED|EXPLICIT|PROPERTY) && !(isProperty(code) && isField(code)) // both 1 & 2 can not be set && (isProperty(code) || isField(code) || isUnknown(code)) && ((isMixed(code) && isExplicit(code)) || !isMixed(code)); }
/** * Affirms if the sub class access type is compatible with super class * access style. */ public static boolean isCompatibleSuper(int subCode, int superCode) { if (isEmpty(superCode)) return true; if (isValidClassCode(subCode) && isValidClassCode(superCode)) { if (isExplicit(subCode)) return true; return subCode == superCode; } return false; }
public static int getMixedCode(int cCode, int fCode) { if (isMixed(cCode) || (isProperty(cCode) == isProperty(fCode))) return cCode; return MIXED | cCode; }
public static int toFieldCode(int code) { if (isProperty(code)) return PROPERTY; if (isField(code)) return FIELD; return UNKNOWN; }
public static String toFieldString(int code) { if (!isValidFieldCode(code)) return "invalid code " + code; if (code == UNKNOWN) return "unknown access"; if (code == EMPTY) return "empty access"; return (isMixed(code) ? "mixed " : "") + (isExplicit(code) ? "explicit " : "implicit ") + (isField(code) ? "field" : "property") + " access"; }
if (isValidClassCode(cCode) && isValidFieldCode(fCode)) { if (isUnknown(cCode)) { if (isUnknown(fCode)) return UNKNOWN; return isProperty(fCode) ? PROPERTY : FIELD; boolean mixed = isProperty(cCode) != isProperty(fCode); if (isExplicit(cCode)) { if (mixed) { return MIXED | cCode; throw new IllegalStateException( (_loc.get("access-cannot-merge", toFieldString(fCode), toClassString(cCode)).toString()));
public static String toClassString(int code) { if (!isValidClassCode(code)) return "invalid code " + code; if (code == UNKNOWN) return "unknown access"; if (code == EMPTY) return "empty access"; return (isMixed(code) ? "mixed " : "") + (isExplicit(code) ? "explicit " : "implicit ") + (isField(code) ? "field" : "property") + " access"; } }
public static boolean isValidFieldCode(int code) { return code%2 == 0 // code must be even && code >= UNKNOWN && code <= (EXPLICIT|PROPERTY) && !(isProperty(code) && isField(code)) && (isProperty(code) || isField(code) || isUnknown(code)); }
/** * Assert that this class' access type is allowed. * If no access style is set or an explicit style is set return. * Otherwise, if the superclass has persistent attributes, check that * the superclass access style, if defaulted, is the same as that of this * receiver. */ private void validateAccessType() { if (AccessCode.isEmpty(_accessType) || AccessCode.isExplicit(_accessType)) return; ClassMetaData sup = getPCSuperclassMetaData(); while (sup != null && sup.isExplicitAccess()) sup = sup.getPCSuperclassMetaData(); if (sup != null && sup.getDeclaredFields().length > 0) { int supCode = sup.getAccessType(); if (!AccessCode.isCompatibleSuper(_accessType, supCode)) throw new MetaDataException(_loc.get("access-inconsistent-inherit", new Object[]{this, AccessCode.toClassString(_accessType), sup, AccessCode.toClassString(supCode)}).toString()); } }
Method getter = Reflection.findGetter(cls, property, false); Method setter = Reflection.findSetter(cls, property, false); int accessCode = AccessCode.isUnknown(access) ? meta.getAccessType() : access; if (field == null && getter == null) field, getter).toString()); if (AccessCode.isField(accessCode)) { if (isAnnotatedAccess(getter, AccessType.PROPERTY)) { meta.setAccessType(AccessCode.MIXED | meta.getAccessType()); } else if (AccessCode.isProperty(accessCode)) { if (isAnnotatedAccess(field, AccessType.FIELD)) { meta.setAccessType(AccessCode.MIXED | meta.getAccessType()); } else if (AccessCode.isUnknown(accessCode)) { if (isAnnotated(field)) { meta.setAccessType(AccessCode.FIELD); AccessCode.toClassString(meta.getAccessType()));
public static int mergeFieldCode(ClassMetaData meta, FieldMetaData fmd, int fCode) { int cCode = meta.getAccessType(); try { return mergeFieldCode(cCode, fCode); } catch (IllegalStateException e) { throw new UserException(_loc.get("access-illegal-merge", fmd.getFullName(false), toFieldString(fCode), toClassString(cCode))); } }
/** * Gets the access type used by this field. If no access type is set for * this field then return the access type used by the declaring class. */ public int getAccessType() { if (AccessCode.isUnknown(_access)) { int fCode = AccessCode.toFieldCode(getDeclaringMetaData() .getAccessType()); return fCode; } return _access; }
if (meta.getDescribedType().isInterface()) // managed interfaces return AccessCode.PROPERTY; if (!AccessCode.isUnknown(meta)) return meta.getAccessType(); int access = determineExplicitAccessType(meta.getDescribedType()); if (!AccessCode.isUnknown(access)) return access; access = determineImplicitAccessType(meta.getDescribedType(), meta.getRepository().getConfiguration()); if (!AccessCode.isUnknown(access)) return access; if (sup != null && !AccessCode.isUnknown(sup)) return sup.getAccessType(); trace(meta, _loc.get("access-default", meta, AccessCode.toClassString(getDefaultAccessType()))); return getDefaultAccessType();
/** * Affirms if the given field is using field-based access. */ boolean isPropertyAccess(FieldMetaData fmd) { return fmd != null && AccessCode.isProperty(fmd.getAccessType()); }
/** * Gets the list of persistent fields and/or methods for the given type. * * Scans relevant @AccessType annotation and field/method as per JPA * specification to determine the candidate set of field/methods. */ public Set<Element> getPersistentMembers(TypeElement type) { int access = determineTypeAccess(type); if (AccessCode.isExplicit(access)) { return AccessCode.isField(access) ? getFieldAccessPersistentMembers(type) : getPropertyAccessPersistentMembers(type); } return getDefaultAccessPersistentMembers(type, access); }
/** * Gets the fields that are possible candidate for being persisted. The * result depends on the current access style of the given class. */ List<Field> getPersistentFields(ClassMetaData meta, boolean ignoreTransient) { boolean explicit = meta.isExplicitAccess(); boolean unknown = AccessCode.isUnknown(meta); boolean isField = AccessCode.isField(meta); if (explicit || unknown || isField) { Field[] fields = AccessController.doPrivileged(J2DoPrivHelper. getDeclaredFieldsAction(meta.getDescribedType())); return filter(fields, fieldFilter, ignoreTransient ? null : nonTransientFilter, unknown || isField ? null : annotatedFilter, explicit ? (isField ? null : fieldAccessFilter) : null); } return Collections.EMPTY_LIST; }
/** * Sets the access type. */ public void setAccessType(int type) { if (type == _accessType || type == AccessCode.UNKNOWN) return; if (!AccessCode.isValidClassCode(type)) { throw new IllegalArgumentException(_loc.get("access-type-invalid", this, AccessCode.toClassString(type)).getMessage()); } if (_accessType != AccessCode.UNKNOWN) { // changing access type _repos.getLog().trace(_loc.get("access-type-change", this, AccessCode.toClassString(type), AccessCode.toClassString(_accessType)).getMessage()); } _accessType = type; }
public static boolean isUnknown(ClassMetaData meta) { return isUnknown(meta.getAccessType()); }
/** * Affirms if the given field is using method-based access. */ boolean isFieldAccess(FieldMetaData fmd) { return fmd != null && AccessCode.isField(fmd.getAccessType()); }
/** * Affirms if access style is explicitly defined. */ public boolean isExplicitAccess() { return AccessCode.isExplicit(_accessType); }