private void writePropertyBlock(PropertyBlock block) throws IOException {
byte blockSize = (byte) block.getSize();
assert blockSize > 0 : blockSize + " is not a valid block size value";
channel.put(blockSize); // 1
long[] propBlockValues = block.getValueBlocks();
for (long propBlockValue : propBlockValues) {
channel.putLong(propBlockValue);
}
/*
* For each block we need to keep its dynamic record chain if
* it is just created. Deleted dynamic records are in the property
* record and dynamic records are never modified. Also, they are
* assigned as a whole, so just checking the first should be enough.
*/
if (block.isLight()) {
/*
* This has to be int. If this record is not light
* then we have the number of DynamicRecords that follow,
* which is an int. We do not currently want/have a flag bit so
* we simplify by putting an int here always
*/
channel.putInt(0); // 4 or
} else {
writeDynamicRecords(block.getValueRecords());
}
}
private void writePropertyRecord(PropertyRecord record) throws IOException {
byte inUse = record.inUse() ? Record.IN_USE.byteValue() : Record.NOT_IN_USE.byteValue();
if (record.getRelId() != -1) {
// Here we add 2, i.e. set the second lsb.
inUse += Record.REL_PROPERTY.byteValue();
}
channel.put(inUse); // 1
channel.putLong(record.getNextProp()).putLong(record.getPrevProp()); // 8 + 8
long nodeId = record.getNodeId();
long relId = record.getRelId();
if (nodeId != -1) {
channel.putLong(nodeId); // 8 or
} else if (relId != -1) {
channel.putLong(relId); // 8 or
} else {
// means this records value has not changed, only place in
// prop chain
channel.putLong(-1); // 8
}
channel.put((byte) record.numberOfProperties()); // 1
for (PropertyBlock block : record) {
assert block.getSize() > 0 : record + " seems kinda broken";
writePropertyBlock(block);
}
writeDynamicRecords(record.getDeletedRecords());
}
PropertyBlock readPropertyBlock() throws IOException {
PropertyBlock toReturn = new PropertyBlock();
byte blockSize = channel.get(); // the size is stored in bytes // 1
assert blockSize > 0 && blockSize % 8 == 0 : blockSize + " is not a valid block size value";
// Read in blocks
long[] blocks = readLongs(blockSize / 8);
assert blocks.length == blockSize / 8
: blocks.length
+ " longs were read in while i asked for what corresponds to "
+ blockSize;
assert PropertyType.getPropertyType(blocks[0], false).calculateNumberOfBlocksUsed(blocks[0])
== blocks.length
: blocks.length
+ " is not a valid number of blocks for type "
+ PropertyType.getPropertyType(blocks[0], false);
/*
* Ok, now we may be ready to return, if there are no DynamicRecords. So
* we start building the Object
*/
toReturn.setValueBlocks(blocks);
/*
* Read in existence of DynamicRecords. Remember, this has already been
* read in the buffer with the blocks, above.
*/
if (readDynamicRecords(toReturn, PROPERTY_BLOCK_DYNAMIC_RECORD_ADDER) == -1) {
return null;
}
return toReturn;
}
@Override
public void processProperty(RecordStore<PropertyRecord> store, PropertyRecord property) {
int size = 0;
for (PropertyBlock block : property) {
update(typeHistogram, block.getType());
size++;
}
update(sizeHistogram, size);
}