Module: ZMachine

Extended by:
Forwardable
Defined in:
lib/zmachine/deferrable.rb,
lib/zmachine.rb,
lib/zmachine/timers.rb,
lib/zmachine/channel.rb,
lib/zmachine/reactor.rb,
lib/zmachine/acceptor.rb,
lib/zmachine/connection.rb,
lib/zmachine/tcp_channel.rb,
lib/zmachine/zmq_channel.rb

Overview

–

Author

Francis Cianfrocca (gmail: blackhedd)

Homepage

rubyeventmachine.com

Date

16 Jul 2006

See ZMachine and ZMachine::Connection for documentation and usage examples.

Copyright © 2006-07 by Francis Cianfrocca. All Rights Reserved. Gmail: blackhedd

This program is free software; you can redistribute it and/or modify it under the terms of either: 1) the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version; or 2) Ruby’s License.

See the file COPYING for complete licensing information.

Defined Under Namespace

Modules: Deferrable Classes: Acceptor, Channel, Connection, ConnectionError, ConnectionNotBound, DefaultDeferrable, PeriodicTimer, Reactor, TCPChannel, Timer, UnknownTimerFired, Unsupported, ZMQChannel

Class Method Summary collapse

Class Method Details

._not_implemented ⇒ Object

Raises:

  • (RuntimeError) 


45
46
47
 
# File 'lib/zmachine.rb', line 45

def self._not_implemented
  raise RuntimeError.new("API call not implemented!")
end

.add_periodic_timer(*args, &block) ⇒ Object 



49
50
51
52
53
 
# File 'lib/zmachine.rb', line 49

def self.add_periodic_timer(*args, &block)
  interval = args.shift
  callback = args.shift || block
  PeriodicTimer.new(interval, callback)
end

.attach(io, handler = nil, *args, &blk) ⇒ Object 



55
56
57
 
# File 'lib/zmachine.rb', line 55

def self.attach(io, handler = nil, *args, &blk)
  _not_implemented
end

.bind_connect(bind_addr, bind_port, server, port = nil, handler = nil, *args) ⇒ Object 



59
60
61
 
# File 'lib/zmachine.rb', line 59

def self.bind_connect(bind_addr, bind_port, server, port = nil, handler = nil, *args)
  _not_implemented
end

.Callback(object = nil, method = nil, &blk) ⇒ Object 



63
64
65
 
# File 'lib/zmachine.rb', line 63

def self.Callback(object = nil, method = nil, &blk)
  _not_implemented
end

.connect_unix_domain(socketname, *args, &blk) ⇒ Object 



67
68
69
 
# File 'lib/zmachine.rb', line 67

def self.connect_unix_domain(socketname, *args, &blk)
  _not_implemented
end

.context ⇒ Object 



22
23
24
25
26
 
# File 'lib/zmachine.rb', line 22

def self.context
  @context ||= ThreadLocal.new
  @context.set(ZContext.new) unless @context.get
  @context.get
end

.defer(op = nil, callback = nil, &blk) ⇒ Object 



71
72
73
 
# File 'lib/zmachine.rb', line 71

def self.defer(op = nil, callback = nil, &blk)
  _not_implemented
end

.defers_finished? ⇒ Boolean 



75
76
77
 
# File 'lib/zmachine.rb', line 75

def self.defers_finished?
  _not_implemented
end

.disable_proxy(from) ⇒ Object 



79
80
81
 
# File 'lib/zmachine.rb', line 79

def self.disable_proxy(from)
  _not_implemented
end

.enable_proxy(from, to, bufsize = 0, length = 0) ⇒ Object 



83
84
85
 
# File 'lib/zmachine.rb', line 83

def self.enable_proxy(from, to, bufsize = 0, length = 0)
  _not_implemented
end

.fork_reactor(&block) ⇒ Object 



87
88
89
 
# File 'lib/zmachine.rb', line 87

def self.fork_reactor(&block)
  _not_implemented
end

.get_max_timers ⇒ Object 



