How to use

getMappedClass

method

in

org.hibernate.metadata.ClassMetadata

protected void populateCaches(String targetMode, Map<String, Object> managerMap) {
  final EntityManager em = getEntityManager(managerMap);
  final PlatformTransactionManager txManager = getTransactionManager(managerMap);
  final EJB3ConfigurationDao ejb3ConfigurationDao = getEJB3ConfigurationDao(managerMap);
  SessionFactory sessionFactory = em.unwrap(Session.class).getSessionFactory();
  for (Object item : sessionFactory.getAllClassMetadata().values()) {
    ClassMetadata metadata = (ClassMetadata) item;
    Class<?> mappedClass = metadata.getMappedClass();
    String managerCacheKey = buildManagerCacheKey(targetMode, mappedClass);
    ENTITY_MANAGER_CACHE.put(managerCacheKey, em);
    TRANSACTION_MANAGER_CACHE.put(managerCacheKey, txManager);
    String ejb3ConfigDaoCacheKey = buildEJB3ConfigDaoCacheKey(mappedClass);
    if (!EJB3_CONFIG_DAO_CACHE.containsKey(ejb3ConfigDaoCacheKey)) {
      EJB3_CONFIG_DAO_CACHE.put(ejb3ConfigDaoCacheKey, ejb3ConfigurationDao);
    }
  }
}

