Example usage for javax.persistence.metamodel Metamodel managedType

Introduction

In this page you can find the example usage for javax.persistence.metamodel Metamodel managedType.

Prototype

<X> ManagedType<X> managedType(Class<X> cls);

Source Link

Document

Return the metamodel managed type representing the entity, mapped superclass, or embeddable class.

Usage

From source file:de.micromata.genome.jpa.metainf.MetaInfoUtils.java

/**
 * Gets the column meta data./*from  w  ww. j  av a 2  s. c o m*/
 *
 * @param emgrFac the emgr fac
 * @param entity the entity
 * @return the column meta data
 */
public static EntityMetadata getColumnMetaData(EmgrFactory<?> emgrFac, Class<?> entity) {
    EntityMetadataBean ret = new EntityMetadataBean();

    Metamodel metamodel = emgrFac.getEntityManagerFactory().getMetamodel();
    ManagedType<?> mt = metamodel.managedType(entity);
    return toEntityMetaData(mt);
}

---

From source file:cz.datalite.dao.support.JpaMetamodelEntityInformation.java

/**
 * Creates a new {@link JpaMetamodelEntityInformation} for the given domain class and {@link javax.persistence.metamodel.Metamodel}.
 *
 * @param domainClass must not be {@literal null}.
 * @param metamodel must not be {@literal null}.
 *///from w w w. j a  v  a 2s  .  c  om
public JpaMetamodelEntityInformation(Class<T> domainClass, Metamodel metamodel) {

    super(domainClass);

    assert (metamodel != null);
    ManagedType<T> type = metamodel.managedType(domainClass);

    if (type == null) {
        throw new IllegalArgumentException("The given domain class can not be found in the given Metamodel!");
    }

    if (!(type instanceof IdentifiableType)) {
        throw new IllegalArgumentException("The given domain class does not contain an id attribute!");
    }

    this.idMetadata = new IdMetadata<T>((IdentifiableType<T>) type);
    this.versionAttribute = findVersionAttribute(type);
}

---

From source file:org.broadleafcommerce.openadmin.server.service.persistence.module.criteria.FieldPathBuilder.java

@SuppressWarnings({ "rawtypes", "unchecked", "serial" })
public Path getPath(From root, FieldPath fieldPath, final CriteriaBuilder builder) {
    FieldPath myFieldPath = fieldPath;//  w  w w .j  av a  2s . c o m
    if (!StringUtils.isEmpty(fieldPath.getTargetProperty())) {
        myFieldPath = getFieldPath(root, fieldPath.getTargetProperty());
    }
    From myRoot = root;
    for (String pathElement : myFieldPath.getAssociationPath()) {
        myRoot = myRoot.join(pathElement);
    }
    Path path = myRoot;

    for (int i = 0; i < myFieldPath.getTargetPropertyPieces().size(); i++) {
        String piece = myFieldPath.getTargetPropertyPieces().get(i);

        if (path.getJavaType().isAnnotationPresent(Embeddable.class)) {
            String original = ((SingularAttributePath) path).getAttribute().getDeclaringType().getJavaType()
                    .getName() + "." + ((SingularAttributePath) path).getAttribute().getName() + "." + piece;
            String copy = path.getJavaType().getName() + "." + piece;
            copyCollectionPersister(original, copy,
                    ((CriteriaBuilderImpl) builder).getEntityManagerFactory().getSessionFactory());
        }

        try {
            path = path.get(piece);
        } catch (IllegalArgumentException e) {
            // We weren't able to resolve the requested piece, likely because it's in a polymoprhic version
            // of the path we're currently on. Let's see if there's any polymoprhic version of our class to
            // use instead.
            EntityManagerFactoryImpl em = ((CriteriaBuilderImpl) builder).getEntityManagerFactory();
            Metamodel mm = em.getMetamodel();
            boolean found = false;

            Class<?>[] polyClasses = dynamicDaoHelper.getAllPolymorphicEntitiesFromCeiling(path.getJavaType(),
                    em.getSessionFactory(), true, true);

            for (Class<?> clazz : polyClasses) {
                ManagedType mt = mm.managedType(clazz);
                try {
                    Attribute attr = mt.getAttribute(piece);
                    if (attr != null) {
                        Root additionalRoot = criteria.from(clazz);
                        restrictions.add(builder.equal(path, additionalRoot));
                        path = additionalRoot.get(piece);
                        found = true;
                        break;
                    }
                } catch (IllegalArgumentException e2) {
                    // Do nothing - we'll try the next class and see if it has the attribute
                }
            }

            if (!found) {
                throw new IllegalArgumentException(
                        "Could not resolve requested attribute against path, including"
                                + " known polymorphic versions of the root",
                        e);
            }
        }

        if (path.getParentPath() != null
                && path.getParentPath().getJavaType().isAnnotationPresent(Embeddable.class)
                && path instanceof PluralAttributePath) {
            //We need a workaround for this problem until it is resolved in Hibernate (loosely related to and likely resolved by https://hibernate.atlassian.net/browse/HHH-8802)
            //We'll throw a specialized exception (and handle in an alternate flow for calls from BasicPersistenceModule)
            throw new CriteriaConversionException(String.format(
                    "Unable to create a JPA criteria Path through an @Embeddable object to a collection that resides therein (%s)",
                    fieldPath.getTargetProperty()), fieldPath);
            //                //TODO this code should work, but there still appear to be bugs in Hibernate's JPA criteria handling for lists
            //                //inside Embeddables
            //                Class<?> myClass = ((PluralAttributePath) path).getAttribute().getClass().getInterfaces()[0];
            //                //we don't know which version of "join" to call, so we'll let reflection figure it out
            //                try {
            //                    From embeddedJoin = myRoot.join(((SingularAttributePath) path.getParentPath()).getAttribute());
            //                    Method join = embeddedJoin.getClass().getMethod("join", myClass);
            //                    path = (Path) join.invoke(embeddedJoin, ((PluralAttributePath) path).getAttribute());
            //                } catch (Exception e) {
            //                    throw new RuntimeException(e);
            //                }
        }
    }

    return path;
}

---