Struct xpcom::interfaces::nsIFile

#[repr(C)]
pub struct nsIFile { /* fields omitted */ }

interface nsIFile : nsISupports

/**
 * An nsIFile is an abstract representation of a filename. It manages
 * filename encoding issues, pathname component separators ('/' vs. '\\'
 * vs. ':') and weird stuff like differing volumes with identical names, as
 * on pre-Darwin Macintoshes.
 *
 * This file has long introduced itself to new hackers with this opening
 * paragraph:
 *
 *    This is the only correct cross-platform way to specify a file.
 *    Strings are not such a way. If you grew up on windows or unix, you
 *    may think they are.  Welcome to reality.
 *
 * While taking the pose struck here to heart would be uncalled for, one
 * may safely conclude that writing cross-platform code is an embittering
 * experience.
 *
 * All methods with string parameters have two forms.  The preferred
 * form operates on UCS-2 encoded characters strings.  An alternate
 * form operates on characters strings encoded in the "native" charset.
 *
 * A string containing characters encoded in the native charset cannot
 * be safely passed to javascript via xpconnect.  Therefore, the "native
 * methods" are not scriptable.
 */

Methods

impl nsIFile

pub fn coerce<T: nsIFileCoerce>(&self) -> &T

Cast this nsIFile to one of its base interfaces.

impl nsIFile

pub const NORMAL_FILE_TYPE: i64

NORMAL_FILE_TYPE: i64 = 0

/**
     *  Create Types
     *
     *  NORMAL_FILE_TYPE - A normal file.
     *  DIRECTORY_TYPE   - A directory/folder.
     */

pub const DIRECTORY_TYPE: i64

DIRECTORY_TYPE: i64 = 1

pub const OS_READAHEAD: i64

OS_READAHEAD: i64 = 1073741824

/**
     * Flag for openNSPRFileDesc(), to hint to the OS that the file will be
     * read sequentially with agressive readahead.
     */

pub const DELETE_ON_CLOSE: i64

DELETE_ON_CLOSE: i64 = 2147483648

/**
     * Flag for openNSPRFileDesc(). Deprecated and unreliable!
     * Instead use NS_OpenAnonymousTemporaryFile() to create a temporary
     * file which will be deleted upon close!
     */

pub unsafe fn Append(&self, node: &nsAString) -> nsresult

/**
     *  append[Native]
     *
     *  This function is used for constructing a descendent of the
     *  current nsIFile.
     *
     *   @param node
     *       A string which is intended to be a child node of the nsIFile.
     *       For the |appendNative| method, the node must be in the native
     *       filesystem charset.
     */

void append (in AString node);

pub unsafe fn AppendNative(&self, node: &nsACString) -> nsresult

[noscript] void appendNative (in ACString node);

pub unsafe fn Normalize(&self) -> nsresult

/**
     *  Normalize the pathName (e.g. removing .. and . components on Unix).
     */

void normalize ();

pub unsafe fn Create(&self, type_: uint32_t, permissions: uint32_t) -> nsresult

/**
     *  create
     *
     *  This function will create a new file or directory in the
     *  file system. Any nodes that have not been created or
     *  resolved, will be.  If the file or directory already
     *  exists create() will return NS_ERROR_FILE_ALREADY_EXISTS.
     *
     *   @param type
     *       This specifies the type of file system object
     *       to be made.  The only two types at this time
     *       are file and directory which are defined above.
     *       If the type is unrecongnized, we will return an
     *       error (NS_ERROR_FILE_UNKNOWN_TYPE).
     *
     *   @param permissions
     *       The unix style octal permissions.  This may
     *       be ignored on systems that do not need to do
     *       permissions.
     */

[must_use] void create (in unsigned long type, in unsigned long permissions);

pub unsafe fn GetLeafName(&self, aLeafName: &mut nsAString) -> nsresult

/**
     *  Accessor to the leaf name of the file itself.
     *  For the |nativeLeafName| method, the nativeLeafName must
     *  be in the native filesystem charset.
     */

