How to use

getManagedType

method

in

com.blazebit.persistence.parser.EntityMetamodel

@Override
public ParameterValueTransformer getToEntityTranformer(Class<?> entityType) {
  IdentifiableType<?> managedType = (IdentifiableType<?>) metamodel.getManagedType(entityType);
  Attribute<?, ?> idAttribute = JpaMetamodelUtils.getSingleIdAttribute(managedType);
  return AssociationFromIdParameterTransformer.getInstance(entityType, idAttribute);
}

private Class<?> getCorrelationBasisEntityType(Class<?> entityClazz) {
  EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel();
  ManagedType<?> managedType = entityMetamodel.getManagedType(entityClazz);
  // Return the class if it is identifiable, otherwise return null. When null, it will use fromIdentifiableValues in correlation builders to correlate values
  if (JpaMetamodelUtils.isIdentifiable(managedType)) {
    return entityClazz;
  }
  return null;
}

protected Set<Type<?>> determinePersistSubtypeSet(Type<?> superType, Set<ManagedViewTypeImplementor<?>> subtypes1, Set<ManagedViewTypeImplementor<?>> subtypes2, MetamodelBuildingContext context) {
  Class<?> superTypeClass = superType.getJavaType();
  Set<Type<?>> set = new HashSet<>(subtypes1.size() + subtypes2.size());
  if (superType.getMappingType() == Type.MappingType.BASIC && context.getEntityMetamodel().getManagedType(superType.getJavaType()) != null
      || superType.getMappingType() != Type.MappingType.BASIC && ((ManagedViewType<?>) superType).isCreatable()) {
    set.add(superType);
  }
  addToPersistSubtypeSet(set, superTypeClass, subtypes1, context, false);
  addToPersistSubtypeSet(set, superTypeClass, subtypes2, context, true);
  return Collections.unmodifiableSet(set);
}

private String getIdAttribute(Class<?> entityClass) {
  return cbf.getService(EntityMetamodel.class)
      .getManagedType(ExtendedManagedType.class, entityClass)
      .getIdAttribute()
      .getName();
}

public static Map<String, ExtendedAttribute<?, ?>> getCollectionAttributeEntries(EntityMetamodel metamodel, EntityType<?> entityType, ExtendedAttribute<?, ?> attribute) {
  Map<String, ExtendedAttribute<?, ?>> collectionAttributeEntries = new HashMap<>();
  JoinTable joinTable = attribute.getJoinTable();
  if (joinTable == null) {
    throw new IllegalArgumentException("No support for inserting into inverse collection via DML API yet!");
  }
  ExtendedManagedType<?> extendedManagedType = metamodel.getManagedType(ExtendedManagedType.class, entityType);
  for (String idAttributeName : joinTable.getIdAttributeNames()) {
    collectionAttributeEntries.put(idAttributeName, extendedManagedType.getAttribute(idAttributeName));
  }
  if (((PluralAttribute<?, ?, ?>) attribute.getAttribute()).getElementType() instanceof ManagedType<?>) {
    String prefix = attribute.getAttributePathString() + ".";
    for (Map.Entry<String, ? extends ExtendedAttribute<?, ?>> entry : extendedManagedType.getAttributes().entrySet()) {
      if (entry.getKey().startsWith(prefix)) {
        collectionAttributeEntries.put(entry.getKey(), entry.getValue());
      }
    }
  }
  collectionAttributeEntries.put(attribute.getAttributePathString(), attribute);
  return collectionAttributeEntries;
}

private String getIdAttribute(Class<?> entityClass) {
  return cbf.getService(EntityMetamodel.class)
      .getManagedType(ExtendedManagedType.class, entityClass)
      .getIdAttribute()
      .getName();
}

