SEIFE:: Daten:: ComplexType ist eine abstrakte Kategorie für das Herstellen und das Handhaben der komplizierten SEIFE:: Datenobjekte.

SYNOPSE

mein verpacken:: SEIFE:: Daten:: ComplexType:: Foo;
strenges verwenden;
Vorsichtshinweise verwenden;
Gebrauch SEIFE:: Daten:: ComplexType;
vars qw (@ISA) verwenden;
@ISA = qw (SEIFE:: Daten:: ComplexType);

konstantes OBJ_URI => http://foo.bar.baz verwenden;
konstantes OBJ_TYPE => ns1 verwenden: myFoo;
konstantes OBJ_FIELDS => verwenden {
=> field1 [Zeichenkette, undef, undef],
=> field2 [int, undef, undef],
=> field3 [xsd: Datum/Uhrzeit, undef, undef]
};

Vorneue {
mein $proto = Schiebung;
mein $class = Hinweis ($proto) || $proto;
mein $data = Schiebung;
mein $obj_fields = Schiebung;
$obj_fields = definierte $obj_fields && Hinweis ($obj_fields) eq DURCHEINANDER? {% {+OBJ_FIELDS}, % {$obj_fields}}: OBJ_FIELDS;
mein $self = $class->SUPER:: neu ($data, $obj_fields);
zurückgehen segnen ($self, $class);
}

mein verpacken:: SEIFE:: Daten:: ComplexType:: Rechtsanwaltschaft;
strenges verwenden;
Vorsichtshinweise verwenden;
Gebrauch SEIFE:: Daten:: ComplexType;
vars qw (@ISA) verwenden;
@ISA = qw (SEIFE:: Daten:: ComplexType);

konstantes OBJ_URI => http://bar.baz.uri verwenden;
konstantes OBJ_TYPE => ns1 verwenden: myBar;
konstantes OBJ_FIELDS => verwenden {
=> val1 [Zeichenkette, undef, undef],
=> val2 [
[
Mein:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_TYPE,
Mein:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_FIELDS
],
Mein:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_URI, undef
]
};

Vorneues {
mein $proto = Schiebung;
mein $class = Hinweis ($proto) || $proto;
mein $data = Schiebung;
mein $obj_fields = Schiebung;
$obj_fields = definiertes $obj_fields && Hinweis ($obj_fields) eq DURCHEINANDER? {% {+OBJ_FIELDS}, % {$obj_fields}}: OBJ_FIELDS;
mein $self = $class->SUPER:: neu ($data, $obj_fields);
zurückgehen segnen ($self, $class);
}

########################################################################
Pakethauptleitung;

mein $request_obj = mein:: SEIFE:: Daten:: ComplexType:: Bar->new ({
=> val1 sometext,
=> val2 {
=> field1 moretext,
field2 => 12345,
field3 => 2005-10-26T12: 00: 00.000Z
}
});
Druck $request_obj->as_xml_data;

Gebrauch SEIFE:: Lite;
mein $result = SEIFE:: Lite
- >uri ($uri)
- >proxy ($proxy)
- >somemethod (SEIFE:: Data->value ($request_obj->as_soap_data))
- >result;

das #assuming die Methode zurückbringt eine Nachricht des Typen Foo… ringt
wenn (Hinweis ($result) eq Foo) {
mein $result_obj = mein:: SEIFE:: Daten:: ComplexType:: Foo->new ($result);
Druck „$_=“. $result_obj->$_. „N“ foreach befestigt % {+My:: SEIFE:: Daten:: ComplexType:: Foo:: OBJ_FIELDS};
}

AUSZUG

SEIFE:: Daten:: ComplexType definiert eine strukturierte Schnittstelle, um Kategorien zu implementieren, die unendlich komplizierte SEIFE: darstellen: Datenobjekte. Nachrichtenfälle können komplizierte SEIFE dynamisch festlegen:: Datenstrukturen oder reines XML, wie gebraucht. Bereiche einer Nachricht können leicht erreicht werden, indem man einen Methodenaufruf mit Namen des Bereichs als die Methode bildet, und Bereichwerte können nach Nachrichtenaufbau durch die Anwendung der gleichen Methode mit einem Parameter geändert werden.

Gesegnete Nachrichten zurückgingen durch eine SEIFE: gen: Lite-Methoden SEIFE:: SOM->result kann verwendet werden, um die Nachricht zurück in ein gleichwertiges ComplexType wieder herzustellen und Mängel der SEIFE so lösen:: Lites Handhaben der komplizierten Typen und Erlauben Benutzern, auf ihre Nachrichten auf eine viel abstraktere und intuive Art zurückzugreifen. Dieses ist auch für Anwendungen außergewöhnlich nützlich, die Gebrauch SEIFEN-Resultatsnachrichten in den zukünftigen SEIFEN-Aufrufen benötigen.

BESCHREIBUNG

Diese Baugruppe soll sie viel einfacher bilden, komplizierte SEIFE herzustellen:: Datenobjekte in einer objektorientierten Kategoriezelle, als Benutzern der SEIFE:: Lite muß SEIFEN-Datenstrukturen aktuell manuell in Handarbeit machen. Er verwendet SEIFE:: Daten:: Erbauer innerlich, zum von Nachrichtendaten zu lagern und festzulegen.
Ich hoffe, daß diese Baugruppe erheblich Produktivität jeder möglicher SEIFE: verbessert: Lite-Programmierer, besonders die, die viele komplizierten datatypes beschäftigen oder mit SEIFE apps arbeiten, die Erbschaft implementieren.