attribute AString leafName;

pub unsafe fn SetLeafName(&self, aLeafName: &nsAString) -> nsresult

/**
     *  Accessor to the leaf name of the file itself.
     *  For the |nativeLeafName| method, the nativeLeafName must
     *  be in the native filesystem charset.
     */

attribute AString leafName;

pub unsafe fn GetNativeLeafName(
    &self,
    aNativeLeafName: &mut nsACString
) -> nsresult

[noscript] attribute ACString nativeLeafName;

pub unsafe fn SetNativeLeafName(&self, aNativeLeafName: &nsACString) -> nsresult

[noscript] attribute ACString nativeLeafName;

pub unsafe fn CopyTo(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsAString
) -> nsresult

/**
     *  copyTo[Native]
     *
     *  This will copy this file to the specified newParentDir.
     *  If a newName is specified, the file will be renamed.
     *  If 'this' is not created we will return an error
     *  (NS_ERROR_FILE_TARGET_DOES_NOT_EXIST).
     *
     *  copyTo may fail if the file already exists in the destination
     *  directory.
     *
     *  copyTo will NOT resolve aliases/shortcuts during the copy.
     *
     *   @param newParentDir
     *       This param is the destination directory. If the
     *       newParentDir is null, copyTo() will use the parent
     *       directory of this file. If the newParentDir is not
     *       empty and is not a directory, an error will be
     *       returned (NS_ERROR_FILE_DESTINATION_NOT_DIR). For the
     *       |CopyToNative| method, the newName must be in the
     *       native filesystem charset.
     *
     *   @param newName
     *       This param allows you to specify a new name for
     *       the file to be copied. This param may be empty, in
     *       which case the current leaf name will be used.
     */

void copyTo (in nsIFile newParentDir, in AString newName);

pub unsafe fn CopyToNative(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsACString
) -> nsresult

[noscript] void CopyToNative (in nsIFile newParentDir, in ACString newName);

pub unsafe fn CopyToFollowingLinks(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsAString
) -> nsresult

/**
     *  copyToFollowingLinks[Native]
     *
     *  This function is identical to copyTo with the exception that,
     *  as the name implies, it follows symbolic links.  The XP_UNIX
     *  implementation always follow symbolic links when copying.  For
     *  the |CopyToFollowingLinks| method, the newName must be in the
     *  native filesystem charset.
     */

void copyToFollowingLinks (in nsIFile newParentDir, in AString newName);

pub unsafe fn CopyToFollowingLinksNative(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsACString
) -> nsresult

[noscript] void copyToFollowingLinksNative (in nsIFile newParentDir, in ACString newName);

pub unsafe fn MoveTo(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsAString
) -> nsresult

/**
     *  moveTo[Native]
     *
     *  A method to move this file or directory to newParentDir.
     *  If a newName is specified, the file or directory will be renamed.
     *  If 'this' is not created we will return an error
     *  (NS_ERROR_FILE_TARGET_DOES_NOT_EXIST).
     *  If 'this' is a file, and the destination file already exists, moveTo
     *  will replace the old file.
     *  This object is updated to refer to the new file.
     *
     *  moveTo will NOT resolve aliases/shortcuts during the copy.
     *  moveTo will do the right thing and allow copies across volumes.
     *  moveTo will return an error (NS_ERROR_FILE_DIR_NOT_EMPTY) if 'this' is
     *  a directory and the destination directory is not empty.
     *  moveTo will return an error (NS_ERROR_FILE_ACCESS_DENIED) if 'this' is
     *  a directory and the destination directory is not writable.
     *
     *   @param newParentDir
     *       This param is the destination directory. If the
     *       newParentDir is empty, moveTo() will rename the file
     *       within its current directory. If the newParentDir is
     *       not empty and does not name a directory, an error will
     *       be returned (NS_ERROR_FILE_DESTINATION_NOT_DIR).  For
     *       the |moveToNative| method, the newName must be in the
     *       native filesystem charset.
     *
     *   @param newName
     *       This param allows you to specify a new name for
     *       the file to be moved. This param may be empty, in
     *       which case the current leaf name will be used.
     */

