IKVM.Java.Externs.java.io.FileOutputStream Class Reference

Static Public Member Functions
static void	open0 (object this_, string path, bool append)
	Implements the native method 'open0'.
static void	write (object self, int byte_, bool append)
	Implements the native method 'write'.
static void	writeBytes (object self, byte[] bytes, int off, int len, bool append)
	Implements the native method 'writeBytes'.
static void	close0 (object this_)
	Implements the native method 'close0'.

Detailed Description

Definition at line 14 of file FileOutputStream.cs.

Member Function Documentation

close0()

static void IKVM.Java.Externs.java.io.FileOutputStream.close0 ( object this_ )

static

Implements the native method 'close0'.

Parameters

this_

Definition at line 245 of file FileOutputStream.cs.

        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            var fd = FileOutputStreamAccessor.GetFd(this_);
            if (fd == null)
                throw new global::java.io.IOException("The handle is invalid.");
 
            if (FileDescriptorAccessor.GetStream(fd) is Stream stream)
            {
                try
                {
                    stream.Close();
                    FileDescriptorAccessor.SetPtr(fd, -1);
                }
                catch
                {
                    // ignore
                }
            }
            else
            {
                __callerID ??= global::ikvm.@internal.CallerID.create(typeof(global::java.io.FileOutputStream).TypeHandle);
                __jniPtr__close0 ??= Marshal.GetDelegateForFunctionPointer<__jniDelegate__close0>(JNIFrame.GetFuncPtr(__callerID, "java/io/FileOutputStream", nameof(close0), "()V"));
                var jniFrm = new JNIFrame();
                var jniEnv = jniFrm.Enter(__callerID);
                try
                {
                    __jniPtr__close0(jniEnv, jniFrm.MakeLocalRef(this_));
                }
                catch (Exception ex)
                {
                    System.Console.WriteLine("*** exception in native code ***");
                    System.Console.WriteLine(ex);
                    throw;
                }
                finally
                {
                    jniFrm.Leave();
                }
            }
#endif
        }

open0()

static void IKVM.Java.Externs.java.io.FileOutputStream.open0 ( object this_, string path, bool append )

static

Implements the native method 'open0'.

Parameters

this_
path
append

Definition at line 44 of file FileOutputStream.cs.

        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            if (JVM.Vfs.IsPath(path))
            {
                try
                {
                    var fd = FileOutputStreamAccessor.GetFd(this_);
                    if (fd == null)
                        throw new global::java.io.IOException("The handle is invalid.");
 
                    FileDescriptorAccessor.SetPtr(fd, -1);
                    FileDescriptorAccessor.SetStream(fd, JVM.Vfs.Open(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write));
                }
                catch (ObjectDisposedException e)
                {
                    throw new global::java.io.IOException(e.Message);
                }
                catch (ArgumentException e)
                {
                    throw new global::java.io.FileNotFoundException(e.Message);
                }
                catch (SecurityException e)
                {
                    throw new global::java.lang.SecurityException(e.Message);
                }
                catch (UnauthorizedAccessException)
                {
                    throw new global::java.io.FileNotFoundException(path + " (Access is denied)");
                }
                catch (IOException e)
                {
                    throw new global::java.io.FileNotFoundException(e.Message);
                }
                catch (NotSupportedException e)
                {
                    throw new global::java.io.FileNotFoundException(e.Message);
                }
            }
            else
            {
                __callerID ??= global::ikvm.@internal.CallerID.create(typeof(global::java.io.FileOutputStream).TypeHandle);
                __jniPtr__open0 ??= Marshal.GetDelegateForFunctionPointer<__jniDelegate__open0>(JNIFrame.GetFuncPtr(__callerID, "java/io/FileOutputStream", nameof(open0), "(Ljava/lang/String;Z)V"));
                var jniFrm = new JNIFrame();
                var jniEnv = jniFrm.Enter(__callerID);
                try
                {
                    var selfRef = jniFrm.MakeLocalRef(this_);
                    var pathRef = jniFrm.MakeLocalRef(path);
                    __jniPtr__open0(jniEnv, selfRef, pathRef, append ? JNIEnv.JNI_TRUE : JNIEnv.JNI_FALSE);
                }
                catch (Exception ex)
                {
                    System.Console.WriteLine("*** exception in native code ***");
                    System.Console.WriteLine(ex);
                    throw;
                }
                finally
                {
                    jniFrm.Leave();
                }
            }
#endif
        }

