libcore.io.IoBridge.open java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 ScheduledThreadPoolExecutor s =new ScheduledThreadPoolExecutor(corePoolSize)
ThreadFactory threadFactory;new ScheduledThreadPoolExecutor(corePoolSize, threadFactory)
String str;new ScheduledThreadPoolExecutor(1, new ThreadFactoryBuilder().setNameFormat(str).build())
Smart code suggestions by Tabnine
}

/**
 * Constructs a new {@code FileInputStream} that reads from {@code file}.
 *
 * @param file
 *            the file from which this stream reads.
 * @throws FileNotFoundException
 *             if {@code file} does not exist.
 */
public FileInputStream(File file) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.fd = IoBridge.open(file.getAbsolutePath(), O_RDONLY);
  this.shouldClose = true;
  guard.open("close");
}

/**
 * Constructs a new {@code FileOutputStream} that writes to {@code file}.
 * If {@code append} is true and the file already exists, it will be appended to; otherwise
 * it will be truncated. The file will be created if it does not exist.
 *
 * @throws FileNotFoundException if the file cannot be opened for writing.
 */
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.mode = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
  this.fd = IoBridge.open(file.getAbsolutePath(), mode);
  this.shouldClose = true;
  this.guard.open("close");
}

this.fd = IoBridge.open(file.getAbsolutePath(), flags);

public FileReader(String absolutePath) throws IOException {
  // We use IoBridge.open because callers might differentiate
  // between a FileNotFoundException and a general IOException.
  //
  // NOTE: This costs us an additional call to fstat(2) to test whether
  // "absolutePath" is a directory or not. We can eliminate it
  // at the cost of copying some code from IoBridge.open.
  try {
    fd = IoBridge.open(absolutePath, O_RDONLY);
  } catch (FileNotFoundException fnfe) {
    throw fnfe;
  }
  int capacity;
  try {
    final StructStat stat = Libcore.os.fstat(fd);
    // Like RAF & other APIs, we assume that the file size fits
    // into a 32 bit integer.
    capacity = (int) stat.st_size;
    if (capacity == 0) {
      unknownLength = true;
      capacity = 8192;
    }
  } catch (ErrnoException exception) {
    closeQuietly(fd);
    throw exception.rethrowAsIOException();
  }
  bytes = new byte[capacity];
}

/**
 * Constructs a new {@code FileOutputStream} that writes to {@code file}.
 * If {@code append} is true and the file already exists, it will be appended to; otherwise
 * it will be truncated. The file will be created if it does not exist.
 *
 * @throws FileNotFoundException if the file cannot be opened for writing.
 */
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.mode = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
  this.fd = IoBridge.open(file.getAbsolutePath(), mode);
  this.shouldClose = true;
  this.guard.open("close");
}

/**
 * Constructs a new {@code FileInputStream} that reads from {@code file}.
 *
 * @param file
 *            the file from which this stream reads.
 * @throws FileNotFoundException
 *             if {@code file} does not exist.
 */
public FileInputStream(File file) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.fd = IoBridge.open(file.getAbsolutePath(), O_RDONLY);
  this.shouldClose = true;
  guard.open("close");
}

/**
 * Constructs a new {@code FileOutputStream} that writes to {@code file}.
 * If {@code append} is true and the file already exists, it will be appended to; otherwise
 * it will be truncated. The file will be created if it does not exist.
 *
 * @throws FileNotFoundException if the file cannot be opened for writing.
 */
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.mode = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
  this.fd = IoBridge.open(file.getAbsolutePath(), mode);
  this.shouldClose = true;
  this.guard.open("close");
}

/**
 * Constructs a new {@code FileInputStream} that reads from {@code file}.
 *
 * @param file
 *            the file from which this stream reads.
 * @throws FileNotFoundException
 *             if {@code file} does not exist.
 */
public FileInputStream(File file) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.fd = IoBridge.open(file.getAbsolutePath(), O_RDONLY);
  this.shouldClose = true;
  guard.open("close");
}

/**
 * Constructs a new {@code FileInputStream} that reads from {@code file}.
 *
 * @param file
 *            the file from which this stream reads.
 * @throws FileNotFoundException
 *             if {@code file} does not exist.
 */