ManagedType<?> t = metamodel.getManagedType(parameterType);
fields[i] = new Field[accessPath.size()];
getters[i] = new Method[accessPath.size()];
    throw new IllegalArgumentException("Unsupported attribute member type [" + member + "] for attribute [" + attribute.getName() + "] of class [" + t.getJavaType().getName() + "]");
  t = metamodel.getManagedType(JpaMetamodelUtils.resolveFieldClass(t.getJavaType(), attribute));

private String getMapping(String prefixParts, String mapping, Class<?> expressionType) {
  if (expressionType == null) {
    return getMapping(prefixParts, mapping);
  }
  ManagedType<?> managedType = metamodel.getManagedType(expressionType);
  Set<SingularAttribute<?, ?>> idAttributes;
  if (managedType == null || !JpaMetamodelUtils.isIdentifiable(managedType) || (idAttributes = JpaMetamodelUtils.getIdAttributes((IdentifiableType<?>) managedType)).size() > 1) {
    return getMapping(prefixParts, mapping);
  }
  javax.persistence.metamodel.SingularAttribute<?, ?> idAttr = idAttributes.iterator().next();
  if (mapping.isEmpty()) {
    return getMapping(prefixParts, idAttr.getName());
  } else {
    return getMapping(prefixParts, mapping + '.' + idAttr.getName());
  }
}