write()

static void IKVM.Java.Externs.java.io.FileOutputStream.write ( object self, int byte_, bool append )

static

Implements the native method 'write'.

Parameters

self
byte_
append

Definition at line 117 of file FileOutputStream.cs.

        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            var fd = FileOutputStreamAccessor.GetFd(self);
            if (fd == null)
                throw new global::java.io.IOException("The handle is invalid.");
 
            if (FileDescriptorAccessor.GetStream(fd) is Stream stream)
            {
                if (stream.CanWrite == false)
                    throw new global::java.io.IOException("The handle is invalid.");
 
                try
                {
                    stream.WriteByte((byte)byte_);
                    stream.Flush();
                }
                catch (ObjectDisposedException e)
                {
                    throw new global::java.io.IOException(e.Message);
                }
                catch (NotSupportedException e)
                {
                    throw new global::java.io.IOException(e.Message);
                }
                catch (IOException e)
                {
                    throw new global::java.io.IOException(e.Message);
                }
            }
            else
            {
                __callerID ??= global::ikvm.@internal.CallerID.create(typeof(global::java.io.FileOutputStream).TypeHandle);
                __jniPtr__write ??= Marshal.GetDelegateForFunctionPointer<__jniDelegate__write>(JNIFrame.GetFuncPtr(__callerID, "java/io/FileOutputStream", nameof(write), "(IZ)V"));
                var jniFrm = new JNIFrame();
                var jniEnv = jniFrm.Enter(__callerID);
                try
                {
                    var selfRef = jniFrm.MakeLocalRef(self);
                    __jniPtr__write(jniEnv, selfRef, byte_, append ? JNIEnv.JNI_TRUE : JNIEnv.JNI_FALSE);
                }
                catch (Exception ex)
                {
                    System.Console.WriteLine("*** exception in native code ***");
                    System.Console.WriteLine(ex);
                    throw;
                }
                finally
                {
                    jniFrm.Leave();
                }
            }
#endif
        }

writeBytes()

static void IKVM.Java.Externs.java.io.FileOutputStream.writeBytes ( object self, byte[] bytes, int off, int len, bool append )

static

Implements the native method 'writeBytes'.

Parameters

self
bytes
off
len
append

Definition at line 182 of file FileOutputStream.cs.

        {
#if FIRST_PASS
            throw new NotImplementedException();
#else
            var fd = FileOutputStreamAccessor.GetFd(self);
            if (fd == null)
                throw new global::java.io.IOException("The handle is invalid.");
 
            if (FileDescriptorAccessor.GetStream(fd) is Stream stream)
            {
                if ((off < 0) || (off > bytes.Length) || (len < 0) || (len > (bytes.Length - off)))
                    throw new global::java.lang.IndexOutOfBoundsException();
 
                if (stream.CanWrite == false)
                    throw new global::java.io.IOException("The handle is invalid.");
 
                try
                {
                    stream.Write(bytes, off, len);
                    stream.Flush();
                }
                catch (ObjectDisposedException e)
                {
                    throw new global::java.io.IOException(e.Message);
                }
                catch (NotSupportedException e)
                {
                    throw new global::java.io.IOException(e.Message);
                }
                catch (IOException e)
                {
                    throw new global::java.io.IOException(e.Message);
                }
            }
            else
            {
                __callerID ??= global::ikvm.@internal.CallerID.create(typeof(global::java.io.FileOutputStream).TypeHandle);
                __jniPtr__writeBytes ??= Marshal.GetDelegateForFunctionPointer<__jniDelegate__writeBytes>(JNIFrame.GetFuncPtr(__callerID, "java/io/FileOutputStream", nameof(writeBytes), "([BIIZ)V"));
                var jniFrm = new JNIFrame();
                var jniEnv = jniFrm.Enter(__callerID);
                try
                {
                    __jniPtr__writeBytes(jniEnv, jniFrm.MakeLocalRef(self), jniFrm.MakeLocalRef(bytes), off, len, append ? JNIEnv.JNI_TRUE : JNIEnv.JNI_FALSE);
                }
                catch (Exception ex)
                {
                    System.Console.WriteLine("*** exception in native code ***");
                    System.Console.WriteLine(ex);
                    throw;
                }
                finally
                {
                    jniFrm.Leave();
                }
            }
#endif
        }

---

The documentation for this class was generated from the following file:

• src/IKVM.Runtime/Java/Externs/java/io/FileOutputStream.cs