Files

Class Index [+]

Quicksearch

SOAP::Mapping::RubytypeFactory

Constants

TYPE_STRING
TYPE_TIME
TYPE_ARRAY
TYPE_REGEXP
TYPE_RANGE
TYPE_CLASS
TYPE_MODULE
TYPE_SYMBOL
TYPE_STRUCT
TYPE_HASH

Public Class Methods

new(config = {}) click to toggle source
    # File lib/soap/mapping/rubytypeFactory.rb, line 25
25:   def initialize(config = {})
26:     @config = config
27:     @allow_untyped_struct = @config.key?(:allow_untyped_struct) ?
28:       @config[:allow_untyped_struct] : true
29:     @allow_original_mapping = @config.key?(:allow_original_mapping) ?
30:       @config[:allow_original_mapping] : false
31:     @string_factory = StringFactory_.new(true)
32:     @basetype_factory = BasetypeFactory_.new(true)
33:     @datetime_factory = DateTimeFactory_.new(true)
34:     @array_factory = ArrayFactory_.new(true)
35:     @hash_factory = HashFactory_.new(true)
36:   end

Public Instance Methods

obj2soap(soap_class, obj, info, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 38
 38:   def obj2soap(soap_class, obj, info, map)
 39:     param = nil
 40:     case obj
 41:     when ::String
 42:       unless @allow_original_mapping
 43:         return nil
 44:       end
 45:       param = @string_factory.obj2soap(SOAPString, obj, info, map)
 46:       if obj.class != String
 47:         param.extraattr[RubyTypeName] = obj.class.name
 48:       end
 49:       addiv2soapattr(param, obj, map)
 50:     when ::Time
 51:       unless @allow_original_mapping
 52:         return nil
 53:       end
 54:       param = @datetime_factory.obj2soap(SOAPDateTime, obj, info, map)
 55:       if obj.class != Time
 56:         param.extraattr[RubyTypeName] = obj.class.name
 57:       end
 58:       addiv2soapattr(param, obj, map)
 59:     when ::Array
 60:       unless @allow_original_mapping
 61:         return nil
 62:       end
 63:       param = @array_factory.obj2soap(nil, obj, info, map)
 64:       if obj.class != Array
 65:         param.extraattr[RubyTypeName] = obj.class.name
 66:       end
 67:       addiv2soapattr(param, obj, map)
 68:     when ::NilClass
 69:       unless @allow_original_mapping
 70:         return nil
 71:       end
 72:       param = @basetype_factory.obj2soap(SOAPNil, obj, info, map)
 73:       addiv2soapattr(param, obj, map)
 74:     when ::FalseClass, ::TrueClass
 75:       unless @allow_original_mapping
 76:         return nil
 77:       end
 78:       param = @basetype_factory.obj2soap(SOAPBoolean, obj, info, map)
 79:       addiv2soapattr(param, obj, map)
 80:     when ::Integer
 81:       unless @allow_original_mapping
 82:         return nil
 83:       end
 84:       param = @basetype_factory.obj2soap(SOAPInt, obj, info, map)
 85:       param ||= @basetype_factory.obj2soap(SOAPInteger, obj, info, map)
 86:       param ||= @basetype_factory.obj2soap(SOAPDecimal, obj, info, map)
 87:       addiv2soapattr(param, obj, map)
 88:     when ::Float
 89:       unless @allow_original_mapping
 90:         return nil
 91:       end
 92:       param = @basetype_factory.obj2soap(SOAPDouble, obj, info, map)
 93:       if obj.class != Float
 94:         param.extraattr[RubyTypeName] = obj.class.name
 95:       end
 96:       addiv2soapattr(param, obj, map)
 97:     when ::Hash
 98:       unless @allow_original_mapping
 99:         return nil
100:       end
101:       if obj.respond_to?(:default_proc) && obj.default_proc
102:         raise TypeError.new("cannot dump hash with default proc")
103:       end
104:       param = SOAPStruct.new(TYPE_HASH)
105:       mark_marshalled_obj(obj, param)
106:       if obj.class != Hash
107:         param.extraattr[RubyTypeName] = obj.class.name
108:       end
109:       obj.each do |key, value|
110:         elem = SOAPStruct.new # Undefined type.
111:         elem.add("key", Mapping._obj2soap(key, map))
112:         elem.add("value", Mapping._obj2soap(value, map))
113:         param.add("item", elem)
114:       end
115:       param.add('default', Mapping._obj2soap(obj.default, map))
116:       addiv2soapattr(param, obj, map)
117:     when ::Regexp
118:       unless @allow_original_mapping
119:         return nil
120:       end
121:       param = SOAPStruct.new(TYPE_REGEXP)
122:       mark_marshalled_obj(obj, param)
123:       if obj.class != Regexp
124:         param.extraattr[RubyTypeName] = obj.class.name
125:       end
126:       param.add('source', SOAPBase64.new(obj.source))
127:       if obj.respond_to?('options')
128:         # Regexp#options is from Ruby/1.7
129:         options = obj.options
130:       else
131:         options = 0
132:         obj.inspect.sub(/^.*\//, '').each_byte do |c|
133:           options += case c
134:             when ii
135:               1
136:             when xx
137:               2
138:             when mm
139:               4
140:             when nn
141:               16
142:             when ee
143:               32
144:             when ss
145:               48
146:             when uu
147:               64
148:             end
149:         end
150:       end
151:       param.add('options', SOAPInt.new(options))
152:       addiv2soapattr(param, obj, map)
153:     when ::Range
154:       unless @allow_original_mapping
155:         return nil
156:       end
157:       param = SOAPStruct.new(TYPE_RANGE)
158:       mark_marshalled_obj(obj, param)
159:       if obj.class != Range
160:         param.extraattr[RubyTypeName] = obj.class.name
161:       end
162:       param.add('begin', Mapping._obj2soap(obj.begin, map))
163:       param.add('end', Mapping._obj2soap(obj.end, map))
164:       param.add('exclude_end', SOAP::SOAPBoolean.new(obj.exclude_end?))
165:       addiv2soapattr(param, obj, map)
166:     when ::Class
167:       unless @allow_original_mapping
168:         return nil
169:       end
170:       if obj.to_s[0] == ##
171:         raise TypeError.new("can't dump anonymous class #{obj}")
172:       end
173:       param = SOAPStruct.new(TYPE_CLASS)
174:       mark_marshalled_obj(obj, param)
175:       param.add('name', SOAPString.new(obj.name))
176:       addiv2soapattr(param, obj, map)
177:     when ::Module
178:       unless @allow_original_mapping
179:         return nil
180:       end
181:       if obj.to_s[0] == ##
182:         raise TypeError.new("can't dump anonymous module #{obj}")
183:       end
184:       param = SOAPStruct.new(TYPE_MODULE)
185:       mark_marshalled_obj(obj, param)
186:       param.add('name', SOAPString.new(obj.name))
187:       addiv2soapattr(param, obj, map)
188:     when ::Symbol
189:       unless @allow_original_mapping
190:         return nil
191:       end
192:       param = SOAPStruct.new(TYPE_SYMBOL)
193:       mark_marshalled_obj(obj, param)
194:       param.add('id', SOAPString.new(obj.id2name))
195:       addiv2soapattr(param, obj, map)
196:     when ::Struct
197:       unless @allow_original_mapping
198:         # treat it as an user defined class. [ruby-talk:104980]
199:         #param = unknownobj2soap(soap_class, obj, info, map)
200:         param = SOAPStruct.new(XSD::AnyTypeName)
201:         mark_marshalled_obj(obj, param)
202:         obj.members.each do |member|
203:           param.add(Mapping.name2elename(member),
204:             Mapping._obj2soap(obj[member], map))
205:         end
206:       else
207:         param = SOAPStruct.new(TYPE_STRUCT)
208:         mark_marshalled_obj(obj, param)
209:         param.add('type', ele_type = SOAPString.new(obj.class.to_s))
210:         ele_member = SOAPStruct.new
211:         obj.members.each do |member|
212:           ele_member.add(Mapping.name2elename(member),
213:             Mapping._obj2soap(obj[member], map))
214:         end
215:         param.add('member', ele_member)
216:         addiv2soapattr(param, obj, map)
217:       end
218:     when ::IO, ::Binding, ::Continuation, ::Data, ::Dir, ::File::Stat,
219:         ::MatchData, Method, ::Proc, ::Thread, ::ThreadGroup
220:         # from 1.8: Process::Status, UnboundMethod
221:       return nil
222:     when ::SOAP::Mapping::Object
223:       param = SOAPStruct.new(XSD::AnyTypeName)
224:       mark_marshalled_obj(obj, param)
225:       obj.__xmlele.each do |key, value|
226:         param.add(key.name, Mapping._obj2soap(value, map))
227:       end
228:       obj.__xmlattr.each do |key, value|
229:         param.extraattr[key] = value
230:       end
231:     when ::Exception
232:       typestr = Mapping.name2elename(obj.class.to_s)
233:       param = SOAPStruct.new(XSD::QName.new(RubyTypeNamespace, typestr))
234:       mark_marshalled_obj(obj, param)
235:       param.add('message', Mapping._obj2soap(obj.message, map))
236:       param.add('backtrace', Mapping._obj2soap(obj.backtrace, map))
237:       addiv2soapattr(param, obj, map)
238:     else
239:       param = unknownobj2soap(soap_class, obj, info, map)
240:     end
241:     param
242:   end
soap2obj(obj_class, node, info, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 244
244:   def soap2obj(obj_class, node, info, map)
245:     rubytype = node.extraattr[RubyTypeName]
246:     if rubytype or node.type.namespace == RubyTypeNamespace
247:       rubytype2obj(node, info, map, rubytype)
248:     elsif node.type == XSD::AnyTypeName or node.type == XSD::AnySimpleTypeName
249:       anytype2obj(node, info, map)
250:     else
251:       unknowntype2obj(node, info, map)
252:     end
253:   end

Private Instance Methods

addiv2soapattr(node, obj, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 257
257:   def addiv2soapattr(node, obj, map)
258:     return if obj.instance_variables.empty?
259:     ivars = SOAPStruct.new    # Undefined type.
260:     setiv2soap(ivars, obj, map)
261:     node.extraattr[RubyIVarName] = ivars
262:   end
unknownobj2soap(soap_class, obj, info, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 264
264:   def unknownobj2soap(soap_class, obj, info, map)
265:     if anonymous_class?(obj)
266:       raise TypeError.new("can't dump anonymous class #{obj}")
267:     end
268:     singleton_class = class << obj; self; end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.