public FileInputStream(File file) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.fd = IoBridge.open(file.getAbsolutePath(), O_RDONLY);
  this.shouldClose = true;
  guard.open("close");
}

/**
 * Constructs a new {@code FileOutputStream} that writes to {@code file}.
 * If {@code append} is true and the file already exists, it will be appended to; otherwise
 * it will be truncated. The file will be created if it does not exist.
 *
 * @throws FileNotFoundException if the file cannot be opened for writing.
 */
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.mode = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
  this.fd = IoBridge.open(file.getAbsolutePath(), mode);
  this.shouldClose = true;
  this.guard.open("close");
}

/**
 * Constructs a new {@code FileInputStream} that reads from {@code file}.
 *
 * @param file
 *            the file from which this stream reads.
 * @throws FileNotFoundException
 *             if {@code file} does not exist.
 */
public FileInputStream(File file) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.fd = IoBridge.open(file.getAbsolutePath(), O_RDONLY);
  this.shouldClose = true;
  guard.open("close");
}

/**
 * Constructs a new {@code FileOutputStream} that writes to {@code file}.
 * If {@code append} is true and the file already exists, it will be appended to; otherwise
 * it will be truncated. The file will be created if it does not exist.
 *
 * @throws FileNotFoundException if the file cannot be opened for writing.
 */
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.mode = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
  this.fd = IoBridge.open(file.getAbsolutePath(), mode);
  this.shouldClose = true;
  this.guard.open("close");
}

/**
 * Constructs a new {@code FileOutputStream} that writes to {@code file}.
 * If {@code append} is true and the file already exists, it will be appended to; otherwise
 * it will be truncated. The file will be created if it does not exist.
 *
 * @throws FileNotFoundException if the file cannot be opened for writing.
 */
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.mode = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
  this.fd = IoBridge.open(file.getAbsolutePath(), mode);
  this.shouldClose = true;
  this.guard.open("close");
}

/**
 * Constructs a new {@code FileInputStream} that reads from {@code file}.
 *
 * @param file
 *            the file from which this stream reads.
 * @throws FileNotFoundException
 *             if {@code file} does not exist.
 */
public FileInputStream(File file) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.fd = IoBridge.open(file.getAbsolutePath(), O_RDONLY);
  this.shouldClose = true;
  guard.open("close");
}

/**
 * Constructs a new {@code FileInputStream} that reads from {@code file}.
 *
 * @param file
 *            the file from which this stream reads.
 * @throws FileNotFoundException
 *             if {@code file} does not exist.
 */
public FileInputStream(File file) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.fd = IoBridge.open(file.getAbsolutePath(), O_RDONLY);
  this.shouldClose = true;
  guard.open("close");
}

/**
 * Constructs a new {@code FileOutputStream} that writes to {@code file}.
 * If {@code append} is true and the file already exists, it will be appended to; otherwise
 * it will be truncated. The file will be created if it does not exist.
 *
 * @throws FileNotFoundException if the file cannot be opened for writing.
 */
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
  if (file == null) {
    throw new NullPointerException("file == null");
  }
  this.mode = O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC);
  this.fd = IoBridge.open(file.getAbsolutePath(), mode);
  this.shouldClose = true;
  this.guard.open("close");
}

public FileReader(String absolutePath) throws IOException {
  // We use IoBridge.open because callers might differentiate
  // between a FileNotFoundException and a general IOException.
  //
  // NOTE: This costs us an additional call to fstat(2) to test whether
  // "absolutePath" is a directory or not. We can eliminate it
  // at the cost of copying some code from IoBridge.open.
  try {
    fd = IoBridge.open(absolutePath, O_RDONLY);
  } catch (FileNotFoundException fnfe) {
    throw fnfe;
  }
  int capacity;
  try {
    final StructStat stat = Libcore.os.fstat(fd);
    // Like RAF & other APIs, we assume that the file size fits
    // into a 32 bit integer.
    capacity = (int) stat.st_size;
    if (capacity == 0) {
      unknownLength = true;
      capacity = 8192;
    }
  } catch (ErrnoException exception) {
    closeQuietly(fd);
    throw exception.rethrowAsIOException();
  }
  bytes = new byte[capacity];
}

