How to use

PersistentEntity

in

org.grails.datastore.mapping.model

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 void validatePropertyName(String propertyName, String methodName) {
  if (persistentEntity == null) return;
  if (propertyName == null) {
    throw new IllegalArgumentException("Cannot use [" + methodName +
        "] restriction with null property name");
  }
  PersistentProperty property = persistentEntity.getPropertyByName(propertyName);
  if (property == null && persistentEntity.getIdentity().getName().equals(propertyName)) {
    property = persistentEntity.getIdentity();
  }
  if (property == null && !queryCreator.isSchemaless()) {
    throw new IllegalArgumentException("Property [" + propertyName +
        "] is not a valid property of class [" + persistentEntity + "]");
  }
}

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;
}

  @Override
  public void convertArguments(PersistentEntity persistentEntity) {
    ConversionService conversionService = persistentEntity
        .getMappingContext().getConversionService();
    String propertyName = this.propertyName;
    PersistentProperty<?> prop = persistentEntity
        .getPropertyByName(propertyName);
    Object[] arguments = this.arguments;
    convertArgumentsForProp(persistentEntity, prop, propertyName, arguments, conversionService);
  }
}

protected void initializeJoinStatus() {
  Boolean cachedStatus = JOIN_STATUS_CACHE.get(entity.getName());
  if(cachedStatus != null) hasJoins = cachedStatus;
  else {
    for(Association a : entity.getAssociations()) {
      if( a.getFetchStrategy() == FetchType.EAGER ) hasJoins = true;
    }
  }
}

protected void storeDateCreatedAndLastUpdatedInfo(PersistentEntity persistentEntity) {
  if(persistentEntity.isInitialized()) {
    ClassMapping<?> classMapping = persistentEntity.getMapping();
    Entity mappedForm = classMapping.getMappedForm();
    if(mappedForm == null || mappedForm.isAutoTimestamp()) {
      storeTimestampAvailability(entitiesWithDateCreated, persistentEntity, persistentEntity.getPropertyByName(DATE_CREATED_PROPERTY));
      storeTimestampAvailability(entitiesWithLastUpdated, persistentEntity, persistentEntity.getPropertyByName(LAST_UPDATED_PROPERTY));
    }
  }
  else {
    uninitializedEntities.add(persistentEntity.getName());
  }
}

