001 package org.cumulus4j.store.model;
002
003 import java.util.ArrayList;
004 import java.util.Collection;
005 import java.util.HashMap;
006 import java.util.Map;
007 import java.util.concurrent.atomic.AtomicLong;
008
009 import javax.jdo.annotations.Column;
010 import javax.jdo.annotations.Discriminator;
011 import javax.jdo.annotations.DiscriminatorStrategy;
012 import javax.jdo.annotations.IdentityType;
013 import javax.jdo.annotations.Inheritance;
014 import javax.jdo.annotations.InheritanceStrategy;
015 import javax.jdo.annotations.NotPersistent;
016 import javax.jdo.annotations.PersistenceCapable;
017 import javax.jdo.annotations.Queries;
018 import javax.jdo.annotations.Query;
019 import javax.jdo.annotations.Unique;
020 import javax.jdo.annotations.Uniques;
021
022 import org.datanucleus.store.ExecutionContext;
023
024 @PersistenceCapable(identityType=IdentityType.APPLICATION, detachable="true")
025 @Inheritance(strategy=InheritanceStrategy.NEW_TABLE)
026 @Discriminator(strategy=DiscriminatorStrategy.VALUE_MAP, value="EmbeddedClassMeta")
027 @Uniques({
028 @Unique(members={"embeddingFieldMeta_fieldID"}, columns=@Column(name="discriminator"))
029 })
030 @Queries({
031 @Query(
032 name=EmbeddedClassMeta.NamedQueries.getEmbeddedClassMetaByEmbeddingFieldMeta_fieldID,
033 value="SELECT UNIQUE FROM org.cumulus4j.store.model.EmbeddedClassMeta EXCLUDE SUBCLASSES WHERE this.embeddingFieldMeta_fieldID == :embeddingFieldMeta_fieldID"
034 )
035 })
036 public class EmbeddedClassMeta extends ClassMeta {
037
038 protected static final String UNIQUE_SCOPE_PREFIX_EMBEDDED_CLASS_META = EmbeddedClassMeta.class.getSimpleName() + '.';
039
040 protected static class NamedQueries {
041 public static final String getEmbeddedClassMetaByEmbeddingFieldMeta_fieldID = "getEmbeddedClassMetaByEmbeddingFieldMeta_fieldID";
042 }
043
044 // @Persistent(nullValue=NullValue.EXCEPTION)
045 @NotPersistent
046 private ClassMeta nonEmbeddedClassMeta;
047
048 private long nonEmbeddedClassMeta_classID;
049
050 // @Persistent(nullValue=NullValue.EXCEPTION)
051 @NotPersistent
052 private FieldMeta embeddingFieldMeta;
053
054 private long embeddingFieldMeta_fieldID;
055
056 @NotPersistent
057 private Map<FieldMeta, EmbeddedFieldMeta> nonEmbeddedFieldMeta2EmbeddedFieldMeta;
058
059 protected EmbeddedClassMeta() { }
060
061 public EmbeddedClassMeta(ExecutionContext executionContext, ClassMeta nonEmbeddedClassMeta, FieldMeta embeddingFieldMeta) {
062 super(executionContext.getClassLoaderResolver().classForName(nonEmbeddedClassMeta.getClassName()));
063 if (embeddingFieldMeta == null)
064 throw new IllegalArgumentException("embeddingFieldMeta == null");
065
066 if (nonEmbeddedClassMeta instanceof EmbeddedClassMeta)
067 // nonEmbeddedClassMeta = ((EmbeddedClassMeta) nonEmbeddedClassMeta).getNonEmbeddedClassMeta();
068 throw new IllegalArgumentException("nonEmbeddedClassMeta is an instance of EmbeddedClassMeta: " + nonEmbeddedClassMeta);
069
070 this.nonEmbeddedClassMeta = nonEmbeddedClassMeta;
071 this.nonEmbeddedClassMeta_classID = nonEmbeddedClassMeta.getClassID();
072 if (nonEmbeddedClassMeta_classID < 0)
073 throw new IllegalStateException("nonEmbeddedClassMeta not yet persisted: " + nonEmbeddedClassMeta);
074
075 this.embeddingFieldMeta = embeddingFieldMeta;
076 this.embeddingFieldMeta_fieldID = embeddingFieldMeta.getFieldID();
077 if (embeddingFieldMeta_fieldID < 0)
078 throw new IllegalStateException("embeddingFieldMeta not yet persisted: " + embeddingFieldMeta);
079
080 // setUniqueScope(null); // set in jdoPreStore, because id not assigned, yet
081 setUniqueScope(UNIQUE_SCOPE_PREFIX_EMBEDDED_CLASS_META + embeddingFieldMeta_fieldID);
082 }
083
084 @Override
085 public void addFieldMeta(FieldMeta fieldMeta) {
086 if (!(fieldMeta instanceof EmbeddedFieldMeta)) {
087 throw new IllegalArgumentException("fieldMeta is NOT an instance of EmbeddedFieldMeta: " + fieldMeta);
088 }
089 super.addFieldMeta(fieldMeta);
090 Map<FieldMeta, EmbeddedFieldMeta> nefm2efmMap = nonEmbeddedFieldMeta2EmbeddedFieldMeta;
091 if (nefm2efmMap != null) {
092 EmbeddedFieldMeta embeddedFieldMeta = (EmbeddedFieldMeta) fieldMeta;
093 nefm2efmMap.put(embeddedFieldMeta.getNonEmbeddedFieldMeta(), embeddedFieldMeta);
094 }
095 }
096
097 @Override
098 public void removeFieldMeta(FieldMeta fieldMeta) {
099 super.removeFieldMeta(fieldMeta);
100 nonEmbeddedFieldMeta2EmbeddedFieldMeta = null;
101 }
102
103 /**
104 * Get the non-embedded {@link ClassMeta} of which this instance is a reference wihtin the scope of
105 * the {@link #getEmbeddingFieldMeta()}.
106 * @return the non-embedded {@link ClassMeta} (the one representing FCOs). Never <code>null</code>.
107 */
108 public ClassMeta getNonEmbeddedClassMeta() {
109 if (nonEmbeddedClassMeta == null) {
110 nonEmbeddedClassMeta = new ClassMetaDAO(getPersistenceManager()).getClassMeta(nonEmbeddedClassMeta_classID, true);
111 }
112 return nonEmbeddedClassMeta;
113 }
114
115 /**
116 * Get the field embedding this pseudo-class.
117 * <p>
118 * This may be an {@link EmbeddedFieldMeta}, if this is a nested-embedded-field-situation.
119 * @return the field embedding this pseudo-class. Never <code>null</code>.
120 */
121 public FieldMeta getEmbeddingFieldMeta() {
122 if (embeddingFieldMeta == null) {
123 embeddingFieldMeta = new FieldMetaDAO(getPersistenceManager()).getFieldMeta(embeddingFieldMeta_fieldID, true);
124 }
125 return embeddingFieldMeta;
126 }
127
128 // @Override
129 // public void jdoPreStore() {
130 // super.jdoPreStore();
131 // if (getUniqueScope() == null || !getUniqueScope().startsWith(UNIQUE_SCOPE_PREFIX_EMBEDDED_CLASS_META)) {
132 // setUniqueScope("TEMPORARY_" + UUID.randomUUID());
133 // if (nonEmbeddedClassMeta_classID < 0)
134 // nonEmbeddedClassMeta_classID = nextTemp_nonEmbeddedClassMeta_classID.decrementAndGet();
135 //
136 // if (embeddingFieldMeta_fieldID < 0)
137 // embeddingFieldMeta_fieldID = nextTemp_embeddingFieldMeta_fieldID.decrementAndGet();
138 //
139 // PostStoreRunnableManager.getInstance().addRunnable(new Runnable() {
140 // @Override
141 // public void run() {
142 // PersistenceManager pm = JDOHelper.getPersistenceManager(EmbeddedClassMeta.this);
143 //
144 // if (nonEmbeddedClassMeta != null)
145 // nonEmbeddedClassMeta = pm.makePersistent(nonEmbeddedClassMeta);
146 //
147 // if (nonEmbeddedClassMeta_classID < 0 && nonEmbeddedClassMeta != null)
148 // nonEmbeddedClassMeta_classID = nonEmbeddedClassMeta.getClassID();
149 //
150 // if (nonEmbeddedClassMeta_classID < 0)
151 // throw new IllegalStateException("nonEmbeddedClassMeta_classID < 0");
152 //
153 // if (embeddingFieldMeta != null)
154 // embeddingFieldMeta = pm.makePersistent(embeddingFieldMeta);
155 //
156 // if (embeddingFieldMeta_fieldID < 0 && embeddingFieldMeta != null)
157 // embeddingFieldMeta_fieldID = embeddingFieldMeta.getFieldID();
158 //
159 // if (embeddingFieldMeta_fieldID < 0)
160 // throw new IllegalStateException("embeddingFieldMeta_fieldID < 0");
161 //
162 // setUniqueScope(UNIQUE_SCOPE_PREFIX_EMBEDDED_CLASS_META + embeddingFieldMeta.getFieldID());
163 //
164 // pm.flush();
165 // }
166 // });
167 // }
168 // }
169
170 private static AtomicLong nextTemp_nonEmbeddedClassMeta_classID = new AtomicLong();
171 private static AtomicLong nextTemp_embeddingFieldMeta_fieldID = new AtomicLong();
172
173 /**
174 * Get the {@link FieldMeta} managed by this instances corresponding to the given <code>fieldMeta</code>.
175 * <p>
176 * The given <code>fieldMeta</code> can be a sub-FieldMeta (not directly assigned to the corresponding ClassMeta,
177 * but assigned to one of its FieldMetas).
178 * @param fieldMeta a non-embedded {@link FieldMeta} (i.e. <b>not</b> an instance of {@link EmbeddedFieldMeta}).
179 * @return
180 */
181 public EmbeddedFieldMeta getEmbeddedFieldMetaForNonEmbeddedFieldMeta(FieldMeta fieldMeta) {
182 if (fieldMeta == null)
183 throw new IllegalArgumentException("fieldMeta == null");
184
185 if (fieldMeta instanceof EmbeddedFieldMeta)
186 throw new IllegalArgumentException("fieldMeta is an instance of EmbeddedFieldMeta, but it should be a non-embedded FieldMeta!");
187
188 if (!this.getNonEmbeddedClassMeta().equals(fieldMeta.getClassMeta()))
189 throw new IllegalArgumentException("fieldMeta.classMeta != this.nonEmbeddedClassMeta");
190
191 if (nonEmbeddedFieldMeta2EmbeddedFieldMeta == null) {
192 Map<FieldMeta, EmbeddedFieldMeta> m = new HashMap<FieldMeta, EmbeddedFieldMeta>();
193 for (FieldMeta efm : getFieldMetasWithSubFieldMetas()) {
194 EmbeddedFieldMeta embeddedFieldMeta = (EmbeddedFieldMeta) efm;
195 m.put(embeddedFieldMeta.getNonEmbeddedFieldMeta(), embeddedFieldMeta);
196 }
197 nonEmbeddedFieldMeta2EmbeddedFieldMeta = m;
198 }
199 return nonEmbeddedFieldMeta2EmbeddedFieldMeta.get(fieldMeta);
200 }
201
202 protected Collection<FieldMeta> getFieldMetasWithSubFieldMetas() {
203 Collection<FieldMeta> result = new ArrayList<FieldMeta>();
204 for (FieldMeta fieldMeta : getFieldMetas()) {
205 populateFieldMetasWithSubFieldMetas(result, fieldMeta);
206 }
207 return result;
208 }
209 protected void populateFieldMetasWithSubFieldMetas(Collection<FieldMeta> result, FieldMeta fieldMeta) {
210 result.add(fieldMeta);
211 for (FieldMeta subFieldMeta : fieldMeta.getSubFieldMetas()) {
212 populateFieldMetasWithSubFieldMetas(result, subFieldMeta);
213 }
214 }
215
216 @Override
217 public void jdoPostDetach(Object o) {
218 final PostDetachRunnableManager postDetachRunnableManager = PostDetachRunnableManager.getInstance();
219 postDetachRunnableManager.enterScope();
220 try {
221 super.jdoPostDetach(o);
222 postDetachRunnableManager.addRunnable(new Runnable() {
223 @Override
224 public void run() {
225 DetachedClassMetaModel detachedClassMetaModel = DetachedClassMetaModel.getInstance();
226
227 if (detachedClassMetaModel == null) // we currently only detach with this being present - at least it should, hence we don't need to handle things differently.
228 throw new IllegalStateException("DetachedClassMetaModel.getInstance() returned null!");
229
230 if (detachedClassMetaModel != null) {
231 nonEmbeddedClassMeta = detachedClassMetaModel.getClassMeta(nonEmbeddedClassMeta_classID, false);
232 if (nonEmbeddedClassMeta == null)
233 setNonEmbeddedClassMetaPostponedInPostDetach(postDetachRunnableManager, detachedClassMetaModel, 1);
234 }
235 }
236 });
237 } finally {
238 postDetachRunnableManager.exitScope();
239 }
240 }
241
242 protected void setNonEmbeddedClassMetaPostponedInPostDetach(final PostDetachRunnableManager postDetachRunnableManager, final DetachedClassMetaModel detachedClassMetaModel, final int postponeCounter) {
243 postDetachRunnableManager.addRunnable(new Runnable() {
244 @Override
245 public void run() {
246 nonEmbeddedClassMeta = detachedClassMetaModel.getClassMeta(nonEmbeddedClassMeta_classID, false);
247 if (nonEmbeddedClassMeta == null) {
248 final int maxPostponeCounter = 100;
249 if (postponeCounter > maxPostponeCounter)
250 throw new IllegalStateException("postponeCounter > " + maxPostponeCounter);
251
252 setNonEmbeddedClassMetaPostponedInPostDetach(postDetachRunnableManager, detachedClassMetaModel, postponeCounter + 1);
253 }
254 }
255 });
256 }
257 }