| /******************************************************************************* |
| * Copyright (c) 2008, 2011 Oracle. All rights reserved. |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v1.0, which accompanies this distribution |
| * and is available at http://www.eclipse.org/legal/epl-v10.html. |
| * |
| * Contributors: |
| * Oracle - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.jpt.jpa.eclipselink.core.internal.context.java; |
| |
| import java.util.List; |
| import org.eclipse.jdt.core.dom.CompilationUnit; |
| import org.eclipse.jpt.common.core.resource.java.JavaResourceType; |
| import org.eclipse.jpt.common.core.utility.TextRange; |
| import org.eclipse.jpt.common.utility.internal.StringTools; |
| import org.eclipse.jpt.jpa.core.context.PersistentType; |
| import org.eclipse.jpt.jpa.core.context.TypeMapping; |
| import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType; |
| import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode; |
| import org.eclipse.jpt.jpa.core.internal.jpa2.context.java.NullJavaCacheable2_0; |
| import org.eclipse.jpt.jpa.core.jpa2.context.CacheableHolder2_0; |
| import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaCacheable2_0; |
| import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaCacheableHolder2_0; |
| import org.eclipse.jpt.jpa.core.jpa2.context.persistence.PersistenceUnit2_0; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkCacheCoordinationType; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkCacheIsolationType2_2; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkCacheType; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkExistenceType; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTimeOfDay; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkCaching; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.java.JavaEclipseLinkNonEmbeddableTypeMapping; |
| import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit; |
| import org.eclipse.jpt.jpa.eclipselink.core.internal.DefaultEclipseLinkJpaValidationMessages; |
| import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLinkJpaValidationMessages; |
| import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkCacheAnnotation; |
| import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkExistenceCheckingAnnotation; |
| import org.eclipse.jpt.jpa.eclipselink.core.resource.java.EclipseLinkTimeOfDayAnnotation; |
| import org.eclipse.wst.validation.internal.provisional.core.IMessage; |
| import org.eclipse.wst.validation.internal.provisional.core.IReporter; |
| |
| public class JavaEclipseLinkCachingImpl |
| extends AbstractJavaJpaContextNode |
| implements JavaEclipseLinkCaching, JavaCacheableHolder2_0 |
| { |
| protected EclipseLinkCacheType specifiedType; |
| protected Integer specifiedSize; |
| protected Boolean specifiedShared; |
| protected Boolean specifiedAlwaysRefresh; |
| protected Boolean specifiedRefreshOnlyIfNewer; |
| protected Boolean specifiedDisableHits; |
| |
| protected EclipseLinkCacheCoordinationType specifiedCoordinationType; |
| |
| protected Integer expiry; |
| protected EclipseLinkJavaTimeOfDay expiryTimeOfDay; |
| |
| protected boolean existenceChecking; |
| protected EclipseLinkExistenceType specifiedExistenceType; |
| protected EclipseLinkExistenceType defaultExistenceType; |
| |
| protected final JavaCacheable2_0 cacheable; |
| |
| protected EclipseLinkCacheIsolationType2_2 specifiedIsolation; |
| |
| public JavaEclipseLinkCachingImpl(JavaEclipseLinkNonEmbeddableTypeMapping parent) { |
| super(parent); |
| |
| EclipseLinkCacheAnnotation cacheAnnotation = this.getCacheAnnotation(); |
| this.specifiedType = EclipseLinkCacheType.fromJavaResourceModel(cacheAnnotation.getType()); |
| this.specifiedSize = cacheAnnotation.getSize(); |
| this.specifiedShared = cacheAnnotation.getShared(); |
| this.specifiedAlwaysRefresh = cacheAnnotation.getAlwaysRefresh(); |
| this.specifiedRefreshOnlyIfNewer = cacheAnnotation.getRefreshOnlyIfNewer(); |
| this.specifiedDisableHits = cacheAnnotation.getDisableHits(); |
| |
| this.specifiedCoordinationType = EclipseLinkCacheCoordinationType.fromJavaResourceModel(cacheAnnotation.getCoordinationType()); |
| |
| this.expiry = cacheAnnotation.getExpiry(); |
| this.expiryTimeOfDay = this.buildExpiryTimeOfDay(cacheAnnotation.getExpiryTimeOfDay()); |
| |
| EclipseLinkExistenceCheckingAnnotation ecAnnotation = this.getExistenceCheckingAnnotation(); |
| this.existenceChecking = (ecAnnotation != null); |
| this.specifiedExistenceType = this.buildSpecifiedExistenceType(ecAnnotation); |
| |
| this.cacheable = this.buildCacheable(); |
| |
| this.specifiedIsolation = EclipseLinkCacheIsolationType2_2.fromJavaResourceModel(cacheAnnotation.getIsolation()); |
| } |
| |
| |
| // ********** synchronize/update ********** |
| |
| @Override |
| public void synchronizeWithResourceModel() { |
| super.synchronizeWithResourceModel(); |
| |
| EclipseLinkCacheAnnotation cacheAnnotation = this.getCacheAnnotation(); |
| this.setSpecifiedType_(EclipseLinkCacheType.fromJavaResourceModel(cacheAnnotation.getType())); |
| this.setSpecifiedSize_(cacheAnnotation.getSize()); |
| this.setSpecifiedShared_(cacheAnnotation.getShared()); |
| this.setSpecifiedAlwaysRefresh_(cacheAnnotation.getAlwaysRefresh()); |
| this.setSpecifiedRefreshOnlyIfNewer_(cacheAnnotation.getRefreshOnlyIfNewer()); |
| this.setSpecifiedDisableHits_(cacheAnnotation.getDisableHits()); |
| |
| this.setSpecifiedCoordinationType_(EclipseLinkCacheCoordinationType.fromJavaResourceModel(cacheAnnotation.getCoordinationType())); |
| |
| this.setExpiry_(cacheAnnotation.getExpiry()); |
| this.syncExpiryTimeOfDay(cacheAnnotation.getExpiryTimeOfDay()); |
| |
| EclipseLinkExistenceCheckingAnnotation ecAnnotation = this.getExistenceCheckingAnnotation(); |
| this.setExistenceChecking_(ecAnnotation != null); |
| this.setSpecifiedExistenceType_(this.buildSpecifiedExistenceType(ecAnnotation)); |
| |
| this.cacheable.synchronizeWithResourceModel(); |
| |
| this.setSpecifiedIsolation_(EclipseLinkCacheIsolationType2_2.fromJavaResourceModel(cacheAnnotation.getIsolation())); |
| } |
| |
| @Override |
| public void update() { |
| super.update(); |
| if (this.expiryTimeOfDay != null) { |
| this.expiryTimeOfDay.update(); |
| } |
| this.setDefaultExistenceType(this.buildDefaultExistenceType()); |
| this.cacheable.update(); |
| } |
| |
| |
| // ********** type ********** |
| |
| public EclipseLinkCacheType getType() { |
| return (this.specifiedType != null) ? this.specifiedType : this.getDefaultType(); |
| } |
| |
| public EclipseLinkCacheType getSpecifiedType() { |
| return this.specifiedType; |
| } |
| |
| public void setSpecifiedType(EclipseLinkCacheType type) { |
| this.getCacheAnnotation().setType(EclipseLinkCacheType.toJavaResourceModel(type)); |
| this.setSpecifiedType_(type); |
| |
| if (type != null) { |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setSpecifiedType_(EclipseLinkCacheType type) { |
| EclipseLinkCacheType old = this.specifiedType; |
| this.specifiedType = type; |
| this.firePropertyChanged(SPECIFIED_TYPE_PROPERTY, old, type); |
| } |
| |
| public EclipseLinkCacheType getDefaultType() { |
| String puDefaultCacheTypeName = ((EclipseLinkPersistenceUnit)getPersistenceUnit()).getDefaultCacheTypePropertyValue(); |
| if (!StringTools.stringIsEmpty(puDefaultCacheTypeName)) { |
| try { |
| return EclipseLinkCacheType.valueOf(StringTools.convertCamelCaseToAllCaps(puDefaultCacheTypeName)); |
| } catch (IllegalArgumentException exception) { |
| //no match, return default |
| } |
| } |
| return DEFAULT_TYPE; |
| } |
| |
| // ********** size ********** |
| |
| public int getSize() { |
| return (this.specifiedSize != null) ? this.specifiedSize.intValue() : this.getDefaultSize(); |
| } |
| |
| public Integer getSpecifiedSize() { |
| return this.specifiedSize; |
| } |
| |
| public void setSpecifiedSize(Integer size) { |
| this.getCacheAnnotation().setSize(size); |
| this.setSpecifiedSize_(size); |
| |
| if (size != null) { |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setSpecifiedSize_(Integer size) { |
| Integer old = this.specifiedSize; |
| this.specifiedSize = size; |
| this.firePropertyChanged(SPECIFIED_SIZE_PROPERTY, old, size); |
| } |
| |
| public int getDefaultSize() { |
| String puDefaultCacheSize = ((EclipseLinkPersistenceUnit)getPersistenceUnit()).getDefaultCacheSizePropertyValue(); |
| if (!StringTools.stringIsEmpty(puDefaultCacheSize)) { |
| try { |
| return Integer.valueOf(puDefaultCacheSize).intValue(); |
| } catch (NumberFormatException exception) { |
| //couldn't parse, return default |
| } |
| } |
| return DEFAULT_SIZE; |
| } |
| |
| |
| // ********** shared ********** |
| |
| public boolean isShared() { |
| return (this.specifiedShared != null) ? this.specifiedShared.booleanValue() : this.isDefaultShared(); |
| } |
| |
| public Boolean getSpecifiedShared() { |
| return this.specifiedShared; |
| } |
| |
| public void setSpecifiedShared(Boolean shared) { |
| this.getCacheAnnotation().setShared(shared); |
| this.setSpecifiedShared_(shared); |
| |
| if ((shared != null) && ! shared.booleanValue()) { // Boolean.FALSE |
| this.setSpecifiedType(null); |
| this.setSpecifiedSize(null); |
| this.setSpecifiedAlwaysRefresh(null); |
| this.setSpecifiedRefreshOnlyIfNewer(null); |
| this.setSpecifiedDisableHits(null); |
| this.setSpecifiedCoordinationType(null); |
| this.setExpiry(null); |
| this.removeExpiryTimeOfDayIfNecessary(); |
| } |
| } |
| |
| protected void setSpecifiedShared_(Boolean shared) { |
| Boolean old = this.specifiedShared; |
| this.specifiedShared = shared; |
| this.firePropertyChanged(SPECIFIED_SHARED_PROPERTY, old, shared); |
| } |
| |
| public boolean isDefaultShared() { |
| String puDefaultSharedCache = ((EclipseLinkPersistenceUnit)getPersistenceUnit()).getDefaultCacheSharedPropertyValue(); |
| return !StringTools.stringIsEmpty(puDefaultSharedCache) ? Boolean.valueOf(puDefaultSharedCache).booleanValue() : DEFAULT_SHARED; |
| } |
| |
| |
| // ********** always refresh ********** |
| |
| public boolean isAlwaysRefresh() { |
| return (this.specifiedAlwaysRefresh != null) ? this.specifiedAlwaysRefresh.booleanValue() : this.isDefaultAlwaysRefresh(); |
| } |
| |
| public Boolean getSpecifiedAlwaysRefresh() { |
| return this.specifiedAlwaysRefresh; |
| } |
| |
| public void setSpecifiedAlwaysRefresh(Boolean alwaysRefresh) { |
| this.getCacheAnnotation().setAlwaysRefresh(alwaysRefresh); |
| this.setSpecifiedAlwaysRefresh_(alwaysRefresh); |
| |
| if (alwaysRefresh != null) { |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setSpecifiedAlwaysRefresh_(Boolean alwaysRefresh) { |
| Boolean old = this.specifiedAlwaysRefresh; |
| this.specifiedAlwaysRefresh = alwaysRefresh; |
| this.firePropertyChanged(SPECIFIED_ALWAYS_REFRESH_PROPERTY, old, alwaysRefresh); |
| } |
| |
| public boolean isDefaultAlwaysRefresh() { |
| return DEFAULT_ALWAYS_REFRESH; |
| } |
| |
| |
| // ********** refresh only if newer ********** |
| |
| public boolean isRefreshOnlyIfNewer() { |
| return (this.specifiedRefreshOnlyIfNewer != null) ? this.specifiedRefreshOnlyIfNewer.booleanValue() : this.isDefaultRefreshOnlyIfNewer(); |
| } |
| |
| public Boolean getSpecifiedRefreshOnlyIfNewer() { |
| return this.specifiedRefreshOnlyIfNewer; |
| } |
| |
| public void setSpecifiedRefreshOnlyIfNewer(Boolean refreshOnlyIfNewer) { |
| this.getCacheAnnotation().setRefreshOnlyIfNewer(refreshOnlyIfNewer); |
| this.setSpecifiedRefreshOnlyIfNewer_(refreshOnlyIfNewer); |
| |
| if (refreshOnlyIfNewer != null) { |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setSpecifiedRefreshOnlyIfNewer_(Boolean refreshOnlyIfNewer) { |
| Boolean old = this.specifiedRefreshOnlyIfNewer; |
| this.specifiedRefreshOnlyIfNewer = refreshOnlyIfNewer; |
| this.firePropertyChanged(SPECIFIED_REFRESH_ONLY_IF_NEWER_PROPERTY, old, refreshOnlyIfNewer); |
| } |
| |
| public boolean isDefaultRefreshOnlyIfNewer() { |
| return DEFAULT_REFRESH_ONLY_IF_NEWER; |
| } |
| |
| |
| // ********** disable hits ********** |
| |
| public boolean isDisableHits() { |
| return (this.specifiedDisableHits != null) ? this.specifiedDisableHits.booleanValue() : this.isDefaultDisableHits(); |
| } |
| |
| public Boolean getSpecifiedDisableHits() { |
| return this.specifiedDisableHits; |
| } |
| |
| public void setSpecifiedDisableHits(Boolean disableHits) { |
| this.getCacheAnnotation().setDisableHits(disableHits); |
| this.setSpecifiedDisableHits_(disableHits); |
| |
| if (disableHits != null) { |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setSpecifiedDisableHits_(Boolean disableHits) { |
| Boolean old = this.specifiedDisableHits; |
| this.specifiedDisableHits = disableHits; |
| this.firePropertyChanged(SPECIFIED_DISABLE_HITS_PROPERTY, old, disableHits); |
| } |
| |
| public boolean isDefaultDisableHits() { |
| return DEFAULT_DISABLE_HITS; |
| } |
| |
| |
| // ********** coordination type ********** |
| |
| public EclipseLinkCacheCoordinationType getCoordinationType() { |
| return (this.specifiedCoordinationType != null) ? this.specifiedCoordinationType : this.getDefaultCoordinationType(); |
| } |
| |
| public EclipseLinkCacheCoordinationType getSpecifiedCoordinationType() { |
| return this.specifiedCoordinationType; |
| } |
| |
| public void setSpecifiedCoordinationType(EclipseLinkCacheCoordinationType type) { |
| this.getCacheAnnotation().setCoordinationType(EclipseLinkCacheCoordinationType.toJavaResourceModel(type)); |
| this.setSpecifiedCoordinationType_(type); |
| |
| if (type != null) { |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setSpecifiedCoordinationType_(EclipseLinkCacheCoordinationType type) { |
| EclipseLinkCacheCoordinationType old = this.specifiedCoordinationType; |
| this.specifiedCoordinationType = type; |
| this.firePropertyChanged(SPECIFIED_COORDINATION_TYPE_PROPERTY, old, type); |
| } |
| |
| public EclipseLinkCacheCoordinationType getDefaultCoordinationType() { |
| return DEFAULT_COORDINATION_TYPE; |
| } |
| |
| |
| // ********** expiry ********** |
| |
| public Integer getExpiry() { |
| return this.expiry; |
| } |
| |
| public void setExpiry(Integer expiry) { |
| this.getCacheAnnotation().setExpiry(expiry); |
| this.setExpiry_(expiry); |
| |
| if (expiry != null) { |
| this.removeExpiryTimeOfDayIfNecessary(); |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setExpiry_(Integer expiry) { |
| Integer old = this.expiry; |
| this.expiry = expiry; |
| this.firePropertyChanged(EXPIRY_PROPERTY, old, expiry); |
| } |
| |
| |
| // ********** expiry time of day ********** |
| |
| public EclipseLinkTimeOfDay getExpiryTimeOfDay() { |
| return this.expiryTimeOfDay; |
| } |
| |
| public EclipseLinkTimeOfDay addExpiryTimeOfDay() { |
| if (this.expiryTimeOfDay != null) { |
| throw new IllegalStateException("expiry time of day already exists: " + this.expiryTimeOfDay); //$NON-NLS-1$ |
| } |
| EclipseLinkTimeOfDayAnnotation timeOfDayAnnotation = this.getCacheAnnotation().addExpiryTimeOfDay(); |
| EclipseLinkJavaTimeOfDay timeOfDay = this.buildExpiryTimeOfDay(timeOfDayAnnotation); |
| this.setExpiryTimeOfDay(timeOfDay); |
| |
| this.setExpiry(null); |
| this.setSpecifiedShared(null); |
| |
| return timeOfDay; |
| } |
| |
| public void removeExpiryTimeOfDay() { |
| if (this.expiryTimeOfDay == null) { |
| throw new IllegalStateException("expiry time of day does not exist"); //$NON-NLS-1$ |
| } |
| this.removeExpiryTimeOfDay_(); |
| } |
| |
| protected void removeExpiryTimeOfDayIfNecessary() { |
| if (this.expiryTimeOfDay != null) { |
| this.removeExpiryTimeOfDay_(); |
| } |
| } |
| |
| protected void removeExpiryTimeOfDay_() { |
| this.getCacheAnnotation().removeExpiryTimeOfDay(); |
| this.setExpiryTimeOfDay(null); |
| } |
| |
| public void setExpiryTimeOfDay(EclipseLinkJavaTimeOfDay timeOfDay) { |
| EclipseLinkJavaTimeOfDay old = this.expiryTimeOfDay; |
| this.expiryTimeOfDay = timeOfDay; |
| this.firePropertyChanged(EXPIRY_TIME_OF_DAY_PROPERTY, old, timeOfDay); |
| } |
| |
| protected void syncExpiryTimeOfDay(EclipseLinkTimeOfDayAnnotation timeOfDayAnnotation) { |
| if (timeOfDayAnnotation == null) { |
| if (this.expiryTimeOfDay != null) { |
| this.setExpiryTimeOfDay(null); |
| } |
| } else { |
| if ((this.expiryTimeOfDay != null) && (this.expiryTimeOfDay.getTimeOfDayAnnotation() == timeOfDayAnnotation)) { |
| this.expiryTimeOfDay.synchronizeWithResourceModel(); |
| } else { |
| this.setExpiryTimeOfDay(this.buildExpiryTimeOfDay(timeOfDayAnnotation)); |
| } |
| } |
| } |
| |
| protected EclipseLinkJavaTimeOfDay buildExpiryTimeOfDay(EclipseLinkTimeOfDayAnnotation timeOfDayAnnotation) { |
| return (timeOfDayAnnotation == null) ? null : new EclipseLinkJavaTimeOfDay(this, timeOfDayAnnotation); |
| } |
| |
| |
| // ********** existence checking ********** |
| |
| public boolean isExistenceChecking() { |
| return this.existenceChecking; |
| } |
| |
| public void setExistenceChecking(boolean existenceChecking) { |
| if (existenceChecking != this.existenceChecking) { |
| if (existenceChecking) { |
| this.addExistenceCheckingAnnotation(); |
| } else { |
| this.removeExistenceCheckingAnnotation(); |
| this.setSpecifiedExistenceType(null); |
| } |
| this.setExistenceChecking_(existenceChecking); |
| } |
| } |
| |
| protected void setExistenceChecking_(boolean existenceChecking) { |
| boolean old = this.existenceChecking; |
| this.existenceChecking = existenceChecking; |
| this.firePropertyChanged(EXISTENCE_CHECKING_PROPERTY, old, existenceChecking); |
| } |
| |
| |
| // ********** existence type ********** |
| |
| public EclipseLinkExistenceType getExistenceType() { |
| return (this.specifiedExistenceType != null) ? this.specifiedExistenceType : this.defaultExistenceType; |
| } |
| |
| public EclipseLinkExistenceType getSpecifiedExistenceType() { |
| return this.specifiedExistenceType; |
| } |
| |
| public void setSpecifiedExistenceType(EclipseLinkExistenceType type) { |
| if (this.valuesAreDifferent(type, this.specifiedExistenceType)) { |
| if (type != null) { |
| this.setExistenceChecking(true); |
| } |
| this.getExistenceCheckingAnnotation().setValue(EclipseLinkExistenceType.toJavaResourceModel(type)); |
| this.setSpecifiedExistenceType_(type); |
| } |
| } |
| |
| protected void setSpecifiedExistenceType_(EclipseLinkExistenceType type) { |
| EclipseLinkExistenceType old = this.specifiedExistenceType; |
| this.specifiedExistenceType = type; |
| this.firePropertyChanged(SPECIFIED_EXISTENCE_TYPE_PROPERTY, old, type); |
| } |
| |
| protected EclipseLinkExistenceType buildSpecifiedExistenceType(EclipseLinkExistenceCheckingAnnotation ecAnnotation) { |
| return (ecAnnotation == null) ? null : EclipseLinkExistenceType.fromJavaResourceModel(ecAnnotation.getValue()); |
| } |
| |
| public EclipseLinkExistenceType getDefaultExistenceType() { |
| return this.defaultExistenceType; |
| } |
| |
| protected void setDefaultExistenceType(EclipseLinkExistenceType type) { |
| EclipseLinkExistenceType old = this.defaultExistenceType; |
| this.defaultExistenceType = type; |
| this.firePropertyChanged(DEFAULT_EXISTENCE_TYPE_PROPERTY, old, type); |
| } |
| |
| protected EclipseLinkExistenceType buildDefaultExistenceType() { |
| return this.existenceChecking ? EclipseLinkExistenceType.CHECK_CACHE : DEFAULT_EXISTENCE_TYPE; |
| } |
| |
| |
| // ********** cacheable ********** |
| |
| public JavaCacheable2_0 getCacheable() { |
| return this.cacheable; |
| } |
| |
| public boolean calculateDefaultCacheable() { |
| CacheableHolder2_0 superCacheableHolder = this.getCacheableSuperPersistentType(this.getPersistentType()); |
| return (superCacheableHolder != null) ? |
| superCacheableHolder.getCacheable().isCacheable() : |
| ((PersistenceUnit2_0) this.getPersistenceUnit()).calculateDefaultCacheable(); |
| } |
| |
| protected CacheableHolder2_0 getCacheableSuperPersistentType(PersistentType persistentType) { |
| PersistentType superPersistentType = persistentType.getSuperPersistentType(); |
| if (superPersistentType == null) { |
| return null; |
| } |
| TypeMapping superMapping = superPersistentType.getMapping(); |
| return (superMapping instanceof CacheableHolder2_0) ? |
| (CacheableHolder2_0) superMapping : |
| this.getCacheableSuperPersistentType(superPersistentType); // recurse |
| } |
| |
| protected JavaCacheable2_0 buildCacheable() { |
| return this.isJpa2_0Compatible() ? |
| this.getJpaFactory2_0().buildJavaCacheable(this) : |
| new NullJavaCacheable2_0(this); |
| } |
| |
| |
| // ********** isolation ********** |
| |
| public EclipseLinkCacheIsolationType2_2 getIsolation() { |
| return (this.specifiedIsolation != null) ? this.specifiedIsolation : this.getDefaultIsolation(); |
| } |
| |
| public EclipseLinkCacheIsolationType2_2 getSpecifiedIsolation() { |
| return this.specifiedIsolation; |
| } |
| |
| public void setSpecifiedIsolation(EclipseLinkCacheIsolationType2_2 isolation) { |
| this.getCacheAnnotation().setIsolation(EclipseLinkCacheIsolationType2_2.toJavaResourceModel(isolation)); |
| this.setSpecifiedIsolation_(isolation); |
| |
| if (isolation != null) { |
| this.setSpecifiedShared(null); |
| } |
| } |
| |
| protected void setSpecifiedIsolation_(EclipseLinkCacheIsolationType2_2 isolation) { |
| EclipseLinkCacheIsolationType2_2 old = this.specifiedIsolation; |
| this.specifiedIsolation = isolation; |
| this.firePropertyChanged(SPECIFIED_ISOLATION_PROPERTY, old, isolation); |
| } |
| |
| public EclipseLinkCacheIsolationType2_2 getDefaultIsolation() { |
| return DEFAULT_ISOLATION; |
| } |
| |
| // ********** cache annotation ********** |
| |
| protected EclipseLinkCacheAnnotation getCacheAnnotation() { |
| return (EclipseLinkCacheAnnotation) this.getJavaResourceType().getNonNullAnnotation(this.getCacheAnnotationName()); |
| } |
| |
| protected String getCacheAnnotationName() { |
| return EclipseLinkCacheAnnotation.ANNOTATION_NAME; |
| } |
| |
| |
| // ********** existence checking annotation ********** |
| |
| protected EclipseLinkExistenceCheckingAnnotation getExistenceCheckingAnnotation() { |
| return (EclipseLinkExistenceCheckingAnnotation) this.getJavaResourceType().getAnnotation(this.getExistenceCheckingAnnotationName()); |
| } |
| |
| protected EclipseLinkExistenceCheckingAnnotation addExistenceCheckingAnnotation() { |
| return (EclipseLinkExistenceCheckingAnnotation) this.getJavaResourceType().addAnnotation(this.getExistenceCheckingAnnotationName()); |
| } |
| |
| protected void removeExistenceCheckingAnnotation() { |
| this.getJavaResourceType().removeAnnotation(this.getExistenceCheckingAnnotationName()); |
| } |
| |
| protected String getExistenceCheckingAnnotationName() { |
| return EclipseLinkExistenceCheckingAnnotation.ANNOTATION_NAME; |
| } |
| |
| |
| // ********** misc ********** |
| |
| @Override |
| public JavaEclipseLinkNonEmbeddableTypeMapping getParent() { |
| return (JavaEclipseLinkNonEmbeddableTypeMapping) super.getParent(); |
| } |
| |
| protected JavaEclipseLinkNonEmbeddableTypeMapping getTypeMapping() { |
| return this.getParent(); |
| } |
| |
| protected JavaPersistentType getPersistentType() { |
| return this.getTypeMapping().getPersistentType(); |
| } |
| |
| public JavaResourceType getJavaResourceType() { |
| return this.getTypeMapping().getJavaResourceType(); |
| } |
| |
| // ********** validation ********** |
| |
| @Override |
| public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) { |
| super.validate(messages, reporter, astRoot); |
| this.validateExpiry(messages, astRoot); |
| } |
| |
| protected void validateExpiry(List<IMessage> messages, CompilationUnit astRoot) { |
| if ((this.expiry != null) && (this.expiryTimeOfDay != null)) { |
| messages.add( |
| DefaultEclipseLinkJpaValidationMessages.buildMessage( |
| IMessage.HIGH_SEVERITY, |
| EclipseLinkJpaValidationMessages.CACHE_EXPIRY_AND_EXPIRY_TIME_OF_DAY_BOTH_SPECIFIED, |
| new String[] {this.getPersistentType().getName()}, |
| this, |
| this.getValidationTextRange(astRoot) |
| ) |
| ); |
| } |
| } |
| |
| public TextRange getValidationTextRange(CompilationUnit astRoot) { |
| TextRange textRange = this.getCacheAnnotation().getTextRange(astRoot); |
| return (textRange != null) ? textRange : this.getTypeMapping().getValidationTextRange(astRoot); |
| } |
| } |