internal override void AssertAdditionalHeader(PageCursor cursor, TreeNode <MutableLong, MutableLong> node, int pageSize)
{ // no addition header
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: void visitTreeNode(org.neo4j.io.pagecache.PageCursor cursor, GBPTreeVisitor<KEY,VALUE> visitor) throws java.io.IOException
internal virtual void VisitTreeNode(PageCursor cursor, GBPTreeVisitor <KEY, VALUE> visitor)
{
//[TYPE][GEN][KEYCOUNT] ([RIGHTSIBLING][LEFTSIBLING][SUCCESSOR]))
bool isLeaf;
int keyCount;
long generation = -1;
do
{
isLeaf = TreeNode.IsLeaf(cursor);
keyCount = TreeNode.KeyCount(cursor);
if (!_node.reasonableKeyCount(keyCount))
{
cursor.CursorException = "Unexpected keyCount " + keyCount;
}
generation = TreeNode.Generation(cursor);
} while (cursor.ShouldRetry());
visitor.BeginNode(cursor.CurrentPageId, isLeaf, generation, keyCount);
KEY key = _layout.newKey();
VALUE value = _layout.newValue();
for (int i = 0; i < keyCount; i++)
{
long child = -1;
do
{
_node.keyAt(cursor, key, i, isLeaf ? LEAF : INTERNAL);
if (isLeaf)
{
_node.valueAt(cursor, value, i);
}
else
{
child = pointer(_node.childAt(cursor, i, _stableGeneration, _unstableGeneration));
}
} while (cursor.ShouldRetry());
visitor.Position(i);
if (isLeaf)
{
visitor.Key(key, isLeaf);
visitor.Value(value);
}
else
{
visitor.Child(child);
visitor.Key(key, isLeaf);
}
}
if (!isLeaf)
{
long child;
do
{
child = pointer(_node.childAt(cursor, keyCount, _stableGeneration, _unstableGeneration));
} while (cursor.ShouldRetry());
visitor.Position(keyCount);
visitor.Child(child);
}
visitor.EndNode(cursor.CurrentPageId);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static void visitTreeState(org.neo4j.io.pagecache.PageCursor cursor, GBPTreeVisitor visitor) throws java.io.IOException
internal static void VisitTreeState(PageCursor cursor, GBPTreeVisitor visitor)
{
Pair <TreeState, TreeState> statePair = TreeStatePair.ReadStatePages(cursor, IdSpace.STATE_PAGE_A, IdSpace.STATE_PAGE_B);
visitor.treeState(statePair);
}
protected internal abstract void DoWriteInternal(RECORD record, PageCursor cursor);
protected internal static long DecodeCompressedReference(PageCursor cursor, long headerByte, int headerBitMask, long nullValue)
{
return(has(headerByte, headerBitMask) ? DecodeCompressedReference(cursor) : nullValue);
}
protected internal override void DoReadInternal(RelationshipGroupRecord record, PageCursor cursor, int recordSize, long headerByte, bool inUse)
{
record.Initialize(inUse, cursor.Short & 0xFFFF, DecodeCompressedReference(cursor, headerByte, _hasOutgoingBit, Null), DecodeCompressedReference(cursor, headerByte, _hasIncomingBit, Null), DecodeCompressedReference(cursor, headerByte, _hasLoopBit, Null), DecodeCompressedReference(cursor), DecodeCompressedReference(cursor, headerByte, _hasNextBit, Null));
}
private void Write(PageCursor cursor, TreeState origin)
{
TreeState.Write(cursor, origin.StableGeneration(), origin.UnstableGeneration(), origin.RootId(), origin.RootGeneration(), origin.LastId(), origin.FreeListWritePageId(), origin.FreeListReadPageId(), origin.FreeListWritePos(), origin.FreeListReadPos(), origin.Clean);
}
public override void WriteKey(PageCursor cursor, MutableLong key)
{
cursor.PutLong(key.longValue());
cursor.PutBytes(_keyPadding, ( sbyte )0);
}
public override void WriteValue(PageCursor cursor, MutableLong value)
{
cursor.PutLong(value.longValue());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustAutomaticallyStartEvictionThread() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void MustAutomaticallyStartEvictionThread()
{
using (FileSystemAbstraction fs = new DefaultFileSystemAbstraction(), JobScheduler jobScheduler = new ThreadPoolJobScheduler())
{
File file = (new File(TestDirectory.directory(), "a")).CanonicalFile;
fs.Create(file).close();
using (PageCache cache = ConfigurableStandalonePageCacheFactory.CreatePageCache(fs, jobScheduler), PagedFile pf = cache.Map(file, 4096), PageCursor cursor = pf.Io(0, Org.Neo4j.Io.pagecache.PagedFile_Fields.PfSharedWriteLock))
{
// The default size is currently 8MBs.
// It should be possible to write more than that.
// If the eviction thread has not been started, then this test will block forever.
for (int i = 0; i < 10_000; i++)
{
assertTrue(cursor.Next());
cursor.PutInt(42);
}
}
}
}
private void Write(PageCursor cursor, int offset, GSP gsp)
{
cursor.Offset = offset;
GenerationSafePointer.Write(cursor, gsp.Generation, gsp.Pointer);
}
private void NodeAdvance(NodeRecord record, PageCursor pageCursor)
{
_read.nextRecordByCursor(record, RecordLoad.CHECK, pageCursor);
}
private void Node(NodeRecord record, long reference, PageCursor pageCursor)
{
_read.getRecordByCursor(reference, record, RecordLoad.CHECK, pageCursor);
}
protected internal override void WriteRecordData(PropertyKeyTokenRecord record, PageCursor cursor)
{
cursor.PutInt(record.PropertyCount);
cursor.PutInt(record.NameId);
}
public override abstract void WriteValue(Org.Neo4j.Io.pagecache.PageCursor cursor, VALUE value);
public override void ReadKey(PageCursor cursor, MutableLong into, int keySize)
{
into.Value = cursor.Long;
cursor.GetBytes(new sbyte[_keyPadding]);
}
public override abstract void WriteKey(Org.Neo4j.Io.pagecache.PageCursor cursor, KEY key);
public override void ReadValue(PageCursor cursor, MutableLong into, int valueSize)
{
into.Value = cursor.Long;
}
protected internal override void DoWriteInternal(RelationshipGroupRecord record, PageCursor cursor)
{
cursor.PutShort(( short )record.Type);
Encode(cursor, record.FirstOut, Null);
Encode(cursor, record.FirstIn, Null);
Encode(cursor, record.FirstLoop, Null);
Encode(cursor, record.OwningNode);
Encode(cursor, record.Next, Null);
}
public override void WriteMetaData(PageCursor cursor)
{
WriteString(cursor, _customNameAsMetaData);
cursor.PutInt(_keyPadding);
}
protected internal abstract void DoReadInternal(RECORD record, PageCursor cursor, int recordSize, long inUseByte, bool inUse);
private static void WriteString(PageCursor cursor, string @string)
{
sbyte[] bytes = @string.GetBytes(UTF_8);
cursor.PutInt(@string.Length);
cursor.PutBytes(bytes);
}
protected internal static long DecodeCompressedReference(PageCursor cursor)
{
return(Reference.decode(cursor));
}
public override abstract void WriteMetaData(Org.Neo4j.Io.pagecache.PageCursor cursor);
protected internal static void Encode(PageCursor cursor, long reference)
{
Reference.encode(reference, cursor);
}
public override abstract void ReadValue(Org.Neo4j.Io.pagecache.PageCursor cursor, VALUE into, int valueSize);
private static PageCursor Select(PageCursor readCursor, PageCursor writeCursor)
{
return(writeCursor == null ? readCursor : readCursor.CurrentPageId == writeCursor.CurrentPageId ? writeCursor : readCursor);
}
public override abstract void ReadKey(Org.Neo4j.Io.pagecache.PageCursor cursor, KEY into, int keySize);
protected internal override void DoWriteInternal(NodeRecord record, PageCursor cursor)
{
Encode(cursor, record.NextRel, Null);
Encode(cursor, record.NextProp, Null);
Encode(cursor, record.LabelField, _nullLabels);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void write(RECORD record, org.neo4j.io.pagecache.PageCursor cursor, int recordSize) throws java.io.IOException
public override void Write(RECORD record, PageCursor cursor, int recordSize)
{
_actual.write(record, cursor, recordSize);
}
