@Nullable protected Class getEffectiveResultClass() { if (resultClass == null) { return null; } if (Entity.class.isAssignableFrom(resultClass)) { return metadata.getExtendedEntities().getEffectiveClass(resultClass); } return resultClass; }
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param originalClass original entity * @return extended or original entity */ public Class getEffectiveClass(Class originalClass) { return getEffectiveClass(metadata.getSession().getClassNN(originalClass)); }
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param originalMetaClass original entity * @return extended or original entity */ public MetaClass getEffectiveMetaClass(MetaClass originalMetaClass) { if (originalMetaClass instanceof KeyValueMetaClass) return originalMetaClass; return metadata.getSession().getClassNN(getEffectiveClass(originalMetaClass)); }
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param entityName original entity * @return extended or original entity */ public Class getEffectiveClass(String entityName) { return getEffectiveClass(metadata.getSession().getClassNN(entityName)); }
/** * Searches for an extended entity and returns it if found, otherwise returns the original entity. * * @param originalClass original entity * @return extended or original entity */ public MetaClass getEffectiveMetaClass(Class originalClass) { return metadata.getSession().getClassNN(getEffectiveClass(originalClass)); }
protected <T> T __create(Class<T> entityClass) { @SuppressWarnings("unchecked") Class<T> extClass = extendedEntities.getEffectiveClass(entityClass); try { T obj = extClass.newInstance(); assignIdentifier((Entity) obj); assignUuid((Entity) obj); createEmbedded((Entity) obj); invokePostConstructMethods((Entity) obj); return obj; } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) { throw new RuntimeException("Unable to create entity instance", e); } }
@SuppressWarnings("unchecked") @Override public <T extends Entity<K>, K> T getReference(Class<T> clazz, K id) { Class<T> effectiveClass = metadata.getExtendedEntities().getEffectiveClass(clazz); T reference = delegate.getReference(effectiveClass, getRealId(id)); BaseEntityInternalAccess.setNew((BaseGenericIdEntity) reference, false); return reference; }
protected <E extends Entity> void initializeNestedEntity(E entity, Nested container) { InstanceContainer masterContainer = container.getMaster(); String property = container.getProperty(); MetaClass masterMetaClass = masterContainer.getEntityMetaClass(); MetaProperty metaProperty = masterMetaClass.getPropertyNN(property); MetaProperty inverseProp = metaProperty.getInverse(); if (inverseProp != null) { Class<?> inversePropClass = extendedEntities.getEffectiveClass(inverseProp.getDomain()); Class<?> containerEntityClass = extendedEntities.getEffectiveClass(((CollectionContainer) container).getEntityMetaClass()); if (inversePropClass.isAssignableFrom(containerEntityClass)) { entity.setValue(inverseProp.getName(), masterContainer.getItem()); } } }
@SuppressWarnings("unchecked") protected <E extends Entity> void excludeItems(RemoveBuilder<E> builder, List<E> selectedItems) { CollectionContainer<E> container = getCollectionContainer(builder); if (!(container instanceof Nested)) { throw new IllegalArgumentException("Exclude action supports only Nested containers"); } InstanceContainer masterDc = ((Nested) container).getMaster(); String property = ((Nested) container).getProperty(); Entity masterItem = masterDc.getItem(); MetaProperty metaProperty = masterItem.getMetaClass().getPropertyNN(property); MetaProperty inverseMetaProperty = metaProperty.getInverse(); if (inverseMetaProperty != null && !inverseMetaProperty.getRange().getCardinality().isMany()) { Class inversePropClass = extendedEntities.getEffectiveClass(inverseMetaProperty.getDomain()); Class dcClass = extendedEntities.getEffectiveClass(container.getEntityMetaClass()); if (inversePropClass.isAssignableFrom(dcClass)) { // update reference for One-To-Many for (Entity item : selectedItems) { item.setValue(inverseMetaProperty.getName(), null); } } } container.getMutableItems().removeAll(selectedItems); focusListComponent(builder); }
" by EclipseLink: " + resultClass); Class effectiveClass = metadata.getExtendedEntities().getEffectiveClass(resultClass); query = (JpaQuery) emDelegate.createNativeQuery(queryString, effectiveClass);
&& !inverseMetaProperty.getRange().getCardinality().isMany()) { Class<?> inversePropClass = extendedEntities.getEffectiveClass(inverseMetaProperty.getDomain()); Class<?> dcClass = extendedEntities.getEffectiveClass(collectionDc.getEntityMetaClass());
protected void initEntityTypeField() { final ExtendedEntities extendedEntities = metadata.getExtendedEntities(); Map<String, MetaClass> options = new TreeMap<>();//the map sorts meta classes by the string key for (MetaClass metaClass : metadata.getTools().getAllPersistentMetaClasses()) { if (metadata.getTools().hasCompositePrimaryKey(metaClass) && !HasUuid.class.isAssignableFrom(metaClass.getJavaClass())) { continue; } options.put(messageTools.getDetailedEntityCaption(metaClass), metaClass); } entityType.setOptionsMap(options); if (category.getEntityType() != null) { entityType.setValue(extendedEntities.getEffectiveMetaClass( extendedEntities.getEffectiveClass(category.getEntityType()))); } entityType.addValueChangeListener(e -> { MetaClass metaClass = (MetaClass) e.getValue(); MetaClass originalClass = extendedEntities.getOriginalMetaClass(metaClass); category.setEntityType(originalClass == null ? metaClass.getName() : originalClass.getName()); }); }
ExtendedEntities extendedEntities = metadata.getExtendedEntities(); Class inversePropClass = extendedEntities.getEffectiveClass(inverseProp.getDomain()); Class dsClass = extendedEntities.getEffectiveClass(ds.getMetaClass()); if (inversePropClass.isAssignableFrom(dsClass)) { for (Entity item : selected) {
MetaClass effectiveMetaClass = session.getClass(extendedEntities.getEffectiveClass(metaClass)); Class effectiveDomainClass = extendedEntities.getEffectiveClass(metaProperty.getDomain()); MetaClass effectiveDomainMeta = session.getClass(effectiveDomainClass); if (metaProperty.getDomain() != effectiveDomainMeta) { Class effectiveRangeClass = extendedEntities.getEffectiveClass(range.asClass()); MetaClass effectiveRangeMeta = session.getClass(effectiveRangeClass); if (effectiveRangeMeta != range.asClass()) {
Class inversePropClass = extendedEntities.getEffectiveClass(inverseProp.getDomain()); Class dsClass = extendedEntities.getEffectiveClass(ds.getMetaClass());
Class effectiveClass = metadata.getExtendedEntities().getEffectiveClass(entityName); MetaClass effectiveMetaClass = metadata.getClassNN(effectiveClass); String effectiveEntityName = effectiveMetaClass.getName();
protected boolean canUpdateMasterRefs() { MetaPropertyPath mpp = getMaster().getMetaClass().getPropertyPath(metaPropertyPath.toPathString()); if (mpp == null) { return false; } if (!mpp.getMetaProperty().getRange().getCardinality().isMany()) { return false; } MetaProperty inverseProperty = mpp.getMetaProperty().getInverse(); if (inverseProperty == null || inverseProperty.getType() != MetaProperty.Type.ASSOCIATION || inverseProperty.getRange().getCardinality().isMany()) { return false; } ExtendedEntities extendedEntities = metadata.getExtendedEntities(); Class invPropEntityClass = extendedEntities.getEffectiveClass(inverseProperty.getDomain()); Class datasourceEntityClass = datasource.getMetaClass().getJavaClass(); //noinspection unchecked return invPropEntityClass.isAssignableFrom(datasourceEntityClass); }
ExtendedEntities extendedEntities = metadata.getExtendedEntities(); Class inversePropClass = extendedEntities.getEffectiveClass(inverseProp.getDomain()); Class dsClass = extendedEntities.getEffectiveClass(datasource.getMetaClass()); if (inversePropClass.isAssignableFrom(dsClass)) { item.setValue(inverseProp.getName(), masterDs.getItem());