$obj = SOAP::Data->new(name => 'idx', value => 5);
This is the class constructor. Almost all of the attributes related to the class may be passed to the constructor as key/value pairs. This method isn't often used directly because SOAP::Data objects are generally created for temporary use. It is available for those situations that require it.
$obj->name('index');
Gets or sets the current value of the name, as the object regards it. The name is what the serializer will use for the tag when generating the XML for this object. It is what will become the accessor for the data element. Optionally, the object's value may be updated if passed as a second argument.
$obj->type('int');
Gets or sets the type associated with the current value in the object. This is useful for those cases where the SOAP::Data object is used to explicitly specify the type of data that would otherwise be interpreted as a different type completely (such as perceiving the string 123 as an integer, instead). Allows the setting of the object's value, if passed as a second argument to the method.
$obj->uri('http://www.perl.com/SOAP');
Gets or sets the URI that will be used as the namespace for the resulting XML entity, if one is desired. This doesn't set the label for the namespace. If one isn't provided by means of the prefix method, one is generated automatically when needed. Also allows the setting of the object's value, if passed as a second argument to the method.
$obj->prefix('perl');
Provides the prefix, or label, for use when associating the data object with a specific namespace. Also allows the setting of the object's value, if passed as a second argument to the method.
$obj->attr({ attr1 => 'value' });
Allows for the setting of arbitrary attributes on the data object. Keep in mind the requirement that any attributes not natively known to SOAP must be namespace-qualified. Also allows the setting of the object's value, if passed as a second argument to the method.
$obj->value(10);
Fetches the current value encapsulated by the object, or explicitly sets it.
The last four methods are convenience shortcuts for the attributes that SOAP itself supports. Each also permits inclusion of a new value, as an optional second argument.
$obj->actor($new_actor_name);
Gets or sets the value of the actor attribute; useful only when the object generates an entity for the message header.
$obj->mustUnderstand(0);
Manipulates the mustUnderstand attribute, which tells the SOAP processor whether it is required to understand the entity in question.
$obj->encodingStyle($soap_11_encoding);
This method is most likely to be used in places outside the header creation. Sets encodingStyle, which specifies an encoding that differs from the one that would otherwise be defaulted to.
$obj->root(1);
When the application must explicitly specify which data element is to be regarded as the root element for the sake of generating the object model, this method provides the access to the root attribute.
$elem = SOAP::Data->name('idx')->value(5);
If, however, you need to serialize this into a long, then the following code will do so:
$elem = SOAP::Data->name('idx')->value(5)->type('long');
$elem1 = SOAP::Data->new(name => 'idx', value => 5); $elem2 = SOAP::Data->name('idx' => 5); $elem3 = SOAP::Data->name('idx')->value(5);
SOAP::Data->name('foo' => \SOAP::Data->value( SOAP::Data->name('bar' => '123')));
The above code will produce the following XML:
<foo> <bar>123</bar> </foo>
$elem1 = SOAP::Data->name('item' => 123)->type('SomeObject'); $elem2 = SOAP::Data->name('item' => 456)->type('SomeObject'); push(@array,$elem1); push(@array,$elem2); my $client = SOAP::Lite ->readable(1) ->uri($NS) ->proxy($HOST); $temp_elements = SOAP::Data ->name("CallDetails" => \SOAP::Data->value( SOAP::Data->name("elem1" => 'foo'), SOAP::Data->name("elem2" => 'baz'), SOAP::Data->name("someArray" => \SOAP::Data->value( SOAP::Data->name("someArrayItem" => @array) ->type("SomeObject")) )->type("ArrayOf_SomeObject") )) ->type("SomeObject"); $response = $client->someMethod($temp_elements);
Will produce the following XML:
<?xml version="1.0" encoding="UTF-8"?> <SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:namesp2="http://namespaces.soaplite.com/perl" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"> <SOAP-ENV:Body> <namesp1:someMethod xmlns:namesp1="urn:TemperatureService"> <CallDetails xsi:type="namesp2:SomeObject"> <elem1 xsi:type="xsd:string">foo</elem1> <elem2 xsi:type="xsd:string">baz</elem2> <someArray xsi:type="namesp2:ArrayOf_SomeObject"> <item xsi:type="namesp2:SomeObject">123</bar> <item xsi:type="namesp2:SomeObject">456</bar> </someArray> </CallDetails> </namesp1:test> </SOAP-ENV:Body> </SOAP-ENV:Envelope>
In the code above, the @array variable can be an array of anything. If you pass in an array of numbers, then SOAP::Lite will properly serialize that into such. If however you need to encode an array of complex types, then simply pass in an array of other SOAP::Data objects and you are all set.
$xml_content = "<foo><bar>123</bar></foo>"; $elem = SOAP::Data->type('xml' => $xml_content);
SOAP::Lite's serializer simple takes whatever text is passed to it, and inserts into the encoded SOAP::Data element verbatim. The text input is NOT validated to ensure it is valid XML, nor is the resulting SOAP::Data element validated to ensure that it will produce valid XML. Therefore, it is incumbent upon the developer to ensure that any XML data used in this fashion is valid and will result in a valid XML document.
$elem = SOAP::Data->name("myElement" => "myValue") ->attr( { 'xmlns:foo2' => 'urn:Foo2', 'xmlns:foo3' => 'urn:Foo3' } );
This will produce the following XML:
<myElement xmlns:foo2="urn:Foo2" xmlns:foo3="urn:Foo3">myValue</myElement>
This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
Randy J. Ray (rjray@blackperl.com)
Byrne Reese (byrne@majordojo.com)