void moveTo (in nsIFile newParentDir, in AString newName);

pub unsafe fn MoveToNative(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsACString
) -> nsresult

[noscript] void moveToNative (in nsIFile newParentDir, in ACString newName);

pub unsafe fn RenameTo(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsAString
) -> nsresult

/**
     *  renameTo
     *
     *  This method is identical to moveTo except that if this file or directory
     *  is moved to a a different volume, it fails and returns an error
     *  (NS_ERROR_FILE_ACCESS_DENIED).
     *  This object will still point to the old location after renaming.
     */

void renameTo (in nsIFile newParentDir, in AString newName);

pub unsafe fn RenameToNative(
    &self,
    newParentDir: *const nsIFile,
    newName: &nsACString
) -> nsresult

[noscript] void renameToNative (in nsIFile newParentDir, in ACString newName);

pub unsafe fn Remove(&self, recursive: bool) -> nsresult

/**
     *  This will try to delete this file.  The 'recursive' flag
     *  must be PR_TRUE to delete directories which are not empty.
     *
     *  This will not resolve any symlinks.
     */

void remove (in boolean recursive);

pub unsafe fn GetPermissions(&self, aPermissions: *mut uint32_t) -> nsresult

/**
     *  Attributes of nsIFile.
     */

attribute unsigned long permissions;

pub unsafe fn SetPermissions(&self, aPermissions: uint32_t) -> nsresult

/**
     *  Attributes of nsIFile.
     */

attribute unsigned long permissions;

pub unsafe fn GetPermissionsOfLink(
    &self,
    aPermissionsOfLink: *mut uint32_t
) -> nsresult

attribute unsigned long permissionsOfLink;

pub unsafe fn SetPermissionsOfLink(
    &self,
    aPermissionsOfLink: uint32_t
) -> nsresult

attribute unsigned long permissionsOfLink;

pub unsafe fn GetLastModifiedTime(
    &self,
    aLastModifiedTime: *mut PRTime
) -> nsresult

/**
     *  File Times are to be in milliseconds from
     *  midnight (00:00:00), January 1, 1970 Greenwich Mean
     *  Time (GMT).
     */

attribute PRTime lastModifiedTime;

pub unsafe fn SetLastModifiedTime(&self, aLastModifiedTime: PRTime) -> nsresult

/**
     *  File Times are to be in milliseconds from
     *  midnight (00:00:00), January 1, 1970 Greenwich Mean
     *  Time (GMT).
     */

attribute PRTime lastModifiedTime;

pub unsafe fn GetLastModifiedTimeOfLink(
    &self,
    aLastModifiedTimeOfLink: *mut PRTime
) -> nsresult

attribute PRTime lastModifiedTimeOfLink;

pub unsafe fn SetLastModifiedTimeOfLink(
    &self,
    aLastModifiedTimeOfLink: PRTime
) -> nsresult

attribute PRTime lastModifiedTimeOfLink;

pub unsafe fn GetFileSize(&self, aFileSize: *mut int64_t) -> nsresult

/**
     *  WARNING!  On the Mac, getting/setting the file size with nsIFile
     *  only deals with the size of the data fork.  If you need to
     *  know the size of the combined data and resource forks use the
     *  GetFileSizeWithResFork() method defined on nsILocalFileMac.
     */

attribute int64_t fileSize;

pub unsafe fn SetFileSize(&self, aFileSize: int64_t) -> nsresult

/**
     *  WARNING!  On the Mac, getting/setting the file size with nsIFile
     *  only deals with the size of the data fork.  If you need to
     *  know the size of the combined data and resource forks use the
     *  GetFileSizeWithResFork() method defined on nsILocalFileMac.
     */

attribute int64_t fileSize;

pub unsafe fn GetFileSizeOfLink(
    &self,
    aFileSizeOfLink: *mut int64_t
) -> nsresult

