internal FreeListIdProvider(PagedFile pagedFile, int pageSize, long lastId, Monitor monitor) { this._pagedFile = pagedFile; this._monitor = monitor; this._freelistNode = new FreelistNode(pageSize); this._lastId = lastId; }
public UpdateWorkerAnonymousInnerClass(PageCacheSlowTest <T> outerInstance, int i, int filePages, AtomicBoolean shouldStop, Org.Neo4j.Io.pagecache.PagedFile pagedFile) : base(i, filePages, shouldStop, pagedFile) { this.outerInstance = outerInstance; this._shouldStop = shouldStop; this._filePages = filePages; this._pagedFile = pagedFile; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: PageLoader getLoader(org.neo4j.io.pagecache.PagedFile file) throws java.io.IOException internal virtual PageLoader GetLoader(PagedFile file) { if (FileUtils.highIODevice(file.File().toPath(), false)) { return(new ParallelPageLoader(file, _executor, _pageCache)); } return(new SingleCursorPageLoader(file)); }
internal KeyValueStoreFile(PagedFile file, int keySize, int valueSize, Metadata metadata) { this._file = file; this._keySize = keySize; this._valueSize = valueSize; this._headerEntries = metadata.HeaderEntries(); this._totalEntries = metadata.TotalEntries(); this._headers = metadata.Headers(); this._pageCatalogue = metadata.PageCatalogue(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void verifyPageCacheLongArray() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void VerifyPageCacheLongArray() { PageCache pageCache = _pageCacheRule.getPageCache(_fs); PagedFile file = pageCache.Map(_dir.file("file"), pageCache.PageSize(), CREATE, DELETE_ON_CLOSE); using (LongArray array = new PageCacheLongArray(file, COUNT, 0, 0)) { VerifyBehaviour(array); } }
/// <summary> /// Visit the header, that is tree state and meta information, about the tree present in the given {@code file}. /// </summary> /// <param name="pageCache"> <seealso cref="PageCache"/> able to map tree contained in {@code file}. </param> /// <param name="file"> <seealso cref="File"/> containing the tree to print header for. </param> /// <param name="visitor"> <seealso cref="GBPTreeVisitor"/> that shall visit header. </param> /// <exception cref="IOException"> on I/O error. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static void visitHeader(org.neo4j.io.pagecache.PageCache pageCache, java.io.File file, GBPTreeVisitor visitor) throws java.io.IOException public static void VisitHeader(PageCache pageCache, File file, GBPTreeVisitor visitor) { using (PagedFile pagedFile = pageCache.Map(file, pageCache.PageSize(), StandardOpenOption.READ)) { using (PageCursor cursor = pagedFile.Io(IdSpace.STATE_PAGE_A, Org.Neo4j.Io.pagecache.PagedFile_Fields.PF_SHARED_READ_LOCK)) { VisitMeta(cursor, visitor); VisitTreeState(cursor, visitor); } } }
public override ByteArray NewByteArray(long length, sbyte[] defaultValue, long @base) { try { File tempFile = File.createTempFile("byteArray", ".tmp", _storeDir); PagedFile pagedFile = _pageCache.map(tempFile, _pageCache.pageSize(), DELETE_ON_CLOSE, CREATE); return(new PageCacheByteArray(pagedFile, length, defaultValue, @base)); } catch (IOException e) { throw new UncheckedIOException(e); } }
//JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the Java 'super' constraint: //ORIGINAL LINE: static <Buffer extends BigEndianByteArrayBuffer> void scanAll(org.neo4j.io.pagecache.PagedFile file, int startOffset, EntryVisitor<? super Buffer> visitor, Buffer key, Buffer value) throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal static void ScanAll <Buffer, T1>(PagedFile file, int startOffset, EntryVisitor <T1> visitor, Buffer key, Buffer value) where Buffer : BigEndianByteArrayBuffer { bool visitHeaders = !(visitor is KeyValueVisitor); using (PageCursor cursor = file.Io(startOffset / file.PageSize(), PF_SHARED_READ_LOCK)) { if (!cursor.Next()) { return; } ReadKeyValuePair(cursor, startOffset, key, value); VisitKeyValuePairs(file.PageSize(), cursor, startOffset, visitor, visitHeaders, key, value); } }
public override void Set(long index, long value) { long pageId = pageId(index); int offset = offset(index); try { using (PageCursor cursor = PagedFile.io(pageId, PF_SHARED_WRITE_LOCK | PF_NO_GROW)) { cursor.Next(); cursor.PutLong(offset, value); CheckBounds(cursor); } } catch (IOException e) { throw new UncheckedIOException(e); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: PageCacheNumberArray(org.neo4j.io.pagecache.PagedFile pagedFile, int entrySize, long length, long defaultValue, long super) throws java.io.IOException internal PageCacheNumberArray(PagedFile pagedFile, int entrySize, long length, long defaultValue, long @base) { this.PagedFile = pagedFile; this.EntrySize = entrySize; this.EntriesPerPage = pagedFile.PageSize() / entrySize; this._length = length; this._defaultValue = defaultValue; this.@base = @base; using (PageCursor cursorToSetLength = pagedFile.Io(0, PF_SHARED_WRITE_LOCK)) { SetLength(cursorToSetLength, length); } if (defaultValue != 0) { DefaultValue = defaultValue; } }
private bool DatabaseExistsAndContainsData() { File metaDataFile = _databaseLayout.metadataStore(); try { using (PagedFile pagedFile = _pageCache.map(metaDataFile, _pageCache.pageSize(), StandardOpenOption.READ)) { // OK so the db probably exists } } catch (IOException) { // It's OK return(false); } using (NeoStores stores = NewStoreFactory(_databaseLayout).openNeoStores(StoreType.NODE, StoreType.RELATIONSHIP)) { return(stores.NodeStore.HighId > 0 || stores.RelationshipStore.HighId > 0); } }
public override long Get(long index) { long pageId = pageId(index); int offset = offset(index); try { using (PageCursor cursor = PagedFile.io(pageId, PF_SHARED_READ_LOCK)) { cursor.Next(); long result; do { result = cursor.GetLong(offset); } while (cursor.ShouldRetry()); CheckBounds(cursor); return(result); } } catch (IOException e) { throw new UncheckedIOException(e); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: SingleCursorPageLoader(org.neo4j.io.pagecache.PagedFile file) throws java.io.IOException internal SingleCursorPageLoader(PagedFile file) { _cursor = file.Io(0, PF_SHARED_READ_LOCK); }
public AdversarialPagedFile(PagedFile @delegate, Adversary adversary) { this.@delegate = Objects.requireNonNull(@delegate); this._adversary = Objects.requireNonNull(adversary); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: PageCacheLongArray(org.neo4j.io.pagecache.PagedFile pagedFile, long length, long defaultValue, long super) throws java.io.IOException internal PageCacheLongArray(PagedFile pagedFile, long length, long defaultValue, long @base) : base(pagedFile, Long.BYTES, length, defaultValue, @base) { }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: PageCacheNumberArray(org.neo4j.io.pagecache.PagedFile pagedFile, int entrySize, long length, long super) throws java.io.IOException internal PageCacheNumberArray(PagedFile pagedFile, int entrySize, long length, long @base) : this(pagedFile, entrySize, length, 0, @base) { }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: PageCacheIntArray(org.neo4j.io.pagecache.PagedFile pagedFile, long length, long defaultValue, long super) throws java.io.IOException internal PageCacheIntArray(PagedFile pagedFile, long length, long defaultValue, long @base) : base(pagedFile, Integer.BYTES, length, defaultValue | defaultValue << (sizeof(int) * 8), @base) { }