public FileChannelClientDispatcher(string directory, string clientName, string channelName, IFileChannelFormatter channelFormatter, Action<object> onReceiveReplyMessage) { if (string.IsNullOrEmpty(directory)) { throw new ArgumentNullException(nameof(directory)); } if (string.IsNullOrEmpty(clientName)) { throw new ArgumentNullException(nameof(clientName)); } if (string.IsNullOrEmpty(channelName)) { throw new ArgumentNullException(nameof(channelName)); } if (channelFormatter == null) { throw new ArgumentNullException(nameof(channelFormatter)); } if (onReceiveReplyMessage == null) { throw new ArgumentNullException(nameof(onReceiveReplyMessage)); } _directory = directory; _requestFile = $"{clientName}.{channelName}.Request"; _replyFile = $"{clientName}.{channelName}.Reply"; _clientChannel = new FileChannel(directory, _replyFile, channelFormatter, onReceiveReplyMessage); }
/// <exception cref="System.Exception"/> public virtual void TestMlock() { Assume.AssumeTrue(NativeIO.IsAvailable()); FilePath TestFile = new FilePath(new FilePath(Runtime.GetProperty("test.build.data" , "build/test/data")), "testMlockFile"); int BufLen = 12289; byte[] buf = new byte[BufLen]; int bufSum = 0; for (int i = 0; i < buf.Length; i++) { buf[i] = unchecked ((byte)(i % 60)); bufSum += buf[i]; } FileOutputStream fos = new FileOutputStream(TestFile); try { fos.Write(buf); fos.GetChannel().Force(true); } finally { fos.Close(); } FileInputStream fis = null; FileChannel channel = null; try { // Map file into memory fis = new FileInputStream(TestFile); channel = fis.GetChannel(); long fileSize = channel.Size(); MappedByteBuffer mapbuf = channel.Map(FileChannel.MapMode.ReadOnly, 0, fileSize); // mlock the buffer NativeIO.POSIX.Mlock(mapbuf, fileSize); // Read the buffer int sum = 0; for (int i_1 = 0; i_1 < fileSize; i_1++) { sum += mapbuf.Get(i_1); } Assert.Equal("Expected sums to be equal", bufSum, sum); // munmap the buffer, which also implicitly unlocks it NativeIO.POSIX.Munmap(mapbuf); } finally { if (channel != null) { channel.Close(); } if (fis != null) { fis.Close(); } } }
static long CopyFileStream(FileInputStream @is, FileOutputStream os) { FileChannel srcChannel = null; FileChannel destChannel = null; long length; try { srcChannel = @is.Channel; destChannel = os.Channel; length = srcChannel.TransferTo(0L, srcChannel.Size(), destChannel); } finally { if (srcChannel != null) { srcChannel.Close(); } if (destChannel != null) { destChannel.Close(); } } return(length); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private java.nio.channels.FileLock createLockedStoreLockFileIn(java.nio.file.Path databaseDir) throws java.io.IOException private FileLock CreateLockedStoreLockFileIn(Path databaseDir) { Path storeLockFile = Files.createFile(DatabaseLayout.of(databaseDir.toFile()).StoreLayout.storeLockFile().toPath()); _channel = FileChannel.open(storeLockFile, READ, WRITE); return(_channel.@lock(0, long.MaxValue, true)); }
/// <summary> /// Return the length of bytes in the given file after subtracting /// the trailer of 0xFF (OP_INVALID)s. /// </summary> /// <remarks> /// Return the length of bytes in the given file after subtracting /// the trailer of 0xFF (OP_INVALID)s. /// This seeks to the end of the file and reads chunks backwards until /// it finds a non-0xFF byte. /// </remarks> /// <exception cref="System.IO.IOException">if the file cannot be read</exception> private static long GetNonTrailerLength(FilePath f) { int chunkSizeToRead = 256 * 1024; FileInputStream fis = new FileInputStream(f); try { byte[] buf = new byte[chunkSizeToRead]; FileChannel fc = fis.GetChannel(); long size = fc.Size(); long pos = size - (size % chunkSizeToRead); while (pos >= 0) { fc.Position(pos); int readLen = (int)Math.Min(size - pos, chunkSizeToRead); IOUtils.ReadFully(fis, buf, 0, readLen); for (int i = readLen - 1; i >= 0; i--) { if (buf[i] != FSEditLogOpCodes.OpInvalid.GetOpCode()) { return(pos + i + 1); } } // + 1 since we count this byte! pos -= chunkSizeToRead; } return(0); } finally { fis.Close(); } }
/// <summary> /// Write a ByteBuffer to a FileChannel at a given offset, /// handling short writes. /// </summary> /// <param name="fc">The FileChannel to write to</param> /// <param name="buf">The input buffer</param> /// <param name="offset">The offset in the file to start writing at</param> /// <exception cref="System.IO.IOException">On I/O error</exception> public static void WriteFully(FileChannel fc, ByteBuffer buf, long offset) { do { offset += fc.Write(buf, offset); }while (buf.Remaining() > 0); }
private BlockReaderLocal(BlockReaderLocal.Builder builder) { this.replica = builder.replica; this.dataIn = replica.GetDataStream().GetChannel(); this.dataPos = builder.dataPos; this.checksumIn = replica.GetMetaStream().GetChannel(); BlockMetadataHeader header = builder.replica.GetMetaHeader(); this.checksum = header.GetChecksum(); this.verifyChecksum = builder.verifyChecksum && (this.checksum.GetChecksumType(). id != DataChecksum.ChecksumNull); this.filename = builder.filename; this.block = builder.block; this.bytesPerChecksum = checksum.GetBytesPerChecksum(); this.checksumSize = checksum.GetChecksumSize(); this.maxAllocatedChunks = (bytesPerChecksum == 0) ? 0 : ((builder.bufferSize + bytesPerChecksum - 1) / bytesPerChecksum); // Calculate the effective maximum readahead. // We can't do more readahead than there is space in the buffer. int maxReadaheadChunks = (bytesPerChecksum == 0) ? 0 : ((Math.Min(builder.bufferSize , builder.maxReadahead) + bytesPerChecksum - 1) / bytesPerChecksum); if (maxReadaheadChunks == 0) { this.zeroReadaheadRequested = true; maxReadaheadChunks = 1; } else { this.zeroReadaheadRequested = false; } this.maxReadaheadLength = maxReadaheadChunks * bytesPerChecksum; this.storageType = builder.storageType; }
/// <summary> /// Close all the files. /// </summary> /// <exception cref="SecurityException"> if a security manager exists and if /// the caller does not have <tt>LoggingPermission("control")</tt>. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: @Override public synchronized void close() throws SecurityException public override void Close() { lock (this) { base.Close(); // Unlock any lock file. if (LockFileName == null) { return; } try { // Close the lock file channel (which also will free any locks) LockFileChannel.Close(); } catch (Exception) { // Problems closing the stream. Punt. } lock (Locks) { Locks.Remove(LockFileName); } if (System.IO.Directory.Exists(LockFileName)) { System.IO.Directory.Delete(LockFileName, true); } else { System.IO.File.Delete(LockFileName); } LockFileName = null; LockFileChannel = null; } }
/// <summary>Truncate a block file</summary> /// <exception cref="System.IO.IOException"/> private long TruncateBlockFile() { lock (fds) { foreach (ReplicaInfo b in FsDatasetTestUtil.GetReplicas(fds, bpid)) { FilePath f = b.GetBlockFile(); FilePath mf = b.GetMetaFile(); // Truncate a block file that has a corresponding metadata file if (f.Exists() && f.Length() != 0 && mf.Exists()) { FileOutputStream s = null; FileChannel channel = null; try { s = new FileOutputStream(f); channel = s.GetChannel(); channel.Truncate(0); Log.Info("Truncated block file " + f.GetAbsolutePath()); return(b.GetBlockId()); } finally { IOUtils.Cleanup(Log, channel, s); } } } } return(0); }
public static bool CopyFile(File sourceFile, File destFile) { if (!destFile.Exists()) { destFile.CreateNewFile(); } FileChannel source = null; FileChannel destination = null; try { source = new FileInputStream(sourceFile).Channel; destination = new FileOutputStream(destFile).Channel; destination.TransferFrom(source, 0, source.Size()); } catch (Exception e) { //FileLog.e("tmessages", e); return(false); } finally { if (source != null) { source.Close(); } if (destination != null) { destination.Close(); } } return(false); }
public FileChannelServerDispatcher(string directory, string channelName, IFileChannelFormatter channelFormatter, Action<object> onReceiveRequestMessage) { if (string.IsNullOrEmpty(directory)) { throw new ArgumentNullException(nameof(directory)); } if (string.IsNullOrEmpty(channelName)) { throw new ArgumentNullException(nameof(channelName)); } if (channelFormatter == null) { throw new ArgumentNullException(nameof(channelFormatter)); } if (onReceiveRequestMessage == null) { throw new ArgumentNullException(nameof(onReceiveRequestMessage)); } var requestFileMask = $"*.{channelName}.Request"; _channelName = channelName; _serverChannel = new FileChannel(directory, requestFileMask, channelFormatter, onReceiveRequestMessage); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void truncate(java.io.File path, long size) throws java.io.IOException public override void Truncate(File path, long size) { using (FileChannel channel = FileChannel.open(path(path))) { channel.truncate(size); } }
public FileChannelClientDispatcher(string directory, string clientName, string channelName, IFileChannelFormatter channelFormatter, Action <object> onReceiveReplyMessage) { if (string.IsNullOrEmpty(directory)) { throw new ArgumentNullException(nameof(directory)); } if (string.IsNullOrEmpty(clientName)) { throw new ArgumentNullException(nameof(clientName)); } if (string.IsNullOrEmpty(channelName)) { throw new ArgumentNullException(nameof(channelName)); } if (channelFormatter == null) { throw new ArgumentNullException(nameof(channelFormatter)); } if (onReceiveReplyMessage == null) { throw new ArgumentNullException(nameof(onReceiveReplyMessage)); } _directory = directory; _requestFile = $"{clientName}.{channelName}.Request"; _replyFile = $"{clientName}.{channelName}.Reply"; _clientChannel = new FileChannel(directory, _replyFile, channelFormatter, onReceiveReplyMessage); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long lockPositionWriteVectorAndRetryIfInterrupted(long filePageId, java.nio.channels.FileChannel channel, long fileOffset, ByteBuffer[] srcs, int attemptsLeft) throws java.io.IOException private long LockPositionWriteVectorAndRetryIfInterrupted(long filePageId, FileChannel channel, long fileOffset, ByteBuffer[] srcs, int attemptsLeft) { try { long toWrite = _filePageSize * ( long )srcs.Length; long bytesWritten = 0; lock (PositionLock(channel)) { channel.position(fileOffset); do { bytesWritten += channel.write(srcs); } while (bytesWritten < toWrite); return(bytesWritten); } } catch (ClosedChannelException e) { TryReopen(filePageId, e); if (attemptsLeft < 1) { throw new IOException("IO failed due to interruption", e); } bool interrupted = Thread.interrupted(); channel = UnwrappedChannel(filePageId); long bytesWritten = LockPositionWriteVectorAndRetryIfInterrupted(filePageId, channel, fileOffset, srcs, attemptsLeft - 1); if (interrupted) { Thread.CurrentThread.Interrupt(); } return(bytesWritten); } }
public FileChannelServerDispatcher(string directory, string channelName, IFileChannelFormatter channelFormatter, Action <object> onReceiveRequestMessage) { if (string.IsNullOrEmpty(directory)) { throw new ArgumentNullException(nameof(directory)); } if (string.IsNullOrEmpty(channelName)) { throw new ArgumentNullException(nameof(channelName)); } if (channelFormatter == null) { throw new ArgumentNullException(nameof(channelFormatter)); } if (onReceiveRequestMessage == null) { throw new ArgumentNullException(nameof(onReceiveRequestMessage)); } var requestFileMask = $"*.{channelName}.Request"; _channelName = channelName; _serverChannel = new FileChannel(directory, requestFileMask, channelFormatter, onReceiveRequestMessage); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long readPositionedVectoredToFileChannel(long startFilePageId, long[] bufferAddresses, int arrayOffset, int length) throws Exception private long ReadPositionedVectoredToFileChannel(long startFilePageId, long[] bufferAddresses, int arrayOffset, int length) { long fileOffset = PageIdToPosition(startFilePageId); FileChannel channel = UnwrappedChannel(startFilePageId); ByteBuffer[] srcs = ConvertToByteBuffers(bufferAddresses, arrayOffset, length); long bytesRead = LockPositionReadVectorAndRetryIfInterrupted(startFilePageId, channel, fileOffset, srcs, MAX_INTERRUPTED_CHANNEL_REOPEN_ATTEMPTS); if (bytesRead == -1) { foreach (long address in bufferAddresses) { UnsafeUtil.setMemory(address, _filePageSize, MuninnPageCache.ZERO_BYTE); } return(0); } else if (bytesRead < (( long )_filePageSize) * length) { int pagesRead = ( int )(bytesRead / _filePageSize); int bytesReadIntoLastReadPage = ( int )(bytesRead % _filePageSize); int pagesNeedingZeroing = length - pagesRead; for (int i = 0; i < pagesNeedingZeroing; i++) { long address = bufferAddresses[arrayOffset + pagesRead + i]; long bytesToZero = _filePageSize; if (i == 0) { address += bytesReadIntoLastReadPage; bytesToZero -= bytesReadIntoLastReadPage; } UnsafeUtil.setMemory(address, bytesToZero, MuninnPageCache.ZERO_BYTE); } } return(bytesRead); }
/// <exception cref="System.IO.IOException"/> public override void Close() { if (fp == null) { throw new IOException("Trying to use aborted output stream"); } try { // close should have been called after all pending transactions // have been flushed & synced. // if already closed, just skip if (doubleBuf != null) { doubleBuf.Close(); doubleBuf = null; } // remove any preallocated padding bytes from the transaction log. if (fc != null && fc.IsOpen()) { fc.Truncate(fc.Position()); fc.Close(); fc = null; } fp.Close(); fp = null; } finally { IOUtils.Cleanup(Log, fc, fp); doubleBuf = null; fc = null; fp = null; } fp = null; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public StoreFileChannel open(java.io.File fileName, OpenMode openMode) throws java.io.IOException public override StoreFileChannel Open(File fileName, OpenMode openMode) { // Returning only the channel is ok, because the channel, when close()d will close its parent File. FileChannel channel = (new RandomAccessFile(fileName, openMode.mode())).Channel; return(GetStoreFileChannel(channel)); }
public virtual void TestRecoveryMode() { // edits generated by nnHelper (MiniDFSCluster), should have all op codes // binary, XML, reparsed binary string edits = nnHelper.GenerateEdits(); FileOutputStream os = new FileOutputStream(edits, true); // Corrupt the file by truncating the end FileChannel editsFile = os.GetChannel(); editsFile.Truncate(editsFile.Size() - 5); string editsParsedXml = folder.NewFile("editsRecoveredParsed.xml").GetAbsolutePath (); string editsReparsed = folder.NewFile("editsRecoveredReparsed").GetAbsolutePath(); string editsParsedXml2 = folder.NewFile("editsRecoveredParsed2.xml").GetAbsolutePath (); // Can't read the corrupted file without recovery mode NUnit.Framework.Assert.AreEqual(-1, RunOev(edits, editsParsedXml, "xml", false)); // parse to XML then back to binary NUnit.Framework.Assert.AreEqual(0, RunOev(edits, editsParsedXml, "xml", true)); NUnit.Framework.Assert.AreEqual(0, RunOev(editsParsedXml, editsReparsed, "binary" , false)); NUnit.Framework.Assert.AreEqual(0, RunOev(editsReparsed, editsParsedXml2, "xml", false)); // judgment time NUnit.Framework.Assert.IsTrue("Test round trip", FileUtils.ContentEqualsIgnoreEOL (new FilePath(editsParsedXml), new FilePath(editsParsedXml2), "UTF-8")); os.Close(); }
Load(long length, FileInputStream blockIn, FileInputStream metaIn, string blockFileName ) { Org.Apache.Hadoop.Hdfs.Server.Datanode.Fsdataset.Impl.MappableBlock mappableBlock = null; MappedByteBuffer mmap = null; FileChannel blockChannel = null; try { blockChannel = blockIn.GetChannel(); if (blockChannel == null) { throw new IOException("Block InputStream has no FileChannel."); } mmap = blockChannel.Map(FileChannel.MapMode.ReadOnly, 0, length); NativeIO.POSIX.GetCacheManipulator().Mlock(blockFileName, mmap, length); VerifyChecksum(length, metaIn, blockChannel, blockFileName); mappableBlock = new Org.Apache.Hadoop.Hdfs.Server.Datanode.Fsdataset.Impl.MappableBlock (mmap, length); } finally { IOUtils.CloseQuietly(blockChannel); if (mappableBlock == null) { if (mmap != null) { NativeIO.POSIX.Munmap(mmap); } } } // unmapping also unlocks return(mappableBlock); }
/// <exception cref="System.IO.IOException"></exception> public static void CopyFile(FilePath sourceFile, FilePath destFile) { if (!destFile.Exists()) { destFile.CreateNewFile(); } FileChannel source = null; FileChannel destination = null; try { source = new FileInputStream(sourceFile).GetChannel(); destination = new FileOutputStream(destFile).GetChannel(); destination.TransferFrom(source, 0, source.Size()); } finally { if (source != null) { source.Close(); } if (destination != null) { destination.Close(); } } }
/// <summary> /// Transfers data from FileChannel using /// <see cref="FileChannel.TransferTo(long, long, WritableByteChannel) /// "/> /// . /// Updates <code>waitForWritableTime</code> and <code>transferToTime</code> /// with the time spent blocked on the network and the time spent transferring /// data from disk to network respectively. /// Similar to readFully(), this waits till requested amount of /// data is transfered. /// </summary> /// <param name="fileCh">FileChannel to transfer data from.</param> /// <param name="position">position within the channel where the transfer begins</param> /// <param name="count">number of bytes to transfer.</param> /// <param name="waitForWritableTime"> /// nanoseconds spent waiting for the socket /// to become writable /// </param> /// <param name="transferTime">nanoseconds spent transferring data</param> /// <exception cref="System.IO.EOFException"> /// /// If end of input file is reached before requested number of /// bytes are transfered. /// </exception> /// <exception cref="SocketTimeoutException"> /// /// If this channel blocks transfer longer than timeout for /// this stream. /// </exception> /// <exception cref="System.IO.IOException"> /// Includes any exception thrown by /// <see cref="FileChannel.TransferTo(long, long, WritableByteChannel) /// "/> /// . /// </exception> public virtual void TransferToFully(FileChannel fileCh, long position, int count, LongWritable waitForWritableTime, LongWritable transferToTime) { long waitTime = 0; long transferTime = 0; while (count > 0) { /* * Ideally we should wait after transferTo returns 0. But because of * a bug in JRE on Linux (http://bugs.sun.com/view_bug.do?bug_id=5103988), * which throws an exception instead of returning 0, we wait for the * channel to be writable before writing to it. If you ever see * IOException with message "Resource temporarily unavailable" * thrown here, please let us know. * * Once we move to JAVA SE 7, wait should be moved to correct place. */ long start = Runtime.NanoTime(); WaitForWritable(); long wait = Runtime.NanoTime(); int nTransfered = (int)fileCh.TransferTo(position, count, GetChannel()); if (nTransfered == 0) { //check if end of file is reached. if (position >= fileCh.Size()) { throw new EOFException("EOF Reached. file size is " + fileCh.Size() + " and " + count + " more bytes left to be " + "transfered."); } } else { //otherwise assume the socket is full. //waitForWritable(); // see comment above. if (nTransfered < 0) { throw new IOException("Unexpected return of " + nTransfered + " from transferTo()" ); } else { position += nTransfered; count -= nTransfered; } } long transfer = Runtime.NanoTime(); waitTime += wait - start; transferTime += transfer - wait; } if (waitForWritableTime != null) { waitForWritableTime.Set(waitTime); } if (transferToTime != null) { transferToTime.Set(transferTime); } }
public LogFileMonitor(FileInfo file) { this.fileChannel = new FileChannel(file); watch.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName; watch.Filter = file.Name; watch.Changed += new FileSystemEventHandler(OnChanged); watch.Created += new FileSystemEventHandler(OnChanged); }
public IrEncoder(ByteBuffer buffer, IntermediateRepresentation ir) { Channel = null; ResultBuffer = buffer; this.Buffer = ByteBuffer.allocateDirect(CAPACITY); DirectBuffer = new DirectBuffer(this.Buffer); this.Ir = ir; }
/// <exception cref="System.IO.IOException"/> public virtual void Close() { if (ch != null) { ch.Close(); ch = null; } }
public IrEncoder(string fileName, IntermediateRepresentation ir) { Channel = (new FileOutputStream(fileName)).Channel; ResultBuffer = null; Buffer = ByteBuffer.allocateDirect(CAPACITY); DirectBuffer = new DirectBuffer(Buffer); this.Ir = ir; }
/// <summary>Copy the current file content into the temporary file.</summary> /// <remarks> /// Copy the current file content into the temporary file. /// <p> /// This method saves the current file content by inserting it into the /// temporary file, so that the caller can safely append rather than replace /// the primary file. /// <p> /// This method does nothing if the current file does not exist, or exists /// but is empty. /// </remarks> /// <exception cref="System.IO.IOException"> /// the temporary file could not be written, or a read error /// occurred while reading from the current file. The lock is /// released before throwing the underlying IO exception to the /// caller. /// </exception> /// <exception cref="Sharpen.RuntimeException"> /// the temporary file could not be written. The lock is released /// before throwing the underlying exception to the caller. /// </exception> public virtual void CopyCurrentContent() { RequireLock(); try { FileInputStream fis = new FileInputStream(@ref); try { if (fsync) { FileChannel @in = fis.GetChannel(); long pos = 0; long cnt = @in.Size(); while (0 < cnt) { long r = os.GetChannel().TransferFrom(@in, pos, cnt); pos += r; cnt -= r; } } else { byte[] buf = new byte[2048]; int r; while ((r = fis.Read(buf)) >= 0) { os.Write(buf, 0, r); } } } finally { fis.Close(); } } catch (FileNotFoundException) { } catch (IOException ioe) { // Don't worry about a file that doesn't exist yet, it // conceptually has no current content to copy. // Unlock(); throw; } catch (RuntimeException ioe) { Unlock(); throw; } catch (Error ioe) { Unlock(); throw; } }
public static int MakeFileChannel(FileStream fileInputStream) { for (int i = 0; i < ChannelTable.Length; i++) { if (ChannelTable [i] == null) { ChannelTable [i] = new FileChannel (fileInputStream); return i; } } throw new NotImplementedException (); }
private MappedByteBuffer getModel(AssetManager assets, string modelFilename) { AssetFileDescriptor fileDescriptor = assets.OpenFd(modelFilename); FileInputStream inputStream = new FileInputStream(fileDescriptor.FileDescriptor); FileChannel fileChannel = inputStream.Channel; long startOffset = fileDescriptor.StartOffset; long declaredLength = fileDescriptor.DeclaredLength; return(fileChannel.Map(FileChannel.MapMode.ReadOnly, startOffset, declaredLength)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long writePositionedVectoredToFileChannel(long startFilePageId, long[] bufferAddresses, int arrayOffset, int length) throws Exception private long WritePositionedVectoredToFileChannel(long startFilePageId, long[] bufferAddresses, int arrayOffset, int length) { long fileOffset = PageIdToPosition(startFilePageId); IncreaseFileSizeTo(fileOffset + ((( long )_filePageSize) * length)); FileChannel channel = UnwrappedChannel(startFilePageId); ByteBuffer[] srcs = ConvertToByteBuffers(bufferAddresses, arrayOffset, length); return(LockPositionWriteVectorAndRetryIfInterrupted(startFilePageId, channel, fileOffset, srcs, MAX_INTERRUPTED_CHANNEL_REOPEN_ATTEMPTS)); }
/* * Memory-map the model file in Assets. */ public static MappedByteBuffer LoadModelFile(Context context, string modelFile) { AssetFileDescriptor fileDescriptor = context.Assets.OpenFd(modelFile); FileInputStream inputStream = new FileInputStream(fileDescriptor.FileDescriptor); FileChannel fileChannel = inputStream.Channel; long startOffset = fileDescriptor.StartOffset; long declaredLength = fileDescriptor.DeclaredLength; return(fileChannel.Map(FileChannel.MapMode.ReadOnly, startOffset, declaredLength)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static void main(String[] args) throws java.io.IOException public static void Main(string[] args) { Path path = Paths.get(args[0]); using (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ, StandardOpenOption.WRITE), java.nio.channels.FileLock @lock = channel.@lock()) { Console.WriteLine(LOCKED_OUTPUT); System.out.flush(); Console.Read(); } }
public long TransferFrom (FileChannel src, long pos, long count) { if (buffer == null) buffer = new byte [8092]; int nr = src.s.Read (buffer, 0, (int) Math.Min (buffer.Length, count)); long curPos = s.Position; s.Position = pos; s.Write (buffer, 0, nr); s.Position = curPos; return nr; }
/// <exception cref="System.IO.IOException"></exception> private NGit.Storage.File.ReflogWriter Log(string refName, byte[] rec) { FilePath log = LogFor(refName); bool write = forceWrite || (IsLogAllRefUpdates() && ShouldAutoCreateLog(refName)) || log.IsFile(); if (!write) { return(this); } WriteConfig wc = GetRepository().GetConfig().Get(WriteConfig.KEY); FileOutputStream @out; try { @out = new FileOutputStream(log, true); } catch (FileNotFoundException err) { FilePath dir = log.GetParentFile(); if (dir.Exists()) { throw; } if (!dir.Mkdirs() && !dir.IsDirectory()) { throw new IOException(MessageFormat.Format(JGitText.Get().cannotCreateDirectory, dir)); } @out = new FileOutputStream(log, true); } try { if (wc.GetFSyncRefFiles()) { FileChannel fc = @out.GetChannel(); ByteBuffer buf = ByteBuffer.Wrap(rec); while (0 < buf.Remaining()) { fc.Write(buf); } fc.Force(true); } else { @out.Write(rec); } } finally { @out.Close(); } return(this); }
/// <summary> /// Reads as much as possible from the channel into the buffer. /// </summary> /// <param name="channel"> The channel. </param> /// <param name="buffer"> The buffer. </param> /// <param name="ptr"> The initial position in the channel. </param> /// <exception cref="IOException"> if an I/O error occurs. </exception> /// <exception cref="EOFException"> /// if the end of the file was reached and the buffer /// could not be completely populated. /// </exception> public static void ReadFully(FileChannel channel, ByteBuffer buffer, long ptr) { while (buffer.remaining() > 0) { long read = channel.read(buffer, ptr); if (read == -1) { throw new EOFException(); } ptr += read; } }
static void exportKml(string filename, string outputFile) { Document kml = new Document(); FileChannel ch = new FileChannel(filename); UAVObjectManager mgr = new UAVObjectManager(); UAVObjectsInitialize.register(mgr); UavTalk.UavTalkProto tlk = new UavTalkProto(ch, mgr); mgr.getObject<GPSPositionSensor>().onUpdated += new EventHandler(GpsPositionReceived); mgr.getObject<PositionState>().onUpdated += new EventHandler(GpsPositionReceived); ch.open(); while (ch.isRunning) Thread.Sleep(50); LineString ls = new LineString(); ls.AltitudeMode = SharpKml.Dom.AltitudeMode.Absolute; ls.Extrude = true; ls.Coordinates = coords; Placemark pm = new Placemark(); pm.Name = "Flight Path "; //pm.StyleUrl = new Uri("#yellowLineGreenPoly", UriKind.Relative); pm.Geometry = ls; kml.AddFeature(pm); Serializer serializer = new Serializer(); serializer.Serialize(kml); StreamWriter sw = new StreamWriter(outputFile); sw.Write(serializer.Xml); sw.Close(); }
private void updateFileData(FileChannel item) { bool isNew = (item.Channel.ChannelID == null); string[] lines = item.ReadLastBlock(); if (isNew && item.Channel.ChannelID != null) { if (ChangedLogChannel != null) { ChangedLogChannel(item.Channel); } } if (lines != null) { foreach (string line in lines) { // ((FileChannel)item).LogCannel if (LogMessage.isValidMessage(line)) { LogMessage message = new LogMessage(item.Channel, line); if (ChangedLogMessage != null) { ChangedLogMessage(message); } } } } }
/// <summary> This procedure is invoked to process the "open" Tcl command. /// See the user documentation for details on what it does. /// /// </summary> /// <param name="interp">the current interpreter. /// </param> /// <param name="argv">command arguments. /// </param> public TCL.CompletionCode cmdProc( Interp interp, TclObject[] argv ) { bool pipeline = false; /* True if opening pipeline chan */ int prot = 438; /* Final rdwr permissions of file */ int modeFlags = TclIO.RDONLY; /* Rdwr mode for the file. See the * TclIO class for more info on the * valid modes */ if ( ( argv.Length < 2 ) || ( argv.Length > 4 ) ) { throw new TclNumArgsException( interp, 1, argv, "fileName ?access? ?permissions?" ); } if ( argv.Length > 2 ) { TclObject mode = argv[2]; string modeStr = mode.ToString(); int len = modeStr.Length; // This "r+1" hack is just to get a test case to pass if ( ( len == 0 ) || ( modeStr.StartsWith( "r+" ) && len >= 3 ) ) { throw new TclException( interp, "illegal access mode \"" + modeStr + "\"" ); } if ( len < 3 ) { switch ( modeStr[0] ) { case 'r': { if ( len == 1 ) { modeFlags = TclIO.RDONLY; break; } else if ( modeStr[1] == '+' ) { modeFlags = TclIO.RDWR; break; } } goto case 'w'; case 'w': { FileInfo f = FileUtil.getNewFileObj( interp, argv[1].ToString() ); bool tmpBool; if ( File.Exists( f.FullName ) ) tmpBool = true; else tmpBool = Directory.Exists( f.FullName ); if ( tmpBool ) { bool tmpBool2; try { if ( File.Exists( f.FullName ) ) { File.SetAttributes( f.FullName, FileAttributes.Normal ); File.Delete( f.FullName ); tmpBool2 = true; } else if ( Directory.Exists( f.FullName ) ) { Directory.Delete( f.FullName ); tmpBool2 = true; } else { tmpBool2 = false; } } // ATK added because .NET do not allow often to delete // files used by another process catch ( IOException e ) { throw new TclException( interp, "cannot open file: " + argv[1].ToString() ); } bool generatedAux = tmpBool2; } if ( len == 1 ) { modeFlags = ( TclIO.WRONLY | TclIO.CREAT ); break; } else if ( modeStr[1] == '+' ) { modeFlags = ( TclIO.RDWR | TclIO.CREAT ); break; } } goto case 'a'; case 'a': { if ( len == 1 ) { modeFlags = ( TclIO.WRONLY | TclIO.APPEND ); break; } else if ( modeStr[1] == '+' ) { modeFlags = ( TclIO.RDWR | TclIO.CREAT | TclIO.APPEND ); break; } } goto default; default: { throw new TclException( interp, "illegal access mode \"" + modeStr + "\"" ); } } } else { modeFlags = 0; bool gotRorWflag = false; int mlen = TclList.getLength( interp, mode ); for ( int i = 0; i < mlen; i++ ) { TclObject marg = TclList.index( interp, mode, i ); if ( marg.ToString().Equals( "RDONLY" ) ) { modeFlags |= TclIO.RDONLY; gotRorWflag = true; } else { if ( marg.ToString().Equals( "WRONLY" ) ) { modeFlags |= TclIO.WRONLY; gotRorWflag = true; } else { if ( marg.ToString().Equals( "RDWR" ) ) { modeFlags |= TclIO.RDWR; gotRorWflag = true; } else { if ( marg.ToString().Equals( "APPEND" ) ) { modeFlags |= TclIO.APPEND; } else { if ( marg.ToString().Equals( "CREAT" ) ) { modeFlags |= TclIO.CREAT; } else { if ( marg.ToString().Equals( "EXCL" ) ) { modeFlags |= TclIO.EXCL; } else { if ( marg.ToString().Equals( "TRUNC" ) ) { modeFlags |= TclIO.TRUNC; } else { throw new TclException( interp, "invalid access mode \"" + marg.ToString() + "\": must be RDONLY, WRONLY, RDWR, APPEND, " + "CREAT EXCL, NOCTTY, NONBLOCK, or TRUNC" ); } } } } } } } } if ( !gotRorWflag ) { throw new TclException( interp, "access mode must include either RDONLY, WRONLY, or RDWR" ); } } } if ( argv.Length == 4 ) { prot = TclInteger.get( interp, argv[3] ); throw new TclException( interp, "setting permissions not implemented yet" ); } if ( ( argv[1].ToString().Length > 0 ) && ( argv[1].ToString()[0] == '|' ) ) { pipeline = true; throw new TclException( interp, "pipes not implemented yet" ); } /* * Open the file or create a process pipeline. */ if ( !pipeline ) { try { FileChannel file = new FileChannel(); file.open( interp, argv[1].ToString(), modeFlags ); TclIO.registerChannel( interp, file ); interp.setResult( file.ChanName ); } catch ( IOException e ) { throw new TclException( interp, "cannot open file: " + argv[1].ToString() ); } } else { /* * Pipeline code here... */ } return TCL.CompletionCode.RETURN; }