readonly attribute int64_t fileSizeOfLink;

pub unsafe fn GetTarget(&self, aTarget: &mut nsAString) -> nsresult

/**
     *  target & path
     *
     *  Accessor to the string path.  The native version of these
     *  strings are not guaranteed to be a usable path to pass to
     *  NSPR or the C stdlib.  There are problems that affect
     *  platforms on which a path does not fully specify a file
     *  because two volumes can have the same name (e.g., mac).
     *  This is solved by holding "private", native data in the
     *  nsIFile implementation.  This native data is lost when
     *  you convert to a string.
     *
     *      DO NOT PASS TO USE WITH NSPR OR STDLIB!
     *
     *  target
     *      Find out what the symlink points at.  Will give error
     *      (NS_ERROR_FILE_INVALID_PATH) if not a symlink.
     *
     *  path
     *      Find out what the nsIFile points at.
     *
     *  Note that the ACString attributes are returned in the
     *  native filesystem charset.
     *
     */

readonly attribute AString target;

pub unsafe fn GetNativeTarget(&self, aNativeTarget: &mut nsACString) -> nsresult

[noscript] readonly attribute ACString nativeTarget;

pub unsafe fn GetPath(&self, aPath: &mut nsAString) -> nsresult

readonly attribute AString path;

pub unsafe fn GetNativePath(&self, aNativePath: &mut nsACString) -> nsresult

[noscript] readonly attribute ACString nativePath;

pub unsafe fn Exists(&self, _retval: *mut bool) -> nsresult

boolean exists ();

pub unsafe fn IsWritable(&self, _retval: *mut bool) -> nsresult

boolean isWritable ();

pub unsafe fn IsReadable(&self, _retval: *mut bool) -> nsresult

boolean isReadable ();

pub unsafe fn IsExecutable(&self, _retval: *mut bool) -> nsresult

boolean isExecutable ();

pub unsafe fn IsHidden(&self, _retval: *mut bool) -> nsresult

boolean isHidden ();

pub unsafe fn IsDirectory(&self, _retval: *mut bool) -> nsresult

boolean isDirectory ();

pub unsafe fn IsFile(&self, _retval: *mut bool) -> nsresult

boolean isFile ();

pub unsafe fn IsSymlink(&self, _retval: *mut bool) -> nsresult

boolean isSymlink ();

pub unsafe fn IsSpecial(&self, _retval: *mut bool) -> nsresult

/**
     * Not a regular file, not a directory, not a symlink.
     */

boolean isSpecial ();

pub unsafe fn CreateUnique(
    &self,
    type_: uint32_t,
    permissions: uint32_t
) -> nsresult

/**
     *  createUnique
     *
     *  This function will create a new file or directory in the
     *  file system. Any nodes that have not been created or
     *  resolved, will be.  If this file already exists, we try
     *  variations on the leaf name "suggestedName" until we find
     *  one that did not already exist.
     *
     *  If the search for nonexistent files takes too long
     *  (thousands of the variants already exist), we give up and
     *  return NS_ERROR_FILE_TOO_BIG.
     *
     *   @param type
     *       This specifies the type of file system object
     *       to be made.  The only two types at this time
     *       are file and directory which are defined above.
     *       If the type is unrecongnized, we will return an
     *       error (NS_ERROR_FILE_UNKNOWN_TYPE).
     *
     *   @param permissions
     *       The unix style octal permissions.  This may
     *       be ignored on systems that do not need to do
     *       permissions.
     */

[must_use] void createUnique (in unsigned long type, in unsigned long permissions);

pub unsafe fn Clone(&self, _retval: *mut *const nsIFile) -> nsresult

/**
      * clone()
      *
      * This function will allocate and initialize a nsIFile object to the
      * exact location of the |this| nsIFile.
      *
      *   @param file
      *          A nsIFile which this object will be initialize
      *          with.
      *
      */

nsIFile clone ();

