Class: Libuv::File

Inherits:
Q::DeferredPromise show all
Includes:
Assertions, FsChecks, Listener, Resource
Defined in:
lib/libuv/file.rb

Constant Summary

Constants included from Assertions

Assertions::MSG_NO_PROC

Constants inherited from Q::Promise

Q::Promise::MAKE_PROMISE

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Assertions

#assert_block, #assert_boolean, #assert_type

Methods included from Resource

#check_result, #check_result!, #resolve, #to_ptr

Methods included from FsChecks

#stat

Methods inherited from Q::DeferredPromise

#then

Methods inherited from Q::Promise

#catch, #finally, #progress

Constructor Details

#initialize(loop, path, flags = 0, mode = 0) ⇒ File

Returns a new instance of File.



9
10
11
12
13
14
15
16
17
18
 
# File 'lib/libuv/file.rb', line 9

def initialize(loop, path, flags = 0, mode = 0)
    super(loop, loop.defer)

    @fileno = -1
    @closed = true 
    @path, @flags, @mode = path, flags, mode

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check @defer, request, ::Libuv::Ext.fs_open(@loop, request, @path, @flags, @mode, callback(:on_open))
end

Instance Attribute Details

#closed ⇒ Object (readonly)

Returns the value of attribute closed.



6
7
8
 
# File 'lib/libuv/file.rb', line 6

def closed
  @closed
end

#fileno ⇒ Object (readonly)

Returns the value of attribute fileno.



6
7
8
 
# File 'lib/libuv/file.rb', line 6

def fileno
  @fileno
end

Instance Method Details

#chmod(mode) ⇒ Object 



86
87
88
89
90
91
92
93
 
# File 'lib/libuv/file.rb', line 86

def chmod(mode)
    assert_type(Integer, mode, "mode must be an Integer")
    @chmod_deferred = @loop.defer

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check @chmod_deferred, request, ::Libuv::Ext.fs_fchmod(@loop.handle, request, @fileno, mode, callback(:on_chmod))
    @chmod_deferred.promise
end

#chown(uid, gid) ⇒ Object 



95
96
97
98
99
100
101
102
103
 
# File 'lib/libuv/file.rb', line 95

def chown(uid, gid)
    assert_type(Integer, uid, "uid must be an Integer")
    assert_type(Integer, gid, "gid must be an Integer")
    @chown_deferred = @loop.defer

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check @chown_deferred, request, ::Libuv::Ext.fs_fchown(@loop.handle, request, @fileno, uid, gid, callback(:on_chown))
    @chown_deferred.promise
end

#close ⇒ Object 



20
21
22
23
24
 
# File 'lib/libuv/file.rb', line 20

def close
    @closed = true
    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check(@defer, request, ::Libuv::Ext.fs_close(@loop.handle, request, @fileno, callback(:on_close)))
end

#datasync ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/libuv/file.rb', line 59

def datasync
    @datasync_deferred = @loop.defer

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check @datasync_deferred, request, ::Libuv::Ext.fs_fdatasync(@loop.handle, request, @fileno, callback(:on_datasync))
    @datasync_deferred.promise
end

#read(length, offset = 0) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/libuv/file.rb', line 26

def read(length, offset = 0)
    assert_type(Integer, length, "length must be an Integer")
    assert_type(Integer, offset, "offset must be an Integer")
    @read_deferred = @loop.defer

    @read_buffer = FFI::MemoryPointer.new(length)

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check(@read_deferred, request, ::Libuv::Ext.fs_read(@loop.handle, request, @fileno, @read_buffer, length, offset, callback(:on_read)))
    @read_deferred.promise
end

#sync ⇒ Object 



51
52
53
54
55
56
57
 
# File 'lib/libuv/file.rb', line 51

def sync
    @sync_deferred = @loop.defer

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check @sync_deferred, request, ::Libuv::Ext.fs_fsync(@loop.handle, request, @fileno, callback(:on_sync))
    @sync_deferred.promise
end

#truncate(offset) ⇒ Object 



67
68
69
70
71
72
73
74
 
# File 'lib/libuv/file.rb', line 67

def truncate(offset)
    assert_type(Integer, offset, "offset must be an Integer")
    @truncate_deferred = @loop.defer

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check @truncate_deferred, request, ::Libuv::Ext.fs_ftruncate(@loop.handle, request, @fileno, offset, callback(:on_truncate))
    @truncate_deferred.promise
end

#utime(atime, mtime) ⇒ Object 



76
77
78
79
80
81
82
83
84
 
# File 'lib/libuv/file.rb', line 76

def utime(atime, mtime)
    assert_type(Integer, atime, "atime must be an Integer")
    assert_type(Integer, mtime, "mtime must be an Integer")
    @utime_deferred = @loop.defer

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check @utime_deferred, request, ::Libuv::Ext.fs_futime(@loop.handle, request, @fileno, atime, mtime, callback(:on_utime))
    @utime_deferred.promise
end

#write(data, offset = 0) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/libuv/file.rb', line 38

def write(data, offset = 0)
    assert_type(String, data, "data must be a String")
    assert_type(Integer, offset, "offset must be an Integer")
    @write_deferred = @loop.defer

    length = data.respond_to?(:bytesize) ? data.bytesize : data.size
    @write_buffer = FFI::MemoryPointer.from_string(data)

    request = ::Libuv::Ext.create_request(:uv_fs)
    pre_check(@write_deferred, request, ::Libuv::Ext.fs_write(@loop.handle, request, @fileno, @write_buffer, length, offset, callback(:on_write)))
    @write_deferred.promise
end