1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
#!/usr/bin/env ruby
# **********************************************************************
#
# Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
require 'Ice'
Ice::loadSlice('Value.ice')
#
# Reopen Demo::Printer (generated 'on the fly' by loadSlice above)
# and define printBackwards
#
class Demo::Printer
def printBackwards()
puts message.reverse
end
end
#
# We can also use derivation (and register a factory) to implement
# local operations
#
class DerivedPrinterI < Demo::DerivedPrinter
def printUppercase(current=nil)
puts derivedMessage.upcase
end
end
class ObjectFactory
def create(type)
if type == "::Demo::DerivedPrinter"
return DerivedPrinterI.new
end
fail "unknown type"
end
end
#
# Redefine a number of methods in Ice::Application
#
class Ice::Application
def interruptCallback(sig)
begin
Ice::Application::communicator.destroy
rescue => ex
puts ex
end
exit(0)
end
def run(args)
if args.length > 0:
puts $0 + ": too many argumnets"
return 1
end
#
# Since this is an interactive demo we want the custom interrupt
# callback to be called when the process is interrupted.
#
Ice::Application::callbackOnInterrupt
initial = Demo::InitialPrx::checkedCast(Ice::Application::communicator().propertyToProxy('Initial.Proxy'))
if not initial
puts $0 + ": invalid proxy"
return 1
end
puts "\n"\
"Let's first transfer a simple object, for a class without\n"\
"operations, and print its contents. No factory is ever required\n"\
"for this.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
simple = initial.getSimple()
puts "==> " + simple.message
puts "\n"\
"Yes, this worked. Now let's try to transfer an object for a class\n"\
"with operations as type ::Demo::Printer.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
printer, printerProxy = initial.getPrinter()
puts "==> " + printer.message
puts "\n"\
"Cool, it worked! Let's try calling the printBackwards() method\n"\
"on the object we just received locally.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
print "==> "
printer.printBackwards()
puts "\n"\
"Now we call the same method, but on the remote object. Watch the\n"\
"server's output.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
printerProxy.printBackwards()
puts "\n"\
"Next, we transfer a derived object from the server.\n"\
"With Ice for Ruby, installing an object factory is optional,\n"\
"and since we compiled the Slice definition for DerivedPrinter, the object\n"\
"is not sliced.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
derived = initial.getDerivedPrinter()
puts "==> The type ID of the received object is \"" + derived.ice_id() + "\""
fail unless derived.ice_id() == "::Demo::DerivedPrinter"
puts "\n"\
"However since we did not implement Demo::DerivedPrinter::printUppercase.\n"\
"calling printUppercase on this object does not work.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
begin
derived.printUpperCase
puts $0 + ": Did not get the expected NoMethodError!"
exit(false)
rescue NoMethodError => ex
puts "==> " + ex
end
puts "\n"\
"Now we install a factory for the derived class, and try again.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
Ice::Application::communicator().addObjectFactory(ObjectFactory.new, "::Demo::DerivedPrinter")
derived = initial.getDerivedPrinter()
puts "==> The type ID of the received object is \"" + derived.ice_id() + "\""
puts "\n"\
"Let's print the message contained in the derived object, and\n"\
"call the operation printUppercase() on the derived object\n"\
"locally.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
puts "==> " + derived.derivedMessage
print "==> "
derived.printUppercase()
puts "\n"\
"Finally, we try the same again, but instead of returning the\n"\
"derived object, we throw an exception containing the derived\n"\
"object.\n"\
"[press enter]"
STDOUT.flush
STDIN.readline
begin
initial.throwDerivedPrinter()
puts $0 + "Did not get the expected DerivedPrinterException!"
exit(false)
rescue Demo::DerivedPrinterException => ex
derived = ex.derived
fail unless derived
end
puts "==> " + derived.derivedMessage
print "==> "
derived.printUppercase()
puts "\n"\
"That's it for this demo. Have fun with Ice!"
initial.shutdown()
return 0
end
end
app = Ice::Application.new
exit(app.main(ARGV, "config.client"))
|
