@Override public Type getType() { return persister.getPropertyTypes()[index]; }
private Object[] createDeletedState(EntityPersister persister, Object[] currentState, EventSource session) { Type[] propTypes = persister.getPropertyTypes(); final Object[] deletedState = new Object[propTypes.length]; // TypeFactory.deepCopy( currentState, propTypes, persister.getPropertyUpdateability(), deletedState, session ); boolean[] copyability = new boolean[propTypes.length]; java.util.Arrays.fill( copyability, true ); TypeHelper.deepCopy( currentState, propTypes, copyability, deletedState, session ); return deletedState; }
private void evictCachedCollections(EntityPersister persister, Serializable id, EventSource source) { evictCachedCollections( persister.getPropertyTypes(), id, source ); }
public HibernateTraversableResolver( EntityPersister persister, ConcurrentHashMap<EntityPersister, Set<String>> associationsPerEntityPersister, SessionFactoryImplementor factory) { this.associations = associationsPerEntityPersister.get( persister ); if (this.associations == null) { this.associations = new HashSet<String>(); addAssociationsToTheSetForAllProperties( persister.getPropertyNames(), persister.getPropertyTypes(), "", factory ); associationsPerEntityPersister.put( persister, associations ); } }
@Override public Object createNaturalIdKey(Object[] naturalIdValues, EntityPersister persister, SharedSessionContractImplementor session) { // natural ids always need to be wrapped return new NaturalIdCacheKey(naturalIdValues, persister.getPropertyTypes(), persister.getNaturalIdentifierProperties(), null, session); }
/** * Walk the tree starting from the given entity. * * @param object * @param persister * @throws HibernateException */ void process(Object object, EntityPersister persister) throws HibernateException { processEntityPropertyValues( persister.getPropertyValues( object ), persister.getPropertyTypes() ); }
public static Object staticCreateNaturalIdKey(Object[] naturalIdValues, EntityPersister persister, SharedSessionContractImplementor session) { return new NaturalIdCacheKey( naturalIdValues, persister.getPropertyTypes(), persister.getNaturalIdentifierProperties(), persister.getRootEntityName(), session ); }
@Override void process(Object object, EntityPersister persister) throws HibernateException { final Object[] values = persister.getPropertyValues( object ); final Type[] types = persister.getPropertyTypes(); processEntityPropertyValues( values, types ); if ( isSubstitutionRequired() ) { persister.setPropertyValues( object, values ); } } }
protected void copyValues( final EntityPersister persister, final Object entity, final Object target, final SessionImplementor source, final Map copyCache) { final Object[] copiedValues = TypeHelper.replace( persister.getPropertyValues( entity ), persister.getPropertyValues( target ), persister.getPropertyTypes(), source, target, copyCache ); persister.setPropertyValues( target, copiedValues ); }
Type[] types = entityPersister.getPropertyTypes(); String[] names = entityPersister.getPropertyNames(); Object[] values = entityPersister.getPropertyValues( entity );
); final String[] propertyNames = meta.getPropertyNames(); final Type[] propertyTypes = meta.getPropertyTypes();
/** * Constructs a StandardCacheEntryImpl * * @param state The extracted state * @param persister The entity persister * @param version The current version (if versioned) * @param session The originating session * @param owner The owner * * @throws HibernateException Generally indicates a problem performing the dis-assembly. */ public StandardCacheEntryImpl( final Object[] state, final EntityPersister persister, final Object version, final SharedSessionContractImplementor session, final Object owner) throws HibernateException { // disassembled state gets put in a new array (we write to cache by value!) this.disassembledState = TypeHelper.disassemble( state, persister.getPropertyTypes(), persister.isLazyPropertiesCacheable() ? null : persister.getPropertyLaziness(), session, owner ); this.subclass = persister.getEntityName(); this.version = version; }
protected boolean invokeInterceptor( SessionImplementor session, Object entity, EntityEntry entry, final Object[] values, EntityPersister persister) { boolean isDirty = false; if ( entry.getStatus() != Status.DELETED ) { if ( callbackRegistry.preUpdate( entity ) ) { isDirty = copyState( entity, persister.getPropertyTypes(), values, session.getFactory() ); } } final boolean answerFromInterceptor = session.getInterceptor().onFlushDirty( entity, entry.getId(), values, entry.getLoadedState(), persister.getPropertyNames(), persister.getPropertyTypes() ); return answerFromInterceptor || isDirty; }
@Override public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) { final EntityPersister meta = criteriaQuery.getFactory().getEntityPersister( criteriaQuery.getEntityName( criteria ) ); final String[] propertyNames = meta.getPropertyNames(); final Type[] propertyTypes = meta.getPropertyTypes(); final Object[] values = meta.getPropertyValues( exampleEntity ); final List<TypedValue> list = new ArrayList<TypedValue>(); for ( int i=0; i<propertyNames.length; i++ ) { final Object value = values[i]; final Type type = propertyTypes[i]; final String name = propertyNames[i]; final boolean isVersionProperty = i == meta.getVersionProperty(); if ( ! isVersionProperty && isPropertyIncluded( value, name, type ) ) { if ( propertyTypes[i].isComponentType() ) { addComponentTypedValues( name, value, (CompositeType) type, list, criteria, criteriaQuery ); } else { addPropertyTypedValue( value, type, list ); } } } return list.toArray( new TypedValue[ list.size() ] ); }
public void onPreLoad(PreLoadEvent event) { EntityPersister persister = event.getPersister(); event.getSession() .getInterceptor() .onLoad( event.getEntity(), event.getId(), event.getState(), persister.getPropertyNames(), persister.getPropertyTypes() ); }
private boolean hasDirtyCollections(FlushEntityEvent event, EntityPersister persister, Status status) { if ( isCollectionDirtyCheckNecessary( persister, status ) ) { DirtyCollectionSearchVisitor visitor = new DirtyCollectionSearchVisitor( event.getSession(), persister.getPropertyVersionability() ); visitor.processEntityPropertyValues( event.getPropertyValues(), persister.getPropertyTypes() ); boolean hasDirtyCollections = visitor.wasDirtyCollectionFound(); event.setHasDirtyCollection( hasDirtyCollections ); return hasDirtyCollections; } else { return false; } }
values, persister.getPropertyNames(), persister.getPropertyTypes() );
public enum NullabilityCheckType { CREATE, UPDATE, DELETE }
/** * Nullifies any references to transient entities in the entity state * maintained by this action. References to transient entities * should be nullified when an entity is made "managed" or when this * action is executed, whichever is first. * <p/> * References will only be nullified the first time this method is * called for a this object, so it can safely be called both when * the entity is made "managed" and when this action is executed. * * @see {@link #makeEntityManaged() } */ protected final void nullifyTransientReferencesIfNotAlready() { if ( ! areTransientReferencesNullified ) { new ForeignKeys.Nullifier( getInstance(), false, isEarlyInsert(), getSession() ) .nullifyTransientReferences( getState(), getPersister().getPropertyTypes() ); new Nullability( getSession() ).checkNullability( getState(), getPersister(), false ); areTransientReferencesNullified = true; } }
final EntityPersister persister = entry.getPersister(); final Status status = entry.getStatus(); final Type[] types = persister.getPropertyTypes();