public FileReader(String absolutePath) throws IOException {
  // We use IoBridge.open because callers might differentiate
  // between a FileNotFoundException and a general IOException.
  //
  // NOTE: This costs us an additional call to fstat(2) to test whether
  // "absolutePath" is a directory or not. We can eliminate it
  // at the cost of copying some code from IoBridge.open.
  try {
    fd = IoBridge.open(absolutePath, O_RDONLY);
  } catch (FileNotFoundException fnfe) {
    throw fnfe;
  }
  int capacity;
  try {
    final StructStat stat = Libcore.os.fstat(fd);
    // Like RAF & other APIs, we assume that the file size fits
    // into a 32 bit integer.
    capacity = (int) stat.st_size;
    if (capacity == 0) {
      unknownLength = true;
      capacity = 8192;
    }
  } catch (ErrnoException exception) {
    closeQuietly(fd);
    throw exception.rethrowAsIOException();
  }
  bytes = new byte[capacity];
}

public FileReader(String absolutePath) throws IOException {
  // We use IoBridge.open because callers might differentiate
  // between a FileNotFoundException and a general IOException.
  //
  // NOTE: This costs us an additional call to fstat(2) to test whether
  // "absolutePath" is a directory or not. We can eliminate it
  // at the cost of copying some code from IoBridge.open.
  try {
    fd = IoBridge.open(absolutePath, O_RDONLY);
  } catch (FileNotFoundException fnfe) {
    throw fnfe;
  }
  int capacity;
  try {
    final StructStat stat = Libcore.os.fstat(fd);
    // Like RAF & other APIs, we assume that the file size fits
    // into a 32 bit integer.
    capacity = (int) stat.st_size;
    if (capacity == 0) {
      unknownLength = true;
      capacity = 8192;
    }
  } catch (ErrnoException exception) {
    closeQuietly(fd);
    throw exception.rethrowAsIOException();
  }
  bytes = new byte[capacity];
}

public FileReader(String absolutePath) throws IOException {
  // We use IoBridge.open because callers might differentiate
  // between a FileNotFoundException and a general IOException.
  //
  // NOTE: This costs us an additional call to fstat(2) to test whether
  // "absolutePath" is a directory or not. We can eliminate it
  // at the cost of copying some code from IoBridge.open.
  try {
    fd = IoBridge.open(absolutePath, O_RDONLY);
  } catch (FileNotFoundException fnfe) {
    throw fnfe;
  }
  int capacity;
  try {
    final StructStat stat = Libcore.os.fstat(fd);
    // Like RAF & other APIs, we assume that the file size fits
    // into a 32 bit integer.
    capacity = (int) stat.st_size;
    if (capacity == 0) {
      unknownLength = true;
      capacity = 8192;
    }
  } catch (ErrnoException exception) {
    closeQuietly(fd);
    throw exception.rethrowAsIOException();
  }
  bytes = new byte[capacity];
}

Javadoc

java.io only throws FileNotFoundException when opening files, regardless of what actually went wrong. Additionally, java.io is more restrictive than POSIX when it comes to opening directories: POSIX says read-only is okay, but java.io doesn't even allow that. We also have an Android-specific hack to alter the default permissions.

Popular methods of IoBridge

available
bind
booleanFromInt
booleanToInt
closeSocket
connect
Connects socket 'fd' to 'inetAddress' on 'port', with a the given 'timeoutMs'. Use timeoutMs == 0 fo
connectDetail
connectErrno
getSocketLocalAddress
getSocketLocalPort
getSocketOption
java.net has its own socket options similar to the underlying Unix ones. We paper over the differenc
getSocketOptionErrno

Popular in Java

Start an intent from android
setScale (BigDecimal)
scheduleAtFixedRate (Timer)
setContentView (Activity)
Table (com.google.common.collect)
A collection that associates an ordered pair of keys, called a row key and a column key, with a sing
MalformedURLException (java.net)
This exception is thrown when a program attempts to create an URL from an incorrect specification.
Path (java.nio.file)
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
Properties (java.util)
A Properties object is a Hashtable where the keys and values must be Strings. Each property can have
Table (org.hibernate.mapping)
A relational table
PhpStorm for WordPress

How to use openmethodin libcore.io.IoBridge

Best Java code snippets using libcore.io.IoBridge.open (Showing top 20 results out of 315)

How to use
open
method
in
libcore.io.IoBridge