public boolean hasClassAnnotation(Class type, Class<? extends Annotation> anntype) { if (anntype != XmlRootElement.class && anntype != XmlType.class && anntype != XmlAccessorType.class) { return false; } AbstractClassMetaData acmd = metaDataMgr.getMetaDataForClass(type, clr); return acmd != null; }
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; }
/** * Method to perform the replication for all objects registered in the pmf source. */ public void replicateRegisteredClasses() { ClassLoaderResolver clr = ((JDOPersistenceManager)pmfSource.getPersistenceManager()).getExecutionContext().getClassLoaderResolver(); MetaDataManager mmgr = ((JDOPersistenceManagerFactory)pmfSource).getNucleusContext().getMetaDataManager(); Collection classNames = mmgr.getClassesWithMetaData(); ArrayList arrayTypes = new ArrayList(); Iterator iterator = classNames.iterator(); while (iterator.hasNext()) { String className = (String) iterator.next(); AbstractClassMetaData cmd = mmgr.getMetaDataForClass(className, clr); if (!cmd.isEmbeddedOnly()) // Omit embedded-only classes since can't replicate those { arrayTypes.add(clr.classForName(className)); } } replicate((Class[])arrayTypes.toArray(new Class[arrayTypes.size()])); }
protected AbstractClassMetaData getCandidateClassMetaData() { AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(candidateClass, clr); if (candidateClass.isInterface()) { // Query of interface String[] impls = ec.getMetaDataManager().getClassesImplementingInterface(candidateClass.getName(), clr); if (impls.length == 1 && cmd.isImplementationOfPersistentDefinition()) { // Only the generated implementation, so just use its metadata } else { // Use metadata for the persistent interface cmd = ec.getMetaDataManager().getMetaDataForInterface(candidateClass, clr); if (cmd == null) { throw new NucleusUserException("Attempting to query an interface yet it is not declared 'persistent'." + " Define the interface in metadata as being persistent to perform this operation, and make sure" + " any implementations use the same identity and identity member(s)"); } } } return cmd; }
if (storeMgr.getNucleusContext().getMetaDataManager().isPersistentInterface(elementType)) { elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForInterface(element_class,clr); elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForImplementationOfReference(element_class,null,clr); if (elementCmd != null) elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForClass(element_class, clr); if (elementTable == null) { String[] subclassNames = storeMgr.getNucleusContext().getMetaDataManager().getSubclassesForClass(element_class.getName(), true); if (subclassNames.length == 1) { elementTable = this.storeMgr.getDatastoreClass(subclassNames[0], clr);
Collection<String> classesWithMetaData = mdm.getClassesWithMetaData(); for (String className : classesWithMetaData) AbstractClassMetaData otherCmd = mdm.getMetaDataForClass(className, clr); if (otherCmd.isEmbeddedOnly()) 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())))
mmgr.registerListener(metadataListener); Collection<String> classNamesLoaded = mmgr.getClassesWithMetaData(); if (classNamesLoaded != null && !classNamesLoaded.isEmpty()) AbstractClassMetaData cmd = mmgr.getMetaDataForClass(className, clr); if (cmd != null)
ClassMetaData cmd = (ClassMetaData)metaDataMgr.getMetaDataForClass(cls, clr); if (cmd == null) if (!metaDataMgr.hasMetaDataForClass(obj.getClass().getName())) metaDataMgr.registerImplementationOfAbstractClass(cmd, obj.getClass(), clr); InterfaceMetaData imd = metaDataMgr.getMetaDataForInterface(cls, clr); if (imd == null) if (!metaDataMgr.hasMetaDataForClass(obj.getClass().getName())) metaDataMgr.registerPersistentInterface(imd, obj.getClass(), clr);
JavaTypeMapping discrimMapping = discrimMapIdx.getMapping(); DiscriminatorMetaData dismd = (discrimMapping != null ? discrimMapping.getTable().getDiscriminatorMetaData() : null); className = ec.getMetaDataManager().getClassNameFromDiscriminatorValue(discrimValue, dismd); if (className != null) String[] subclasses = ec.getMetaDataManager().getSubclassesForClass(pcClassForObject.getName(), false); if (subclasses == null || subclasses.length == 0) String[] subclasses = ec.getMetaDataManager().getSubclassesForClass(pcClassForObject.getName(), false); if (subclasses != null) AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(pcClassForObject, clr); if (cmd == null) cmd = ec.getMetaDataManager().getMetaDataForInterface(persistentClass, clr); if (cmd == null) cmd = ec.getMetaDataManager().getMetaDataForClass(pcClassForObject, clr);
AbstractClassMetaData rootEmbCmd = mmgr.getMetaDataForClass(typeName, clr); if (rootEmbCmd == null) if (fieldTypes != null && fieldTypes.length == 1) rootEmbCmd = mmgr.getMetaDataForClass(fieldTypes[0], clr); rootEmbCmd = mmgr.getMetaDataForInterface(clr.classForName(typeName), clr); if (rootEmbCmd == null && mmd.getFieldTypes() != null && mmd.getFieldTypes().length == 1) rootEmbCmd = mmgr.getMetaDataForInterface(clr.classForName(mmd.getFieldTypes()[0]), clr); String[] subclasses = mmgr.getSubclassesForClass(rootEmbCmd.getFullClassName(), true); if (subclasses != null && subclasses.length > 0) AbstractClassMetaData subEmbCmd = storeMgr.getMetaDataManager().getMetaDataForClass(subclasses[i], clr); AbstractMemberMetaData[] subEmbMmds = subEmbCmd.getManagedMembers(); if (subEmbMmds != null)
if (mmd.getType().isInterface()) typeCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForInterface(mmd.getType(), clr); typeCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForClass(mmd.getType(), clr); AbstractClassMetaData cmdForFmd = table.getStoreManager().getMetaDataManager().getMetaDataForClass(mmd.getClassName(), clr); overrideMmd = cmdForFmd.getMetaDataForMember(mmd.getName());
/** * Initialisation method. */ private void initialize(ClassLoaderResolver clr) { elementType = elementMapping.getType(); elementsAreEmbedded = isEmbeddedMapping(elementMapping); elementsAreSerialised = isEmbeddedMapping(elementMapping); // Load the element class Class elementCls = clr.classForName(elementType); if (ClassUtils.isReferenceType(elementCls)) { elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForImplementationOfReference(elementCls, null, clr); } else { elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForClass(elementCls, clr); } if (elementCmd != null) { elementType = elementCmd.getFullClassName(); elementInfo = getComponentInformationForClass(elementType, elementCmd); } }
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]); } } } }
Iterator iter = getMetaDataManager().getReferencedClasses(filteredClassNames, clr).iterator(); while (iter.hasNext())
omfCtx.getMetaDataManager().loadPersistenceUnit(unitMetaData, null); Collection<String> loadedClasses = omfCtx.getMetaDataManager().getClassesWithMetaData(); omfCtx.getStoreManager().addClasses(loadedClasses.toArray(new String[loadedClasses.size()]), omfCtx.getClassLoaderResolver(null));
/** * Method to generate a set of class names using the input list. * If no input class names are provided then uses the list of classes known to have metadata. * @param ctx NucleusContext * @param inputClassNames Class names to start from * @return The set of class names */ protected static Set<String> cleanInputClassNames(NucleusContext ctx, Set<String> inputClassNames) { Set<String> classNames = new TreeSet<>(); if (inputClassNames == null || inputClassNames.size() == 0) { // Use all "known" persistable classes classNames.addAll(ctx.getMetaDataManager().getClassesWithMetaData()); } else { // Use all input classes classNames.addAll(inputClassNames); } return classNames; } }
private void registerMetadataListener( final MetaDataManager metaDataManager, final Map<String, String> datanucleusProps) { final MetaDataListener listener = createMetaDataListener(); if(listener == null) { return; } if(listener instanceof DataNucleusPropertiesAware) { ((DataNucleusPropertiesAware) listener).setDataNucleusProperties(datanucleusProps); } // and install the listener for any classes that are lazily loaded subsequently // (shouldn't be any, this is mostly backwards compatibility with previous design). metaDataManager.registerListener(listener); }
/** * Release of resources */ public synchronized void close() { nucleusContext.getMetaDataManager().deregisterListener(metadataListener); super.close(); }
AbstractClassMetaData refCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForInterface(mmd.getType(), clr); if (refCmd != null && refCmd.getInheritanceMetaData().getStrategy() == InheritanceStrategy.SUBCLASS_TABLE)
if (ClassUtils.isReferenceType(element_class)) elementIsPersistentInterface = storeMgr.getNucleusContext().getMetaDataManager().isPersistentInterface(element_class.getName()); if (elementIsPersistentInterface) elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForInterface(element_class,clr); elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForImplementationOfReference(element_class,null,clr); elementCmd = storeMgr.getNucleusContext().getMetaDataManager().getMetaDataForClass(element_class, clr); otherCmd = storeMgr.getMetaDataManager().getMetaDataForClass(otherMmd.getTypeName(), clr); if (remainingMappedBy.indexOf('.') < 0)