for (Object item : sessionFactory.getAllClassMetadata().values()) {
  ClassMetadata metadata = (ClassMetadata) item;
  Class<?> mappedClass = metadata.getMappedClass();
  if (mappedClass != null && ceilingClass.isAssignableFrom(mappedClass)) {
    entities.add(mappedClass);

ClassMetadata metadata = (ClassMetadata) item;
String idProperty = metadata.getIdentifierPropertyName();
Class<?> mappedClass = metadata.getMappedClass();
Field idField;
try {

public MetamodelUtilFromSessionFactory(SessionFactory factory)
{
 // Go through all the entities 
 for (String entityClassName: factory.getAllClassMetadata().keySet())
 {
   ClassMetadata entityData = factory.getClassMetadata(entityClassName);
   classToEntityName.put(entityData.getMappedClass(), entityData.getEntityName());
   classNameToEntityName.put(entityClassName, entityData.getEntityName());
   //System.out.println(entityClassName + " " + entityData.getMappedClass().getCanonicalName() + " " + entityData.getEntityName());
   // TODO: It turns out all three values are the same, but I think it's ok for now.
      scanClassMetadata(entityData);
 }
}

Class<?> entityClass = classMetadata.getMappedClass();
if (Order.class.equals(entityClass)) {

private void scanClassMetadata(ClassMetadata meta)
{
 Class<?> entityClass = meta.getMappedClass();
 String[] names = meta.getPropertyNames();
 Type[] types = meta.getPropertyTypes();
 for (int n = 0; n < names.length; n++)
 {
   String fieldName = names[n];
   Type type = types[n];
   registerEntityField(entityClass, fieldName, type);
 }
 if (meta.getIdentifierPropertyName() != null)
   registerEntityField(entityClass, meta.getIdentifierPropertyName(), meta.getIdentifierType());
 
 //System.out.println(names + " " + types);
}

@Override
public Class getMappedClass() {
  return metadata.getMappedClass();
}

public Class<?> getJavaClass() {
  return metadata.getMappedClass();
}

private FeatureInvocationHandler(Object o, ClassMetadata meta) {
  //TODO check if this is sufficiently general. What if not a POJO?
  if (meta.getMappedClass(EntityMode.POJO) != o.getClass()) {
    throw new RuntimeException("Metadata and POJO class do not cohere");
  }
  this.target = o;
  this.metadata = meta;
}

@Override
protected Class<?> getClassForName(final String name) throws ClassNotFoundException {
 Collection<ClassMetadata> classes = metadata.values();
 for (ClassMetadata classMetadata : classes) {
  Class<?> mappedClass = classMetadata.getMappedClass();
  if (name.equals(mappedClass.getSimpleName())) {
   return mappedClass;
  }
 }
 return super.getClassForName(name);
}

 public <T> Class<? extends T> findEntityClassForEntityInterface(
  SessionFactory sessionFactory, 
  Class<T> entityInterface
) {
  for (ClassMetadata metadata : sessionFactory.getAllClassMetadata().values()) {
    Class entityClass = metadata.getMappedClass(EntityMode.POJO);
    if (entityInterface.isAssignableFrom(entityClass)) {
      return entityClass;
    }
  }
  return null;
}

@Override
public void populateEntityDictionary(EntityDictionary dictionary) {
  /* bind all entities */
  for (ClassMetadata meta : sessionFactory.getAllClassMetadata().values()) {
    dictionary.bindEntity(meta.getMappedClass(EntityMode.POJO));
  }
}

private ClassMetadata getIndexClassMetadata(String ownerClassName) {
  if (metaDataMap.containsKey(ownerClassName)) {
    return metaDataMap.get(ownerClassName);
  }
  String indexClassName = ownerClassName  + "ContentIndex";
  ClassMetadata meta = sessionFactory.getClassMetadata(indexClassName);
  if (meta != null) {
    Class<?> indexClass = meta.getMappedClass();
    if (ContentIndex.class.isAssignableFrom(indexClass)) {
      Filter filter = indexClass.getAnnotation(Filter.class);
      Assert.isTrue(filter != null && filter.name().equals("contentIndex"),
          String.format("%s must be annotated with @Filter(name=\"contentIndex\")",
          indexClass.getName()));
    }
    else {
      meta = null;
      log.warn("Class {} matches the naming convention for content " +
          "indexes but does not extend ContentIndex.", indexClass);
    }
  }
  metaDataMap.put(ownerClassName, meta);
  return meta;
}

private Method getGetterFor(String property) {
  Class cl = this.metadata.getMappedClass(EntityMode.POJO);
  Getter getter = ReflectHelper.getGetter(cl, property);
  return getter.getMethod();
}

public static void configureHibernateDomainClasses(SessionFactory sessionFactory,
    String sessionFactoryName, GrailsApplication application) {
  Map<String, GrailsDomainClass> hibernateDomainClassMap = new HashMap<String, GrailsDomainClass>();
  for (Object o : sessionFactory.getAllClassMetadata().values()) {
    ClassMetadata classMetadata = (ClassMetadata) o;
    configureDomainClass(sessionFactory, sessionFactoryName, application, classMetadata,
        classMetadata.getMappedClass(EntityMode.POJO),
        hibernateDomainClassMap);
  }
  configureInheritanceMappings(hibernateDomainClassMap);
}

@SuppressWarnings("unchecked")
public void postProcessConfiguration(Configuration config)
    throws IOException, TemplateException {
  
  TemplateHashModel statics = getBeansWrapper(config).getStaticModels();
  Collection<ClassMetadata> allMetadata = sessionFactory.getAllClassMetadata().values();
  for (ClassMetadata meta : allMetadata) {
    Class<?> mappedClass = meta.getMappedClass();
    if (ActiveRecord.class.isAssignableFrom(mappedClass)) {
      String key = ClassUtils.getShortName(mappedClass);
      if (config.getSharedVariable(key) != null) {
        log.warn("Another shared variable with the name '{}'" +
            " already exist. Use statics[\"{}\"] in your" +
            " FreeMarker templates to access the static" +
            " methods of your ActiveRecord class.", 
            key, mappedClass.getName());
      }
      else {
        TemplateModel tm = statics.get(mappedClass.getName());
        config.setSharedVariable(key, tm);
      }
    }
  }
}

@Override
@SuppressWarnings("deprecation")
public Map getAllClassMetadata() throws HibernateException {
  try {
    final Map<Class, ClassMetadata> map = new HashMap<>();
    for (String entityName : getSessionFactoryV5().getMetamodel().getAllEntityNames()) {
      org.hibernate.metadata.ClassMetadata metadata = getSessionFactoryV5().getClassMetadata(entityName);
      map.put(metadata.getMappedClass(), ClassMetadataV2Adapter.adapt(metadata, getSessionFactoryV5(), null));
    }
    return map;
  } catch (final PersistenceException ex) {
    throw HibernateExceptionAdapter.adapt(ex);
  }
}

public static References getReferencingClasses(SessionFactory sessionFactory, Class<?> clazz) {
  References references = new References(); 
  for (Map.Entry<String, ClassMetadata> entry: sessionFactory.getAllClassMetadata().entrySet()) {
    Class<?> mappedClass = entry.getValue().getMappedClass();
    for (String propertyName: entry.getValue().getPropertyNames()) {
      Type t = entry.getValue().getPropertyType(propertyName);
      if (t instanceof EntityType) {
        EntityType entityType=(EntityType) t;
        if (entityType.getAssociatedEntityName().equals(clazz.getName())) {
          references.addEntityReference(propertyName, mappedClass);
        }
      }
      else if (t.isCollectionType()) {
        CollectionType cType = (CollectionType) t;
        QueryableCollection collectionPersister = (QueryableCollection) ((SessionFactoryImplementor) sessionFactory).getCollectionPersister( cType.getRole());
        if (collectionPersister.getElementType().isEntityType() && collectionPersister.getElementPersister().getEntityName().equals(clazz.getName())) {
          references.addCollectionReference(propertyName, mappedClass);
        }
        
      }
    }
  }
  return references;
}

/**
 * Contributes {@link ApplicationStateContribution}s for all registered Hibernate entity classes.
 *
 * @param configuration
 *         Configuration to contribute
 * @param entitySessionStatePersistenceStrategyEnabled
 *         indicates if contribution should take place
 * @param sessionSource
 *         creates Hibernate session
 */
public static void contributeApplicationStateManager(
    MappedConfiguration<Class, ApplicationStateContribution> configuration,
    @Symbol(HibernateSymbols.ENTITY_SESSION_STATE_PERSISTENCE_STRATEGY_ENABLED)
    boolean entitySessionStatePersistenceStrategyEnabled, HibernateSessionSource sessionSource)
{
  if (!entitySessionStatePersistenceStrategyEnabled)
    return;
  for (ClassMetadata classMetadata : sessionSource.getSessionFactory().getAllClassMetadata().values())
  {
    final Class entityClass = classMetadata.getMappedClass();
    configuration.add(entityClass, new ApplicationStateContribution(HibernatePersistenceConstants.ENTITY));
  }
}

@Override
public void destroy() throws HibernateException {
  if (grailsApplication.isWarDeployed()) {
    MetaClassRegistry registry = GroovySystem.getMetaClassRegistry();
    Map<?, ?> classMetaData = getSessionFactory().getAllClassMetadata();
    for (Object o : classMetaData.values()) {
      ClassMetadata classMetadata = (ClassMetadata) o;
      Class<?> mappedClass = classMetadata.getMappedClass(EntityMode.POJO);
      registry.removeMetaClass(mappedClass);
    }
  }
  try {
    super.destroy();
  } catch (HibernateException e) {
    if (e.getCause() instanceof NameNotFoundException) {
      LOG.debug(e.getCause().getMessage(), e);
    }
    else {
      throw e;
    }
  }
}