=begin
 This is a machine generated stub using stdlib-doc for <b>class File</b>
 Ruby sources used:  RUBY-1.8.6-p111
 Created on Fri Dec 07 13:50:52 +0300 2007 by IntelliJ IDEA Ruby Plugin.
=end

#   
#     A <code>File</code> is an abstraction of any file object accessible
#     by the program and is closely associated with class <code>IO</code>
#     <code>File</code> includes the methods of module
#     <code>FileTest</code> as class methods, allowing you to write (for
#     example) <code>File.exist?("foo")</code>.
#        
#     In the description of File methods,
#     <em>permission bits</em> are a platform-specific
#     set of bits that indicate permissions of a file. On Unix-based
#     systems, permissions are viewed as a set of three octets, for the
#     owner, the group, and the rest of the world. For each of these
#     entities, permissions may be set to read, write, or execute the
#     file:
#        
#     The permission bits <code>0644</code> (in octal) would thus be
#     interpreted as read/write for owner, and read-only for group and
#     other. Higher-order bits may also be used to indicate the type of
#     file (plain, directory, pipe, socket, and so on) and various other
#     special features. If the permissions are for a directory, the
#     meaning of the execute bit changes; when set the directory can be
#     searched.
#        
#     On non-Posix operating systems, there may be only the ability to
#     make a file read-only or read-write. In this case, the remaining
#     permission bits will be synthesized to resemble typical values. For
#     instance, on Windows NT the default permission bits are
#     <code>0644</code>, which means read/write for owner, read-only for
#     all others. The only change that can be made is to make the file
#     read-only, which is reported as <code>0444</code>.
#    
# 
class File < IO
    Separator = nil #value is unknown, used for indexing.
    SEPARATOR = nil #value is unknown, used for indexing.
    ALT_SEPARATOR = nil #value is unknown, used for indexing.
    ALT_SEPARATOR = nil #value is unknown, used for indexing.
    PATH_SEPARATOR = nil #value is unknown, used for indexing.
    public
    #  
    # File.fnmatch( pattern, path, [flags] ) => (true or false)
    # File.fnmatch?( pattern, path, [flags] ) => (true or false)
    #   
    #     
    #     Returns true if <i>path</i> matches against <i>pattern</i> The
    #     pattern is not a regular expression; instead it follows rules
    #     similar to shell filename globbing. It may contain the following
    #     metacharacters:
    #   
    #     <code>*</code>::        Matches any file. Can be restricted by
    #                             other values in the glob. <code>*</code>
    #                             will match all files; <code>c*</code> will
    #                             match all files beginning with
    #                             <code>c</code>; <code>*c</code> will match
    #                             all files ending with <code>c</code>; and
    #                             <code>*c*</code> will match all files that
    #                             have <code>c</code> in them (including at
    #                             the beginning or end). Equivalent to
    #                             <code>/ .* /x</code> in regexp.
    #     <code>**</code>::       Matches directories recursively or files
    #                             expansively.
    #     <code>?</code>::        Matches any one character. Equivalent to
    #                             <code>/.{1}/</code> in regexp.
    #     <code>[set]</code>::    Matches any one character in +set+.
    #                             Behaves exactly like character sets in
    #                             Regexp, including set negation
    #                             (<code>[^a-z]</code>).
    #     <code>\</code>::        Escapes the next metacharacter.
    #   
    #     <i>flags</i> is a bitwise OR of the <code>FNM_xxx</code>
    #     parameters. The same glob pattern and flags are used by
    #     <code>Dir::glob</code>.
    #   
    #        File.fnmatch('cat',       'cat')        #=> true  : match entire string
    #        File.fnmatch('cat',       'category')   #=> false : only match partial string
    #        File.fnmatch('c{at,ub}s', 'cats')       #=> false : { } isn't supported
    #   
    #        File.fnmatch('c?t',     'cat')          #=> true  : '?' match only 1 character
    #        File.fnmatch('c??t',    'cat')          #=> false : ditto
    #        File.fnmatch('c*',      'cats')         #=> true  : '*' match 0 or more characters
    #        File.fnmatch('c*t',     'c/a/b/t')      #=> true  : ditto
    #        File.fnmatch('ca[a-z]', 'cat')          #=> true  : inclusive bracket expression
    #        File.fnmatch('ca[^t]',  'cat')          #=> false : exclusive bracket expression ('^' or '!')
    #   
    #        File.fnmatch('cat', 'CAT')                     #=> false : case sensitive
    #        File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true  : case insensitive
    #   
    #        File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false : wildcard doesn't match '/' on FNM_PATHNAME
    #        File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false : ditto
    #        File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false : ditto
    #   
    #        File.fnmatch('\?',   '?')                       #=> true  : escaped wildcard becomes ordinary
    #        File.fnmatch('\a',   'a')                       #=> true  : escaped ordinary remains ordinary
    #        File.fnmatch('\a',   '\a', File::FNM_NOESCAPE)  #=> true  : FNM_NOESACPE makes '\' ordinary
    #        File.fnmatch('[\?]', '?')                       #=> true  : can escape inside bracket expression
    #   
    #        File.fnmatch('*',   '.profile')                      #=> false : wildcard doesn't match leading
    #        File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true    period by default.
    #        File.fnmatch('.*',  '.profile')                      #=> true
    #   
    #        rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
    #        File.fnmatch(rbfiles, 'main.rb')                    #=> false
    #        File.fnmatch(rbfiles, './main.rb')                  #=> false
    #        File.fnmatch(rbfiles, 'lib/song.rb')                #=> true
    #        File.fnmatch('**.rb', 'main.rb')                    #=> true
    #        File.fnmatch('**.rb', './main.rb')                  #=> false
    #        File.fnmatch('**.rb', 'lib/song.rb')                #=> true
    #        File.fnmatch('*',           'dave/.profile')                      #=> true
    #   
    #        pattern = '*' '/' '*'
    #        File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME)  #=> false
    #        File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
    #   
    #        pattern = '**' '/' 'foo'
    #        File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
    #        File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
    #        File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
    #        File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
    #        File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
    #    
    def self.fnmatch(pattern, path, *flags)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.fnmatch( pattern, path, [flags] ) => (true or false)
    # File.fnmatch?( pattern, path, [flags] ) => (true or false)
    #   
    #     
    #     Returns true if <i>path</i> matches against <i>pattern</i> The
    #     pattern is not a regular expression; instead it follows rules
    #     similar to shell filename globbing. It may contain the following
    #     metacharacters:
    #   
    #     <code>*</code>::        Matches any file. Can be restricted by
    #                             other values in the glob. <code>*</code>
    #                             will match all files; <code>c*</code> will
    #                             match all files beginning with
    #                             <code>c</code>; <code>*c</code> will match
    #                             all files ending with <code>c</code>; and
    #                             <code>*c*</code> will match all files that
    #                             have <code>c</code> in them (including at
    #                             the beginning or end). Equivalent to
    #                             <code>/ .* /x</code> in regexp.
    #     <code>**</code>::       Matches directories recursively or files
    #                             expansively.
    #     <code>?</code>::        Matches any one character. Equivalent to
    #                             <code>/.{1}/</code> in regexp.
    #     <code>[set]</code>::    Matches any one character in +set+.
    #                             Behaves exactly like character sets in
    #                             Regexp, including set negation
    #                             (<code>[^a-z]</code>).
    #     <code>\</code>::        Escapes the next metacharacter.
    #   
    #     <i>flags</i> is a bitwise OR of the <code>FNM_xxx</code>
    #     parameters. The same glob pattern and flags are used by
    #     <code>Dir::glob</code>.
    #   
    #        File.fnmatch('cat',       'cat')        #=> true  : match entire string
    #        File.fnmatch('cat',       'category')   #=> false : only match partial string
    #        File.fnmatch('c{at,ub}s', 'cats')       #=> false : { } isn't supported
    #   
    #        File.fnmatch('c?t',     'cat')          #=> true  : '?' match only 1 character
    #        File.fnmatch('c??t',    'cat')          #=> false : ditto
    #        File.fnmatch('c*',      'cats')         #=> true  : '*' match 0 or more characters
    #        File.fnmatch('c*t',     'c/a/b/t')      #=> true  : ditto
    #        File.fnmatch('ca[a-z]', 'cat')          #=> true  : inclusive bracket expression
    #        File.fnmatch('ca[^t]',  'cat')          #=> false : exclusive bracket expression ('^' or '!')
    #   
    #        File.fnmatch('cat', 'CAT')                     #=> false : case sensitive
    #        File.fnmatch('cat', 'CAT', File::FNM_CASEFOLD) #=> true  : case insensitive
    #   
    #        File.fnmatch('?',   '/', File::FNM_PATHNAME)  #=> false : wildcard doesn't match '/' on FNM_PATHNAME
    #        File.fnmatch('*',   '/', File::FNM_PATHNAME)  #=> false : ditto
    #        File.fnmatch('[/]', '/', File::FNM_PATHNAME)  #=> false : ditto
    #   
    #        File.fnmatch('\?',   '?')                       #=> true  : escaped wildcard becomes ordinary
    #        File.fnmatch('\a',   'a')                       #=> true  : escaped ordinary remains ordinary
    #        File.fnmatch('\a',   '\a', File::FNM_NOESCAPE)  #=> true  : FNM_NOESACPE makes '\' ordinary
    #        File.fnmatch('[\?]', '?')                       #=> true  : can escape inside bracket expression
    #   
    #        File.fnmatch('*',   '.profile')                      #=> false : wildcard doesn't match leading
    #        File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)  #=> true    period by default.
    #        File.fnmatch('.*',  '.profile')                      #=> true
    #   
    #        rbfiles = '**' '/' '*.rb' # you don't have to do like this. just write in single string.
    #        File.fnmatch(rbfiles, 'main.rb')                    #=> false
    #        File.fnmatch(rbfiles, './main.rb')                  #=> false
    #        File.fnmatch(rbfiles, 'lib/song.rb')                #=> true
    #        File.fnmatch('**.rb', 'main.rb')                    #=> true
    #        File.fnmatch('**.rb', './main.rb')                  #=> false
    #        File.fnmatch('**.rb', 'lib/song.rb')                #=> true
    #        File.fnmatch('*',           'dave/.profile')                      #=> true
    #   
    #        pattern = '*' '/' '*'
    #        File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME)  #=> false
    #        File.fnmatch(pattern, 'dave/.profile', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
    #   
    #        pattern = '**' '/' 'foo'
    #        File.fnmatch(pattern, 'a/b/c/foo', File::FNM_PATHNAME)     #=> true
    #        File.fnmatch(pattern, '/a/b/c/foo', File::FNM_PATHNAME)    #=> true
    #        File.fnmatch(pattern, 'c:/a/b/c/foo', File::FNM_PATHNAME)  #=> true
    #        File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME)    #=> false
    #        File.fnmatch(pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH) #=> true
    #    
    def self.fnmatch?(pattern, path, *flags)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.stat(file_name)   =>  stat
    #   
    #     
    #     Returns a <code>File::Stat</code> object for the named file (see
    #     <code>File::Stat</code>).
    #        
    #        File.stat("testfile").mtime   #=> Tue Apr 08 12:58:04 CDT 2003
    #        
    #    
    # 
    def self.stat(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.lstat(file_name)   => stat
    #   
    #     
    #     Same as <code>File::stat</code>, but does not follow the last symbolic
    #     link. Instead, reports on the link itself.
    #        
    #        File.symlink("testfile", "link2test")   #=> 0
    #        File.stat("testfile").size              #=> 66
    #        File.lstat("link2test").size            #=> 8
    #        File.stat("link2test").size             #=> 66
    #        
    #    
    # 
    def self.lstat(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.ftype(file_name)   => string
    #   
    #     
    #     Identifies the type of the named file; the return string is one of
    #     ``<code>file</code>'', ``<code>directory</code>'',
    #     ``<code>characterSpecial</code>'', ``<code>blockSpecial</code>'',
    #     ``<code>fifo</code>'', ``<code>link</code>'',
    #     ``<code>socket</code>'', or ``<code>unknown</code>''.
    #        
    #        File.ftype("testfile")            #=> "file"
    #        File.ftype("/dev/tty")            #=> "characterSpecial"
    #        File.ftype("/tmp/.X11-unix/X0")   #=> "socket"
    #    
    # 
    def self.ftype(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.atime(file_name)  =>  time
    #   
    #     
    #     Returns the last access time for the named file as a Time object).
    #        
    #        File.atime("testfile")   #=> Wed Apr 09 08:51:48 CDT 2003
    #        
    #    
    # 
    def self.atime(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.mtime(file_name)  =>  time
    #   
    #     
    #     Returns the modification time for the named file as a Time object.
    #        
    #        File.mtime("testfile")   #=> Tue Apr 08 12:58:04 CDT 2003
    #        
    #    
    # 
    def self.mtime(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.ctime(file_name)  => time
    #   
    #     
    #     Returns the change time for the named file (the time at which
    #     directory information about the file was changed, not the file
    #     itself).
    #        
    #        File.ctime("testfile")   #=> Wed Apr 09 08:53:13 CDT 2003
    #        
    #    
    # 
    def self.ctime(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.utime(atime, mtime, file_name,...)   =>  integer
    #   
    #    
    #    Sets the access and modification times of each
    #    named file to the first two arguments. Returns
    #    the number of file names in the argument list.
    #    
    # 
    def self.utime(atime, mtime, file_name,*smth)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.chmod(mode_int, file_name, ... ) -> integer
    #   
    #     
    #     Changes permission bits on the named file(s) to the bit pattern
    #     represented by <i>mode_int</i>. Actual effects are operating system
    #     dependent (see the beginning of this section). On Unix systems, see
    #     <code>chmod(2)</code> for details. Returns the number of files
    #     processed.
    #        
    #        File.chmod(0644, "testfile", "out")   #=> 2
    #    
    # 
    def self.chmod(mode_int, file_name, *smth )
        #This is a stub, used for indexing
    end
    public
    #  
    # File.chown(owner_int, group_int, file_name,... ) -> integer
    #   
    #     
    #     Changes the owner and group of the named file(s) to the given
    #     numeric owner and group id's. Only a process with superuser
    #     privileges may change the owner of a file. The current owner of a
    #     file may change the file's group to any group to which the owner
    #     belongs. A <code>nil</code> or -1 owner or group id is ignored.
    #     Returns the number of files processed.
    #        
    #        File.chown(nil, 100, "testfile")
    #        
    #    
    # 
    def self.chown(owner_int, group_int, file_name,*smth )
        #This is a stub, used for indexing
    end
    public
    #  
    # File.lchmod(mode_int, file_name, ...)  => integer
    #   
    #     
    #     Equivalent to <code>File::chmod</code>, but does not follow symbolic
    #     links (so it will change the permissions associated with the link,
    #     not the file referenced by the link). Often not available.
    #        
    #    
    # 
    def self.lchmod(mode_int, file_name, *smth)
        #This is a stub, used for indexing
    end
    public
    #  
    # file.lchown(owner_int, group_int, file_name,..) => integer
    #   
    #     
    #     Equivalent to <code>File::chown</code>, but does not follow symbolic
    #     links (so it will change the owner associated with the link, not the
    #     file referenced by the link). Often not available. Returns number
    #     of files in the argument list.
    #        
    #    
    # 
    def self.lchown(owner_int, group_int, file_name, *smth)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.link(old_name, new_name)    => 0
    #   
    #     
    #     Creates a new name for an existing file using a hard link. Will not
    #     overwrite <i>new_name</i> if it already exists (raising a subclass
    #     of <code>SystemCallError</code>). Not available on all platforms.
    #        
    #        File.link("testfile", ".testfile")   #=> 0
    #        IO.readlines(".testfile")[0]         #=> "This is line one\n"
    #    
    # 
    def self.link(old_name, new_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.symlink(old_name, new_name)   => 0
    #   
    #     
    #     Creates a symbolic link called <i>new_name</i> for the existing file
    #     <i>old_name</i>. Raises a <code>NotImplemented</code> exception on
    #     platforms that do not support symbolic links.
    #        
    #        File.symlink("testfile", "link2test")   #=> 0
    #        
    #    
    # 
    def self.symlink(old_name, new_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.readlink(link_name) -> file_name
    #   
    #     
    #     Returns the name of the file referenced by the given link.
    #     Not available on all platforms.
    #        
    #        File.symlink("testfile", "link2test")   #=> 0
    #        File.readlink("link2test")              #=> "testfile"
    #    
    # 
    def self.readlink(link_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.delete(file_name, ...)  => integer
    # File.unlink(file_name, ...)  => integer
    #   
    #     
    #     Deletes the named files, returning the number of names
    #     passed as arguments. Raises an exception on any error.
    #     See also <code>Dir::rmdir</code>.
    #    
    # 
    def self.unlink(file_name, *smth)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.delete(file_name, ...)  => integer
    # File.unlink(file_name, ...)  => integer
    #   
    #     
    #     Deletes the named files, returning the number of names
    #     passed as arguments. Raises an exception on any error.
    #     See also <code>Dir::rmdir</code>.
    #    
    # 
    def self.delete(file_name, *smth)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.rename(old_name, new_name)   => 0
    #   
    #     
    #     Renames the given file to the new name. Raises a
    #     <code>SystemCallError</code> if the file cannot be renamed.
    #        
    #        File.rename("afile", "afile.bak")   #=> 0
    #    
    # 
    def self.rename(old_name, new_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.umask()          => integer
    # File.umask(integer)   => integer
    #   
    #     
    #     Returns the current umask value for this process. If the optional
    #     argument is given, set the umask to that value and return the
    #     previous value. Umask values are <em>subtracted</em> from the
    #     default permissions, so a umask of <code>0222</code> would make a
    #     file read-only for everyone.
    #        
    #        File.umask(0006)   #=> 18
    #        File.umask         #=> 6
    #    
    # 
    def self.umask(*several_variants)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.truncate(file_name, integer)  => 0
    #   
    #     
    #     Truncates the file <i>file_name</i> to be at most <i>integer</i>
    #     bytes long. Not available on all platforms.
    #        
    #        f = File.new("out", "w")
    #        f.write("1234567890")     #=> 10
    #        f.close                   #=> nil
    #        File.truncate("out", 5)   #=> 0
    #        File.size("out")          #=> 5
    #        
    #    
    # 
    def self.truncate(file_name, integer)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.expand_path(file_name [, dir_string] ) -> abs_file_name
    #   
    #     
    #     Converts a pathname to an absolute pathname. Relative paths are
    #     referenced from the current working directory of the process unless
    #     <i>dir_string</i> is given, in which case it will be used as the
    #     starting point. The given pathname may start with a
    #     ``<code>~</code>'', which expands to the process owner's home
    #     directory (the environment variable <code>HOME</code> must be set
    #     correctly). ``<code>~</code><i>user</i>'' expands to the named
    #     user's home directory.
    #        
    #        File.expand_path("~oracle/bin")           #=> "/home/oracle/bin"
    #        File.expand_path("../../bin", "/tmp/x")   #=> "/bin"
    #    
    # 
    def self.expand_path(file_name, *dir_string)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.basename(file_name [, suffix] ) -> base_name
    #   
    #     
    #     Returns the last component of the filename given in <i>file_name</i>,
    #     which must be formed using forward slashes (``<code>/</code>'')
    #     regardless of the separator used on the local file system. If
    #     <i>suffix</i> is given and present at the end of <i>file_name</i>,
    #     it is removed.
    #        
    #        File.basename("/home/gumby/work/ruby.rb")          #=> "ruby.rb"
    #        File.basename("/home/gumby/work/ruby.rb", ".rb")   #=> "ruby"
    #    
    # 
    def self.basename(file_name, *suffix)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.dirname(file_name ) -> dir_name
    #   
    #     
    #     Returns all components of the filename given in <i>file_name</i>
    #     except the last one. The filename must be formed using forward
    #     slashes (``<code>/</code>'') regardless of the separator used on the
    #     local file system.
    #        
    #        File.dirname("/home/gumby/work/ruby.rb")   #=> "/home/gumby/work"
    #    
    # 
    def self.dirname(file_name )
        #This is a stub, used for indexing
    end
    public
    #  
    # File.extname(path) -> string
    #   
    #     
    #     Returns the extension (the portion of file name in <i>path</i>
    #     after the period).
    #        
    #        File.extname("test.rb")         #=> ".rb"
    #        File.extname("a/b/d/test.rb")   #=> ".rb"
    #        File.extname("test")            #=> ""
    #        File.extname(".profile")        #=> ""
    #        
    #    
    # 
    def self.extname(path)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.split(file_name)   => array
    #   
    #     
    #     Splits the given string into a directory and a file component and
    #     returns them in a two-element array. See also
    #     <code>File::dirname</code> and <code>File::basename</code>.
    #        
    #        File.split("/home/gumby/.profile")   #=> ["/home/gumby", ".profile"]
    #    
    # 
    def self.split(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.join(string, ...) -> path
    #   
    #     
    #     Returns a new string formed by joining the strings using
    #     <code>File::SEPARATOR</code>.
    #        
    #        File.join("usr", "mail", "gumby")   #=> "usr/mail/gumby"
    #        
    #    
    # 
    def self.join(string, *smth)
        #This is a stub, used for indexing
    end
    public
    #  
    # file.lstat   =>  stat
    #   
    #     
    #     Same as <code>IO#stat</code>, but does not follow the last symbolic
    #     link. Instead, reports on the link itself.
    #        
    #        File.symlink("testfile", "link2test")   #=> 0
    #        File.stat("testfile").size              #=> 66
    #        f = File.new("link2test")
    #        f.lstat.size                            #=> 8
    #        f.stat.size                             #=> 66
    #    
    # 
    def lstat()
        #This is a stub, used for indexing
    end
    public
    #  
    # file.atime    => time
    #   
    #     
    #     Returns the last access time (a <code>Time</code> object)
    #      for <i>file</i>, or epoch if <i>file</i> has not been accessed.
    #        
    #        File.new("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969
    #        
    #    
    # 
    def atime()
        #This is a stub, used for indexing
    end
    public
    #  
    # file.mtime -> time
    #   
    #     
    #     Returns the modification time for <i>file</i>.
    #        
    #        File.new("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003
    #        
    #    
    # 
    def mtime()
        #This is a stub, used for indexing
    end
    public
    #  
    # file.ctime -> time
    #   
    #     
    #     Returns the change time for <i>file</i> (that is, the time directory
    #     information about the file was changed, not the file itself).
    #        
    #        File.new("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003
    #        
    #    
    # 
    def ctime()
        #This is a stub, used for indexing
    end
    public
    #  
    # file.chmod(mode_int)   => 0
    #   
    #     
    #     Changes permission bits on <i>file</i> to the bit pattern
    #     represented by <i>mode_int</i>. Actual effects are platform
    #     dependent; on Unix systems, see <code>chmod(2)</code> for details.
    #     Follows symbolic links. Also see <code>File#lchmod</code>.
    #        
    #        f = File.new("out", "w");
    #        f.chmod(0644)   #=> 0
    #    
    # 
    def chmod(mode_int)
        #This is a stub, used for indexing
    end
    public
    #  
    # file.chown(owner_int, group_int )   => 0
    #   
    #     
    #     Changes the owner and group of <i>file</i> to the given numeric
    #     owner and group id's. Only a process with superuser privileges may
    #     change the owner of a file. The current owner of a file may change
    #     the file's group to any group to which the owner belongs. A
    #     <code>nil</code> or -1 owner or group id is ignored. Follows
    #     symbolic links. See also <code>File#lchown</code>.
    #        
    #        File.new("testfile").chown(502, 1000)
    #        
    #    
    # 
    def chown(owner_int, group_int )
        #This is a stub, used for indexing
    end
    public
    #  
    # file.truncate(integer)    => 0
    #   
    #     
    #     Truncates <i>file</i> to at most <i>integer</i> bytes. The file
    #     must be opened for writing. Not available on all platforms.
    #        
    #        f = File.new("out", "w")
    #        f.syswrite("1234567890")   #=> 10
    #        f.truncate(5)              #=> 0
    #        f.close()                  #=> nil
    #        File.size("out")           #=> 5
    #    
    # 
    def truncate(integer)
        #This is a stub, used for indexing
    end
    public
    #  
    # file.flock (locking_constant ) =>  0 or false
    #   
    #     
    #     Locks or unlocks a file according to <i>locking_constant</i> (a
    #     logical <em>or</em> of the values in the table below).
    #     Returns <code>false</code> if <code>File::LOCK_NB</code> is
    #     specified and the operation would otherwise have blocked. Not
    #     available on all platforms.
    #        
    #     Locking constants (in class File):
    #   
    #        LOCK_EX   | Exclusive lock. Only one process may hold an
    #                  | exclusive lock for a given file at a time.
    #        ----------+------------------------------------------------
    #        LOCK_NB   | Don't block when locking. May be combined
    #                  | with other lock options using logical or.
    #        ----------+------------------------------------------------
    #        LOCK_SH   | Shared lock. Multiple processes may each hold a
    #                  | shared lock for a given file at the same time.
    #        ----------+------------------------------------------------
    #        LOCK_UN   | Unlock.
    #   
    #     Example:
    #   
    #        File.new("testfile").flock(File::LOCK_UN)   #=> 0
    #        
    #    
    # 
    def flock(locking_constant )
        #This is a stub, used for indexing
    end
    public
    #  
    # file.path -> filename
    #   
    #     
    #     Returns the pathname used to create <i>file</i> as a string. Does
    #     not normalize the name.
    #        
    #        File.new("testfile").path               #=> "testfile"
    #        File.new("/tmp/../tmp/xxx", "w").path   #=> "/tmp/../tmp/xxx"
    #        
    #    
    # 
    def path()
        #This is a stub, used for indexing
    end
    public
    #  
    # File.directory?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is a directory,
    #    <code>false</code> otherwise.
    #   
    #       File.directory?(".")
    #    
    # 
    def self.directory?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.exist?(file_name)    =>  true or false
    # File.exists?(file_name)   =>  true or false    (obsolete)
    #   
    #    
    #    Return <code>true</code> if the named file exists.
    #    
    # 
    def self.exist?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.exist?(file_name)    =>  true or false
    # File.exists?(file_name)   =>  true or false    (obsolete)
    #   
    #    
    #    Return <code>true</code> if the named file exists.
    #    
    # 
    def self.exists?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.readable?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is readable by the effective
    #    user id of this process.
    #    
    # 
    def self.readable?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.readable_real?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is readable by the real
    #    user id of this process.
    #    
    # 
    def self.readable_real?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.writable?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is writable by the effective
    #    user id of this process.
    #    
    # 
    def self.writable?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.writable_real?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is writable by the real
    #    user id of this process.
    #    
    # 
    def self.writable_real?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.executable?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is executable by the effective
    #    user id of this process.
    #    
    # 
    def self.executable?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.executable_real?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is executable by the real
    #    user id of this process.
    #    
    # 
    def self.executable_real?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.file?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file exists and is a
    #    regular file.
    #    
    # 
    def self.file?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.zero?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file exists and has
    #    a zero size.
    #    
    # 
    def self.zero?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.size?(file_name)   => Integer or nil
    #   
    #    
    #    Returns +nil+ if +file_name+ doesn't exist or has zero size, the size of the
    #    file otherwise.
    #    
    # 
    def self.size?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.size(file_name)   => integer
    #   
    #    
    #    Returns the size of <code>file_name</code>.
    #    
    # 
    def self.size(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.owned?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file exists and the
    #    effective used id of the calling process is the owner of
    #    the file.
    #    
    # 
    def self.owned?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.grpowned?(file_name)   => true or false
    #   
    #    
    #    Returns <code>true</code> if the named file exists and the
    #    effective group id of the calling process is the owner of
    #    the file. Returns <code>false</code> on Windows.
    #    
    # 
    def self.grpowned?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.pipe?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is a pipe.
    #    
    # 
    def self.pipe?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.symlink?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is a symbolic link.
    #    
    # 
    def self.symlink?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.socket?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is a socket.
    #    
    # 
    def self.socket?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.blockdev?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is a block device.
    #    
    # 
    def self.blockdev?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.chardev?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file is a character device.
    #    
    def self.chardev?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.setuid?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file has the setuid bit set.
    #    
    # 
    def self.setuid?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.setgid?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file has the setgid bit set.
    #    
    # 
    def self.setgid?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.sticky?(file_name)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named file has the sticky bit set.
    #    
    # 
    def self.sticky?(file_name)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.identical?(file_1, file_2)   =>  true or false
    #   
    #    
    #    Returns <code>true</code> if the named files are identical.
    #   
    #        open("a", "w") {}
    #        p File.identical?("a", "a")      #=> true
    #        p File.identical?("a", "./a")    #=> true
    #        File.link("a", "b")
    #        p File.identical?("a", "b")      #=> true
    #        File.symlink("a", "c")
    #        p File.identical?("a", "c")      #=> true
    #        open("d", "w") {}
    #        p File.identical?("a", "d")      #=> false
    #    
    # 
    def self.identical?(file_1, file_2)
        #This is a stub, used for indexing
    end
    public
    #  
    # File.new(filename, mode="r")            => file
    # File.new(filename [, mode [, perm]])    => file
    #   
    #     
    #     Opens the file named by _filename_ according to
    #     _mode_ (default is ``r'') and returns a new
    #     <code>File</code> object. See the description of class +IO+ for
    #     a description of _mode_. The file mode may optionally be
    #     specified as a +Fixnum+ by _or_-ing together the
    #     flags (O_RDONLY etc, again described under +IO+). Optional
    #     permission bits may be given in _perm_. These mode and permission
    #     bits are platform dependent; on Unix systems, see
    #     <code>open(2)</code> for details.
    #   
    #        f = File.new("testfile", "r")
    #        f = File.new("newfile",  "w+")
    #        f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
    #    
    # 
    def self.new(*several_variants)
        #This is a stub, used for indexing
    end
    #    this is IO's method   
    module Constants
    end
    #   
    #     Objects of class <code>File::Stat</code> encapsulate common status
    #     information for <code>File</code> objects. The information is
    #     recorded at the moment the <code>File::Stat</code> object is
    #     created; changes made to the file after that point will not be
    #     reflected. <code>File::Stat</code> objects are returned by
    #     <code>IO#stat</code>, <code>File::stat</code>,
    #     <code>File#lstat</code>, and <code>File::lstat</code>. Many of these
    #     methods return platform-specific values, and not all values are
    #     meaningful on all systems. See also <code>Kernel#test</code>.
    #    
    class Stat < Object
        include Comparable
        public
        #  
        # 
        #   
        #    
        #      File::Stat.new(file_name)  => stat
        #   
        #    Create a File::Stat object for the given file name (raising an
        #    exception if the file doesn't exist).
        #    
        # 
        def self.new(p1)
            #This is a stub, used for indexing
        end
        public
        #  
        # stat <=> other_stat    => -1, 0, 1
        #   
        #     
        #     Compares <code>File::Stat</code> objects by comparing their
        #     respective modification times.
        #        
        #        f1 = File.new("f1", "w")
        #        sleep 1
        #        f2 = File.new("f2", "w")
        #        f1.stat <=> f2.stat   #=> -1
        #    
        # 
        def <=> other_stat
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.dev    => fixnum
        #   
        #     
        #     Returns an integer representing the device on which <i>stat</i>
        #     resides.
        #        
        #        File.stat("testfile").dev   #=> 774
        #    
        # 
        def dev()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.dev_major   => fixnum
        #   
        #     
        #     Returns the major part of <code>File_Stat#dev</code> or
        #     <code>nil</code>.
        #        
        #        File.stat("/dev/fd1").dev_major   #=> 2
        #        File.stat("/dev/tty").dev_major   #=> 5
        #    
        # 
        def dev_major()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.dev_minor   => fixnum
        #   
        #     
        #     Returns the minor part of <code>File_Stat#dev</code> or
        #     <code>nil</code>.
        #        
        #        File.stat("/dev/fd1").dev_minor   #=> 1
        #        File.stat("/dev/tty").dev_minor   #=> 0
        #    
        # 
        def dev_minor()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.ino   => fixnum
        #   
        #     
        #     Returns the inode number for <i>stat</i>.
        #        
        #        File.stat("testfile").ino   #=> 1083669
        #        
        #    
        # 
        def ino()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.mode   => fixnum
        #   
        #     
        #     Returns an integer representing the permission bits of
        #     <i>stat</i>. The meaning of the bits is platform dependent; on
        #     Unix systems, see <code>stat(2)</code>.
        #        
        #        File.chmod(0644, "testfile")   #=> 1
        #        s = File.stat("testfile")
        #        sprintf("%o", s.mode)          #=> "100644"
        #    
        # 
        def mode()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.nlink   => fixnum
        #   
        #     
        #     Returns the number of hard links to <i>stat</i>.
        #        
        #        File.stat("testfile").nlink             #=> 1
        #        File.link("testfile", "testfile.bak")   #=> 0
        #        File.stat("testfile").nlink             #=> 2
        #        
        #    
        # 
        def nlink()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.uid    => fixnum
        #   
        #     
        #     Returns the numeric user id of the owner of <i>stat</i>.
        #        
        #        File.stat("testfile").uid   #=> 501
        #        
        #    
        # 
        def uid()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.gid   => fixnum
        #   
        #     
        #     Returns the numeric group id of the owner of <i>stat</i>.
        #        
        #        File.stat("testfile").gid   #=> 500
        #        
        #    
        # 
        def gid()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.rdev   =>  fixnum or nil
        #   
        #     
        #     Returns an integer representing the device type on which
        #     <i>stat</i> resides. Returns <code>nil</code> if the operating
        #     system doesn't support this feature.
        #        
        #        File.stat("/dev/fd1").rdev   #=> 513
        #        File.stat("/dev/tty").rdev   #=> 1280
        #    
        # 
        def rdev()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.rdev_major   => fixnum
        #   
        #     
        #     Returns the major part of <code>File_Stat#rdev</code> or
        #     <code>nil</code>.
        #        
        #        File.stat("/dev/fd1").rdev_major   #=> 2
        #        File.stat("/dev/tty").rdev_major   #=> 5
        #    
        # 
        def rdev_major()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.rdev_minor   => fixnum
        #   
        #     
        #     Returns the minor part of <code>File_Stat#rdev</code> or
        #     <code>nil</code>.
        #        
        #        File.stat("/dev/fd1").rdev_minor   #=> 1
        #        File.stat("/dev/tty").rdev_minor   #=> 0
        #    
        # 
        def rdev_minor()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.size    => fixnum
        #   
        #     
        #     Returns the size of <i>stat</i> in bytes.
        #        
        #        File.stat("testfile").size   #=> 66
        #    
        # 
        def size()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.blksize   => integer or nil
        #   
        #     
        #     Returns the native file system's block size. Will return <code>nil</code>
        #     on platforms that don't support this information.
        #        
        #        File.stat("testfile").blksize   #=> 4096
        #        
        #    
        # 
        def blksize()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.blocks    => integer or nil
        #   
        #     
        #     Returns the number of native file system blocks allocated for this
        #     file, or <code>nil</code> if the operating system doesn't 
        #     support this feature.
        #        
        #        File.stat("testfile").blocks   #=> 2
        #    
        # 
        def blocks()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.atime   => time
        #   
        #     
        #     Returns the last access time for this file as an object of class
        #     <code>Time</code>.
        #        
        #        File.stat("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969
        #        
        #    
        # 
        def atime()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.mtime -> aTime
        #   
        #     
        #     Returns the modification time of <i>stat</i>.
        #        
        #        File.stat("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003
        #        
        #    
        # 
        def mtime()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.ctime -> aTime
        #   
        #     
        #     Returns the change time for <i>stat</i> (that is, the time
        #     directory information about the file was changed, not the file
        #     itself).
        #        
        #        File.stat("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003
        #        
        #    
        # 
        def ctime()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.inspect  =>  string
        #   
        #    
        #    Produce a nicely formatted description of <i>stat</i>.
        #   
        #      File.stat("/etc/passwd").inspect
        #         #=> "#<File::Stat dev=0xe000005, ino=1078078, mode=0100644, 
        #              nlink=1, uid=0, gid=0, rdev=0x0, size=1374, blksize=4096, 
        #              blocks=8, atime=Wed Dec 10 10:16:12 CST 2003, 
        #              mtime=Fri Sep 12 15:41:41 CDT 2003, 
        #              ctime=Mon Oct 27 11:20:27 CST 2003>"
        #    
        # 
        def inspect()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.ftype   => string
        #   
        #     
        #     Identifies the type of <i>stat</i>. The return string is one of:
        #     ``<code>file</code>'', ``<code>directory</code>'',
        #     ``<code>characterSpecial</code>'', ``<code>blockSpecial</code>'',
        #     ``<code>fifo</code>'', ``<code>link</code>'',
        #     ``<code>socket</code>'', or ``<code>unknown</code>''.
        #        
        #        File.stat("/dev/tty").ftype   #=> "characterSpecial"
        #        
        #    
        # 
        def ftype()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.directory?   => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is a directory,
        #     <code>false</code> otherwise.
        #        
        #        File.stat("testfile").directory?   #=> false
        #        File.stat(".").directory?          #=> true
        #    
        # 
        def directory?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.readable?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is readable by the
        #     effective user id of this process.
        #        
        #        File.stat("testfile").readable?   #=> true
        #        
        #    
        # 
        def readable?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.readable_real? -> true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is readable by the real
        #     user id of this process.
        #        
        #        File.stat("testfile").readable_real?   #=> true
        #        
        #    
        # 
        def readable_real?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.writable? -> true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is writable by the
        #     effective user id of this process.
        #        
        #        File.stat("testfile").writable?   #=> true
        #        
        #    
        # 
        def writable?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.writable_real? -> true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is writable by the real
        #     user id of this process.
        #        
        #        File.stat("testfile").writable_real?   #=> true
        #        
        #    
        # 
        def writable_real?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.executable?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is executable or if the
        #     operating system doesn't distinguish executable files from
        #     nonexecutable files. The tests are made using the effective owner of
        #     the process.
        #        
        #        File.stat("testfile").executable?   #=> false
        #        
        #    
        # 
        def executable?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.executable_real?    => true or false
        #   
        #     
        #     Same as <code>executable?</code>, but tests using the real owner of
        #     the process.
        #    
        # 
        # 
        def executable_real?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.file?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is a regular file (not
        #     a device file, pipe, socket, etc.).
        #        
        #        File.stat("testfile").file?   #=> true
        #        
        #    
        # 
        def file?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.zero?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is a zero-length file;
        #     <code>false</code> otherwise.
        #        
        #        File.stat("testfile").zero?   #=> false
        #        
        #    
        # 
        def zero?()
            #This is a stub, used for indexing
        end
        public
        #  
        # state.size    => integer
        #   
        #     
        #     Returns the size of <i>stat</i> in bytes.
        #        
        #        File.stat("testfile").size   #=> 66
        #        
        #    
        # 
        def size?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.owned?    => true or false
        #   
        #     
        #     Returns <code>true</code> if the effective user id of the process is
        #     the same as the owner of <i>stat</i>.
        #        
        #        File.stat("testfile").owned?      #=> true
        #        File.stat("/etc/passwd").owned?   #=> false
        #        
        #    
        # 
        def owned?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.grpowned?   => true or false
        #   
        #     
        #     Returns true if the effective group id of the process is the same as
        #     the group id of <i>stat</i>. On Windows NT, returns <code>false</code>.
        #        
        #        File.stat("testfile").grpowned?      #=> true
        #        File.stat("/etc/passwd").grpowned?   #=> false
        #        
        #    
        # 
        def grpowned?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.pipe?    => true or false
        #   
        #     
        #     Returns <code>true</code> if the operating system supports pipes and
        #     <i>stat</i> is a pipe; <code>false</code> otherwise.
        #    
        # 
        def pipe?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.symlink?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is a symbolic link,
        #     <code>false</code> if it isn't or if the operating system doesn't
        #     support this feature. As <code>File::stat</code> automatically
        #     follows symbolic links, <code>symlink?</code> will always be
        #     <code>false</code> for an object returned by
        #     <code>File::stat</code>.
        #        
        #        File.symlink("testfile", "alink")   #=> 0
        #        File.stat("alink").symlink?         #=> false
        #        File.lstat("alink").symlink?        #=> true
        #        
        #    
        # 
        def symlink?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.socket?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> is a socket,
        #     <code>false</code> if it isn't or if the operating system doesn't
        #     support this feature.
        #        
        #        File.stat("testfile").socket?   #=> false
        #        
        #    
        # 
        def socket?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.blockdev?   => true or false
        #   
        #     
        #     Returns <code>true</code> if the file is a block device,
        #     <code>false</code> if it isn't or if the operating system doesn't
        #     support this feature.
        #        
        #        File.stat("testfile").blockdev?    #=> false
        #        File.stat("/dev/hda1").blockdev?   #=> true
        #        
        #    
        # 
        def blockdev?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.chardev?    => true or false
        #   
        #     
        #     Returns <code>true</code> if the file is a character device,
        #     <code>false</code> if it isn't or if the operating system doesn't
        #     support this feature.
        #        
        #        File.stat("/dev/tty").chardev?   #=> true
        #        
        #    
        # 
        def chardev?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.setuid?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> has the set-user-id
        #     permission bit set, <code>false</code> if it doesn't or if the
        #     operating system doesn't support this feature.
        #        
        #        File.stat("/bin/su").setuid?   #=> true
        #    
        # 
        def setuid?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.setgid?   => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> has the set-group-id
        #     permission bit set, <code>false</code> if it doesn't or if the
        #     operating system doesn't support this feature.
        #        
        #        File.stat("/usr/sbin/lpc").setgid?   #=> true
        #        
        #    
        # 
        def setgid?()
            #This is a stub, used for indexing
        end
        public
        #  
        # stat.sticky?    => true or false
        #   
        #     
        #     Returns <code>true</code> if <i>stat</i> has its sticky bit set,
        #     <code>false</code> if it doesn't or if the operating system doesn't
        #     support this feature.
        #        
        #        File.stat("testfile").sticky?   #=> false
        #        
        #    
        # 
        def sticky?()
            #This is a stub, used for indexing
        end
    end
end