pub unsafe fn Equals(
    &self,
    inFile: *const nsIFile,
    _retval: *mut bool
) -> nsresult

/**
     *  Will determine if the inFile equals this.
     */

boolean equals (in nsIFile inFile);

pub unsafe fn Contains(
    &self,
    inFile: *const nsIFile,
    _retval: *mut bool
) -> nsresult

/**
     *  Will determine if inFile is a descendant of this file.
     *  This routine looks in subdirectories too.
     */

boolean contains (in nsIFile inFile);

pub unsafe fn GetParent(&self, aParent: *mut *const nsIFile) -> nsresult

/**
     *  Parent will be null when this is at the top of the volume.
     */

readonly attribute nsIFile parent;

pub unsafe fn GetDirectoryEntries(
    &self,
    aDirectoryEntries: *mut *const nsISimpleEnumerator
) -> nsresult

/**
     *  Returns an enumeration of the elements in a directory. Each
     *  element in the enumeration is an nsIFile.
     *
     *   @throws NS_ERROR_FILE_NOT_DIRECTORY if the current nsIFile does
     *           not specify a directory.
     */

readonly attribute nsISimpleEnumerator directoryEntries;

pub unsafe fn InitWithPath(&self, filePath: &nsAString) -> nsresult

/**
     *  initWith[Native]Path
     *
     *  This function will initialize the nsIFile object.  Any
     *  internal state information will be reset.
     *
     *   @param filePath
     *       A string which specifies a full file path to a
     *       location.  Relative paths will be treated as an
     *       error (NS_ERROR_FILE_UNRECOGNIZED_PATH).  For
     *       initWithNativePath, the filePath must be in the native
     *       filesystem charset.
     */

void initWithPath (in AString filePath);

pub unsafe fn InitWithNativePath(&self, filePath: &nsACString) -> nsresult

[noscript] void initWithNativePath (in ACString filePath);

pub unsafe fn InitWithFile(&self, aFile: *const nsIFile) -> nsresult

/**
     *  initWithFile
     *
     *  Initialize this object with another file
     *
     *   @param aFile
     *       the file this becomes equivalent to
     */

void initWithFile (in nsIFile aFile);

pub unsafe fn GetFollowLinks(&self, aFollowLinks: *mut bool) -> nsresult

/**
     *  followLinks
     *
     *  This attribute will determine if the nsLocalFile will auto
     *  resolve symbolic links.  By default, this value will be false
     *  on all non unix systems.  On unix, this attribute is effectively
     *  a noop.
     */

attribute boolean followLinks;

pub unsafe fn SetFollowLinks(&self, aFollowLinks: bool) -> nsresult

/**
     *  followLinks
     *
     *  This attribute will determine if the nsLocalFile will auto
     *  resolve symbolic links.  By default, this value will be false
     *  on all non unix systems.  On unix, this attribute is effectively
     *  a noop.
     */

attribute boolean followLinks;

pub unsafe fn GetDiskSpaceAvailable(
    &self,
    aDiskSpaceAvailable: *mut int64_t
) -> nsresult

[must_use] readonly attribute int64_t diskSpaceAvailable;

pub unsafe fn AppendRelativePath(
    &self,
    relativeFilePath: &nsAString
) -> nsresult

/**
     *  appendRelative[Native]Path
     *
     *  Append a relative path to the current path of the nsIFile object.
     *
     *   @param relativeFilePath
     *       relativeFilePath is a native relative path. For security reasons,
     *       this cannot contain .. or cannot start with a directory separator.
     *       For the |appendRelativeNativePath| method, the relativeFilePath
     *       must be in the native filesystem charset.
     */

void appendRelativePath (in AString relativeFilePath);

pub unsafe fn AppendRelativeNativePath(
    &self,
    relativeFilePath: &nsACString
) -> nsresult

[noscript] void appendRelativeNativePath (in ACString relativeFilePath);

pub unsafe fn GetPersistentDescriptor(
    &self,
    aPersistentDescriptor: &mut nsACString
) -> nsresult

