private void deletePropertyChain(long nextProp) {
PropertyStore propStore = getPropertyStore();
while (nextProp != Record.NO_NEXT_PROPERTY.intValue()) {
PropertyRecord propRecord = propStore.getRecord(nextProp);
/*
* The only reason to loop over the blocks is to handle the dynamic
* records that possibly hang under them. Otherwise, we could just
* set the property record not in use and be done with it. The
* residue of the convenience is that we do not remove individual
* property blocks - we just mark the whole record as !inUse.
*/
for (PropertyBlock propBlock : propRecord.getPropertyBlocks()) {
if (propBlock.isLight()) {
propStore.makeHeavy(propBlock);
}
for (DynamicRecord rec : propBlock.getValueRecords()) {
rec.setInUse(false);
propRecord.addDeletedRecord(rec);
}
}
propRecord.setInUse(false);
nextProp = propRecord.getNextProp();
propStore.updateRecord(propRecord);
}
}
private boolean removePrimitiveProperty(PrimitiveRecord primitive, String property) {
PropertyRecord current = null;
PropertyBlock target = null;
long nextProp = primitive.getNextProp();
int propIndex = indexHolder.getKeyId(property);
if (nextProp == Record.NO_NEXT_PROPERTY.intValue() || propIndex == -1) {
// No properties or no one has that property, nothing changed
return false;
}
while (nextProp != Record.NO_NEXT_PROPERTY.intValue()) {
current = getPropertyStore().getRecord(nextProp);
if ((target = current.removePropertyBlock(propIndex)) != null) {
if (target.isLight()) {
getPropertyStore().makeHeavy(target);
}
for (DynamicRecord dynRec : target.getValueRecords()) {
current.addDeletedRecord(dynRec);
}
break;
}
nextProp = current.getNextProp();
}
if (current.size() > 0) {
getPropertyStore().updateRecord(current);
return false;
} else {
return unlinkPropertyRecord(current, primitive);
}
}
/** @return true if the passed primitive needs updating in the store. */
private boolean setPrimitiveProperty(PrimitiveRecord primitive, String name, Object value) {
boolean result = false;
long nextProp = primitive.getNextProp();
int index = indexHolder.getKeyId(name);
if (index == -1) {
index = createNewPropertyIndex(name);
}
PropertyBlock block = new PropertyBlock();
getPropertyStore().encodeValue(block, index, value);
int size = block.getSize();
/*
* current is the current record traversed
* thatFits is the earliest record that can host the block
* thatHas is the record that already has a block for this index
*/
PropertyRecord current = null, thatFits = null, thatHas = null;
/*
* We keep going while there are records or until we both found the
* property if it exists and the place to put it, if exists.
*/
while (!(nextProp == Record.NO_NEXT_PROPERTY.intValue()
|| (thatHas != null && thatFits != null))) {
current = getPropertyStore().getRecord(nextProp);
/*
* current.getPropertyBlock() is cheap but not free. If we already
* have found thatHas, then we can skip this lookup.
*/
if (thatHas == null && current.getPropertyBlock(index) != null) {
thatHas = current;
PropertyBlock removed = thatHas.removePropertyBlock(index);
if (removed.isLight()) {
getPropertyStore().makeHeavy(removed);
for (DynamicRecord dynRec : removed.getValueRecords()) {
thatHas.addDeletedRecord(dynRec);
}
}
getPropertyStore().updateRecord(thatHas);
}
/*
* We check the size after we remove - potentially we can put in the same record.
*
* current.size() is cheap but not free. If we already found somewhere
* where it fits, no need to look again.
*/
if (thatFits == null && (PropertyType.getPayloadSize() - current.size() >= size)) {
thatFits = current;
}
nextProp = current.getNextProp();
}
/*
* thatHas is of no importance here. We know that the block is definitely not there.
* However, we can be sure that if the property existed, thatHas is not null and does
* not contain the block.
*
* thatFits is interesting. If null, we need to create a new record and link, otherwise
* just add the block there.
*/
if (thatFits == null) {
thatFits = new PropertyRecord(getPropertyStore().nextId());
thatFits.setInUse(true);
result = true;
if (primitive.getNextProp() != Record.NO_NEXT_PROPERTY.intValue()) {
PropertyRecord first = getPropertyStore().getRecord(primitive.getNextProp());
thatFits.setNextProp(first.getId());
first.setPrevProp(thatFits.getId());
getPropertyStore().updateRecord(first);
}
primitive.setNextProp(thatFits.getId());
}
thatFits.addPropertyBlock(block);
getPropertyStore().updateRecord(thatFits);
return result;
}
