public void evictAll(Class pcClass, boolean subclasses) { if (!nucleusCtx.getApiAdapter().isPersistable(pcClass)) { return; } evictAllOfClass(pcClass.getName()); if (subclasses) { String[] subclassNames = nucleusCtx.getMetaDataManager().getSubclassesForClass(pcClass.getName(), true); if (subclassNames != null) { for (int i=0;i<subclassNames.length;i++) { evictAllOfClass(subclassNames[i]); } } } }
/** * Evict the parameter instances from the second-level cache. * @param pcClass the class of instances to evict * @param subclasses if true, evict instances of subclasses also */ public void evictAll(Class pcClass, boolean subclasses) { if (!nucleusCtx.getApiAdapter().isPersistable(pcClass)) { return; } evictAllOfClass(pcClass.getName()); if (subclasses) { String[] subclassNames = nucleusCtx.getMetaDataManager().getSubclassesForClass(pcClass.getName(), true); if (subclassNames != null) { for (int i=0;i<subclassNames.length;i++) { evictAllOfClass(subclassNames[i]); } } } }
private static boolean keyKindIsValid(String kind, AbstractMemberMetaData pkMemberMetaData, Class<?> cls, Key key, ExecutionContext ec, boolean allowSubclasses) { if (key.getKind().equals(kind)) { return true; } if (!allowSubclasses) { return false; } MetaDataManager mdm = ec.getMetaDataManager(); // see if the key kind is a subclass of the requested kind String[] subclasses = mdm.getSubclassesForClass(cls.getName(), true); if (subclasses != null) { for (String subclass : subclasses) { AbstractClassMetaData subAcmd = mdm.getMetaDataForClass(subclass, ec.getClassLoaderResolver()); if (key.getKind().equals(determineKind(subAcmd, ec))) { return true; } } } return false; }
/** * Evict the parameter instances from the second-level cache. * @param pcClass the class of instances to evict * @param subclasses if true, evict instances of subclasses also */ public void evictAll(Class pcClass, boolean subclasses) { if (!nucleusCtx.getApiAdapter().isPersistable(pcClass)) { return; } evictAllOfClass(pcClass.getName()); if (subclasses) { String[] subclassNames = nucleusCtx.getMetaDataManager().getSubclassesForClass(pcClass.getName(), true); if (subclassNames != null) { for (int i=0;i<subclassNames.length;i++) { evictAllOfClass(subclassNames[i]); } } } }
@Override public String getClassNameForObjectID(Object id, ClassLoaderResolver clr, ExecutionContext ec) { String targetClassName = null; if (IdentityUtils.isSingleFieldIdentity(id)) { // Using SingleFieldIdentity so can assume that object is of the target class or a subclass targetClassName = IdentityUtils.getTargetClassNameForIdentity(id); String[] subclasses = getMetaDataManager().getSubclassesForClass(targetClassName, true); if (subclasses == null) { // No subclasses so must be the specified type return targetClassName; } String[] possibleNames = new String[subclasses.length+1]; possibleNames[0] = targetClassName; for (int i=0;i<subclasses.length;i++) { possibleNames[i+1] = subclasses[i]; } return getClassNameForIdentity(ec, possibleNames, id); } return super.getClassNameForObjectID(id, clr, ec); }
String[] subclassNames = ec.getMetaDataManager().getSubclassesForClass(candidateClass.getName(), true); if (subclassNames != null)
/** * @param storeMgr Store Manager * @param ec The object manager * @param candidateCmd The class meta data of the candidate * @param base the search base, or null to use the base of candidateCmd * @param additionalFilter the additional filter, or null to only use the filter of candidateCmd * @param subclasses true to include subclasses * @param ignoreCache whether to ignore the cache * @return List of objects */ public static List<Object> getObjectsOfCandidateType(StoreManager storeMgr, ExecutionContext ec, final AbstractClassMetaData candidateCmd, LdapName base, String additionalFilter, boolean subclasses, boolean ignoreCache) { ClassLoaderResolver clr = ec.getClassLoaderResolver(); List<Object> results = getObjectsOfCandidateType(storeMgr, ec, candidateCmd, base, additionalFilter, ignoreCache); if (subclasses) { // Add on any subclass objects String[] subclassNames = ec.getMetaDataManager().getSubclassesForClass(candidateCmd.getFullClassName(), true); if (subclassNames != null) { for (String subclassName : subclassNames) { AbstractClassMetaData subCmd = ec.getMetaDataManager().getMetaDataForClass(subclassName, clr); results.addAll(getObjectsOfCandidateType(storeMgr, ec, subCmd, base, additionalFilter, ignoreCache)); } } } return results; }
@Override public String getClassNameForObjectID(Object id, ClassLoaderResolver clr, ExecutionContext ec) { if (id == null) { // User stupidity return null; } else if (id instanceof SCOID) { // Object is a SCOID return ((SCOID) id).getSCOClass(); } String rootClassName = super.getClassNameForObjectID(id, clr, ec); // TODO Allow for use of users-own PK class in multiple inheritance trees String[] subclasses = getMetaDataManager().getSubclassesForClass(rootClassName, true); if (subclasses == null || subclasses.length == 0) { // No subclasses so no need to go to the datastore return rootClassName; } AbstractClassMetaData rootCmd = getMetaDataManager().getMetaDataForClass(rootClassName, clr); return Neo4jUtils.getClassNameForIdentity(id, rootCmd, ec, clr); }
@Override public String getClassNameForObjectID(Object id, ClassLoaderResolver clr, ExecutionContext ec) { if (id == null) { // User stupidity return null; } else if (id instanceof SCOID) { // Object is a SCOID return ((SCOID) id).getSCOClass(); } // Find overall root class possible for this id String rootClassName = super.getClassNameForObjectID(id, clr, ec); if (rootClassName != null) { // User could have passed in a superclass of the real class, so consult the datastore for the precise table/class String[] subclasses = getMetaDataManager().getSubclassesForClass(rootClassName, true); if (subclasses == null || subclasses.length == 0) { // No subclasses so no need to go to the datastore return rootClassName; } AbstractClassMetaData rootCmd = getMetaDataManager().getMetaDataForClass(rootClassName, clr); return MongoDBUtils.getClassNameForIdentity(id, rootCmd, ec, clr); } return null; }
if (node == null) String[] classNames = mmgr.getSubclassesForClass(acmd.getFullClassName(), false); if (classNames != null)
String[] subclassNames = ec.getMetaDataManager().getSubclassesForClass(candidateClass.getName(), true); if (subclassNames != null)
String[] subclasses = getMetaDataManager().getSubclassesForClass(cmd.getFullClassName(), true); if (subclasses != null)
public static Map<LdapName, Attributes> getEntries(StoreManager storeMgr, ExecutionContext ec, final AbstractClassMetaData candidateCmd, LdapName base, String additionalFilter, boolean subclasses, boolean ignoreCache) { ManagedConnection mconn = storeMgr.getConnectionManager().getConnection(ec); try { DirContext ctx = (DirContext) mconn.getConnection(); ClassLoaderResolver clr = ec.getClassLoaderResolver(); Map<LdapName, Attributes> results = getEntries(ec, candidateCmd, ctx, base, additionalFilter, ignoreCache); if (subclasses) { // Add on any subclass objects String[] subclassNames = ec.getMetaDataManager().getSubclassesForClass(candidateCmd.getFullClassName(), true); if (subclassNames != null) { for (String subclassName : subclassNames) { AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(subclassName, clr); results.putAll(getEntries(ec, cmd, ctx, base, additionalFilter, ignoreCache)); } } } return results; } finally { mconn.release(); } }
String[] subclassNames = ec.getMetaDataManager().getSubclassesForClass(effectiveClassMetaData.getFullClassName(), true); if (subclassNames != null)
String[] subclassNames = ec.getMetaDataManager().getSubclassesForClass(cmd.getFullClassName(), false); if (subclassNames != null) String[] subclassNames = ec.getMetaDataManager().getSubclassesForClass(cmd.getFullClassName(), false); if (subclassNames != null)
String[] subclassNames = effectiveCmd != null ? op.getExecutionContext().getMetaDataManager().getSubclassesForClass(effectiveCmd.getFullClassName(), true) : null; if (effectiveCmd == op.getClassMetaData() || (subclassNames != null && Arrays.asList(subclassNames).contains( op.getClassMetaData().getFullClassName())))
String[] subclasses = table.getStoreManager().getMetaDataManager().getSubclassesForClass(typeName, false); if (subclasses != null && subclasses.length > 0)
String[] subclassNames = effectiveCmd != null ? op.getExecutionContext().getMetaDataManager().getSubclassesForClass( effectiveCmd.getFullClassName(), true) : null; if (effectiveCmd == op.getClassMetaData() || (subclassNames != null && Arrays.asList(subclassNames).contains(
if (elementTable == null) { String[] subclassNames = storeMgr.getNucleusContext().getMetaDataManager().getSubclassesForClass(element_class.getName(), true); if (subclassNames.length == 1) { elementTable = this.storeMgr.getDatastoreClass(subclassNames[0], clr);
String[] subclasses = ec.getMetaDataManager().getSubclassesForClass(pcCls.getName(), true); if (subclasses != null)