/**
* <p>
* Decodes the content of the supplied <code>ValueState</code> as an array
* of Objects. Usually this array has one element containing the single
* Object value encoded in the <code>ValueState</code>. However, if multiple
* items were written to the original <code>Value</code> from which the
* <code>ValueState</code> was derived in
* <a href="com.persistit.Value.html#_streamMode">Stream Mode</a>, this
* method returns all of the encoded objects.
* </p>
* <p>
* If the <code>valueState</code> represents an undefined value, this method
* returns an array of length zero. If the <code>valueState</code> encodes
* a value of <code>null</code>, then this method returns an array containing
* one element which is <code>null</code>.
* </p>
*
* @param valueState Representation of an encoded {@link Value).
*
* @param context Object passed to any {@link ValueCoder} used in
* decoding the value. May be <code>null</code>
*
* @return Array of zero or more Objects encoded
* in the <code>ValueState</code>
* @throws RemoteException
*/
@Override
public Object[] decodeValueObjects(final ValueState valueState, final CoderContext context)
throws RemoteException {
try {
final Value value = new Value(_persistit);
valueState.copyTo(value);
value.setStreamMode(true);
final Vector vector = new Vector();
while (value.hasMoreItems()) {
vector.addElement(value.get(null, context));
}
final Object[] result = new Object[vector.size()];
for (int index = 0; index < result.length; index++) {
result[index] = vector.get(index);
}
return result;
} catch (final Exception e) {
throw new WrappedRemoteException(e);
}
}
/**
* Look up and return the ClassInfo for an integer handle. This is used when decoding an <code>
* Object</code> from a <code>com.persistit.Value</code> to associate the encoded integer handle
* value with the corresponding class.
*
* @param handle The handle
* @return The associated ClassInfo, or <i>null</i> if there is none.
*/
public ClassInfo lookupByHandle(final int handle) {
final AtomicReferenceArray<ClassInfoEntry> hashTable = _hashTable;
ClassInfoEntry cie = hashTable.get(handle % hashTable.length());
while (cie != null) {
if (cie._classInfo.getHandle() == handle) return cie._classInfo;
cie = cie._next;
}
_cacheMisses.incrementAndGet();
synchronized (this) {
_sessionId.assign();
Exchange ex = null;
try {
ex = getExchange();
final Transaction txn = ex.getTransaction();
txn.begin();
try {
ex.clear().append(BY_HANDLE).append(handle).fetch();
txn.commit();
} catch (final Exception e) {
_persistit.getLogBase().exception.log(e);
throw new ConversionException(e);
} finally {
txn.end();
}
final Value value = ex.getValue();
if (value.isDefined()) {
value.setStreamMode(true);
final int storedId = value.getInt();
final String storedName = value.getString();
final long storedSuid = value.getLong();
if (storedId != handle) {
throw new IllegalStateException(
"ClassInfo stored for handle=" + handle + " has invalid stored handle=" + storedId);
}
final Class<?> cl =
Class.forName(storedName, false, Thread.currentThread().getContextClassLoader());
long suid = 0;
final ObjectStreamClass osc = ObjectStreamClass.lookupAny(cl);
if (osc != null) suid = osc.getSerialVersionUID();
if (storedSuid != suid) {
throw new ConversionException(
"Class "
+ cl.getName()
+ " persistent SUID="
+ storedSuid
+ " does not match current class SUID="
+ suid);
}
final ClassInfo ci = new ClassInfo(cl, suid, handle, osc);
hashClassInfo(ci);
return ci;
} else {
final ClassInfo ci = new ClassInfo(null, 0, handle, null);
hashClassInfo(ci);
return ci;
}
} catch (final ClassNotFoundException cnfe) {
throw new ConversionException(cnfe);
} catch (final PersistitException pe) {
throw new ConversionException(pe);
} finally {
if (ex != null) releaseExchange(ex);
}
}
}
/**
* Look up and return the ClassInfo for a class. This is used when encoding an <code>Object</code>
* into a <code>com.persistit.Value</code>.
*
* @param clazz The <code>Class</code>
* @return The ClassInfo for the specified Class.
*/
public ClassInfo lookupByClass(final Class<?> clazz) {
final AtomicReferenceArray<ClassInfoEntry> hashTable = _hashTable;
ObjectStreamClass osc = null;
long suid = 0;
final int nh = clazz.getName().hashCode() & 0x7FFFFFFF;
ClassInfoEntry cie = hashTable.get(nh % hashTable.length());
while (cie != null) {
if (clazz.equals(cie._classInfo.getDescribedClass())) {
return cie._classInfo;
}
if (cie._classInfo.getDescribedClass() != null
&& cie._classInfo.getName().equals(clazz.getName())) {
if (osc == null) {
osc = ObjectStreamClass.lookupAny(clazz);
if (osc != null) {
suid = osc.getSerialVersionUID();
}
}
if (suid == cie._classInfo.getSUID()) {
return cie._classInfo;
}
}
cie = cie._next;
}
if (osc == null) {
osc = ObjectStreamClass.lookupAny(clazz);
}
if (osc != null) {
suid = osc.getSerialVersionUID();
}
_cacheMisses.incrementAndGet();
/**
* To update the tree, this class uses a unique SessionId and results in using a unique
* Transaction context unrelated to the application context. Therefore if an application does
* this:
*
* <pre>
* <code>
* txn.begin();
* value.put(new SomeClass());
* txn.rollback();
* txn.end();
* </code>
* </pre>
*
* the class SomeClass will be registered even though the enclosing transaction rolled back.
* This is important because other concurrent threads may have started using the handle for
* SomeClass. Therefore this class ensures that a non-nested transaction to insert the new
* ClassInfo into the system volume has committed before adding the handle to the hash table.
*/
synchronized (this) {
final SessionId saveSessionId = _persistit.getSessionId();
Exchange ex = null;
try {
_persistit.setSessionId(_sessionId);
ex = getExchange();
final Transaction txn = ex.getTransaction();
final ClassInfo ci;
final int handle;
txn.begin();
ex.clear().append(BY_NAME).append(clazz.getName()).append(suid).fetch();
final Value value = ex.getValue();
try {
if (value.isDefined()) {
value.setStreamMode(true);
handle = value.getInt();
final String storedName = value.getString();
final long storedSuid = value.getLong();
if (storedSuid != suid || !clazz.getName().equals(storedName)) {
throw new ConversionException(
"Class "
+ clazz.getName()
+ " persistent SUID="
+ storedSuid
+ " does not match current class SUID="
+ suid);
}
ci = new ClassInfo(clazz, suid, handle, osc);
} else {
//
// Store a new ClassInfo record
//
ex.clear().append(NEXT_ID).fetch();
handle = Math.max(_testIdFloor, value.isDefined() ? value.getInt() : HANDLE_BASE) + 1;
value.clear().put(handle);
ex.store();
value.clear();
value.setStreamMode(true);
value.put(handle);
value.put(clazz.getName());
value.put(suid);
ex.clear().append(BY_NAME).append(clazz.getName()).append(suid).store();
ex.clear().append(BY_HANDLE).append(handle).store();
ci = new ClassInfo(clazz, suid, handle, osc);
}
txn.commit();
hashClassInfo(ci);
return ci;
} finally {
txn.end();
}
} catch (final PersistitException pe) {
throw new ConversionException(pe);
} finally {
if (ex != null) {
releaseExchange(ex);
}
_persistit.setSessionId(saveSessionId);
}
}
}
