/** * Accessor for the Java type being represented here. * @return The Java type */ public Class getJavaType() { return clr.classForName(typeName); }
private Class<?> classForName(ClassLoaderResolver clr, String typeStr) { // If typeStr is a primitive it is not a class we can look up using // Class.forName. Consult our map of primitive classnames to see // if this is the case. Class<?> clazz = PrimitiveUtils.PRIMITIVE_CLASSNAMES.get(typeStr); if (clazz == null) { clazz = clr.classForName(typeStr); } return clazz; }
/** * Method to populate the methods of the listener class into the EventListenerMetaData. * Checks the annotations of the listener class itself and adds them in to the definition that * the EventListener uses. * @param elmd EventListenerMetaData (updated by this method) * @param clr ClassLoader resolver */ private void populateListenerMethodsForEventListener(EventListenerMetaData elmd, ClassLoaderResolver clr) { Class listenerClass = clr.classForName(elmd.getClassName()); populateListenerMethodsForClassInEventListener(elmd, listenerClass, clr); }
/** * Method to populate the methods of the listener class into the EventListenerMetaData. * Checks the annotations of the listener class itself and adds them in to the definition that * the EventListener uses. * @param elmd EventListenerMetaData (updated by this method) * @param clr ClassLoader resolver */ private void populateListenerMethodsForEventListener(EventListenerMetaData elmd, ClassLoaderResolver clr) { Class listenerClass = clr.classForName(elmd.getClassName()); populateListenerMethodsForClassInEventListener(elmd, listenerClass, clr); }
public SingularAttribute<X, ?> getDeclaredSingularAttribute(String attr) { AttributeImpl<X, ?> theAttr = (AttributeImpl<X, ?>) attributes.get(attr); if (theAttr == null) { throw new IllegalArgumentException("Attribute " + attr + " was not found in class"); } AbstractMemberMetaData mmd = theAttr.getMetadata(); Class thisCls = model.getClassLoaderResolver().classForName(cmd.getFullClassName()); if (mmd.getMemberRepresented().getDeclaringClass() != thisCls) { throw new IllegalArgumentException("Attribute " + attr + " isn't defined in " + cmd.getFullClassName()); } return (SingularAttribute<X, ?>)theAttr; }
public Type<?> getIdType() { String objectIdClass = cmd.getObjectidClass(); Class pkCls = model.getClassLoaderResolver().classForName(objectIdClass); return model.getType(pkCls); }
@Override public Class getJavaType() { return mmd != null ? mmd.getType() : storeMgr.getNucleusContext().getClassLoaderResolver(null).classForName(type); }
public Class<E> getBindableJavaType() { // What about for a Map ? return owner.model.getClassLoaderResolver().classForName(mmd.getCollection().getElementType()); }
public Class<K> getKeyJavaType() { return owner.model.getClassLoaderResolver().classForName(mmd.getMap().getKeyType()); }
@Override public FieldManager getFieldManagerForResultProcessing(ExecutionContext ec, Object resultSet, StatementClassMapping resultMappings, AbstractClassMetaData cmd) { Class<?> cls = ec.getClassLoaderResolver().classForName(cmd.getFullClassName()); Object internalKey = EntityUtils.idToInternalKey(ec, cls, resultSet, true); // Need to provide this to the field manager in the form of the pk // of the type: Key, Long, encoded String, or unencoded String return new KeyOnlyFieldManager(internalKey); }
public IdentifiableType<? super X> getSupertype() { AbstractClassMetaData superCmd = cmd.getSuperAbstractClassMetaData(); Class superCls = ((MetamodelImpl)model).getClassLoaderResolver().classForName(superCmd.getFullClassName()); return (IdentifiableType<? super X>)model.managedType(superCls); }
public Type<K> getKeyType() { Class keyCls = owner.model.getClassLoaderResolver().classForName(mmd.getMap().getKeyType()); return owner.model.getType(keyCls); } }
public ManagedType<X> getDeclaringType() { Class ownerCls = owner.getModel().getClassLoaderResolver().classForName(mmd.getClassName(true)); return owner.getModel().managedType(ownerCls); }
@Override public ValueMetadata setConverter(AttributeConverter<?, ?> conv) { String valType = ((AbstractMemberMetaData)getInternal().getParent()).getMap().getKeyType(); Class valCls = getInternal().getMetaDataManager().getNucleusContext().getClassLoaderResolver(null).classForName(valType); Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(conv.getClass(), valCls); Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(conv.getClass(), attrType, null); // Register the TypeConverter under the name of the AttributeConverter class JDOTypeConverter typeConv = new JDOTypeConverter(conv); TypeManager typeMgr = getInternal().getMetaDataManager().getNucleusContext().getTypeManager(); typeMgr.registerConverter(conv.getClass().getName(), typeConv, attrType, dbType, false, null); getInternal().addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, conv.getClass().getName()); return this; }
@Override public KeyMetadata setConverter(AttributeConverter<?, ?> conv) { String keyType = ((AbstractMemberMetaData)getInternal().getParent()).getMap().getKeyType(); Class keyCls = getInternal().getMetaDataManager().getNucleusContext().getClassLoaderResolver(null).classForName(keyType); Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(conv.getClass(), keyCls); Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(conv.getClass(), attrType, null); // Register the TypeConverter under the name of the AttributeConverter class JDOTypeConverter typeConv = new JDOTypeConverter(conv); TypeManager typeMgr = getInternal().getMetaDataManager().getNucleusContext().getTypeManager(); typeMgr.registerConverter(conv.getClass().getName(), typeConv, attrType, dbType, false, null); getInternal().addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, conv.getClass().getName()); return this; }
@Override public ElementMetadata setConverter(AttributeConverter<?, ?> conv) { String elemType = ((AbstractMemberMetaData)getInternal().getParent()).getCollection().getElementType(); Class elemCls = getInternal().getMetaDataManager().getNucleusContext().getClassLoaderResolver(null).classForName(elemType); Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(conv.getClass(), elemCls); Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(conv.getClass(), attrType, null); // Register the TypeConverter under the name of the AttributeConverter class JDOTypeConverter typeConv = new JDOTypeConverter(conv); TypeManager typeMgr = getInternal().getMetaDataManager().getNucleusContext().getTypeManager(); typeMgr.registerConverter(conv.getClass().getName(), typeConv, attrType, dbType, false, null); getInternal().addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, conv.getClass().getName()); return this; }
public FieldManager getFieldManagerForResultProcessing(ObjectProvider op, Object resultSet, StatementClassMapping resultMappings) { ExecutionContext ec = op.getExecutionContext(); Class<?> cls = ec.getClassLoaderResolver().classForName(op.getClassMetaData().getFullClassName()); Object internalKey = EntityUtils.idToInternalKey(ec, cls, resultSet, true); // Need to provide this to the field manager in the form of the pk // of the type: Key, Long, encoded String, or unencoded String return new KeyOnlyFieldManager(internalKey); }
@Override public void initialize(AbstractMemberMetaData mmd, Table table, ClassLoaderResolver clr) { CollectionMetaData collectionMetaData = mmd.getCollection(); String wrappedTypeName = collectionMetaData.getElementType(); wrappedTypeClass = clr.classForName(wrappedTypeName); WrappedMemberMetaData wmmd = new WrappedMemberMetaData(mmd, wrappedTypeClass, clr); // Get the actual mapping that handles the the wrapped type wrappedMapping = table.getStoreManager().getMappingManager().getMapping(table, wmmd, clr, FieldRole.ROLE_FIELD); super.initialize(mmd, table, clr); }
public SimpleCollectionMappingStrategy(ObjectProvider sm, AbstractMemberMetaData mmd, Attributes attributes) { super(sm, mmd, attributes); type = sm.getExecutionContext().getClassLoaderResolver().classForName(mmd.getCollection().getElementType()); // For now, each collection element is persisted as its own attribute value if (mmd.getJoinMetaData() == null) { // TODO Drop this hack. Using join as way of saying don't serialise mmd.setJoinMetaData(new JoinMetaData()); } }
@Override public void initialize(RDBMSStoreManager storeMgr, String type) { // We don't have access to any field info yet, so have no idea whether we need a TypeConverter, so just create one Class fieldType = storeMgr.getNucleusContext().getClassLoaderResolver(null).classForName(type); converter = storeMgr.getNucleusContext().getTypeManager().getDefaultTypeConverterForType(fieldType); if (converter == null) { throw new NucleusUserException("Unable to find TypeConverter for converting " + fieldType + " to String"); } super.initialize(storeMgr, type); }