internal int ReadDataCell(MfsCellId cellId, System.IO.Stream stream, int length) { MfsDataCell *dc; byte[] buf = new byte[_dataCellDataMaxLength]; int bytesRead = 0; while (length > 0) { MfsCellId newCellId; int readLength; dc = (MfsDataCell *)this.ReferenceCell(cellId); readLength = length > dc->DataLength ? dc->DataLength : length; Marshal.Copy(new IntPtr(&dc->Data), buf, 0, readLength); stream.Write(buf, 0, readLength); bytesRead += readLength; length -= readLength; newCellId = dc->NextCell; this.DereferenceCell(cellId); cellId = newCellId; if (cellId == MfsCellId.Empty) { break; } } return(bytesRead); }
internal MfsCellId CreateDataCell(MfsCellId prev, byte[] buffer, int offset, int length) { MfsCellId cellId; MfsDataCell *dc; MfsDataCell *prevDc; if (_readOnly) { throw new MfsInvalidOperationException(); } Utils.ValidateBuffer(buffer, offset, length); if (length > _dataCellDataMaxLength) { throw new ArgumentException("length"); } dc = (MfsDataCell *)this.AllocateCell(out cellId); dc->NextCell = MfsCellId.Empty; dc->DataLength = length; if (prev != MfsCellId.Empty) { prevDc = (MfsDataCell *)this.ReferenceCell(prev); prevDc->NextCell = cellId; this.DereferenceCell(prev); } Marshal.Copy(buffer, offset, new IntPtr(&dc->Data), length); this.DereferenceCell(cellId); return(cellId); }
internal int ReadDataCell(MfsCellId cellId, byte[] buffer, int offset, int length) { MfsDataCell *dc; int bytesRead = 0; Utils.ValidateBuffer(buffer, offset, length); while (length > 0) { MfsCellId newCellId; int readLength; dc = (MfsDataCell *)this.ReferenceCell(cellId); readLength = length > dc->DataLength ? dc->DataLength : length; Marshal.Copy(new IntPtr(&dc->Data), buffer, offset, readLength); offset += readLength; bytesRead += readLength; length -= readLength; newCellId = dc->NextCell; this.DereferenceCell(cellId); cellId = newCellId; if (cellId == MfsCellId.Empty) { break; } } return(bytesRead); }
private IntPtr ReferenceCell(MfsCellId cellId) { IntPtr block; block = this.ReferenceBlock(cellId.Block); return(block.Increment(cellId.Cell * _cellSize)); }
private void InitializeObject(MfsObjectHeader *obj, MfsCellId cellId) { obj->Flink = cellId; obj->Blink = cellId; obj->Parent = MfsCellId.Empty; obj->ChildFlink = cellId; obj->ChildBlink = cellId; obj->DataLength = 0; obj->Data = MfsCellId.Empty; obj->LastData = MfsCellId.Empty; }
internal MfsCellId CreateObject(MfsCellId parent, string name) { MfsCellId cellId; MfsObjectHeader *obj; if (_readOnly) { throw new MfsInvalidOperationException(); } obj = (MfsObjectHeader *)this.AllocateCell(out cellId); this.InitializeObject(obj, cellId); this.SetObjectName(obj, name); obj->Parent = parent; MfsObjectHeader *parentObj = this.ReferenceObject(parent); MfsCellId blink; MfsObjectHeader *blinkObj; // Increment the child count. parentObj->ChildCount++; // Insert tail. blink = parentObj->ChildBlink; blinkObj = this.ReferenceObject(blink); obj->Flink = parent; obj->Blink = blink; parentObj->ChildBlink = cellId; // Special case - we are not using linked lists properly, // so we have to use this hack. if (blink == parent) { blinkObj->ChildFlink = cellId; } else { blinkObj->Flink = cellId; } this.DereferenceObject(blink); this.DereferenceObject(parent); this.DereferenceObject(cellId); return(cellId); }
private IntPtr AllocateCell(out MfsCellId cellIdOut) { ushort blockId; ushort cellId; IntPtr lastBlock; MfsBlockHeader *header; if (_header->NextFreeBlock == 1) { // No blocks except for the FS header. Allocate one. lastBlock = this.AllocateBlock(out blockId); } else { blockId = (ushort)(_header->NextFreeBlock - 1); lastBlock = this.ReferenceBlock(blockId); } header = (MfsBlockHeader *)lastBlock; if (header->NextFreeCell == _cellCount) { // Block full. Allocate a new one. this.DereferenceBlock(lastBlock); // Fix up the cached reference. if (_cachedLastBlockView != null) { this.DereferenceBlock(_cachedLastBlockView.BlockId); _cachedLastBlockView = null; } lastBlock = this.AllocateBlock(out blockId); header = (MfsBlockHeader *)lastBlock; // Add a new cached reference. this.ReferenceBlock(blockId); _cachedLastBlockView = _views[blockId]; } cellId = header->NextFreeCell++; cellIdOut = new MfsCellId(blockId, cellId); return(lastBlock.Increment(cellId * _cellSize)); }
internal MemoryObject(MemoryFileSystem fs, MfsCellId cellId, bool fsInternal) { _fs = fs; _cellId = cellId; _obj = _fs.ReferenceObject(cellId); _fsInternal = fsInternal; if (!_fsInternal) { _fs.Reference(); } // Prevent users from disposing the root object wrapper. if (_fsInternal) { this.DisableOwnership(false); } }
internal MfsObjectHeader *ReferenceObject(MfsCellId cellId) { return((MfsObjectHeader *)this.ReferenceCell(cellId)); }
internal void DereferenceObject(MfsCellId cellId) { this.DereferenceCell(cellId); }
private void DereferenceCell(MfsCellId cellId) { this.DereferenceBlock(cellId.Block); }
internal MemoryObject(MemoryFileSystem fs, MfsCellId cellId) : this(fs, cellId, false) { }