public UnmappedBasicAttributeCascadeDeleter(EntityViewManagerImpl evm, String attributeName, ExtendedAttribute<?, ?> attribute, String ownerIdAttributeName, boolean disallowCycle) {
  super(evm, attributeName, attribute);
  EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel();
  ExtendedManagedType extendedManagedType = entityMetamodel.getManagedType(ExtendedManagedType.class, elementEntityClass);
  EntityType<?> entityType = (EntityType<?>) extendedManagedType.getType();
  this.requiresDeleteCascadeAfterRemove = !attribute.isForeignJoinColumn();

t = metamodel.getManagedType(JpaMetamodelUtils.resolveFieldClass(t.getJavaType(), jpaAttribute));
if (jpaAttribute instanceof PluralAttribute<?, ?, ?>) {
  paths.add(sb.toString());

  return false;
ExtendedManagedType<?> managedType = evm.getMetamodel().getEntityMetamodel().getManagedType(ExtendedManagedType.class, managedTypeClass);
ExtendedManagedType<?> correlationBasisManagedType = evm.getMetamodel().getEntityMetamodel().getManagedType(ExtendedManagedType.class, correlationBasisEntity);

public static List<UnmappedAttributeCascadeDeleter> createUnmappedCascadeDeleters(EntityViewManagerImpl evm, Class<?> entityClass, String ownerIdAttributeName) {
  EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel();
  ExtendedManagedType<?> extendedManagedType = entityMetamodel.getManagedType(ExtendedManagedType.class, entityClass);
  Map<String, ? extends ExtendedAttribute<?, ?>> attributes = extendedManagedType.getOwnedAttributes();
  List<UnmappedAttributeCascadeDeleter> deleters = new ArrayList<>(attributes.size());

ExtendedAttribute<?, ?> extendedAttribute = (ExtendedAttribute<?, ?>) metamodel.getManagedType(ExtendedManagedType.class, ownerType).getAttributes().get(fieldPrefix + attributeName);
if (extendedAttribute != null && StringUtils.isEmpty(extendedAttribute.getMappedBy())) {
  ExtendedManagedType<?> managedType = metamodel.getManagedType(ExtendedManagedType.class, (ManagedType<?>) singularAttribute.getType());
  for (String attrName : attributeNames) {
    addAttributes(ownerType, elementCollectionPath, fieldPrefix, newPrefix, (SingularAttribute<?, ?>) managedType.getAttributes().get(attrName).getAttribute(), orderedAttributes);

public AbstractUnmappedAttributeCascadeDeleter(EntityViewManagerImpl evm, String attributeName, ExtendedAttribute<?, ?> attribute) {
  EntityMetamodel entityMetamodel = evm.getMetamodel().getEntityMetamodel();
  this.elementEntityClass = attribute.getElementClass();
  this.attributeName = attributeName;
  if (entityMetamodel.getEntity(elementEntityClass) == null) {
    this.elementIdAttributeName = null;
    this.attributeValuePath = attributeName;
    this.cascadeDeleteElement = false;
  } else {
    ExtendedManagedType extendedManagedType = entityMetamodel.getManagedType(ExtendedManagedType.class, elementEntityClass);
    this.elementIdAttributeName = extendedManagedType.getIdAttribute().getName();
    this.attributeValuePath = attributeName + "." + elementIdAttributeName;
    this.cascadeDeleteElement = attribute.isDeleteCascaded();
  }
}

ExtendedManagedType<?> extendedManagedType = m.getManagedType(ExtendedManagedType.class, entityType);
Set<String> attributePaths;
if (rootNode.getValuesIdNames() != null && !rootNode.getValuesIdNames().isEmpty()) {

public AbstractMethodListAttribute(ManagedViewTypeImplementor<X> viewType, MethodAttributeMapping mapping, MetamodelBuildingContext context, int attributeIndex, int dirtyStateIndex, EmbeddableOwner embeddableMapping) {
  super(viewType, mapping, context, attributeIndex, dirtyStateIndex, embeddableMapping);
  this.isIndexed = mapping.determineIndexed(context, context.getEntityMetamodel().getManagedType(viewType.getEntityClass()));
  this.collectionInstantiator = createCollectionInstantiator(context, createCollectionFactory(context), isIndexed(), isSorted(), isOrdered(), getComparator());
}

public AbstractParameterListAttribute(MappingConstructorImpl<X> mappingConstructor, ParameterAttributeMapping mapping, MetamodelBuildingContext context, EmbeddableOwner embeddableMapping) {
  super(mappingConstructor, mapping, context, embeddableMapping);
  this.isIndexed = mapping.determineIndexed(context, context.getEntityMetamodel().getManagedType(mappingConstructor.getDeclaringType().getEntityClass()));
  this.collectionInstantiator = createCollectionInstantiator(context, null, isIndexed(), isSorted(), isOrdered(), getComparator());
}

ExtendedManagedType extendedManagedType = metamodel.getManagedType(ExtendedManagedType.class, JpaMetamodelUtils.getTypeName(managedType));
Attribute<?, ?> attr = extendedManagedType.getAttribute(expr.getField()).getAttribute();

protected boolean determineForcedUnique(MetamodelBuildingContext context) {
  if (isCollection() && getMapping() != null && getMapping().indexOf('.') == -1) {
    ExtendedManagedType<?> managedType = context.getEntityMetamodel().getManagedType(ExtendedManagedType.class, getDeclaringType().getJpaManagedType());
    ExtendedAttribute<?, ?> attribute = managedType.getOwnedAttributes().get(getMapping());
    if (attribute != null && attribute.getAttribute() instanceof javax.persistence.metamodel.PluralAttribute<?, ?, ?>) {
      // TODO: we should add that information to ExtendedAttribute
      return (((javax.persistence.metamodel.PluralAttribute<?, ?, ?>) attribute.getAttribute()).getCollectionType() != javax.persistence.metamodel.PluralAttribute.CollectionType.MAP)
          && (!StringUtils.isEmpty(attribute.getMappedBy()) || !attribute.isBag())
          && (attribute.getJoinTable() == null || attribute.getJoinTable().getKeyColumnMappings() == null)
          && !MetamodelUtils.isIndexedList(context.getEntityMetamodel(), context.getExpressionFactory(), managedType.getType().getJavaType(), getMapping());
    }
  }
  return false;
}

ExtendedManagedType<?> managedType = metamodel.getManagedType(ExtendedManagedType.class, baseNode.getJavaType());
attr = managedType.getAttribute(pathReference.getField()).getAttribute();