91
92
93
 
# File 'lib/zmachine.rb', line 91

def self.get_max_timers
  _not_implemented
end

.heartbeat_interval ⇒ Object 



95
96
97
 
# File 'lib/zmachine.rb', line 95

def self.heartbeat_interval
  _not_implemented
end

.heartbeat_interval=(time) ⇒ Object 



99
100
101
 
# File 'lib/zmachine.rb', line 99

def self.heartbeat_interval=(time)
  _not_implemented
end

.open_datagram_socket(address, port, handler = nil, *args) ⇒ Object 



103
104
105
 
# File 'lib/zmachine.rb', line 103

def self.open_datagram_socket(address, port, handler = nil, *args)
  _not_implemented
end

.popen(cmd, handler = nil, *args) ⇒ Object 



107
108
109
 
# File 'lib/zmachine.rb', line 107

def self.popen(cmd, handler = nil, *args)
  _not_implemented
end

.reactor ⇒ Object 



16
17
18
19
20
 
# File 'lib/zmachine.rb', line 16

def self.reactor
  @reactor ||= ThreadLocal.new
  @reactor.set(Reactor.new) unless @reactor.get
  @reactor.get
end

.reactor_thread? ⇒ Boolean 



111
112
113
 
# File 'lib/zmachine.rb', line 111

def self.reactor_thread?
  _not_implemented
end

.run_block(&block) ⇒ Object 



115
116
117
118
119
120
121
 
# File 'lib/zmachine.rb', line 115

def self.run_block(&block)
  pr = proc {
    block.call
    ZMachine::stop_event_loop
  }
  run(&pr)
end

.schedule(*a, &b) ⇒ Object 



123
124
125
 
# File 'lib/zmachine.rb', line 123

def self.schedule(*a, &b)
  _not_implemented
end

.set_descriptor_table_size(n_descriptors = nil) ⇒ Object 



127
128
129
 
# File 'lib/zmachine.rb', line 127

def self.set_descriptor_table_size(n_descriptors = nil)
  _not_implemented
end

.set_effective_user(username) ⇒ Object 



131
132
133
 
# File 'lib/zmachine.rb', line 131

def self.set_effective_user(username)
  _not_implemented
end

.set_max_timers(ct) ⇒ Object 



135
136
137
 
# File 'lib/zmachine.rb', line 135

def self.set_max_timers(ct)
  _not_implemented
end

.set_quantum(mills) ⇒ Object 



139
140
141
 
# File 'lib/zmachine.rb', line 139

def self.set_quantum(mills)
  _not_implemented
end

.spawn(&block) ⇒ Object 



143
144
145
 
# File 'lib/zmachine.rb', line 143

def self.spawn(&block)
  _not_implemented
end

.start_unix_domain_server(filename, *args, &block) ⇒ Object 



147
148
149
 
# File 'lib/zmachine.rb', line 147

def self.start_unix_domain_server(filename, *args, &block)
  _not_implemented
end

.system(cmd, *args, &cb) ⇒ Object 



151
152
153
 
# File 'lib/zmachine.rb', line 151

def self.system(cmd, *args, &cb)
  _not_implemented
end

.tick_loop(*a, &b) ⇒ Object 



155
156
157
 
# File 'lib/zmachine.rb', line 155

def self.tick_loop(*a, &b)
  _not_implemented
end

.watch(io, handler = nil, *args, &blk) ⇒ Object 



159
160
161
 
# File 'lib/zmachine.rb', line 159

def self.watch(io, handler = nil, *args, &blk)
  _not_implemented
end

.watch_file(filename, handler = nil, *args) ⇒ Object 



163
164
165
 
# File 'lib/zmachine.rb', line 163

def self.watch_file(filename, handler = nil, *args)
  _not_implemented
end

.watch_process(pid, handler = nil, *args) ⇒ Object 



167
168
169
 
# File 'lib/zmachine.rb', line 167

def self.watch_process(pid, handler = nil, *args)
  _not_implemented
end