Module: SOAP::Mapping::RegistrySupport

Included in:
EncodedRegistry, LiteralRegistry
Defined in:
lib/soap/mapping/registry.rb

Instance Method Summary collapse

Instance Method Details

#add_attributes2soap(obj, ele) ⇒ Object 



218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/soap/mapping/registry.rb', line 218

def add_attributes2soap(obj, ele)
  definition = Mapping.schema_definition_classdef(obj.class)
  if definition && attributes = definition.attributes
    attributes.each do |qname, param|
      at = obj.__send__(
        XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name))
      ele.extraattr[qname] = at
    end
  elsif obj.respond_to?(:__xmlattr)
    obj.__xmlattr.each do |key, value|
      ele.extraattr[key] = value
    end
  end
end

#base2obj(value, klass) ⇒ Object 



247
248
249
250
251
252
253
 
# File 'lib/soap/mapping/registry.rb', line 247

def base2obj(value, klass)
  if value.respond_to?(:data)
    klass.new(value.data).data
  else
    klass.new(nil).data
  end
end

#base2soap(obj, type, qualified = nil) ⇒ Object 



233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/soap/mapping/registry.rb', line 233

def base2soap(obj, type, qualified = nil)
  soap_obj = nil
  if type <= XSD::XSDString
    str = XSD::Charset.encoding_conv(obj.to_s,
      Thread.current[:SOAPMapping][:ExternalCES],
      XSD::Charset.encoding)
    soap_obj = type.new(str)
  else
    soap_obj = type.new(obj)
  end
  soap_obj.qualified = qualified
  soap_obj
end

#find_schema_definition(name) ⇒ Object 



209
210
211
212
213
214
215
216
 
# File 'lib/soap/mapping/registry.rb', line 209

def find_schema_definition(name)
  return nil unless name
  typestr = XSD::CodeGen::GenSupport.safeconstname(name)
  obj_class = Mapping.class_from_name(typestr)
  if obj_class
    schema_definition_from_class(obj_class)
  end
end

#initialize ⇒ Object 



178
179
180
181
182
183
 
# File 'lib/soap/mapping/registry.rb', line 178

def initialize
  super()
  @class_schema_definition = {}
  @elename_schema_definition = {}
  @type_schema_definition = {}
end

#register(definition) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/soap/mapping/registry.rb', line 185

def register(definition)
  obj_class = definition[:class]
  definition = Mapping.create_schema_definition(obj_class, definition)
  @class_schema_definition[obj_class] = definition
  if definition.elename
    @elename_schema_definition[definition.elename] = definition
  end
  if definition.type
    @type_schema_definition[definition.type] = definition
  end
end

#schema_definition_from_class(klass) ⇒ Object 



197
198
199
 
# File 'lib/soap/mapping/registry.rb', line 197

def schema_definition_from_class(klass)
  @class_schema_definition[klass] || Mapping.schema_definition_classdef(klass)
end

#schema_definition_from_elename(qname) ⇒ Object 



201
202
203
 
# File 'lib/soap/mapping/registry.rb', line 201

def schema_definition_from_elename(qname)
  @elename_schema_definition[qname] || find_schema_definition(qname.name)
end

#schema_definition_from_type(type) ⇒ Object 



205
206
207
 
# File 'lib/soap/mapping/registry.rb', line 205

def schema_definition_from_type(type)
  @type_schema_definition[type] || find_schema_definition(type.name)
end