How to use

getJavaClass

method

in

org.grails.datastore.mapping.model.PersistentEntity

@Override
public boolean equals(Object o) {
  if (o == null || !(o instanceof PersistentEntity)) return false;
  if (this == o) return true;
  PersistentEntity other = (PersistentEntity) o;
  return javaClass.equals(other.getJavaClass());
}

/**
 * Obtains a mapping object for the given domain class nam
 *
 * @param domainClass The domain class in question
 * @return A Mapping object or null
 */
public static Mapping getMapping(PersistentEntity domainClass) {
  return domainClass == null ? null : MAPPING_CACHE.get(domainClass.getJavaClass());
}

@Override
public PropertyWriter getPropertyWriter(String name) {
  final PropertyWriter writer = writerMap.get(name);
  if(writer != null) {
    return writer;
  }
  else {
    throw new IllegalArgumentException("Property ["+name+"] is not a valid property of " + entity.getJavaClass());
  }
}

public TPCacheAdapter<T> getTPCacheAdapter(PersistentEntity entity) {
  if (entity == null) {
    return null;
  }
  return adapters.get(entity.getJavaClass().getName());
}

protected Mapping getRootMapping(PersistentEntity referenced) {
  if (referenced == null) return null;
  Class<?> current = referenced.getJavaClass();
  while (true) {
    Class<?> superClass = current.getSuperclass();
    if (Object.class.equals(superClass)) break;
    current = superClass;
  }
  return getMapping(current);
}

@Override
public FastClass fastClass() {
  if(fastClass == null) {
    fastClass = FastClass.create(entity.getJavaClass());
  }
  return fastClass;
}

protected AbstractPersistentCollection(Serializable associationKey, Session session,
                    AssociationQueryExecutor indexer, Collection collection) {
  this.session = session;
  this.associationKey = associationKey;
  this.indexer = indexer;
  this.collection = collection;
  this.childType = indexer.getIndexedEntity().getJavaClass();
}

public AssociationQueryProxyHandler(Session session, AssociationQueryExecutor executor, Serializable associationKey) {
  super(executor.getIndexedEntity().getJavaClass());
  this.session = session;
  this.executor = executor;
  this.associationKey = associationKey;
}

public Collection getCachedCollection(PersistentEntity entity, Serializable key, String name) {
  if(isStateless(entity)) return null;
  if (key == null || name == null) {
    return null;
  }
  return firstLevelCollectionCache.get(
      new CollectionKey(entity.getJavaClass(), key, name));
}

public Object getCachedEntry(PersistentEntity entity, Serializable key, boolean forDirtyCheck) {
  if(isStateless(entity)) return null;
  if (key == null) {
    return null;
  }
  return getEntryCache(entity.getJavaClass(), forDirtyCheck).get(key);
}

public void cacheCollection(PersistentEntity entity, Serializable key, Collection collection, String name) {
  if(isStateless(entity)) return;
  if (key == null || collection == null || name == null) {
    return;
  }
  firstLevelCollectionCache.put(
      new CollectionKey(entity.getJavaClass(), key, name),
      collection);
}

public void cacheEntry(PersistentEntity entity, Serializable key, Object entry) {
  if(isStateless(entity)) return;
  if (key == null || entry == null) {
    return;
  }
  cacheEntry(key, entry, getEntryCache(entity.getJavaClass(), true), true);
  cacheEntry(key, entry, getEntryCache(entity.getJavaClass(), false), false);
}

@Override
public Object clone() {
  Session session = getSession();
  if(session == null) throw new IllegalStateException("Cannot clone a stateless query");
  Query newQuery = session.createQuery(entity.getJavaClass());
  for (Criterion criterion : criteria.getCriteria()) {
    newQuery.add(criterion);
  }
  return newQuery;
}

protected boolean canApplyNullableConstraint(String propertyName, PersistentProperty property, Constrained constrained) {
  if (property == null || property.getType() == null) return false;
  final PersistentEntity domainClass = property.getOwner();
  // only apply default nullable to Groovy entities not legacy Java ones
  if (!GroovyObject.class.isAssignableFrom(domainClass.getJavaClass())) return false;
  final PersistentProperty versionProperty = domainClass.getVersion();
  final boolean isVersion = versionProperty != null && versionProperty.equals(property);
  return !constrained.hasAppliedConstraint(ConstrainedProperty.NULLABLE_CONSTRAINT) &&
      isConstrainableProperty(property, propertyName) && !isVersion;
}

public static org.hibernate.criterion.DetachedCriteria getHibernateDetachedCriteria(QueryableCriteria<?> queryableCriteria) {
  org.hibernate.criterion.DetachedCriteria detachedCriteria = org.hibernate.criterion.DetachedCriteria.forClass(
     queryableCriteria.getPersistentEntity().getJavaClass());
  populateHibernateDetachedCriteria(detachedCriteria, queryableCriteria);
  return detachedCriteria;
}

public Mapping evaluateMapping(PersistentEntity domainClass, Closure<?> defaultMapping, boolean cache) {
  try {
    final Mapping m = (Mapping) domainClass.getMapping().getMappedForm();
    trackCustomCascadingSaves(m, domainClass.getPersistentProperties());
    if (cache) {
      MAPPING_CACHE.put(domainClass.getJavaClass(), m);
    }
    return m;
  } catch (Exception e) {
    throw new DatastoreConfigurationException("Error evaluating ORM mappings block for domain [" +
        domainClass.getName() + "]:  " + e.getMessage(), e);
  }
}

protected boolean isComponentPropertyNullable(PersistentProperty componentProperty) {
  if (componentProperty == null) return false;
  final PersistentEntity domainClass = componentProperty.getOwner();
  final Mapping mapping = getMapping(domainClass.getJavaClass());
  return !domainClass.isRoot() && (mapping == null || mapping.isTablePerHierarchy()) || componentProperty.isNullable();
}

@Override
public <T, K extends Serializable> T createProxy(Session session, AssociationQueryExecutor<K, T> executor, K associationKey) {
  MethodHandler mi = createMethodHandler(session, executor, associationKey);
  Class proxyClass = getProxyClass(executor.getIndexedEntity().getJavaClass());
  Object proxy = ReflectionUtils.instantiate(proxyClass);
  ((ProxyObject)proxy).setHandler(mi);
  return (T) proxy;
}

@SuppressWarnings("unchecked")
public Object proxy(Serializable key) {
  PersistentEntity entity = getPersistentEntity();
  PersistentProperty identity = entity.getIdentity();
  if(identity != null) {
    key = (Serializable) mappingContext.getConversionService().convert(key, identity.getType());
  }
  return getProxyFactory().createProxy(session, entity.getJavaClass(), key);
}

@Override
public List query(Object primaryKey) {
  Association inverseSide = association.getInverseSide();
  Query query = session.createQuery(association.getAssociatedEntity().getJavaClass());
  query.eq(inverseSide.getName(), primaryKey);
  query.projections().id();
  return query.list();
}