Code example for SessionImplementor

				} 
			} 
		} 
	} 
 
	private static EntityKey generateEntityKeyOrNull(Serializable id, SessionImplementor s, String entityName) {
		if ( id == null || s == null || entityName == null ) {
			return null; 
		} 
		return s.generateEntityKey( id, s.getFactory().getEntityPersister( entityName ) );
	} 
 
	@Override 
	public final void unsetSession() { 
		session = null;
		readOnly = false;
		readOnlyBeforeAttachedToSession = null;
	} 
 
	@Override 
	public final void initialize() throws HibernateException {
		if (!initialized) {
			if ( session==null ) {
				throw new LazyInitializationException("could not initialize proxy - no Session");
			} 
			else if ( !session.isOpen() ) {
				throw new LazyInitializationException("could not initialize proxy - the owning Session was closed");
			} 
			else if ( !session.isConnected() ) {
				throw new LazyInitializationException("could not initialize proxy - the owning Session is disconnected");
			} 
			else { 
				target = session.immediateLoad(entityName, id);
				initialized = true;
				checkTargetState(); 
			} 
		} 
		else { 
			checkTargetState(); 
		} 
	} 
 
	private void checkTargetState() { 
		if ( !unwrap ) {
			if ( target == null ) { 
				getSession().getFactory().getEntityNotFoundDelegate().handleEntityNotFound( entityName, id );
			} 
		} 
	} 
 
	/** 
	 * Getter for property 'connectedToSession'. 
	 * 
	 * @return Value for property 'connectedToSession'. 
	 */ 
	protected final boolean isConnectedToSession() { 
		return getProxyOrNull() != null; 
	} 
 
	private Object getProxyOrNull() { 
		final EntityKey entityKey = generateEntityKeyOrNull( getIdentifier(), session, getEntityName() );
		if ( entityKey != null && session != null && session.isOpen() ) {
			return session.getPersistenceContext().getProxy( entityKey );
		} 
		return null; 
	} 
 
	@Override 
	public final Object getImplementation() { 
		initialize();
		return target; 
	} 
 
	@Override 
	public final void setImplementation(Object target) { 
		this.target = target;
		initialized = true;
	} 
 
	@Override 
	public final Object getImplementation(SessionImplementor s) throws HibernateException {
		final EntityKey entityKey = generateEntityKeyOrNull( getIdentifier(), s, getEntityName() );
		return ( entityKey == null ? null : s.getPersistenceContext().getEntity( entityKey ) );
	} 
 
	/** 
	 * Getter for property 'target'. 
	 * <p/> 
	 * Same as {@link #getImplementation()} except that this method will not force initialization. 
	 * 
	 * @return Value for property 'target'. 
	 */ 
	protected final Object getTarget() { 
		return target; 
	} 
 
	@Override 
	public final boolean isReadOnlySettingAvailable() { 
		return ( session != null && ! session.isClosed() );
	} 
 
	private void errorIfReadOnlySettingNotAvailable() { 
		if ( session == null ) {
			throw new TransientObjectException(
					"Proxy is detached (i.e, session is null). The read-only/modifiable setting is only accessible when the proxy is associated with an open session." ); 
		} 
		if ( session.isClosed() ) {
			throw new SessionException(
					"Session is closed. The read-only/modifiable setting is only accessible when the proxy is associated with an open session." ); 
		} 
	} 
 
	@Override 
	public final boolean isReadOnly() { 
		errorIfReadOnlySettingNotAvailable(); 
		return readOnly;
	} 
 
	@Override 
	public final void setReadOnly(boolean readOnly) {
		errorIfReadOnlySettingNotAvailable(); 
		// only update if readOnly is different from current setting 
		if ( this.readOnly != readOnly ) {
			final EntityPersister persister = session.getFactory().getEntityPersister( entityName );
			if ( ! persister.isMutable() && ! readOnly ) {
				throw new IllegalStateException( "cannot make proxies for immutable entities modifiable");
			} 
			this.readOnly = readOnly;
			if ( initialized ) {
				EntityKey key = generateEntityKeyOrNull( getIdentifier(), session, getEntityName() );
				if ( key != null && session.getPersistenceContext().containsEntity( key ) ) {
					session.getPersistenceContext().setReadOnly( target, readOnly );
				} 
			} 
		} 
	} 
 
	/** 
	 * Get the read-only/modifiable setting that should be put in affect when it is 
	 * attached to a session. 
	 * 
	 * This method should only be called during serialization when read-only/modifiable setting 
	 * is not available (i.e., isReadOnlySettingAvailable() == false) 
	 * 
	 * @return null, if the default setting should be used; 
	 *           true, for read-only; 
	 *           false, for modifiable 
	 * @throws IllegalStateException if isReadOnlySettingAvailable() == true 
	 */ 
	protected final Boolean isReadOnlyBeforeAttachedToSession() {
		if ( isReadOnlySettingAvailable() ) {
			throw new IllegalStateException(
					"Cannot call isReadOnlyBeforeAttachedToSession when isReadOnlySettingAvailable == true" 
			); 
		} 
		return readOnlyBeforeAttachedToSession;
	} 
 
	/** 
	 * Set the read-only/modifiable setting that should be put in affect when it is 
	 * attached to a session. 
	 * 
	 * This method should only be called during deserialization, before associating 
	 * the proxy with a session. 
	 * 
	 * @param readOnlyBeforeAttachedToSession, the read-only/modifiable setting to use when 
	 * associated with a session; null indicates that the default should be used. 
	 * @throws IllegalStateException if isReadOnlySettingAvailable() == true 
	 */ 
	/* package-private */ 
	final void setReadOnlyBeforeAttachedToSession(Boolean readOnlyBeforeAttachedToSession) {
		if ( isReadOnlySettingAvailable() ) {
			throw new IllegalStateException(
					"Cannot call setReadOnlyBeforeAttachedToSession when isReadOnlySettingAvailable == true" 
			); 
		} 
		this.readOnlyBeforeAttachedToSession = readOnlyBeforeAttachedToSession;
	} 
 
	@Override 
	public boolean isUnwrap() { 
		return unwrap;
	} 
 
	@Override 
	public void setUnwrap(boolean unwrap) {
		this.unwrap = unwrap;
	} 
}