private static void WriteBaseHeader(PageCursor cursor, sbyte type, long stableGeneration, long unstableGeneration)
{
cursor.PutByte(BYTE_POS_NODE_TYPE, NODE_TYPE_TREE_NODE);
cursor.PutByte(BytePosType, type);
SetGeneration(cursor, unstableGeneration);
SetKeyCount(cursor, 0);
SetRightSibling(cursor, NO_NODE_FLAG, stableGeneration, unstableGeneration);
SetLeftSibling(cursor, NO_NODE_FLAG, stableGeneration, unstableGeneration);
SetSuccessor(cursor, NO_NODE_FLAG, stableGeneration, unstableGeneration);
}
public override void Write(Record record, PageCursor cursor)
{
StandardRecord r = ( StandardRecord )record;
sbyte[] pathBytes = r.File.Path.getBytes(StandardCharsets.UTF_8);
sbyte fileByte = pathBytes[pathBytes.Length - 1];
cursor.PutByte(r.Type);
cursor.PutByte(fileByte);
cursor.PutShort(r.Fill1);
cursor.PutInt(r.RecordId);
cursor.PutLong(r.Fill2);
}
protected internal override void DoWriteInternal(MyRecord record, PageCursor cursor)
{
int intsPerRecord = ShortsPerRecord;
for (int i = 0; i < intsPerRecord; i++)
{
short v = record.Value;
sbyte a = ( sbyte )((v & 0x0000FF00) >> 8);
sbyte b = unchecked (( sbyte )(v & 0x000000FF));
cursor.PutByte(a);
cursor.PutByte(b);
}
}
public override void Write(DynamicRecord record, PageCursor cursor, int recordSize)
{
if (record.InUse())
{
long nextBlock = record.NextBlock;
int highByteInFirstInteger = nextBlock == Record.NO_NEXT_BLOCK.intValue() ? 0 : (int)((nextBlock & 0xF00000000L) >> 8);
highByteInFirstInteger |= Record.IN_USE.byteValue() << 28;
highByteInFirstInteger |= (record.StartRecord ? 0 : 1) << 31;
/*
* First 4b
* [x , ][ , ][ , ][ , ] 0: start record, 1: linked record
* [ x, ][ , ][ , ][ , ] inUse
* [ ,xxxx][ , ][ , ][ , ] high next block bits
* [ , ][xxxx,xxxx][xxxx,xxxx][xxxx,xxxx] nr of bytes in the data field in this record
*
*/
int firstInteger = record.Length;
Debug.Assert(firstInteger < (1 << 24) - 1);
firstInteger |= highByteInFirstInteger;
cursor.PutInt(firstInteger);
cursor.PutInt(( int )nextBlock);
cursor.PutBytes(record.Data);
}
else
{
cursor.PutByte(Record.NOT_IN_USE.byteValue());
}
}
public override void WriteHeader(PageCursor cursor)
{
for (int i = 0; i < RecordHeaderSize; i++)
{
cursor.PutByte(( sbyte )ThreadLocalRandom.current().Next());
}
}
public override void Swap(long fromIndex, long toIndex)
{
long fromPageId = PageId(fromIndex);
int fromOffset = Offset(fromIndex);
long toPageId = PageId(toIndex);
int toOffset = Offset(toIndex);
try
{
using (PageCursor fromCursor = PagedFile.io(fromPageId, PF_SHARED_WRITE_LOCK), PageCursor toCursor = PagedFile.io(toPageId, PF_SHARED_WRITE_LOCK))
{
fromCursor.Next();
toCursor.Next();
for (int i = 0; i < EntrySize; i++, fromOffset++, toOffset++)
{
sbyte intermediary = fromCursor.GetByte(fromOffset);
fromCursor.PutByte(fromOffset, toCursor.GetByte(toOffset));
toCursor.PutByte(toOffset, intermediary);
}
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
public override void Write(DynamicRecord record, PageCursor cursor, int recordSize)
{
if (record.InUse())
{
Debug.Assert(record.Length < (1 << 24) - 1);
sbyte headerByte = ( sbyte )((record.InUse() ? IN_USE_BIT : 0) | (record.StartRecord ? START_RECORD_BIT : 0));
cursor.PutByte(headerByte);
cursor.PutShort(( short )record.Length);
cursor.PutByte(( sbyte )(( int )(( uint )record.Length >> 16)));
cursor.PutLong(record.NextBlock);
cursor.PutBytes(record.Data);
}
else
{
MarkAsUnused(cursor);
}
}
public override int CopyTo(int sourceOffset, PageCursor targetCursor, int targetOffset, int lengthInBytes)
{
if (sourceOffset < 0 || targetOffset < 0 || lengthInBytes < 0)
{
throw new System.ArgumentException(format("sourceOffset=%d, targetOffset=%d, lengthInBytes=%d, currentPageId=%d", sourceOffset, targetOffset, lengthInBytes, _currentPageId));
}
int bytesToCopy = Math.Min(lengthInBytes, Math.Min(_current.CurrentPageSize - sourceOffset, targetCursor.CurrentPageSize - targetOffset));
for (int i = 0; i < bytesToCopy; i++)
{
targetCursor.PutByte(targetOffset + i, GetByte(sourceOffset + i));
}
return(bytesToCopy);
}
public override void SetByte(long index, int offset, sbyte value)
{
long pageId = pageId(index);
offset += offset(index);
try
{
using (PageCursor cursor = PagedFile.io(pageId, PF_SHARED_WRITE_LOCK | PF_NO_GROW))
{
cursor.Next();
cursor.PutByte(offset, value);
CheckBounds(cursor);
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustFinishInitialisationOfIncompleteStoreHeader() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void MustFinishInitialisationOfIncompleteStoreHeader()
{
CreateStore();
int headerSizeInRecords = _store.NumberOfReservedLowIds;
int headerSizeInBytes = headerSizeInRecords * _store.RecordSize;
using (PageCursor cursor = _store.pagedFile.io(0, Org.Neo4j.Io.pagecache.PagedFile_Fields.PfSharedWriteLock))
{
assertTrue(cursor.Next());
for (int i = 0; i < headerSizeInBytes; i++)
{
cursor.PutByte(( sbyte )0);
}
}
int pageSize = _store.pagedFile.pageSize();
_store.close();
_store.pageCache.map(_store.StorageFile, pageSize, StandardOpenOption.TRUNCATE_EXISTING).close();
CreateStore();
}
public override void Set3ByteInt(long index, int offset, int value)
{
long pageId = pageId(index);
offset += offset(index);
try
{
using (PageCursor cursor = PagedFile.io(pageId, PF_SHARED_WRITE_LOCK | PF_NO_GROW))
{
cursor.Next();
cursor.PutShort(offset, ( short )value);
cursor.PutByte(offset + Short.BYTES, ( sbyte )(( int )(( uint )value >> (sizeof(short) * 8))));
CheckBounds(cursor);
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
public override void Set(long index, sbyte[] value)
{
Debug.Assert(value.Length == EntrySize);
long pageId = pageId(index);
int offset = offset(index);
try
{
using (PageCursor cursor = PagedFile.io(pageId, PF_SHARED_WRITE_LOCK | PF_NO_GROW))
{
cursor.Next();
for (int i = 0; i < value.Length; i++)
{
cursor.PutByte(offset + i, value[i]);
}
CheckBounds(cursor);
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
public override void Write(MetaDataRecord record, PageCursor cursor, int recordSize)
{
Debug.Assert(record.InUse());
cursor.PutByte(Record.IN_USE.byteValue());
cursor.PutLong(record.Value);
}
internal virtual void PutInternal(PageCursor cursor)
{
cursor.PutByte(TypeConflict.typeId);
TypeConflict.putValue(cursor, this);
}
private static void Put3BInt(PageCursor cursor, int value)
{
cursor.PutShort(( short )value);
cursor.PutByte(( sbyte )(( int )(( uint )value >> (sizeof(short) * 8))));
}
internal override void PutValue(PageCursor cursor, GenericKey state)
{
cursor.PutByte(( sbyte )state.Long1);
PutArray(cursor, state, NumberArrayElementWriter(state));
}