/**
 * 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());
}

public FieldEntityReflector(PersistentEntity entity) {
  this.entity = entity;
  PersistentProperty identity = entity.getIdentity();
  dirtyCheckingStateField = ReflectionUtils.findField(entity.getJavaClass(), getTraitFieldName(DirtyCheckable.class, "$changedProperties"));
  if(dirtyCheckingStateField != null) {
    ReflectionUtils.makeAccessible(dirtyCheckingStateField);
  ClassPropertyFetcher cpf = ClassPropertyFetcher.forClass(entity.getJavaClass());
  if(identity != null) {
    String identityName = identity.getName();
  PersistentProperty[] composite = entity.getCompositeIdentity();
  if(composite != null) {
    for (PersistentProperty property : composite) {
  List<PersistentProperty> properties = entity.getPersistentProperties();
  readers = new PropertyReader[properties.size()];
  writers = new PropertyWriter[properties.size()];

final List<PersistentProperty> properties = domainClass.getPersistentProperties();
Table table = component.getOwner().getTable();
PersistentClass persistentClass = component.getOwner();
String path = property.getName();
Class<?> propertyType = property.getOwner().getJavaClass();
  if (currentGrailsProp.equals(domainClass.getIdentity())) continue;
  if (currentGrailsProp.getName().equals(GormProperties.VERSION)) continue;

public void convertArguments(PersistentEntity persistentEntity) {
  ConversionService conversionService = persistentEntity
      .getMappingContext().getConversionService();
  PersistentProperty<?> prop = persistentEntity
      .getPropertyByName(propertyName);
  if (prop == null) {
    if (propertyName.equals(persistentEntity.getIdentity().getName())) {
      prop = persistentEntity.getIdentity();

final NativeEntryModifyingEntityAccess entityAccess = (NativeEntryModifyingEntityAccess) createEntityAccess(persistentEntity, obj, tmp);
K k = readObjectIdentifier(entityAccess, persistentEntity.getMapping());
entityAccess.setNativeEntry(e);
final List<PersistentProperty> props = persistentEntity.getPersistentProperties();
final Map<Association, List<Serializable>> toManyKeys = new HashMap<Association, List<Serializable>>();
final Map<OneToMany, Serializable> inverseCollectionUpdates = new HashMap<OneToMany, Serializable>();
              Class associationType = associatedEntity.getJavaClass();
              persistentCollection = getPersistentCollection(associatedObjects, associationType);
              entityAccess.setPropertyNoConversion(oneToMany.getName(), persistentCollection);

Object resolvePropertyValue(PersistentEntity entity, String property, Object value) {
  PersistentProperty persistentProperty = entity.getPropertyByName(property);
  Object resolved;
  if(persistentProperty instanceof Embedded) {
    resolved = value;
  }
  else {
    resolved = resolveIdIfEntity(value);
  }
  return resolved;
}

@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);
}

if(entity.isMultiTenant()) {
  if(datastore == null) {
    datastore = GormEnhancer.findDatastore(entity.getJavaClass());
    TenantId tenantId = entity.getTenantId();
    if(tenantId != null) {
      Serializable currentId;
AbstractPersistenceEvent preInsertEvent = (AbstractPersistenceEvent) event;
PersistentEntity entity = preInsertEvent.getEntity();
if(entity.isMultiTenant()) {
  TenantId tenantId = entity.getTenantId();
  if(datastore == null) {
    datastore = GormEnhancer.findDatastore(entity.getJavaClass());

  private static void convertArgumentsForProp(PersistentEntity persistentEntity, PersistentProperty<?> prop, String propertyName, Object[] arguments, ConversionService conversionService) {
    if (prop == null) {
      if (propertyName.equals(persistentEntity.getIdentity().getName())) {
        prop = persistentEntity.getIdentity();
      }
    }
    if (prop != null) {
      Class<?> type = prop.getType();
      Collection<?> collection = (Collection<?>) arguments[0];
      List<Object> converted;
      if(collection == null) {
        converted = Collections.emptyList();
      }
      else {
        converted = new ArrayList<>(collection.size());
        for (Object o : collection) {
          if (o != null && !type.isAssignableFrom(o.getClass())) {
            o = conversionService.convert(o, type);
          }
          converted.add(o);
        }
      }
      arguments[0] = converted;
    }
  }
}

if(entity != null) {
  properties = entity.getPersistentProperties();
  if (properties != null) {
      PersistentProperty version = entity.getVersion();
      if (canPropertyBeConstrained(p) && !p.equals(version)) {
        if (mappedForm.isDerived()) {
          ConstrainedProperty cp = constrainedProperties.get(propertyName);
          if (cp == null) {
            DefaultConstrainedProperty constrainedProperty = new DefaultConstrainedProperty(entity.getJavaClass(), propertyName, p.getType(), constraintRegistry);
            cp = constrainedProperty;
            constrainedProperty.setOrder(constrainedProperties.size() + 1);

public NativeEntryEntityPersister(MappingContext mappingContext, PersistentEntity entity,
     Session session, ApplicationEventPublisher publisher) {
  super(mappingContext, entity, session, publisher);
  classMapping = entity.getMapping();
}

    throw new DatastoreConfigurationException("Default sort for associations ["+property.getOwner().getName()+"->" + property.getName() +
        "] are not supported with unidirectional one to many relationships.");
    PersistentProperty propertyToSortBy = referenced.getPropertyByName(propConfig.getSort());
    String associatedClassName = property.getAssociatedEntity().getName();
  boolean tablePerSubclass = m != null && !m.getTablePerHierarchy();
  if (referenced != null && !referenced.isRoot() && !tablePerSubclass) {
    Mapping rootMapping = getRootMapping(referenced);
    String discriminatorColumnName = RootClass.DEFAULT_DISCRIMINATOR_COLUMN_NAME;
if(referenced != null && referenced.isMultiTenant()) {
  String filterCondition = getMultiTenantFilterCondition(sessionFactoryBeanName, referenced);
  if(filterCondition != null) {
      LOG.debug("[GrailsDomainBinder] Mapping other side " + otherSide.getOwner().getName() + "." + otherSide.getName() + " -> " + collection.getCollectionTable().getName() + " as ManyToOne");
    ManyToOne element = new ManyToOne(mappings, collection.getCollectionTable());
    bindManyToMany((Association)otherSide, element, mappings, sessionFactoryBeanName);

protected void logCascadeMapping(Association grailsProperty, String cascadeStrategy, PersistentEntity referenced) {
  if (LOG.isDebugEnabled() & referenced != null) {
    String assType = getAssociationDescription(grailsProperty);
    LOG.debug("Mapping cascade strategy for " + assType + " property " + grailsProperty.getOwner().getName() + "." + grailsProperty.getName() + " referencing type [" + referenced.getJavaClass().getName() + "] -> [CASCADE: " + cascadeStrategy + "]");
  }
}

private void registerEntityWithContext(PersistentEntity entity) {
  persistentEntities.remove(entity);
  persistentEntities.add(entity);
  persistentEntitiesByName.put(entity.getName(), entity);
}