@Override public Class getJavaType() { return mmd.getType(); }
protected String getTypeNameForField(AbstractMemberMetaData mmd) { AbstractClassMetaData fieldCmd = classEnhancer.getMetaDataManager().getMetaDataForClass(mmd.getType(), classEnhancer.getClassLoaderResolver()); String fieldTypeName = mmd.getTypeName(); if (fieldCmd != null && fieldCmd.getIdentityType() == IdentityType.APPLICATION) { fieldTypeName = fieldCmd.getObjectidClass(); } return fieldTypeName; }
/** * Accessor for the Java type represented here. * @return The java type */ public Class getJavaType() { if (mmd != null) { return mmd.getType(); } return null; }
public Class<Y> getJavaType() { return mmd.getType(); }
public Class<T> getBindableJavaType() { return mmd.getType(); }
public javax.persistence.metamodel.Bindable.BindableType getBindableType() { // TODO Remove this use of PersistenceCapable return PersistenceCapable.class.isAssignableFrom(mmd.getType()) ? BindableType.ENTITY_TYPE : BindableType.SINGULAR_ATTRIBUTE; } }
public boolean isCollection() { return Collection.class.isAssignableFrom(mmd.getType()); }
/** * Accessor for the element type stored in this array. * @return Name of element type. */ public String getElementType() { return mmd.getType().getComponentType().getName(); }
/** * @param metaData The meta data we'll consult. * * @return {@code true} if the pojo property is an array of bytes. */ private boolean pojoPropertyIsByteArray(AbstractMemberMetaData metaData) { Class<?> componentType = metaData.getType().getComponentType(); return componentType.equals(Byte.class) || componentType.equals(Byte.TYPE); }
protected RuntimeException exceptionForUnexpectedKeyType(String fieldType, int fieldNumber) { return new IllegalStateException(fieldType + " for type " + getClassMetaData().getName() + " is of unexpected type " + getMetaData(fieldNumber).getType().getName() + " (must be String, Long, long, or " + Key.class.getName() + ")"); }
/** * Transform the given {@link Blob} into its deserialized form using the * serialization strategy declared on the given member metadata, or using * the default serialization strategy if no serialization strategy is * explicitly declared. */ Object deserialize(ClassLoaderResolver clr, AbstractMemberMetaData ammd, Blob value) { SerializationStrategy serializationStrategy = getSerializationStrategy(clr, ammd); return serializationStrategy.deserialize(value, ammd.getType()); }
public Object fetchObjectField(int fieldNumber) { AbstractMemberMetaData ammd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); if (isPK(fieldNumber)) { if (ammd.getType().equals(Key.class)) { // If this is a pk field, transform the Key into its String representation. return datastoreEntity.getKey(); } else if (ammd.getType().equals(Long.class)) { return datastoreEntity.getKey().getId(); } } return null; }
private Object convertPojoArrayToDatastoreValue(AbstractMemberMetaData ammd, Object value) { Object result; if (pojoPropertyIsByteArray(ammd)) { result = convertByteArrayToShortBlob(value); } else if (Enum.class.isAssignableFrom(ammd.getType().getComponentType())) { result = convertEnumsToStringList(Arrays.<Enum>asList((Enum[]) value)); } else { // Translate all arrays to lists before storing. result = convertPojoArrayToDatastoreList(value); } return result; } }
void storeParentField(int fieldNumber, Object value) { AbstractMemberMetaData mmd = getMetaData(fieldNumber); if (mmd.getType().equals(Key.class)) { storeParentKeyPK((Key) value); } else { throw exceptionForUnexpectedKeyType("Parent primary key", fieldNumber); } }
@Override public Class getJavaType() { return mmd != null ? mmd.getType() : storeMgr.getNucleusContext().getClassLoaderResolver(null).classForName(type); }
@Override public void setObject(ExecutionContext ec, PreparedStatement ps, int[] pos, Object container) { Object value = null; if (container != null) { ElementContainerHandler containerHandler = ec.getTypeManager().getContainerHandler(mmd.getType()); ContainerAdapter containerAdapter = containerHandler.getAdapter(container); Iterator iterator = containerAdapter.iterator(); value = iterator.hasNext() ? iterator.next() : null; } wrappedMapping.setObject(ec, ps, pos, value); }
@Override public MemberMetadata setConverter(AttributeConverter<?, ?> conv) { Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(conv.getClass(), getInternal().getType()); 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().setTypeConverterName(conv.getClass().getName()); return this; }
void storePKIdField(int fieldNumber, Object value) { AbstractMemberMetaData mmd = getMetaData(fieldNumber); if (!mmd.getType().equals(Long.class)) { throw new NucleusFatalUserException( "Field with \"" + DatastoreManager.PK_ID + "\" extension must be of type Long"); } Key key = null; if (value != null) { key = KeyFactory.createKey(datastoreEntity.getKind(), (Long) value); } storeKeyPK(key); }
@Override public Object getObject(ExecutionContext ec, ResultSet rs, int[] exprIndex) { Object object = wrappedMapping.getObject(ec, rs, exprIndex); ElementContainerHandler containerHandler = ec.getTypeManager().getContainerHandler(mmd.getType()); return containerHandler.newContainer(mmd, object); }
private void storePKNameField(int fieldNumber, String value) { // TODO(maxr) make sure the pk is an encoded string AbstractMemberMetaData mmd = getMetaData(fieldNumber); if (!mmd.getType().equals(String.class)) { throw new NucleusFatalUserException( "Field with \"" + DatastoreManager.PK_ID + "\" extension must be of type String"); } Key key = null; if (value != null) { key = KeyFactory.createKey(datastoreEntity.getParent(), datastoreEntity.getKind(), value); } storeKeyPK(key); }