/**
     *  Accessor to a null terminated string which will specify
     *  the file in a persistent manner for disk storage.
     *
     *  The character set of this attribute is undefined.  DO NOT TRY TO
     *  INTERPRET IT AS HUMAN READABLE TEXT!
     */

[must_use] attribute ACString persistentDescriptor;

pub unsafe fn SetPersistentDescriptor(
    &self,
    aPersistentDescriptor: &nsACString
) -> nsresult

/**
     *  Accessor to a null terminated string which will specify
     *  the file in a persistent manner for disk storage.
     *
     *  The character set of this attribute is undefined.  DO NOT TRY TO
     *  INTERPRET IT AS HUMAN READABLE TEXT!
     */

[must_use] attribute ACString persistentDescriptor;

pub unsafe fn Reveal(&self) -> nsresult

/**
     *  reveal
     *
     *  Ask the operating system to open the folder which contains
     *  this file or folder. This routine only works on platforms which
     *  support the ability to open a folder and is run async on Windows.
     *  This routine must be called on the main.
     */

[must_use] void reveal ();

pub unsafe fn Launch(&self) -> nsresult

/**
     *  launch
     *
     *  Ask the operating system to attempt to open the file.
     *  this really just simulates "double clicking" the file on your platform.
     *  This routine only works on platforms which support this functionality
     *  and is run async on Windows.  This routine must be called on the
     *  main thread.
     */

[must_use] void launch ();

pub unsafe fn GetRelativeDescriptor(
    &self,
    fromFile: *const nsIFile,
    _retval: &mut nsACString
) -> nsresult

/**
     *  getRelativeDescriptor
     *
     *  Returns a relative file path in an opaque, XP format. It is therefore
     *  not a native path.
     *
     *  The character set of the string returned from this function is
     *  undefined.  DO NOT TRY TO INTERPRET IT AS HUMAN READABLE TEXT!
     *
     *   @param fromFile
     *       the file from which the descriptor is relative.
     *       Throws if fromFile is null.
     */

[must_use] ACString getRelativeDescriptor (in nsIFile fromFile);

pub unsafe fn SetRelativeDescriptor(
    &self,
    fromFile: *const nsIFile,
    relativeDesc: &nsACString
) -> nsresult

/**
     *  setRelativeDescriptor
     *
     *  Initializes the file to the location relative to fromFile using
     *  a string returned by getRelativeDescriptor.
     *
     *   @param fromFile
     *       the file to which the descriptor is relative
     *   @param relative
     *       the relative descriptor obtained from getRelativeDescriptor
     */

[must_use] void setRelativeDescriptor (in nsIFile fromFile, in ACString relativeDesc);

pub unsafe fn GetRelativePath(
    &self,
    fromFile: *const nsIFile,
    _retval: &mut nsACString
) -> nsresult

/**
     *  getRelativePath
     *
     *  Returns a relative file from 'fromFile' to this file as a UTF-8 string.
     *  Going up the directory tree is represented via "../".  '/' is used as
     *  the path segment separator.  This is not a native path, since it's UTF-8
     *  encoded.
     *
     *   @param fromFile
     *       the file from which the path is relative.
     *       Throws if fromFile is null.
     */

[must_use] AUTF8String getRelativePath (in nsIFile fromFile);

pub unsafe fn SetRelativePath(
    &self,
    fromFile: *const nsIFile,
    relativeDesc: &nsACString
) -> nsresult

/**
     *  setRelativePath
     *
     *  Initializes the file to the location relative to fromFile using
     *  a string returned by getRelativePath.
     *
     *   @param fromFile
     *       the file from which the path is relative
     *   @param relative
     *       the relative path obtained from getRelativePath
     */

[must_use] void setRelativePath (in nsIFile fromFile, in AUTF8String relativeDesc);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIFile

const IID: nsIID

IID: nsIID = nsID(799443018, 44645, 16682, [157, 76, 206, 110, 52, 84, 75, 161])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIFile

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIFile

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.